KoXmlWriter.h

/* This file is part of the KDE project
   Copyright (C) 2004 David Faure <faure@kde.org>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/
 
#ifndef XMLWRITER_H
#define XMLWRITER_H
 
#include <tqstring.h>
#include <tqvaluestack.h>
#include <tqmap.h>
#include <koffice_export.h>
 
class TQIODevice;

class KOSTORE_EXPORT KoXmlWriter
{
public:
    KoXmlWriter( TQIODevice* dev, int indentLevel = 0 );

    ~KoXmlWriter();
 
    TQIODevice *device() const { return m_dev; }

    void startDocument( const char* rootElemName, const char* publicId = 0, const char* systemId = 0 );

    void endDocument();

    void startElement( const char* tagName, bool indentInside = true );

    inline void addAttribute( const char* attrName, const TQString& value ) {
        addAttribute( attrName, value.utf8() );
    }

    inline void addAttribute( const char* attrName, int value ) {
        TQCString str;
        str.setNum( value );
        addAttribute( attrName, str.data() );
    }

    inline void addAttribute( const char* attrName, uint value ) {
        TQCString str;
        str.setNum( value );
        addAttribute( attrName, str.data() );
    }

    void addAttribute( const char* attrName, double value );
    void addAttributePt( const char* attrName, double value );

    inline void addAttribute( const char* attrName, const TQCString& value ) {
        addAttribute( attrName, value.data() );
    }

    void addAttribute( const char* attrName, const char* value );
    void endElement();
    inline void addTextNode( const TQString& str ) {
        addTextNode( str.utf8() );
    }

    inline void addTextNode( const TQCString& cstr ) {
        addTextNode( cstr.data() );
    }

    void addTextNode( const char* cstr );

    void addProcessingInstruction( const char* cstr );

    void addCompleteElement( const char* cstr );

    void addCompleteElement( TQIODevice* dev );
 
    // #### Maybe we want to subclass KoXmlWriter for manifest files.
    void addManifestEntry( const TQString& fullPath, const TQString& mediaType );

    void addConfigItem( const TQString & configName, const TQString& value );
    void addConfigItem( const TQString & configName, bool value );
    void addConfigItem( const TQString & configName, int value );
    void addConfigItem( const TQString & configName, double value );
    void addConfigItem( const TQString & configName, long value );
    void addConfigItem( const TQString & configName, short value );
 
    // TODO addConfigItem for datetime and base64Binary

    void addTextSpan( const TQString& text );
    void addTextSpan( const TQString& text, const TQMap<int, int>& tabCache );

    int indentLevel() const { return m_tags.size() + m_baseIndentLevel; }
 
private:
    struct Tag {
        Tag( const char* t = 0, bool ind = true )
            : tagName( t ), hasChildren( false ), lastChildIsText( false ),
              openingTagClosed( false ), indentInside( ind ) {}
        const char* tagName;
        bool hasChildren; 
        bool lastChildIsText; 
        bool openingTagClosed; 
        bool indentInside; 
    };

    void writeIndent();
 
    // writeCString is much faster than writeString.
    // Try to use it as much as possible, especially with constants.
    void writeString( const TQString& str );
 
    // unused and possibly incorrect if length != size
    //inline void writeCString( const TQCString& cstr ) {
    //    m_dev->writeBlock( cstr.data(), cstr.size() - 1 );
    //}
 
    inline void writeCString( const char* cstr ) {
        m_dev->writeBlock( cstr, tqstrlen( cstr ) );
    }
    inline void writeChar( char c ) {
        m_dev->putch( c );
    }
    inline void closeStartElement( Tag& tag ) {
        if ( !tag.openingTagClosed ) {
            tag.openingTagClosed = true;
            writeChar( '>' );
        }
    }
    char* escapeForXML( const char* source, int length ) const;
    bool prepareForChild();
    void prepareForTextNode();
    void init();
 
    TQIODevice* m_dev;
    TQValueStack<Tag> m_tags;
    int m_baseIndentLevel;
 
    class Private;
    Private *d;
 
    char* m_indentBuffer; // maybe make it static, but then it needs a KStaticDeleter,
                          // and would eat 1K all the time... Maybe refcount it :)
    char* m_escapeBuffer; // can't really be static if we want to be thread-safe
    static const int s_escapeBufferLen = 10000;
 
    KoXmlWriter( const KoXmlWriter & ); // forbidden
    KoXmlWriter& operator=( const KoXmlWriter & ); // forbidden
};
 
#endif /* XMLWRITER_H */