shell/source/win32/ooofilereader/contentreader.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 #undef OSL_DEBUG_LEVEL
  21
  22
  23 #include <osl/diagnose.h>
  24
  25 #include "internal/contentreader.hxx"
  26 #include "dummytag.hxx"
  27 #include "simpletag.hxx"
  28 #include "autostyletag.hxx"
  29
  30 #include "assert.h"
  31
  32 /** constructor.
  33 */
  34 CContentReader::CContentReader( const std::string& DocumentName, LocaleSet_t const & DocumentLocale ):
  35 CBaseReader( DocumentName )
  36 {
  37     try
  38     {
  39         m_DefaultLocale = DocumentLocale;
  40         Initialize( DOC_CONTENT_NAME );
  41     }
  42     catch(xml_parser_exception&
  43     #if OSL_DEBUG_LEVEL > 0
  44     ex
  45     #endif
  46     )
  47     {
  48         OSL_ENSURE(false, ex.what());
  49     }
  50     catch(...)
  51     {
  52         OSL_ENSURE(false, "Unknown error");
  53     }
  54 }
  55
  56 CContentReader::CContentReader( StreamInterface* stream, LocaleSet_t const & DocumentLocale ) :
  57 CBaseReader( stream )
  58 {
  59 try
  60     {
  61         m_DefaultLocale = DocumentLocale;
  62         Initialize( DOC_CONTENT_NAME );
  63     }
  64     catch(xml_parser_exception&
  65     #if OSL_DEBUG_LEVEL > 0
  66     ex
  67     #endif
  68     )
  69     {
  70         OSL_ENSURE(false, ex.what());
  71     }
  72     catch(...)
  73     {
  74         OSL_ENSURE(false, "Unknown error");
  75     }
  76 }
  77
  78
  79 /** destructor.
  80 */
  81
  82 CContentReader::~CContentReader()
  83 {
  84 }
  85
  86 /***********************   helper functions  ***********************/
  87
  88 /** choose an appropriate tag reader
  89 */
  90
  91 ITag* CContentReader::chooseTagReader( const std::wstring& tag_name, const XmlTagAttributes_t& XmlAttributes )
  92 {
  93     if (( tag_name == CONTENT_TEXT_A )||( tag_name == CONTENT_TEXT_P )||
  94         ( tag_name == CONTENT_TEXT_SPAN ) ||( tag_name == CONTENT_TEXT_H )||
  95         ( tag_name == CONTENT_TEXT_SEQUENCE ) ||( tag_name == CONTENT_TEXT_BOOKMARK_REF )||
  96         ( tag_name == CONTENT_TEXT_INDEX_TITLE_TEMPLATE ) )
  97         return new CSimpleTag(XmlAttributes);
  98     else if ( tag_name == CONTENT_STYLE_STYLE )
  99     {
 100         // if style:style | style:name is exist,, fill the style field, otherwise do nothing;
 101         if  ( XmlAttributes.find(CONTENT_STYLE_STYLE_NAME) != XmlAttributes.end())
 102             return new CAutoStyleTag(XmlAttributes);
 103        else
 104             return new CDummyTag();
 105     }
 106     else if ( ( tag_name == CONTENT_STYLE_PROPERTIES ) || ( tag_name == CONTENT_TEXT_STYLE_PROPERTIES ) )
 107     {
 108         assert( !m_TagBuilderStack.empty() );
 109
 110         //here we presume that if CONTENT_STYLE_PROPERTIES tag is present, it just follow CONTENT_STYLE_STYLE;
 111         ITag* pTagBuilder = m_TagBuilderStack.top();
 112         pTagBuilder->addAttributes( XmlAttributes );
 113
 114         return new CDummyTag();
 115     }
 116     else
 117         return new CDummyTag();
 118 }
 119
 120 /** get style of the current content.
 121 */
 122 ::std::wstring CContentReader::getCurrentContentStyle()
 123 {
 124     assert( !m_TagBuilderStack.empty() );
 125     ITag* pTagBuilder = m_TagBuilderStack.top();
 126
 127     return ( pTagBuilder->getTagAttribute(CONTENT_TEXT_STYLENAME) );
 128 }
 129
 130 /** add chunk into Chunk Buffer.
 131 */
 132 void CContentReader::addChunk( LocaleSet_t const & Locale, Content_t const & Content )
 133 {
 134     if ( Content == EMPTY_STRING )
 135         return;
 136
 137     if ( ( ( m_ChunkBuffer.empty() ) || ( m_ChunkBuffer.back().first != Locale ) ) &&
 138          ( ( Content != SPACE )  && ( Content != LF ) ) )
 139     {
 140         // if met a new locale, add a blank new chunk;
 141         Chunk_t Chunk;
 142         Chunk.first = Locale;
 143         Chunk.second = EMPTY_STRING;
 144         m_ChunkBuffer.push_back( Chunk );
 145     }
 146
 147     if ( !m_ChunkBuffer.empty() )
 148         m_ChunkBuffer.back().second += Content;
 149 }
 150
 151 /** get a style's locale field.
 152 */
 153
 154 LocaleSet_t const & CContentReader::getLocale( const StyleName_t& Style )
 155 {
 156     if ( m_StyleMap.empty() )
 157         return m_DefaultLocale;
 158
 159     StyleLocaleMap_t :: const_iterator style_Iter;
 160
 161     if ( ( style_Iter = m_StyleMap.find( Style ) ) == m_StyleMap.end( ) )
 162         return m_DefaultLocale;
 163     else
 164         return style_Iter->second;
 165
 166 }
 167
 168 /***********************   event handler functions  ***********************/
 169
 170
 171 // start_element occurs when a tag is start
 172
 173
 174 void CContentReader::start_element(
 175     const std::wstring& /*raw_name*/,
 176     const std::wstring& local_name,
 177     const XmlTagAttributes_t& attributes)
 178 {
 179     //get appropriate Xml Tag Builder using MetaInfoBuilderFactory;
 180     ITag* pTagBuilder = chooseTagReader( local_name,attributes );
 181     assert( pTagBuilder != NULL );
 182     pTagBuilder->startTag( );
 183     m_TagBuilderStack.push( pTagBuilder );
 184
 185 }
 186
 187
 188 // end_element occurs when a tag is closed
 189
 190
 191 void CContentReader::end_element(const std::wstring& /*raw_name*/, const std::wstring& local_name)
 192 {
 193     assert( !m_TagBuilderStack.empty() );
 194     ITag* pTagBuilder = m_TagBuilderStack.top();
 195
 196     if ( local_name == CONTENT_STYLE_STYLE )
 197     {
 198         StyleLocalePair_t StyleLocalePair = static_cast<CAutoStyleTag * >( pTagBuilder)->getStyleLocalePair();
 199         if ( ( static_cast<CAutoStyleTag * >( pTagBuilder)->isFull() ) && ( StyleLocalePair.second != m_DefaultLocale ) )
 200                 m_StyleMap.insert( StyleLocalePair );
 201     }
 202     if (( local_name == CONTENT_TEXT_A )||( local_name == CONTENT_TEXT_SPAN ) ||
 203         ( local_name == CONTENT_TEXT_SEQUENCE )||( local_name == CONTENT_TEXT_BOOKMARK_REF ))
 204         addChunk( getLocale( getCurrentContentStyle() ), ::std::wstring( SPACE ) );
 205     if ((( local_name == CONTENT_TEXT_P )||( local_name == CONTENT_TEXT_H ) ||
 206          ( local_name == CONTENT_TEXT_INDEX_TITLE_TEMPLATE ) )&&
 207         ( EMPTY_STRING != pTagBuilder->getTagContent( ) ) )
 208         addChunk( getLocale( getCurrentContentStyle() ), ::std::wstring( LF ) );
 209
 210     m_TagBuilderStack.pop();
 211     pTagBuilder->endTag();
 212     delete pTagBuilder;
 213
 214 }
 215
 216
 217 // characters occurs when receiving characters
 218
 219
 220 void CContentReader::characters( const std::wstring& character )
 221 {
 222     if ( character.length() > 0 && !HasOnlySpaces( character ) )
 223     {
 224         addChunk( getLocale( getCurrentContentStyle() ), ::std::wstring( character ) );
 225
 226         ITag* pTagBuilder = m_TagBuilderStack.top();
 227         pTagBuilder->addCharacters( character );
 228     }
 229 }
 230
 231 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */