xmloff/source/transform/EventOOoTContext.cxx

   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 "EventOOoTContext.hxx"
  21 #include "EventMap.hxx"
  22 #include "MutableAttrList.hxx"
  23 #include <xmloff/xmlnmspe.hxx>
  24 #include "ActionMapTypesOOo.hxx"
  25 #include "AttrTransformerAction.hxx"
  26 #include "TransformerActions.hxx"
  27 #include "TransformerBase.hxx"
  28 #include <rtl/ustrbuf.hxx>
  29 #include <osl/diagnose.h>
  30
  31 #include <unordered_map>
  32
  33 using namespace ::com::sun::star::uno;
  34 using namespace ::com::sun::star::xml::sax;
  35 using namespace ::xmloff::token;
  36
  37 class XMLTransformerOOoEventMap_Impl:
  38     public std::unordered_map< OUString, NameKey_Impl, OUStringHash >
  39 {
  40 public:
  41
  42     void AddMap( XMLTransformerEventMapEntry *pInit );
  43
  44     XMLTransformerOOoEventMap_Impl( XMLTransformerEventMapEntry *pInit,
  45                                        XMLTransformerEventMapEntry *pInit2  );
  46     ~XMLTransformerOOoEventMap_Impl();
  47 };
  48
  49 void XMLTransformerOOoEventMap_Impl::AddMap( XMLTransformerEventMapEntry *pInit )
  50 {
  51     XMLTransformerOOoEventMap_Impl::key_type aKey;
  52     XMLTransformerOOoEventMap_Impl::mapped_type aData;
  53     while( pInit->m_pOOoName )
  54     {
  55         aKey = OUString::createFromAscii(pInit->m_pOOoName);
  56
  57         OSL_ENSURE( find( aKey ) == end(), "duplicate event map entry" );
  58
  59         aData.m_nPrefix = pInit->m_nOASISPrefix;
  60         aData.m_aLocalName = OUString::createFromAscii(pInit->m_pOASISName);
  61
  62         XMLTransformerOOoEventMap_Impl::value_type aVal( aKey, aData );
  63
  64         if( !insert( aVal ).second )
  65         {
  66             OSL_FAIL( "duplicate OOo event name extry" );
  67         }
  68
  69         ++pInit;
  70     }
  71 }
  72
  73 XMLTransformerOOoEventMap_Impl::XMLTransformerOOoEventMap_Impl(
  74         XMLTransformerEventMapEntry *pInit,
  75         XMLTransformerEventMapEntry *pInit2 )
  76 {
  77     if( pInit )
  78         AddMap( pInit );
  79     if( pInit2 )
  80         AddMap( pInit2 );
  81 }
  82
  83 XMLTransformerOOoEventMap_Impl::~XMLTransformerOOoEventMap_Impl()
  84 {
  85 }
  86
  87 TYPEINIT1( XMLEventOOoTransformerContext, XMLPersElemContentTContext );
  88
  89 XMLEventOOoTransformerContext::XMLEventOOoTransformerContext(
  90         XMLTransformerBase& rImp,
  91         const OUString& rQName,
  92         bool bPersistent ) :
  93     XMLPersElemContentTContext( rImp, rQName,
  94         rImp.GetNamespaceMap().GetKeyByAttrName( rQName ), XML_EVENT_LISTENER ),
  95     m_bPersistent( bPersistent )
  96 {
  97 }
  98
  99 XMLEventOOoTransformerContext::~XMLEventOOoTransformerContext()
 100 {
 101 }
 102
 103 XMLTransformerOOoEventMap_Impl
 104     *XMLEventOOoTransformerContext::CreateEventMap()
 105 {
 106     return new XMLTransformerOOoEventMap_Impl( aTransformerEventMap,
 107                                                   aFormTransformerEventMap );
 108 }
 109
 110 void XMLEventOOoTransformerContext::FlushEventMap(
 111         XMLTransformerOOoEventMap_Impl *p )
 112 {
 113     delete p;
 114 }
 115
 116 sal_uInt16 XMLEventOOoTransformerContext::GetEventName(
 117         const OUString& rName,
 118         OUString& rNewName,
 119            XMLTransformerOOoEventMap_Impl& rMap )
 120 {
 121     XMLTransformerOOoEventMap_Impl::key_type aKey( rName );
 122     XMLTransformerOOoEventMap_Impl::const_iterator aIter = rMap.find( aKey );
 123     if( aIter == rMap.end() )
 124     {
 125         rNewName = rName;
 126         return XML_NAMESPACE_UNKNOWN;
 127     }
 128     else
 129     {
 130         rNewName = (*aIter).second.m_aLocalName;
 131         return (*aIter).second.m_nPrefix;
 132     }
 133 }
 134
 135 void XMLEventOOoTransformerContext::StartElement(
 136     const Reference< XAttributeList >& rAttrList )
 137 {
 138     XMLTransformerActions *pActions =
 139         GetTransformer().GetUserDefinedActions( OOO_EVENT_ACTIONS );
 140     OSL_ENSURE( pActions, "go no actions" );
 141
 142     OUString aLocation, aMacroName;
 143     sal_Int16 nMacroName = -1;
 144     Reference< XAttributeList > xAttrList( rAttrList );
 145     XMLMutableAttributeList *pMutableAttrList = 0;
 146     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
 147     for( sal_Int16 i=0; i < nAttrCount; i++ )
 148     {
 149         const OUString& rAttrName = xAttrList->getNameByIndex( i );
 150         OUString aLocalName;
 151         sal_uInt16 nPrefix =
 152             GetTransformer().GetNamespaceMap().GetKeyByAttrName( rAttrName,
 153                                                                  &aLocalName );
 154         XMLTransformerActions::key_type aKey( nPrefix, aLocalName );
 155         XMLTransformerActions::const_iterator aIter =
 156             pActions->find( aKey );
 157         if( !(aIter == pActions->end() ) )
 158         {
 159             if( !pMutableAttrList )
 160             {
 161                 pMutableAttrList =
 162                         new XMLMutableAttributeList( xAttrList );
 163                 xAttrList = pMutableAttrList;
 164             }
 165             const OUString& rAttrValue = xAttrList->getValueByIndex( i );
 166             switch( (*aIter).second.m_nActionType )
 167             {
 168             case XML_ATACTION_HREF:
 169                 // TODO
 170                 break;
 171             case XML_ATACTION_EVENT_NAME:
 172                 pMutableAttrList->SetValueByIndex( i,
 173                                GetTransformer().GetEventName( rAttrValue ) );
 174                 break;
 175             case XML_ATACTION_ADD_NAMESPACE_PREFIX:
 176                 {
 177                     OUString aAttrValue( rAttrValue );
 178                     sal_uInt16 nValPrefix =
 179                         static_cast<sal_uInt16>((*aIter).second.m_nParam1);
 180                     if( GetTransformer().AddNamespacePrefix( aAttrValue,
 181                                                              nValPrefix ) )
 182                         pMutableAttrList->SetValueByIndex( i, aAttrValue );
 183                 }
 184                 break;
 185             case XML_ATACTION_MACRO_LOCATION:
 186                 aLocation = rAttrValue;
 187                 pMutableAttrList->RemoveAttributeByIndex( i );
 188                 --i;
 189                 --nAttrCount;
 190                 break;
 191             case XML_ATACTION_MACRO_NAME:
 192                 aMacroName = rAttrValue;
 193                 nMacroName = i;
 194                 break;
 195             case XML_ATACTION_COPY:
 196                 break;
 197             default:
 198                 OSL_ENSURE( false, "unknown action" );
 199                 break;
 200             }
 201         }
 202     }
 203
 204     if( nMacroName != -1 && !aLocation.isEmpty() )
 205     {
 206         if( !IsXMLToken( aLocation, XML_APPLICATION ) )
 207             aLocation = GetXMLToken( XML_DOCUMENT );
 208         OUStringBuffer sTmp( aLocation.getLength() + aMacroName.getLength() + 1 );
 209         sTmp = aLocation;
 210         sTmp.append( ':' );
 211         sTmp.append( aMacroName );
 212         pMutableAttrList->SetValueByIndex( nMacroName,
 213                                            sTmp.makeStringAndClear() );
 214     }
 215
 216     if( m_bPersistent )
 217         XMLPersElemContentTContext::StartElement( xAttrList );
 218     else
 219         GetTransformer().GetDocHandler()->startElement( GetExportQName(),
 220                                                         xAttrList );
 221 }
 222
 223 void XMLEventOOoTransformerContext::EndElement()
 224 {
 225     if( m_bPersistent )
 226         XMLPersElemContentTContext::EndElement();
 227     else
 228         GetTransformer().GetDocHandler()->endElement( GetExportQName() );
 229 }
 230
 231 XMLTransformerContext * XMLEventOOoTransformerContext::CreateChildContext(
 232                             sal_uInt16 nPrefix,
 233                             const OUString& rLocalName,
 234                             const OUString& rQName,
 235                             const Reference< XAttributeList >& xAttrList )
 236 {
 237     if( m_bPersistent )
 238         return XMLPersElemContentTContext::CreateChildContext(nPrefix, rLocalName, rQName, xAttrList);
 239     else
 240         return XMLTransformerContext::CreateChildContext(nPrefix, rLocalName, rQName, xAttrList);
 241 }
 242
 243 bool XMLEventOOoTransformerContext::IsPersistent() const
 244 {
 245     return m_bPersistent;
 246 }
 247
 248 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */