oox/source/core/fragmenthandler2.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 <oox/core/fragmenthandler2.hxx>
  21 #include <oox/core/xmlfilterbase.hxx>
  22 #include <oox/helper/attributelist.hxx>
  23 #include <oox/token/namespaces.hxx>
  24 #include <oox/token/tokens.hxx>
  25
  26 namespace oox {
  27 namespace core {
  28
  29 using namespace ::com::sun::star::uno;
  30 using namespace ::com::sun::star::xml::sax;
  31
  32 using ::com::sun::star::uno::Sequence;
  33
  34 FragmentHandler2::FragmentHandler2( XmlFilterBase& rFilter, const OUString& rFragmentPath, bool bEnableTrimSpace ) :
  35     FragmentHandler( rFilter, rFragmentPath ),
  36     ContextHandler2Helper( bEnableTrimSpace )
  37 {
  38 }
  39
  40 FragmentHandler2::~FragmentHandler2()
  41 {
  42 }
  43
  44 // com.sun.star.xml.sax.XFastDocumentHandler interface --------------------
  45
  46 void SAL_CALL FragmentHandler2::startDocument()
  47 {
  48     initializeImport();
  49 }
  50
  51 void SAL_CALL FragmentHandler2::endDocument()
  52 {
  53     finalizeImport();
  54 }
  55
  56 bool FragmentHandler2::prepareMceContext( sal_Int32 nElement, const AttributeList& rAttribs )
  57 {
  58     switch( nElement )
  59     {
  60         case MCE_TOKEN( AlternateContent ):
  61             aMceState.push_back( MCE_STATE::Started );
  62             break;
  63
  64         case MCE_TOKEN( Choice ):
  65             {
  66                 if (aMceState.empty() || aMceState.back() != MCE_STATE::Started)
  67                     return false;
  68
  69                 OUString aRequires = rAttribs.getString( XML_Requires, "none" );
  70
  71                 // At this point we can't access namespaces as the correct xml filter
  72                 // is long gone. For now let's decide depending on a list of supported
  73                 // namespaces like we do in writerfilter
  74
  75                 static std::vector<OUString> aSupportedNS =
  76                 {
  77                     "p14",
  78                     "p15",
  79                     "x12ac",
  80                     "v",
  81                 };
  82
  83                 if (std::find(aSupportedNS.begin(), aSupportedNS.end(), aRequires) != aSupportedNS.end())
  84                     aMceState.back() = MCE_STATE::FoundChoice;
  85                 else
  86                     return false;
  87             }
  88             break;
  89
  90         case MCE_TOKEN( Fallback ):
  91             if( !aMceState.empty() && aMceState.back() == MCE_STATE::Started )
  92                 break;
  93             return false;
  94         default:
  95             {
  96                 OUString str = rAttribs.getString( MCE_TOKEN( Ignorable ), OUString() );
  97                 if( !str.isEmpty() )
  98                 {
  99                     // Sequence< css::xml::FastAttribute > attrs = rAttribs.getFastAttributeList()->getFastAttributes();
 100                     // printf("MCE: %s\n", OUStringToOString( str, RTL_TEXTENCODING_UTF8 ).getStr() );
 101                     // TODO: Check & Get the namespaces in "Ignorable"
 102                     // printf("NS: %d : %s\n", attrs.getLength(), OUStringToOString( str, RTL_TEXTENCODING_UTF8 ).getStr() );
 103                 }
 104             }
 105             return false;
 106     }
 107     return true;
 108 }
 109
 110 // com.sun.star.xml.sax.XFastContextHandler interface -------------------------
 111
 112 Reference< XFastContextHandler > SAL_CALL FragmentHandler2::createFastChildContext(
 113         sal_Int32 nElement, const Reference< XFastAttributeList >& rxAttribs )
 114 {
 115     if( getNamespace( nElement ) == NMSP_mce ) // TODO for checking 'Ignorable'
 116     {
 117         if( prepareMceContext( nElement, AttributeList( rxAttribs ) ) )
 118             return getFastContextHandler();
 119         return nullptr;
 120     }
 121     return implCreateChildContext( nElement, rxAttribs );
 122 }
 123
 124 void SAL_CALL FragmentHandler2::startFastElement(
 125         sal_Int32 nElement, const Reference< XFastAttributeList >& rxAttribs )
 126 {
 127     implStartElement( nElement, rxAttribs );
 128 }
 129
 130 void SAL_CALL FragmentHandler2::characters( const OUString& rChars )
 131 {
 132     implCharacters( rChars );
 133 }
 134
 135 void SAL_CALL FragmentHandler2::endFastElement( sal_Int32 nElement )
 136 {
 137     /* If MCE */
 138     switch( nElement )
 139     {
 140         case MCE_TOKEN( AlternateContent ):
 141             aMceState.pop_back();
 142             break;
 143     }
 144
 145     implEndElement( nElement );
 146 }
 147
 148 // oox.core.ContextHandler interface ------------------------------------------
 149
 150 ContextHandlerRef FragmentHandler2::createRecordContext( sal_Int32 nRecId, SequenceInputStream& rStrm )
 151 {
 152     return implCreateRecordContext( nRecId, rStrm );
 153 }
 154
 155 void FragmentHandler2::startRecord( sal_Int32 nRecId, SequenceInputStream& rStrm )
 156 {
 157     implStartRecord( nRecId, rStrm );
 158 }
 159
 160 void FragmentHandler2::endRecord( sal_Int32 nRecId )
 161 {
 162     implEndRecord( nRecId );
 163 }
 164
 165 // oox.core.ContextHandler2Helper interface -----------------------------------
 166
 167 ContextHandlerRef FragmentHandler2::onCreateContext( sal_Int32, const AttributeList& )
 168 {
 169     return nullptr;
 170 }
 171
 172 void FragmentHandler2::onStartElement( const AttributeList& )
 173 {
 174 }
 175
 176 void FragmentHandler2::onCharacters( const OUString& )
 177 {
 178 }
 179
 180 void FragmentHandler2::onEndElement()
 181 {
 182 }
 183
 184 ContextHandlerRef FragmentHandler2::onCreateRecordContext( sal_Int32, SequenceInputStream& )
 185 {
 186     return nullptr;
 187 }
 188
 189 void FragmentHandler2::onStartRecord( SequenceInputStream& )
 190 {
 191 }
 192
 193 void FragmentHandler2::onEndRecord()
 194 {
 195 }
 196
 197 // oox.core.FragmentHandler2 interface ----------------------------------------
 198
 199 void FragmentHandler2::initializeImport()
 200 {
 201 }
 202
 203 void FragmentHandler2::finalizeImport()
 204 {
 205 }
 206
 207 } // namespace core
 208 } // namespace oox
 209
 210 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */