LCOV - code coverage report
Current view: top level - xmloff/source/transform - StyleOOoTContext.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 321 599 53.6 %
Date: 2014-11-03 Functions: 24 43 55.8 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <com/sun/star/xml/sax/SAXParseException.hpp>
      21             : #include <com/sun/star/xml/sax/SAXException.hpp>
      22             : #include <com/sun/star/xml/sax/XDocumentHandler.hpp>
      23             : #include <com/sun/star/xml/sax/XAttributeList.hpp>
      24             : 
      25             : #include <sax/tools/converter.hxx>
      26             : 
      27             : #include <xmloff/nmspmap.hxx>
      28             : #include <xmloff/xmltoken.hxx>
      29             : #include <xmloff/xmlnmspe.hxx>
      30             : #include "PropType.hxx"
      31             : #include "DeepTContext.hxx"
      32             : #include "RenameElemTContext.hxx"
      33             : #include "ProcAttrTContext.hxx"
      34             : #include "ActionMapTypesOOo.hxx"
      35             : #include "MutableAttrList.hxx"
      36             : #include "TransformerActions.hxx"
      37             : #include "PropertyActionsOOo.hxx"
      38             : #include "TransformerBase.hxx"
      39             : 
      40             : #include "StyleOOoTContext.hxx"
      41             : #include <xmloff/xmluconv.hxx>
      42             : #include <rtl/ustrbuf.hxx>
      43             : #include <rtl/math.hxx>
      44             : 
      45             : using namespace ::xmloff::token;
      46             : using namespace ::com::sun::star::uno;
      47             : using namespace ::com::sun::star::xml::sax;
      48             : 
      49             : const sal_uInt16 MAX_PROP_TYPES = 4;
      50             : #define ENTRY4(a,b,c,d) \
      51             :     { XML_PROP_TYPE_##a, XML_PROP_TYPE_##b, \
      52             :         XML_PROP_TYPE_##c, XML_PROP_TYPE_##d  }
      53             : #define ENTRY3(a,b,c) \
      54             :     { XML_PROP_TYPE_##a, XML_PROP_TYPE_##b,  \
      55             :         XML_PROP_TYPE_##c, XML_PROP_TYPE_END }
      56             : #define ENTRY2(a,b) \
      57             :     { XML_PROP_TYPE_##a, XML_PROP_TYPE_##b, \
      58             :         XML_PROP_TYPE_END, XML_PROP_TYPE_END }
      59             : #define ENTRY1(a) \
      60             :     { XML_PROP_TYPE_##a, XML_PROP_TYPE_##END, \
      61             :         XML_PROP_TYPE_END, XML_PROP_TYPE_END }
      62             : 
      63             : static const XMLPropType aPropTypes[XML_FAMILY_TYPE_END][MAX_PROP_TYPES] =
      64             : {
      65             :     ENTRY3( GRAPHIC, PARAGRAPH, TEXT ),         // XML_FAMILY_TYPE_GRAPHIC,
      66             :     ENTRY3( GRAPHIC, PARAGRAPH, TEXT ),         // XML_FAMILY_TYPE_PRESENTATION,
      67             :     ENTRY1( DRAWING_PAGE ),                     // XML_FAMILY_TYPE_DRAWING_PAGE,
      68             :     ENTRY1( END ),                              // XML_FAMILY_TYPE_MASTER_PAGE
      69             :     ENTRY1( PAGE_LAYOUT ),                      // XML_FAMILY_TYPE_PAGE_LAYOUT,
      70             :     ENTRY1( HEADER_FOOTER ),                    // XML_FAMILY_TYPE_HEADER_FOOTER
      71             :     ENTRY1( TEXT ),                             // XML_FAMILY_TYPE_TEXT,
      72             :     ENTRY2( PARAGRAPH, TEXT ),                  // XML_FAMILY_TYPE_PARAGRAPH,
      73             :     ENTRY1( RUBY ),                             //XML_FAMILY_TYPE_RUBY,
      74             :     ENTRY1( SECTION ),                          // XML_FAMILY_TYPE_SECTION,
      75             :     ENTRY1( TABLE ),                            // XML_FAMILY_TYPE_TABLE,
      76             :     ENTRY1( TABLE_COLUMN ),                     // XML_FAMILY_TYPE_TABLE_COLUMN,
      77             :     ENTRY1( TABLE_ROW ),                        // XML_FAMILY_TYPE_TABLE_ROW,
      78             :     ENTRY3( TABLE_CELL, PARAGRAPH, TEXT ),      // XML_FAMILY_TYPE_TABLE_CELL,
      79             :     ENTRY1( LIST_LEVEL ),                       // XML_FAMILY_TYPE_LIST,
      80             :     ENTRY4( CHART, GRAPHIC, PARAGRAPH, TEXT ),  // XML_FAMILY_TYPE_CHART,
      81             :     ENTRY1( TEXT ),                             // XML_FAMILY_TYPE_DATA,
      82             :     ENTRY1( END ),                              // XML_FAMILY_TYPE_GRADIENT,
      83             :     ENTRY1( END ),                              // XML_FAMILY_TYPE_HATCH,
      84             :     ENTRY1( END ),                              // XML_FAMILY_TYPE_FILL_IMAGE,
      85             :     ENTRY1( END ),                              // XML_FAMILY_TYPE_STROKE_DASH,
      86             :     ENTRY1( END ),                              // XML_FAMILY_TYPE_MARKER,
      87             :     ENTRY1( END )                               // XML_FAMILY_TYPE_PRESENTATION_PAGE_LAYOUT,
      88             : };
      89             : 
      90             : static const XMLTokenEnum aPropTokens[XML_PROP_TYPE_END] =
      91             : {
      92             :     XML_GRAPHIC_PROPERTIES,
      93             :     XML_DRAWING_PAGE_PROPERTIES,
      94             :     XML_PAGE_LAYOUT_PROPERTIES,
      95             :     XML_HEADER_FOOTER_PROPERTIES,
      96             :     XML_TEXT_PROPERTIES,
      97             :     XML_PARAGRAPH_PROPERTIES,
      98             :     XML_RUBY_PROPERTIES,
      99             :     XML_SECTION_PROPERTIES,
     100             :     XML_TABLE_PROPERTIES,
     101             :     XML_TABLE_COLUMN_PROPERTIES,
     102             :     XML_TABLE_ROW_PROPERTIES,
     103             :     XML_TABLE_CELL_PROPERTIES,
     104             :     XML_LIST_LEVEL_PROPERTIES,
     105             :     XML_CHART_PROPERTIES
     106             : };
     107             : 
     108             : static const sal_uInt16 aAttrActionMaps[XML_PROP_TYPE_END] =
     109             : {
     110             :     PROP_OOO_GRAPHIC_ATTR_ACTIONS,
     111             :     PROP_OOO_DRAWING_PAGE_ATTR_ACTIONS,     // DRAWING_PAGE
     112             :     PROP_OOO_PAGE_LAYOUT_ATTR_ACTIONS,
     113             :     PROP_OOO_HEADER_FOOTER_ATTR_ACTIONS,
     114             :     PROP_OOO_TEXT_ATTR_ACTIONS,
     115             :     PROP_OOO_PARAGRAPH_ATTR_ACTIONS,
     116             :     MAX_OOO_PROP_ACTIONS,       // RUBY
     117             :     PROP_OOO_SECTION_ATTR_ACTIONS,
     118             :     PROP_OOO_TABLE_ATTR_ACTIONS,
     119             :     PROP_OOO_TABLE_COLUMN_ATTR_ACTIONS,
     120             :     PROP_OOO_TABLE_ROW_ATTR_ACTIONS,
     121             :     PROP_OOO_TABLE_CELL_ATTR_ACTIONS,
     122             :     PROP_OOO_LIST_LEVEL_ATTR_ACTIONS,
     123             :     PROP_OOO_CHART_ATTR_ACTIONS
     124             : };
     125             : 
     126             : static const sal_uInt16 aElemActionMaps[XML_PROP_TYPE_END] =
     127             : {
     128             :     PROP_OOO_GRAPHIC_ELEM_ACTIONS,
     129             :     MAX_OOO_PROP_ACTIONS,
     130             :     MAX_OOO_PROP_ACTIONS,
     131             :     MAX_OOO_PROP_ACTIONS,
     132             :     PROP_OOO_TEXT_ELEM_ACTIONS,
     133             :     PROP_OOO_PARAGRAPH_ELEM_ACTIONS,
     134             :     MAX_OOO_PROP_ACTIONS,
     135             :     MAX_OOO_PROP_ACTIONS,
     136             :     MAX_OOO_PROP_ACTIONS,
     137             :     MAX_OOO_PROP_ACTIONS,
     138             :     MAX_OOO_PROP_ACTIONS,
     139             :     PROP_OOO_TABLE_CELL_ELEM_ACTIONS,
     140             :     MAX_OOO_PROP_ACTIONS,
     141             :     PROP_OOO_CHART_ELEM_ACTIONS
     142             : };
     143             : 
     144             : class XMLTypedPropertiesOOoTContext_Impl : public XMLPersElemContentTContext
     145             : {
     146             :     ::com::sun::star::uno::Reference<
     147             :         ::com::sun::star::xml::sax::XAttributeList > m_xAttrList;
     148             : 
     149             : public:
     150             : 
     151             :     TYPEINFO_OVERRIDE();
     152             : 
     153             :     XMLTypedPropertiesOOoTContext_Impl( XMLTransformerBase& rTransformer,
     154             :                            const OUString& rQName );
     155             : 
     156             :     virtual ~XMLTypedPropertiesOOoTContext_Impl();
     157             : 
     158             :     using XMLPersAttrListTContext::AddAttribute;
     159             :     void AddAttribute( const OUString &sName ,
     160             :                        const OUString &sValue );
     161             :     void AddAttribute( sal_uInt16 nPrefix, XMLTokenEnum eToken,
     162             :                        const OUString &sValue );
     163             : 
     164             :     virtual void StartElement( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& rAttrList ) SAL_OVERRIDE;
     165             : 
     166             :     virtual void Export() SAL_OVERRIDE;
     167             : };
     168             : 
     169           0 : TYPEINIT1( XMLTypedPropertiesOOoTContext_Impl, XMLPersElemContentTContext );
     170             : 
     171         538 : XMLTypedPropertiesOOoTContext_Impl::XMLTypedPropertiesOOoTContext_Impl(
     172             :     XMLTransformerBase& rImp,
     173             :     const OUString& rQName ) :
     174             :     XMLPersElemContentTContext( rImp, rQName ),
     175         538 :     m_xAttrList( new XMLMutableAttributeList() )
     176             : {
     177         538 : }
     178             : 
     179        1076 : XMLTypedPropertiesOOoTContext_Impl::~XMLTypedPropertiesOOoTContext_Impl()
     180             : {
     181        1076 : }
     182             : 
     183        2840 : void XMLTypedPropertiesOOoTContext_Impl::AddAttribute(
     184             :     const OUString &sName ,
     185             :     const OUString &sValue )
     186             : {
     187        2840 :     static_cast< XMLMutableAttributeList * >( m_xAttrList.get() )
     188        2840 :             ->AddAttribute( sName, sValue );
     189        2840 : }
     190             : 
     191          90 : void XMLTypedPropertiesOOoTContext_Impl::AddAttribute(
     192             :     sal_uInt16 nPrefix, XMLTokenEnum eToken,
     193             :     const OUString &sValue )
     194             : {
     195             :     OUString sName(
     196          90 :             GetTransformer().GetNamespaceMap().GetQNameByKey(
     197         180 :                         nPrefix, ::xmloff::token::GetXMLToken( eToken ) ) );
     198          90 :     static_cast< XMLMutableAttributeList * >( m_xAttrList.get() )
     199          90 :             ->AddAttribute( sName, sValue );
     200          90 : }
     201             : 
     202           0 : void XMLTypedPropertiesOOoTContext_Impl::StartElement(
     203             :         const Reference< XAttributeList >& )
     204             : {
     205             :     // empty, ignore even the attribute list
     206           0 : }
     207             : 
     208         538 : void XMLTypedPropertiesOOoTContext_Impl::Export()
     209             : {
     210         538 :     if( m_xAttrList->getLength() || HasElementContent() )
     211             :     {
     212         538 :         GetTransformer().GetDocHandler()->startElement( GetQName(), m_xAttrList );
     213         538 :         ExportContent();
     214         538 :         GetTransformer().GetDocHandler()->endElement( GetQName() );
     215             :     }
     216         538 : }
     217             : 
     218             : class XMLPropertiesOOoTContext_Impl : public XMLTransformerContext
     219             : {
     220             :     ::rtl::Reference < XMLTypedPropertiesOOoTContext_Impl >
     221             :         m_aPropContexts[MAX_PROP_TYPES];
     222             : 
     223             :     typedef XMLPropType XMLPropTypes[MAX_PROP_TYPES];
     224             : 
     225             :     XMLPropTypes m_aPropTypes;
     226             : 
     227             :     bool m_bPersistent;
     228             : 
     229             :     XMLTypedPropertiesOOoTContext_Impl *GetPropContextAndAction(
     230             :             TransformerAction_Impl& rAction,
     231             :             sal_uInt16 nPrefix, const OUString& rLocalName,
     232             :             bool bElem );
     233             : 
     234             :     XMLTypedPropertiesOOoTContext_Impl *GetPropContext(
     235             :             XMLPropType eType );
     236             : 
     237             : public:
     238             : 
     239             :     TYPEINFO_OVERRIDE();
     240             : 
     241             :     XMLPropertiesOOoTContext_Impl( XMLTransformerBase& rTransformer,
     242             :                            const OUString& rQName,
     243             :                                const XMLPropTypes& rTypes,
     244             :                                bool bPersistent );
     245             : 
     246             :     virtual ~XMLPropertiesOOoTContext_Impl();
     247             : 
     248             :     XMLTransformerContext *CreateChildContext(
     249             :             sal_uInt16 nPrefix,
     250             :             const OUString& rLocalName,
     251             :             const OUString& rQName,
     252             :             const Reference< XAttributeList >& rAttrList ) SAL_OVERRIDE;
     253             : 
     254             :     virtual void StartElement( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& rAttrList ) SAL_OVERRIDE;
     255             : 
     256             :     virtual void EndElement() SAL_OVERRIDE;
     257             : 
     258             :     virtual void Characters( const OUString& rChars ) SAL_OVERRIDE;
     259             : 
     260             :     virtual void Export() SAL_OVERRIDE;
     261             : 
     262             :     virtual bool IsPersistent() const SAL_OVERRIDE;
     263             : };
     264             : 
     265           0 : TYPEINIT1( XMLPropertiesOOoTContext_Impl, XMLTransformerContext );
     266             : 
     267             : XMLTypedPropertiesOOoTContext_Impl
     268          10 :     *XMLPropertiesOOoTContext_Impl::GetPropContext(
     269             :             XMLPropType eType )
     270             : {
     271          10 :     sal_uInt16 nIndex = MAX_PROP_TYPES;
     272          20 :     for( sal_uInt16 i=0; i< MAX_PROP_TYPES; i++ )
     273             :     {
     274          20 :         if( m_aPropTypes[i] == eType )
     275             :         {
     276          10 :             nIndex = i;
     277          10 :             break;
     278             :         }
     279             :     }
     280          10 :     if( MAX_PROP_TYPES == nIndex )
     281           0 :         return 0;
     282             : 
     283          10 :     if( !m_aPropContexts[nIndex].is() )
     284             :     {
     285          40 :         m_aPropContexts[nIndex] =
     286             :             new XMLTypedPropertiesOOoTContext_Impl(
     287          10 :                     GetTransformer(),
     288          10 :                     GetTransformer().GetNamespaceMap().GetQNameByKey(
     289             :                         XML_NAMESPACE_STYLE,
     290             :                         ::xmloff::token::GetXMLToken(
     291          30 :                             aPropTokens[m_aPropTypes[nIndex]] ) ));
     292             :     }
     293             : 
     294          10 :     return m_aPropContexts[nIndex].get();
     295             : }
     296             : 
     297             : XMLTypedPropertiesOOoTContext_Impl
     298        2982 :     *XMLPropertiesOOoTContext_Impl::GetPropContextAndAction(
     299             :             TransformerAction_Impl& rAction,
     300             :             sal_uInt16 nPrefix, const OUString& rLocalName,
     301             :             bool bElem )
     302             : {
     303        2982 :     rAction.m_nActionType = XML_ATACTION_COPY;
     304        2982 :     sal_uInt16 nIndex = 0;
     305             : 
     306        2982 :     XMLTransformerActions::key_type aKey( nPrefix, rLocalName );
     307        2982 :     sal_uInt16 i=0;
     308        8968 :     while( i < MAX_PROP_TYPES && XML_PROP_TYPE_END!=m_aPropTypes[i])
     309             :     {
     310             :         sal_uInt16 nActionMap =
     311        5824 :             (bElem ? aElemActionMaps : aAttrActionMaps)[m_aPropTypes[i]];
     312        5824 :         if( nActionMap < MAX_OOO_PROP_ACTIONS )
     313             :         {
     314             :             XMLTransformerActions *pActions =
     315        5782 :                 GetTransformer().GetUserDefinedActions( nActionMap );
     316             :             OSL_ENSURE( pActions, "go no actions" );
     317        5782 :             if( pActions )
     318             :             {
     319             :                 XMLTransformerActions::const_iterator aIter =
     320        5782 :                     pActions->find( aKey );
     321             : 
     322        5782 :                 if( !(aIter == pActions->end()) )
     323             :                 {
     324        2820 :                     rAction = (*aIter).second;
     325        2820 :                     nIndex = i;
     326        2820 :                     break;
     327             :                 }
     328             :             }
     329             :         }
     330        3004 :         ++i;
     331             :     }
     332             : 
     333             : #ifdef DBG_UTIL
     334             :     if( !( XML_NAMESPACE_NONE == nPrefix ||
     335             :                 (XML_NAMESPACE_UNKNOWN_FLAG & nPrefix) ||
     336             :                 XML_PROP_TYPE_END==m_aPropTypes[1] ||
     337             :                 (i<MAX_PROP_TYPES && XML_PROP_TYPE_END!=m_aPropTypes[i]) ) )
     338             :     {
     339             :         OString aTmp("Didnt't find property: ");
     340             :         const OUString& rPrefix =
     341             :             GetTransformer().GetNamespaceMap().GetPrefixByKey( nPrefix );
     342             :         aTmp += OString( rPrefix.getStr(), rPrefix.getLength(),
     343             :                                 RTL_TEXTENCODING_ASCII_US );
     344             :         aTmp += OString( ':' );
     345             :         aTmp += OString( rLocalName.getStr(), rLocalName.getLength(),
     346             :                                 RTL_TEXTENCODING_ASCII_US );
     347             :         aTmp += OString(", assuming <style:");
     348             :         const OUString& rName =
     349             :             ::xmloff::token::GetXMLToken( aPropTokens[m_aPropTypes[0]] );
     350             :         aTmp += OString( rName.getStr(), rName.getLength(),
     351             :                                 RTL_TEXTENCODING_ASCII_US );
     352             :         aTmp += OString( '>' );
     353             : 
     354             :         OSL_FAIL(aTmp.getStr());
     355             :     }
     356             : #endif
     357             : 
     358        2982 :     if( !m_aPropContexts[nIndex].is() )
     359             :     {
     360        2112 :         m_aPropContexts[nIndex] =
     361             :             new XMLTypedPropertiesOOoTContext_Impl(
     362         528 :                     GetTransformer(),
     363         528 :                     GetTransformer().GetNamespaceMap().GetQNameByKey(
     364             :                         XML_NAMESPACE_STYLE,
     365             :                         ::xmloff::token::GetXMLToken(
     366        1584 :                             aPropTokens[m_aPropTypes[nIndex]] ) ));
     367             :     }
     368             : 
     369        2982 :     return m_aPropContexts[nIndex].get();
     370             : }
     371             : 
     372         366 : XMLPropertiesOOoTContext_Impl::XMLPropertiesOOoTContext_Impl(
     373             :     XMLTransformerBase& rImp,
     374             :     const OUString& rQName,
     375             :     const XMLPropTypes& rTypes,
     376             :     bool bPersistent    ) :
     377             :     XMLTransformerContext( rImp, rQName ),
     378         366 :     m_bPersistent( bPersistent )
     379             : {
     380        1830 :     for( sal_uInt16 i=0; i < MAX_PROP_TYPES; ++i )
     381             :     {
     382             :         // remember the types that belong to the attribute and element lists
     383        1464 :         m_aPropTypes[i] = rTypes[i];
     384             :     }
     385         366 : }
     386             : 
     387         732 : XMLPropertiesOOoTContext_Impl::~XMLPropertiesOOoTContext_Impl()
     388             : {
     389         732 : }
     390             : 
     391          72 : XMLTransformerContext *XMLPropertiesOOoTContext_Impl::CreateChildContext(
     392             :             sal_uInt16 nPrefix,
     393             :             const OUString& rLocalName,
     394             :             const OUString& rQName,
     395             :             const Reference< XAttributeList >& rAttrList )
     396             : {
     397          72 :     TransformerAction_Impl aAction;
     398          72 :     return GetPropContextAndAction( aAction, nPrefix, rLocalName, true )
     399          72 :                 ->CreateChildContext( nPrefix, rLocalName, rQName, rAttrList );
     400             : }
     401             : 
     402         366 : void XMLPropertiesOOoTContext_Impl::StartElement(
     403             :         const Reference< XAttributeList >& rAttrList )
     404             : {
     405         366 :     Reference< XAttributeList > xAttrList( rAttrList );
     406             : 
     407         366 :     XMLTypedPropertiesOOoTContext_Impl * pIntervalMinorDivisorContext = 0;
     408         366 :     double fIntervalMajor = 0.0;
     409         366 :     double fIntervalMinor = 0.0;
     410         366 :     bool bMoveProtect = false;
     411         366 :     bool bSizeProtect = false;
     412         732 :     OUString aProtectAttrValue;
     413         366 :     XMLTypedPropertiesOOoTContext_Impl * pProtectContext = 0;
     414             : 
     415             :     /* Attribute <style:mirror> has to be priority over attribute <style:draw>.
     416             :        The filter from OpenDocument file format to OpenOffice.org file format
     417             :        produces styles with both attributes. (#i49139#)
     418             :     */
     419         366 :     bool bExistStyleMirror( false );
     420         732 :     OUString aStyleMirrorAttrValue;
     421         366 :     bool bExistDrawMirror( false );
     422         732 :     OUString aDrawMirrorAttrValue;
     423         366 :     XMLTypedPropertiesOOoTContext_Impl* pMirrorContext( 0L );
     424             : 
     425         366 :     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
     426        3276 :     for( sal_Int16 i=0; i < nAttrCount; i++ )
     427             :     {
     428        2910 :         const OUString sAttrName = xAttrList->getNameByIndex( i );
     429        5820 :         const OUString sAttrValue = xAttrList->getValueByIndex( i );
     430        5820 :         OUString aLocalName;
     431             :         sal_uInt16 nPrefix =
     432        2910 :             GetTransformer().GetNamespaceMap().GetKeyByAttrName( sAttrName,
     433        2910 :                                                                  &aLocalName );
     434        2910 :         TransformerAction_Impl aAction;
     435             :         XMLTypedPropertiesOOoTContext_Impl *pContext =
     436        2910 :             GetPropContextAndAction( aAction, nPrefix, aLocalName, false );
     437        2910 :         switch( aAction.m_nActionType )
     438             :         {
     439             :         case XML_ATACTION_REMOVE:
     440           0 :             break;
     441             :         case XML_ATACTION_COPY:
     442        1848 :             pContext->AddAttribute( sAttrName, sAttrValue );
     443        1848 :             break;
     444             :         case XML_ATACTION_COPY_DUPLICATE:
     445             :             {
     446          10 :                 pContext->AddAttribute( sAttrName, sAttrValue );
     447             :                 XMLTypedPropertiesOOoTContext_Impl *pContext2 =
     448          10 :                     GetPropContext( (XMLPropType)aAction.m_nParam1 );
     449          10 :                 if( pContext2 )
     450          10 :                     pContext2->AddAttribute( sAttrName, sAttrValue );
     451             :             }
     452          10 :             break;
     453             :         case XML_ATACTION_RENAME:
     454             :             {
     455          40 :                 pContext->AddAttribute( aAction.GetQNamePrefixFromParam1(),
     456             :                                         aAction.GetQNameTokenFromParam1(),
     457          80 :                                         sAttrValue );
     458             :             }
     459          40 :             break;
     460             :         case XML_ATACTION_ENCODE_STYLE_NAME_REF:
     461             :             {
     462          42 :                 OUString aAttrValue( sAttrValue );
     463          42 :                 GetTransformer().EncodeStyleName(aAttrValue);
     464          42 :                 pContext->AddAttribute( sAttrName, aAttrValue );
     465             :             }
     466          42 :             break;
     467             :         case XML_ATACTION_RENAME_ENCODE_STYLE_NAME_REF:
     468             :             {
     469          30 :                 OUString aAttrValue( sAttrValue );
     470          30 :                 GetTransformer().EncodeStyleName(aAttrValue);
     471          30 :                 pContext->AddAttribute( aAction.GetQNamePrefixFromParam1(),
     472             :                                         aAction.GetQNameTokenFromParam1(),
     473          60 :                                         aAttrValue );
     474             :             }
     475          30 :             break;
     476             :         case XML_ATACTION_NEG_PERCENT:
     477             :             {
     478           0 :                 OUString aAttrValue( sAttrValue );
     479           0 :                 XMLTransformerBase::NegPercent(aAttrValue);
     480           0 :                 pContext->AddAttribute( sAttrName, aAttrValue );
     481             :             }
     482           0 :             break;
     483             :         case XML_ATACTION_RENAME_NEG_PERCENT:
     484             :             {
     485           0 :                 OUString aAttrValue( sAttrValue );
     486           0 :                 XMLTransformerBase::NegPercent(aAttrValue);
     487           0 :                 pContext->AddAttribute( aAction.GetQNamePrefixFromParam1(),
     488             :                                         aAction.GetQNameTokenFromParam1(),
     489           0 :                                         aAttrValue );
     490             :             }
     491           0 :             break;
     492             :         case XML_ATACTION_INCH2IN:
     493             :             {
     494         814 :                 OUString aAttrValue( sAttrValue );
     495         814 :                 XMLTransformerBase::ReplaceSingleInchWithIn( aAttrValue );
     496         814 :                 pContext->AddAttribute( sAttrName, aAttrValue );
     497             :             }
     498         814 :             break;
     499             :         case XML_ATACTION_INCH2IN_DUPLICATE:
     500             :             {
     501           0 :                 OUString aAttrValue( sAttrValue );
     502           0 :                 XMLTransformerBase::ReplaceSingleInchWithIn( aAttrValue );
     503           0 :                 pContext->AddAttribute( sAttrName, aAttrValue );
     504             :                 XMLTypedPropertiesOOoTContext_Impl *pContext2 =
     505           0 :                     GetPropContext( (XMLPropType)aAction.m_nParam1 );
     506           0 :                 if( pContext2 )
     507           0 :                     pContext2->AddAttribute( sAttrName, aAttrValue );
     508             :             }
     509           0 :             break;
     510             :         case XML_ATACTION_INCHS2INS:
     511             :             {
     512          60 :                 OUString aAttrValue( sAttrValue );
     513          60 :                 XMLTransformerBase::ReplaceInchWithIn( aAttrValue );
     514          60 :                 pContext->AddAttribute( sAttrName, aAttrValue );
     515             :             }
     516          60 :             break;
     517             :         case XML_PTACTION_LINE_MODE:
     518             :             {
     519             :                 OUString aAttrValue( GetXMLToken(
     520           0 :                                         IsXMLToken( sAttrValue, XML_TRUE )
     521             :                                             ? XML_CONTINUOUS
     522           0 :                                             : XML_SKIP_WHITE_SPACE) );
     523             :                 OUString aAttrQName(
     524           0 :                         GetTransformer().GetNamespaceMap().GetQNameByKey(
     525             :                             XML_NAMESPACE_STYLE,
     526           0 :                             GetXMLToken( XML_TEXT_UNDERLINE_MODE ) ) );
     527           0 :                 pContext->AddAttribute( aAttrQName, aAttrValue );
     528             : 
     529           0 :                 aAttrQName =
     530           0 :                         GetTransformer().GetNamespaceMap().GetQNameByKey(
     531             :                             XML_NAMESPACE_STYLE,
     532           0 :                             GetXMLToken( XML_TEXT_LINE_THROUGH_MODE ) );
     533           0 :                 pContext->AddAttribute( aAttrQName, aAttrValue );
     534             :             }
     535           0 :             break;
     536             :         case XML_PTACTION_KEEP_WITH_NEXT:
     537             :             {
     538             :                 OUString aAttrValue( GetXMLToken(
     539           8 :                                         IsXMLToken( sAttrValue, XML_TRUE )
     540             :                                             ? XML_ALWAYS
     541           8 :                                             : XML_AUTO) );
     542           8 :                 pContext->AddAttribute( sAttrName, aAttrValue );
     543             :             }
     544           8 :             break;
     545             :         case XML_PTACTION_UNDERLINE:
     546             :             {
     547          16 :                 XMLTokenEnum eToken = GetTransformer().GetToken( sAttrValue );
     548          16 :                 bool bBold = false, bDouble = false;
     549          16 :                 switch( eToken )
     550             :                 {
     551             :                 case XML_SINGLE:
     552          16 :                     eToken = XML_SOLID;
     553          16 :                     break;
     554             :                 case XML_DOUBLE:
     555           0 :                     eToken = XML_SOLID;
     556           0 :                     bDouble = true;
     557           0 :                     break;
     558             :                 case XML_BOLD:
     559           0 :                     eToken = XML_SOLID;
     560           0 :                     bBold = true;
     561           0 :                     break;
     562             :                 case XML_BOLD_DOTTED:
     563           0 :                     eToken = XML_DOTTED;
     564           0 :                     bBold = true;
     565           0 :                     break;
     566             :                 case XML_BOLD_DASH:
     567           0 :                     eToken = XML_DASH;
     568           0 :                     bBold = true;
     569           0 :                     break;
     570             :                 case XML_BOLD_LONG_DASH:
     571           0 :                     eToken = XML_LONG_DASH;
     572           0 :                     bBold = true;
     573           0 :                     break;
     574             :                 case XML_BOLD_DOT_DASH:
     575           0 :                     eToken = XML_DOT_DASH;
     576           0 :                     bBold = true;
     577           0 :                     break;
     578             :                 case XML_BOLD_DOT_DOT_DASH:
     579           0 :                     eToken = XML_DOT_DOT_DASH;
     580           0 :                     bBold = true;
     581           0 :                     break;
     582             :                 case XML_BOLD_WAVE:
     583           0 :                     eToken = XML_WAVE;
     584           0 :                     bBold = true;
     585           0 :                     break;
     586             :                 case XML_DOUBLE_WAVE:
     587           0 :                     eToken = XML_WAVE;
     588           0 :                     bDouble = true;
     589           0 :                     break;
     590             :                 case XML_NONE:
     591           0 :                     eToken = XML_NONE;
     592           0 :                     bDouble = false;
     593           0 :                     break;
     594             :                 default:
     595             :                     OSL_FAIL( "xmloff::XMLPropertiesOOoTContext_Impl::StartElement(), unknown underline token!" );
     596           0 :                     break;
     597             :                 }
     598             :                 pContext->AddAttribute(
     599          16 :                         GetTransformer().GetNamespaceMap().GetQNameByKey(
     600             :                             XML_NAMESPACE_STYLE,
     601          16 :                             GetXMLToken( XML_TEXT_UNDERLINE_STYLE ) ),
     602             :                         eToken != XML_TOKEN_END ? GetXMLToken( eToken )
     603          32 :                                                    : sAttrValue );
     604          16 :                 if( bDouble )
     605             :                     pContext->AddAttribute(
     606           0 :                             GetTransformer().GetNamespaceMap().GetQNameByKey(
     607             :                                 XML_NAMESPACE_STYLE,
     608           0 :                                 GetXMLToken( XML_TEXT_UNDERLINE_TYPE ) ),
     609           0 :                             GetXMLToken( XML_DOUBLE ) );
     610          16 :                 if( bBold )
     611             :                     pContext->AddAttribute(
     612           0 :                             GetTransformer().GetNamespaceMap().GetQNameByKey(
     613             :                                 XML_NAMESPACE_STYLE,
     614           0 :                                 GetXMLToken( XML_TEXT_UNDERLINE_WIDTH ) ),
     615           0 :                             GetXMLToken( XML_BOLD ) );
     616             :             }
     617          16 :             break;
     618             :         case XML_PTACTION_LINETHROUGH:
     619             :             {
     620           0 :                 XMLTokenEnum eToken = GetTransformer().GetToken( sAttrValue );
     621           0 :                 bool bBold = false, bDouble = false;
     622           0 :                 sal_Unicode c = 0;
     623           0 :                 switch( eToken )
     624             :                 {
     625             :                 case XML_SINGLE_LINE:
     626           0 :                     eToken = XML_SOLID;
     627           0 :                     break;
     628             :                 case XML_DOUBLE_LINE:
     629           0 :                     eToken = XML_SOLID;
     630           0 :                     bDouble = true;
     631           0 :                     break;
     632             :                 case XML_THICK_LINE:
     633           0 :                     eToken = XML_SOLID;
     634           0 :                     bBold = true;
     635           0 :                     break;
     636             :                 case XML_SLASH:
     637           0 :                     eToken = XML_SOLID;
     638           0 :                     c = '/';
     639           0 :                     break;
     640             :                 case XML_uX:
     641           0 :                     eToken = XML_SOLID;
     642           0 :                     c = 'X';
     643           0 :                     break;
     644             :                 default:
     645           0 :                     break;
     646             :                 }
     647             :                 pContext->AddAttribute(
     648           0 :                         GetTransformer().GetNamespaceMap().GetQNameByKey(
     649             :                             XML_NAMESPACE_STYLE,
     650           0 :                             GetXMLToken( XML_TEXT_LINE_THROUGH_STYLE ) ),
     651             :                         eToken != XML_TOKEN_END ? GetXMLToken( eToken )
     652           0 :                                                    : sAttrValue );
     653           0 :                 if( bDouble )
     654             :                     pContext->AddAttribute(
     655           0 :                             GetTransformer().GetNamespaceMap().GetQNameByKey(
     656             :                                 XML_NAMESPACE_STYLE,
     657           0 :                                 GetXMLToken( XML_TEXT_LINE_THROUGH_TYPE ) ),
     658           0 :                             GetXMLToken( XML_DOUBLE ) );
     659           0 :                 if( bBold )
     660             :                     pContext->AddAttribute(
     661           0 :                             GetTransformer().GetNamespaceMap().GetQNameByKey(
     662             :                                 XML_NAMESPACE_STYLE,
     663           0 :                                 GetXMLToken( XML_TEXT_LINE_THROUGH_WIDTH ) ),
     664           0 :                             GetXMLToken( XML_BOLD ) );
     665           0 :                 if( c )
     666             :                     pContext->AddAttribute(
     667           0 :                             GetTransformer().GetNamespaceMap().GetQNameByKey(
     668             :                                 XML_NAMESPACE_STYLE,
     669           0 :                                 GetXMLToken( XML_TEXT_LINE_THROUGH_TEXT ) ),
     670           0 :                             OUString( c ) );
     671             :             }
     672           0 :             break;
     673             :         case XML_PTACTION_SPLINES:
     674             :             {
     675           6 :                 sal_Int32 nSplineType = sAttrValue.toInt32();
     676           6 :                 OUString aNewAttrName = GetTransformer().GetNamespaceMap().GetQNameByKey(
     677          12 :                     XML_NAMESPACE_CHART, GetXMLToken( XML_INTERPOLATION ) );
     678             : 
     679           6 :                 switch( nSplineType )
     680             :                 {
     681             :                     // straight lines
     682             :                     case 0:
     683             :                         pContext->AddAttribute(
     684           6 :                             aNewAttrName, GetXMLToken( XML_NONE ));
     685           6 :                         break;
     686             :                     // cubic spline
     687             :                     case 1:
     688             :                         pContext->AddAttribute(
     689           0 :                             aNewAttrName, GetXMLToken( XML_CUBIC_SPLINE ));
     690           0 :                         break;
     691             :                     // B-spline
     692             :                     case 2:
     693             :                         pContext->AddAttribute(
     694           0 :                             aNewAttrName, GetXMLToken( XML_B_SPLINE ));
     695           0 :                         break;
     696             : 
     697             :                     default:
     698             :                         OSL_FAIL( "invalid spline type" );
     699             :                         pContext->AddAttribute(
     700           0 :                             aNewAttrName, GetXMLToken( XML_NONE ));
     701           0 :                         break;
     702           6 :                 }
     703             :             }
     704           6 :             break;
     705             :         case XML_PTACTION_INTERVAL_MAJOR:
     706           0 :             pContext->AddAttribute( sAttrName, sAttrValue );
     707           0 :             ::sax::Converter::convertDouble( fIntervalMajor, sAttrValue );
     708           0 :             break;
     709             :         case XML_PTACTION_INTERVAL_MINOR:
     710           0 :             ::sax::Converter::convertDouble( fIntervalMinor, sAttrValue );
     711           0 :             pIntervalMinorDivisorContext = pContext;
     712           0 :             break;
     713             :         case XML_PTACTION_SYMBOL:
     714             :             {
     715           6 :                 sal_Int32 nSymbolType = sAttrValue.toInt32();
     716           6 :                 OUString aNewAttrName = GetTransformer().GetNamespaceMap().GetQNameByKey(
     717          12 :                     XML_NAMESPACE_CHART, GetXMLToken( XML_SYMBOL_TYPE ) );
     718             : 
     719           6 :                 if( nSymbolType >= 0 )
     720             :                 {
     721           0 :                     pContext->AddAttribute( aNewAttrName, GetXMLToken( XML_NAMED_SYMBOL ));
     722           0 :                     enum XMLTokenEnum eToken = XML_TOKEN_INVALID;
     723           0 :                     switch( nSymbolType )
     724             :                     {
     725             :                         // SYMBOL0
     726             :                         case 0:
     727             :                             // "square" has an awkward token name
     728           0 :                             eToken = XML_GRADIENTSTYLE_SQUARE;
     729           0 :                             break;
     730             :                         // SYMBOL1
     731             :                         case 1:
     732           0 :                             eToken = XML_DIAMOND;
     733           0 :                             break;
     734             :                         // SYMBOL2
     735             :                         case 2:
     736           0 :                             eToken = XML_ARROW_DOWN;
     737           0 :                             break;
     738             :                         // SYMBOL3
     739             :                         case 3:
     740           0 :                             eToken = XML_ARROW_UP;
     741           0 :                             break;
     742             :                         // SYMBOL4
     743             :                         case 4:
     744           0 :                             eToken = XML_ARROW_RIGHT;
     745           0 :                             break;
     746             :                         // SYMBOL5
     747             :                         case 5:
     748           0 :                             eToken = XML_ARROW_LEFT;
     749           0 :                             break;
     750             :                         // SYMBOL6
     751             :                         case 6:
     752           0 :                             eToken = XML_BOW_TIE;
     753           0 :                             break;
     754             :                         // SYMBOL7
     755             :                         case 7:
     756           0 :                             eToken = XML_HOURGLASS;
     757           0 :                             break;
     758             :                         case 8:
     759           0 :                             eToken = XML_CIRCLE;
     760           0 :                             break;
     761             :                         case 9:
     762           0 :                             eToken = XML_STAR;
     763           0 :                             break;
     764             :                         case 10:
     765           0 :                             eToken = XML_X;
     766           0 :                             break;
     767             :                         case 11:
     768           0 :                             eToken = XML_PLUS;
     769           0 :                             break;
     770             :                         case 12:
     771           0 :                             eToken = XML_ASTERISK;
     772           0 :                             break;
     773             :                         case 13:
     774           0 :                             eToken = XML_HORIZONTAL_BAR;
     775           0 :                             break;
     776             :                         case 14:
     777           0 :                             eToken = XML_VERTICAL_BAR;
     778           0 :                             break;
     779             :                         default:
     780             :                             OSL_FAIL( "invalid named symbol" );
     781           0 :                             break;
     782             :                     }
     783             : 
     784           0 :                     if( eToken != XML_TOKEN_INVALID )
     785             :                     {
     786           0 :                         pContext->AddAttribute( GetTransformer().GetNamespaceMap().GetQNameByKey(
     787           0 :                                                     XML_NAMESPACE_CHART, GetXMLToken( XML_SYMBOL_NAME )),
     788           0 :                                                 GetXMLToken( eToken ));
     789             :                     }
     790             :                 }
     791             :                 else
     792             :                 {
     793           6 :                     switch( nSymbolType )
     794             :                     {
     795             :                         // NONE
     796             :                         case -3:
     797             :                             pContext->AddAttribute(
     798           6 :                                 aNewAttrName, GetXMLToken( XML_NONE ));
     799           6 :                             break;
     800             :                             // AUTO
     801             :                         case -2:
     802             :                             pContext->AddAttribute(
     803           0 :                                 aNewAttrName, GetXMLToken( XML_AUTOMATIC ));
     804           0 :                             break;
     805             :                             // BITMAPURL
     806             :                         case -1:
     807             :                             pContext->AddAttribute(
     808           0 :                                 aNewAttrName, GetXMLToken( XML_IMAGE ));
     809           0 :                             break;
     810             :                         default:
     811             :                             OSL_FAIL( "invalid symbol type" );
     812             :                             pContext->AddAttribute(
     813           0 :                                 aNewAttrName, GetXMLToken( XML_NONE ));
     814           0 :                             break;
     815             :                     }
     816           6 :                 }
     817             :             }
     818           6 :             break;
     819             :         case XML_PTACTION_SYMBOL_IMAGE_NAME:
     820             :             {
     821             :                 // create an xlink:href element for URI attribute
     822             :                 XMLPersAttrListTContext *pSymbolImageContext = new XMLPersAttrListTContext(
     823           0 :                     GetTransformer(), GetTransformer().GetNamespaceMap().GetQNameByKey(
     824           0 :                         XML_NAMESPACE_CHART, GetXMLToken( XML_SYMBOL_IMAGE )));
     825             : 
     826           0 :                 OUString aAttrValue( sAttrValue );
     827           0 :                 if( GetTransformer().ConvertURIToOASIS( aAttrValue, true ))
     828             :                 {
     829           0 :                     pSymbolImageContext->AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, aAttrValue );
     830           0 :                     pContext->AddContent( pSymbolImageContext );
     831           0 :                 }
     832             :             }
     833           0 :             break;
     834             : 
     835             :         // #i25616#
     836             :         case XML_PTACTION_TRANSPARENCY :
     837             :             {
     838          10 :                 OUString aAttrValue( sAttrValue );
     839          10 :                 XMLTransformerBase::NegPercent(aAttrValue);
     840             :                 pContext->AddAttribute( XML_NAMESPACE_DRAW,
     841             :                                         XML_OPACITY,
     842          10 :                                         aAttrValue );
     843             :                 pContext->AddAttribute( XML_NAMESPACE_DRAW,
     844             :                                         XML_IMAGE_OPACITY,
     845          10 :                                         aAttrValue );
     846             :             }
     847          10 :             break;
     848             : 
     849             :         case XML_PTACTION_BREAK_INSIDE:
     850             :             {
     851             :                 pContext->AddAttribute(
     852             :                     XML_NAMESPACE_FO, XML_KEEP_TOGETHER,
     853             :                     GetXMLToken(
     854           0 :                         IsXMLToken( sAttrValue, XML_COLUMNSPLIT_AVOID )
     855             :                         ? XML_ALWAYS
     856           0 :                         : XML_AUTO ) );
     857             :             }
     858           0 :             break;
     859             :         case XML_ATACTION_CAPTION_ESCAPE_OOO:
     860             :             {
     861           0 :                 OUString aAttrValue( sAttrValue );
     862           0 :                 if( aAttrValue.indexOf( '%' ) != -1 )
     863             :                 {
     864           0 :                     sal_Int32 nValue = 0;
     865           0 :                     ::sax::Converter::convertPercent( nValue, sAttrValue );
     866           0 :                     if( nValue )
     867             :                     {
     868           0 :                         nValue /= 100;
     869           0 :                         OUStringBuffer aOut;
     870           0 :                         ::sax::Converter::convertPercent( aOut, nValue );
     871           0 :                         aAttrValue = aOut.makeStringAndClear();
     872             :                     }
     873             :                 }
     874             :                 else
     875             :                 {
     876           0 :                     XMLTransformerBase::ReplaceSingleInchWithIn( aAttrValue );
     877             :                 }
     878             : 
     879           0 :                 pContext->AddAttribute( sAttrName, aAttrValue );
     880             :             }
     881           0 :             break;
     882             :         case XML_ATACTION_MOVE_PROTECT:
     883           0 :             bMoveProtect = IsXMLToken( sAttrValue, XML_TRUE );
     884           0 :             pProtectContext = pContext;
     885           0 :             break;
     886             :         case XML_ATACTION_SIZE_PROTECT:
     887           0 :             bSizeProtect = IsXMLToken( sAttrValue, XML_TRUE );
     888           0 :             pProtectContext = pContext;
     889           0 :             break;
     890             :         case XML_ATACTION_PROTECT:
     891           0 :             aProtectAttrValue = sAttrValue;
     892           0 :             pProtectContext = pContext;
     893           0 :             break;
     894             :         case XML_ATACTION_DRAW_MIRROR_OOO:   // renames draw:mirror to style:mirror and adapts values
     895             :             {
     896             :                 // OpenDocument file format: attribute value of <style:mirror> wrong (#i49139#)
     897             :                 aDrawMirrorAttrValue =
     898          10 :                                 GetXMLToken( IsXMLToken( sAttrValue, XML_TRUE )
     899          10 :                                              ? XML_HORIZONTAL : XML_NONE );
     900          10 :                 bExistDrawMirror = true;
     901          10 :                 pMirrorContext = pContext;
     902             :             }
     903          10 :             break;
     904             :         // OpenDocument file format: attribute value of <style:mirror> wrong (#i49139#)
     905             :         case XML_ATACTION_STYLE_MIRROR_OOO:   // adapts style:mirror values
     906             :             {
     907           0 :                 SvXMLTokenEnumerator aTokenEnum( sAttrValue );
     908           0 :                 OUString aToken;
     909           0 :                 while( aTokenEnum.getNextToken( aToken ) )
     910             :                 {
     911           0 :                     if ( !aStyleMirrorAttrValue.isEmpty() )
     912             :                     {
     913           0 :                         aStyleMirrorAttrValue += " ";
     914             :                     }
     915             : 
     916           0 :                     if ( IsXMLToken( aToken, XML_HORIZONTAL_ON_LEFT_PAGES ) )
     917             :                     {
     918           0 :                         aStyleMirrorAttrValue += GetXMLToken( XML_HORIZONTAL_ON_EVEN );
     919             :                     }
     920           0 :                     else if ( IsXMLToken( aToken, XML_HORIZONTAL_ON_RIGHT_PAGES ) )
     921             :                     {
     922           0 :                         aStyleMirrorAttrValue += GetXMLToken( XML_HORIZONTAL_ON_ODD );
     923             :                     }
     924             :                     else
     925             :                     {
     926           0 :                         aStyleMirrorAttrValue += aToken;
     927             :                     }
     928             :                 }
     929           0 :                 bExistStyleMirror = true;
     930           0 :                 pMirrorContext = pContext;
     931             :             }
     932           0 :             break;
     933             :         case XML_ATACTION_GAMMA_OOO:        // converts double value to percentage
     934             :             {
     935          10 :                 double fValue = sAttrValue.toDouble();
     936          10 :                 sal_Int32 nValue = (sal_Int32)((fValue * 100.0) + ( fValue > 0 ? 0.5 : - 0.5 ) );
     937             : 
     938          10 :                 OUStringBuffer aOut;
     939          10 :                 ::sax::Converter::convertPercent( aOut, nValue );
     940          20 :                 OUString aAttrValue( aOut.makeStringAndClear() );
     941          20 :                 pContext->AddAttribute( sAttrName, aAttrValue );
     942             :             }
     943          10 :             break;
     944             :         case XML_ATACTION_OPACITY_FIX:
     945             :             {
     946             :                 sal_Int32 nValue;
     947           0 :                 if( sAttrValue.indexOf( '%' ) != -1 )
     948             :                 {
     949           0 :                     ::sax::Converter::convertPercent( nValue, sAttrValue );
     950             :                 }
     951             :                 else
     952             :                 {
     953           0 :                     nValue = sal_Int32( sAttrValue.toDouble() * 100.0 );
     954             :                 }
     955           0 :                 nValue = 100 - nValue;
     956             : 
     957           0 :                 OUStringBuffer aOut;
     958           0 :                 ::sax::Converter::convertPercent( aOut, nValue );
     959           0 :                 pContext->AddAttribute( sAttrName, aOut.makeStringAndClear() );
     960             :             }
     961           0 :             break;
     962             :         default:
     963             :             OSL_ENSURE( false, "unknown action" );
     964           0 :             break;
     965             :         }
     966        2910 :     }
     967             : 
     968             :     // OpenDocument file format: attribute value of <style:mirror> wrong (#i49139#)
     969         366 :     if ( bExistStyleMirror )
     970             :     {
     971             :         pMirrorContext->AddAttribute(
     972           0 :                         GetTransformer().GetNamespaceMap().GetQNameByKey(
     973           0 :                                 XML_NAMESPACE_STYLE, GetXMLToken( XML_MIRROR ) ),
     974           0 :                         aStyleMirrorAttrValue);
     975             :     }
     976         366 :     else if ( bExistDrawMirror )
     977             :     {
     978             :         pMirrorContext->AddAttribute(
     979          10 :                         GetTransformer().GetNamespaceMap().GetQNameByKey(
     980          10 :                                 XML_NAMESPACE_STYLE, GetXMLToken( XML_MIRROR ) ),
     981          10 :                         aDrawMirrorAttrValue);
     982             :     }
     983             : 
     984         366 :     if( bMoveProtect || bSizeProtect || !aProtectAttrValue.isEmpty() )
     985             :     {
     986           0 :         if( (bMoveProtect ||bSizeProtect) && IsXMLToken( aProtectAttrValue, XML_NONE ) )
     987           0 :             aProtectAttrValue = OUString();
     988             : 
     989           0 :         const OUString& rPosition = GetXMLToken( XML_POSITION );
     990           0 :         if( bMoveProtect && -1 == aProtectAttrValue.indexOf( rPosition ) )
     991             :         {
     992           0 :             if( !aProtectAttrValue.isEmpty() )
     993           0 :                 aProtectAttrValue += " ";
     994           0 :             aProtectAttrValue += rPosition;
     995             :         }
     996             : 
     997           0 :         const OUString& rSize = GetXMLToken( XML_SIZE );
     998           0 :         if( bSizeProtect && -1 == aProtectAttrValue.indexOf( rSize ) )
     999             :         {
    1000           0 :             if( !aProtectAttrValue.isEmpty() )
    1001           0 :                 aProtectAttrValue += " ";
    1002           0 :             aProtectAttrValue += rSize;
    1003             :         }
    1004             : 
    1005           0 :         pProtectContext->AddAttribute( GetTransformer().GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_STYLE, GetXMLToken( XML_PROTECT ) ), aProtectAttrValue );
    1006             :     }
    1007             : 
    1008         366 :     if( pIntervalMinorDivisorContext )
    1009             :     {
    1010           0 :         if( fIntervalMinor != 0.0 )
    1011             :         {
    1012             :             sal_Int32 nIntervalMinorDivisor = static_cast< sal_Int32 >(
    1013           0 :                 ::rtl::math::round( fIntervalMajor / fIntervalMinor ));
    1014             : 
    1015           0 :             OUStringBuffer aBuf;
    1016           0 :             ::sax::Converter::convertNumber( aBuf, nIntervalMinorDivisor );
    1017             :             pIntervalMinorDivisorContext->AddAttribute(
    1018           0 :                 GetTransformer().GetNamespaceMap().GetQNameByKey(
    1019             :                     XML_NAMESPACE_CHART,
    1020           0 :                     GetXMLToken( XML_INTERVAL_MINOR_DIVISOR )),
    1021           0 :                 aBuf.makeStringAndClear());
    1022             :         }
    1023         366 :     }
    1024         366 : }
    1025             : 
    1026         366 : void XMLPropertiesOOoTContext_Impl::EndElement()
    1027             : {
    1028         366 :     if( !m_bPersistent )
    1029         366 :         Export();
    1030         366 : }
    1031             : 
    1032           0 : void XMLPropertiesOOoTContext_Impl::Characters( const OUString& )
    1033             : {
    1034             :     // ignore them
    1035           0 : }
    1036             : 
    1037         366 : void XMLPropertiesOOoTContext_Impl::Export()
    1038             : {
    1039             : 
    1040        1830 :     for( sal_uInt16 i=0; i < MAX_PROP_TYPES; i++ )
    1041             :     {
    1042        1464 :         if( m_aPropContexts[i].is() )
    1043         538 :             m_aPropContexts[i]->Export();
    1044             :     }
    1045         366 : }
    1046             : 
    1047           0 : bool XMLPropertiesOOoTContext_Impl::IsPersistent() const
    1048             : {
    1049           0 :     return m_bPersistent;
    1050             : }
    1051             : 
    1052           0 : TYPEINIT1( XMLStyleOOoTContext, XMLPersElemContentTContext );
    1053             : 
    1054         564 : XMLStyleOOoTContext::XMLStyleOOoTContext( XMLTransformerBase& rImp,
    1055             :                                             const OUString& rQName,
    1056             :                                                 XMLFamilyType eT,
    1057             :                                              bool bPersistent ) :
    1058             :     XMLPersElemContentTContext( rImp, rQName ),
    1059             :     m_eFamily( eT ),
    1060         564 :     m_bPersistent( bPersistent )
    1061             : {
    1062         564 : }
    1063             : 
    1064          48 : XMLStyleOOoTContext::XMLStyleOOoTContext(
    1065             :         XMLTransformerBase& rImp,
    1066             :           const OUString& rQName,
    1067             :         XMLFamilyType eT,
    1068             :         sal_uInt16 nPrefix,
    1069             :         ::xmloff::token::XMLTokenEnum eToken,
    1070             :            bool bPersistent ) :
    1071             :     XMLPersElemContentTContext( rImp, rQName, nPrefix, eToken ),
    1072             :     m_eFamily( eT ),
    1073          48 :     m_bPersistent( bPersistent )
    1074             : {
    1075          48 : }
    1076             : 
    1077        1224 : XMLStyleOOoTContext::~XMLStyleOOoTContext()
    1078             : {
    1079        1224 : }
    1080             : 
    1081         534 : XMLTransformerContext *XMLStyleOOoTContext::CreateChildContext(
    1082             :             sal_uInt16 nPrefix,
    1083             :             const OUString& rLocalName,
    1084             :             const OUString& rQName,
    1085             :             const Reference< XAttributeList >& rAttrList )
    1086             : {
    1087         534 :     XMLTransformerContext *pContext = 0;
    1088             : 
    1089         982 :     if( XML_NAMESPACE_STYLE == nPrefix &&
    1090         448 :         IsXMLToken( rLocalName, XML_PROPERTIES ) )
    1091             :     {
    1092         366 :         if( aPropTypes[m_eFamily][0] == XML_PROP_TYPE_END )
    1093             :         {
    1094             :             OSL_ENSURE( false, "unexpected properties element" );
    1095             :             pContext = m_bPersistent
    1096             :                             ? XMLPersElemContentTContext::CreateChildContext(
    1097           0 :                                     nPrefix, rLocalName, rQName, rAttrList )
    1098             :                             : XMLTransformerContext::CreateChildContext(
    1099           0 :                                     nPrefix, rLocalName, rQName, rAttrList );
    1100             :         }
    1101         366 :         else if( aPropTypes[m_eFamily][1] == XML_PROP_TYPE_END )
    1102             :         {
    1103             :             sal_uInt16 nActionMap =
    1104         136 :                 aAttrActionMaps[aPropTypes[m_eFamily][0]];
    1105         136 :             if( nActionMap < MAX_OOO_PROP_ACTIONS )
    1106             :             {
    1107             :                 pContext = new XMLPropertiesOOoTContext_Impl(
    1108         136 :                                     GetTransformer(), rQName,
    1109         136 :                                     aPropTypes[m_eFamily], m_bPersistent );
    1110             :             }
    1111             :             else
    1112             :             {
    1113           0 :                 if( m_bPersistent )
    1114             :                     pContext = new XMLPersElemContentTContext(
    1115           0 :                                     GetTransformer(), rQName,
    1116             :                                     XML_NAMESPACE_STYLE,
    1117           0 :                                     aPropTokens[aPropTypes[m_eFamily][0]] );
    1118             :                 else
    1119             :                     pContext = new XMLRenameElemTransformerContext(
    1120           0 :                                     GetTransformer(), rQName,
    1121             :                                     XML_NAMESPACE_STYLE,
    1122           0 :                                     aPropTokens[aPropTypes[m_eFamily][0]] );
    1123             :             }
    1124             :         }
    1125             :         else
    1126             :         {
    1127             :             pContext = new XMLPropertiesOOoTContext_Impl(
    1128         230 :                                 GetTransformer(), rQName,
    1129         230 :                                 aPropTypes[m_eFamily], m_bPersistent);
    1130             :         }
    1131             : 
    1132         366 :         if( m_bPersistent )
    1133           0 :             AddContent( pContext );
    1134             :     }
    1135             :     else
    1136             :     {
    1137             :         pContext = m_bPersistent
    1138             :                         ? XMLPersElemContentTContext::CreateChildContext(
    1139           0 :                                 nPrefix, rLocalName, rQName, rAttrList )
    1140             :                         : XMLTransformerContext::CreateChildContext(
    1141         168 :                                 nPrefix, rLocalName, rQName, rAttrList );
    1142             :     }
    1143             : 
    1144         534 :     return pContext;
    1145             : }
    1146             : 
    1147         612 : void XMLStyleOOoTContext::StartElement(
    1148             :         const Reference< XAttributeList >& rAttrList )
    1149             : {
    1150             :     XMLTransformerActions *pActions =
    1151         612 :         GetTransformer().GetUserDefinedActions( OOO_STYLE_ACTIONS );
    1152             :     OSL_ENSURE( pActions, "go no actions" );
    1153             : 
    1154         612 :     Reference< XAttributeList > xAttrList( rAttrList );
    1155         612 :     XMLMutableAttributeList *pMutableAttrList = 0;
    1156         612 :     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
    1157        2096 :     for( sal_Int16 i=0; i < nAttrCount; i++ )
    1158             :     {
    1159        1484 :         const OUString sAttrName = xAttrList->getNameByIndex( i );
    1160        2968 :         OUString aLocalName;
    1161             :         sal_uInt16 nPrefix =
    1162        1484 :             GetTransformer().GetNamespaceMap().GetKeyByAttrName( sAttrName,
    1163        1484 :                                                                  &aLocalName );
    1164        2968 :         XMLTransformerActions::key_type aKey( nPrefix, aLocalName );
    1165             :         XMLTransformerActions::const_iterator aIter =
    1166        1484 :             pActions->find( aKey );
    1167        1484 :         if( !(aIter == pActions->end() ) )
    1168             :         {
    1169         984 :             if( !pMutableAttrList )
    1170             :             {
    1171             :                 pMutableAttrList =
    1172         460 :                     new XMLMutableAttributeList( xAttrList );
    1173         460 :                 xAttrList = pMutableAttrList;
    1174             :             }
    1175         984 :             const OUString sAttrValue = xAttrList->getValueByIndex( i );
    1176         984 :             switch( (*aIter).second.m_nActionType )
    1177             :             {
    1178             :             case XML_ATACTION_STYLE_FAMILY:
    1179             :                 {
    1180         360 :                     bool bControl = false;
    1181         360 :                     if( XML_FAMILY_TYPE_END == m_eFamily )
    1182             :                     {
    1183         324 :                         if( IsXMLToken( sAttrValue, XML_GRAPHICS ) )
    1184          40 :                             m_eFamily = XML_FAMILY_TYPE_GRAPHIC;
    1185         284 :                         else if( IsXMLToken( sAttrValue, XML_PRESENTATION ) )
    1186           0 :                             m_eFamily = XML_FAMILY_TYPE_PRESENTATION;
    1187         284 :                         else if( IsXMLToken( sAttrValue, XML_DRAWING_PAGE ) )
    1188           0 :                             m_eFamily = XML_FAMILY_TYPE_DRAWING_PAGE;
    1189         284 :                         else if( IsXMLToken( sAttrValue, XML_TEXT) )
    1190          10 :                             m_eFamily = XML_FAMILY_TYPE_TEXT;
    1191         274 :                         else if( IsXMLToken( sAttrValue, XML_PARAGRAPH) )
    1192         100 :                             m_eFamily = XML_FAMILY_TYPE_PARAGRAPH;
    1193         174 :                         else if( IsXMLToken( sAttrValue, XML_RUBY) )
    1194           0 :                             m_eFamily = XML_FAMILY_TYPE_RUBY;
    1195         174 :                         else if( IsXMLToken( sAttrValue, XML_SECTION) )
    1196           0 :                             m_eFamily = XML_FAMILY_TYPE_SECTION;
    1197         174 :                         else if( IsXMLToken( sAttrValue, XML_TABLE) )
    1198          12 :                             m_eFamily = XML_FAMILY_TYPE_TABLE;
    1199         162 :                         else if( IsXMLToken( sAttrValue, XML_TABLE_COLUMN) )
    1200          10 :                             m_eFamily = XML_FAMILY_TYPE_TABLE_COLUMN;
    1201         152 :                         else if( IsXMLToken( sAttrValue, XML_TABLE_ROW) )
    1202          12 :                             m_eFamily = XML_FAMILY_TYPE_TABLE_ROW;
    1203         140 :                         else if( IsXMLToken( sAttrValue, XML_TABLE_CELL) )
    1204          62 :                             m_eFamily = XML_FAMILY_TYPE_TABLE_CELL;
    1205          78 :                         else if( IsXMLToken( sAttrValue, XML_CHART) )
    1206          78 :                             m_eFamily = XML_FAMILY_TYPE_CHART;
    1207           0 :                         else if( IsXMLToken( sAttrValue, XML_CONTROL) )
    1208             :                         {
    1209           0 :                             m_eFamily = XML_FAMILY_TYPE_PARAGRAPH;
    1210           0 :                             bControl = true;
    1211             :                         }
    1212             :                     }
    1213         360 :                     if( XML_FAMILY_TYPE_GRAPHIC == m_eFamily )
    1214             :                     {
    1215             :                         pMutableAttrList->SetValueByIndex( i,
    1216          40 :                                                 GetXMLToken( XML_GRAPHIC ) );
    1217             :                     }
    1218         320 :                     else if( bControl )
    1219             :                     {
    1220             :                         pMutableAttrList->SetValueByIndex( i,
    1221           0 :                                                 GetXMLToken( XML_PARAGRAPH ) );
    1222             :                     }
    1223             :                 }
    1224         360 :                 break;
    1225             :             case XML_ATACTION_INCH2IN:
    1226             :                 {
    1227          12 :                     OUString aAttrValue( sAttrValue );
    1228          12 :                     if( XMLTransformerBase::ReplaceSingleInchWithIn(
    1229             :                                 aAttrValue ) )
    1230           0 :                         pMutableAttrList->SetValueByIndex( i, aAttrValue );
    1231             :                 }
    1232          12 :                 break;
    1233             :             case XML_ATACTION_ENCODE_STYLE_NAME:
    1234             :                 {
    1235         420 :                     OUString aAttrValue( sAttrValue );
    1236         420 :                     if( GetTransformer().EncodeStyleName(aAttrValue) )
    1237             :                     {
    1238          92 :                         pMutableAttrList->SetValueByIndex( i, aAttrValue );
    1239             :                         OUString aNewAttrQName(
    1240          92 :                             GetTransformer().GetNamespaceMap().
    1241             :                                 GetQNameByKey(
    1242             :                                     nPrefix, ::xmloff::token::GetXMLToken(
    1243         184 :                                         XML_DISPLAY_NAME ) ) );
    1244             :                         pMutableAttrList->AddAttribute( aNewAttrQName,
    1245          92 :                                                         sAttrValue );
    1246         420 :                     }
    1247             :                 }
    1248         420 :                 break;
    1249             :             case XML_ATACTION_ENCODE_STYLE_NAME_REF:
    1250             :                 {
    1251         156 :                     OUString aAttrValue( sAttrValue );
    1252         156 :                     if( GetTransformer().EncodeStyleName(aAttrValue) )
    1253          32 :                         pMutableAttrList->SetValueByIndex( i, aAttrValue );
    1254             :                 }
    1255         156 :                 break;
    1256             :             case XML_ATACTION_NEG_PERCENT:
    1257             :                 {
    1258          24 :                     OUString aAttrValue( sAttrValue );
    1259          24 :                     if( XMLTransformerBase::NegPercent(aAttrValue) )
    1260          24 :                         pMutableAttrList->SetValueByIndex( i, aAttrValue );
    1261             :                 }
    1262          24 :                 break;
    1263             :             case XML_ATACTION_URI_OOO:
    1264             :                 {
    1265          12 :                     OUString aAttrValue( sAttrValue );
    1266          12 :                     if( GetTransformer().ConvertURIToOASIS( aAttrValue,
    1267          12 :                             static_cast< bool >((*aIter).second.m_nParam1)))
    1268          12 :                         pMutableAttrList->SetValueByIndex( i, aAttrValue );
    1269             :                 }
    1270          12 :                 break;
    1271             :             default:
    1272             :                 OSL_ENSURE( false, "unknown action" );
    1273           0 :                 break;
    1274         984 :             }
    1275             :         }
    1276        1484 :     }
    1277         612 :     if( XML_FAMILY_TYPE_END == m_eFamily )
    1278           0 :         m_eFamily = XML_FAMILY_TYPE_TEXT;
    1279         612 :     if( m_bPersistent )
    1280           0 :         XMLPersElemContentTContext::StartElement( xAttrList );
    1281             :     else
    1282        1224 :         GetTransformer().GetDocHandler()->startElement( GetExportQName(),
    1283        1224 :                                                         xAttrList );
    1284         612 : }
    1285             : 
    1286         612 : void XMLStyleOOoTContext::EndElement()
    1287             : {
    1288         612 :     if( m_bPersistent )
    1289           0 :         XMLPersElemContentTContext::EndElement();
    1290             :     else
    1291         612 :         GetTransformer().GetDocHandler()->endElement( GetExportQName() );
    1292         612 : }
    1293             : 
    1294          16 : void XMLStyleOOoTContext::Characters( const OUString& )
    1295             : {
    1296             :     // element content only:
    1297          16 : }
    1298             : 
    1299           0 : bool XMLStyleOOoTContext::IsPersistent() const
    1300             : {
    1301           0 :     return m_bPersistent;
    1302             : }
    1303             : 
    1304         216 : XMLTransformerActions *XMLStyleOOoTContext::CreateTransformerActions(
    1305             :         sal_uInt16 nType )
    1306             : {
    1307         216 :     XMLTransformerActionInit *pInit = 0;
    1308             : 
    1309         216 :     switch( nType )
    1310             :     {
    1311             :     case PROP_OOO_GRAPHIC_ATTR_ACTIONS:
    1312          36 :         pInit = aGraphicPropertyOOoAttrActionTable;
    1313          36 :         break;
    1314             :     case PROP_OOO_GRAPHIC_ELEM_ACTIONS:
    1315          18 :         pInit = aGraphicPropertyOOoElemActionTable;
    1316          18 :         break;
    1317             :     case PROP_OOO_DRAWING_PAGE_ATTR_ACTIONS:
    1318           0 :         pInit = aDrawingPagePropertyOOoAttrActionTable;
    1319           0 :         break;
    1320             :     case PROP_OOO_PAGE_LAYOUT_ATTR_ACTIONS:
    1321          18 :         pInit = aPageLayoutPropertyOOoAttrActionTable;
    1322          18 :         break;
    1323             :     case PROP_OOO_HEADER_FOOTER_ATTR_ACTIONS:
    1324          10 :         pInit = aHeaderFooterPropertyOOoAttrActionTable;
    1325          10 :         break;
    1326             :     case PROP_OOO_TEXT_ATTR_ACTIONS:
    1327          26 :         pInit = aTextPropertyOOoAttrActionTable;
    1328          26 :         break;
    1329             :     case PROP_OOO_TEXT_ELEM_ACTIONS:
    1330           0 :         pInit = aTextPropertyOOoElemActionTable;
    1331           0 :         break;
    1332             :     case PROP_OOO_PARAGRAPH_ATTR_ACTIONS:
    1333          38 :         pInit = aParagraphPropertyOOoAttrActionTable;
    1334          38 :         break;
    1335             :     case PROP_OOO_PARAGRAPH_ELEM_ACTIONS:
    1336          18 :         pInit = aParagraphPropertyOOoElemActionTable;
    1337          18 :         break;
    1338             :     case PROP_OOO_SECTION_ATTR_ACTIONS:
    1339           0 :         pInit = aSectionPropertyOOoAttrActionTable;
    1340           0 :         break;
    1341             :     case PROP_OOO_TABLE_ATTR_ACTIONS:
    1342          12 :         pInit = aTablePropertyOOoAttrActionTable;
    1343          12 :         break;
    1344             :     case PROP_OOO_TABLE_COLUMN_ATTR_ACTIONS:
    1345          10 :         pInit = aTableColumnPropertyOOoAttrActionTable;
    1346          10 :         break;
    1347             :     case PROP_OOO_TABLE_ROW_ATTR_ACTIONS:
    1348          12 :         pInit = aTableRowPropertyOOoAttrActionTable;
    1349          12 :         break;
    1350             :     case PROP_OOO_TABLE_CELL_ATTR_ACTIONS:
    1351          12 :         pInit = aTableCellPropertyOOoAttrActionTable;
    1352          12 :         break;
    1353             :     case PROP_OOO_TABLE_CELL_ELEM_ACTIONS:
    1354           0 :         pInit = aTableCellPropertyOOoElemActionTable;
    1355           0 :         break;
    1356             :     case PROP_OOO_LIST_LEVEL_ATTR_ACTIONS:
    1357           0 :         pInit = aListLevelPropertyOOoAttrActionTable;
    1358           0 :         break;
    1359             :     case PROP_OOO_CHART_ATTR_ACTIONS:
    1360           6 :         pInit = aChartPropertyOOoAttrActionTable;
    1361           6 :         break;
    1362             :     case PROP_OOO_CHART_ELEM_ACTIONS:
    1363           0 :         pInit = aChartPropertyOOoElemActionTable;
    1364           0 :         break;
    1365             :     }
    1366             : 
    1367         216 :     XMLTransformerActions *pActions = 0;
    1368         216 :     if( pInit )
    1369         216 :         pActions = new XMLTransformerActions( pInit );
    1370             : 
    1371         216 :     return pActions;
    1372             : }
    1373             : 
    1374             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10