rtfimport_dom.cpp

/*
   This file is part of the KDE project
   Copyright (C) 2001 Ewald Snel <ewald@rambo.its.tudelft.nl>
   Copyright (C) 2001 Tomasz Grobelny <grotk@poczta.onet.pl>
 
   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.
*/
 
#include <stdio.h>
 
#include <tqdatetime.h>
#include <tqtextcodec.h>
#include <tqcolor.h>
 
#include <kdebug.h>
 
#include "rtfimport_dom.h"

TQString CheckAndEscapeXmlText(const TQString& strText)
{
    TQString strReturn(strText);
    TQChar ch;
 
    for (uint i=0; i<strReturn.length(); i++)
    {
        ch = strReturn[i];
        const int test = ch.unicode();
 
        // The i+= is for the additional characters
        if (test == 38) { strReturn.replace(i, 1, "&amp;"); i+=4; } // &
        else if (test == 60) { strReturn.replace(i, 1, "&lt;"); i+=3; } // <
        else if (test == 62) { strReturn.replace(i, 1, "&gt;"); i+=3; } // >
        else if (test == 34) { strReturn.replace(i, 1, "&quot;"); i+=5; } // "
        else if (test == 39) { strReturn.replace(i, 1, "&apos;"); i+=5; } // '
        else if (test >= 32) continue; // Normal character (from space on)
        else if ((test == 9) || (test == 10) || (test == 13) ) continue; // Allowed control characters: TAB, LF, CR
        else
        {
            // An unallowed control character:
            // - could be a bug in the RTF file
            // - could be not supported encoding.
            // In any case, we must replace this character.
            kdDebug(30515) << "Control character in XML stream: " << test << endl;
            strReturn.replace(i, 1, '?'); // Replacement character
        }
    }
 
    return strReturn;
}
 
 
DomNode::DomNode()
{
    clear(0);
}

DomNode::DomNode( const char *doctype )
{
    documentLevel   = 1;
    hasChildren     = false;
    hasAttributes   = false;
    str += "<?xml version = '1.0' encoding = 'UTF-8'?><!DOCTYPE " ;
    str += doctype;
    str += " >\n<";
    str += doctype;
}

void DomNode::clear( int level )
{
    str = TQString();
    documentLevel   = level;
    hasChildren     = true;
    hasAttributes   = false;
}

void DomNode::addNode( const char *name )
{
    closeTag( true );
    str += " <";
    str += name;
    hasChildren = false;
    ++documentLevel;
}

void DomNode::addTextNode( const char *text, TQTextCodec* codec )
{
    closeTag( false );
 
    if (!codec)
    {
        kdError(30515) << "No TQTextCodec available!" << endl;
        return;
    }
 
    str += CheckAndEscapeXmlText(codec->toUnicode(text));
 
}

void DomNode::addBorder( int id, const TQColor &color, int style, double width )
{
    char attr[16];
    sprintf( attr, "%cRed", id );
    setAttribute( attr, color.red() );
    sprintf( attr, "%cGreen", id );
    setAttribute( attr, color.green() );
    sprintf( attr, "%cBlue", id );
    setAttribute( attr, color.blue() );
    sprintf( attr, "%cStyle", id );
    setAttribute( attr, style );
    sprintf( attr, "%cWidth", id );
    setAttribute( attr, width );
}

void DomNode::addColor( const TQColor &color )
{
    setAttribute( "red", color.red() );
    setAttribute( "green", color.green() );
    setAttribute( "blue", color.blue() );
}

void DomNode::addRect( int left, int top, int right, int bottom )
{
    setAttribute( "left", .05*left );
    setAttribute( "top", .05*top );
    setAttribute( "right", .05*right );
    setAttribute( "bottom", .05*bottom );
}

void DomNode::addKey( const TQDateTime& dt, const TQString& filename, const TQString& name )
{
    const TQDate date ( dt.date() );
    const TQTime time ( dt.time() );
 
    addNode( "KEY" );
    setAttribute( "filename", CheckAndEscapeXmlText(filename) );
    setAttribute( "year", date.year() );
    setAttribute( "month", date.month() );
    setAttribute( "day", date.day() );
    setAttribute( "hour", time.hour() );
    setAttribute( "minute", time.minute() );
    setAttribute( "second", time.second() );
    setAttribute( "msec", time.msec() );
 
    if (!name.isEmpty())
    {
        setAttribute( "name", CheckAndEscapeXmlText(name) );
    }
    closeNode( "KEY" );
}

void DomNode::addFrameSet( const char *name, int frameType, int frameInfo )
{
    addNode( "FRAMESET" );
    setAttribute( "name", name );
    setAttribute( "frameType", frameType );
    setAttribute( "frameInfo", frameInfo );
    setAttribute( "removable", 0 );
    setAttribute( "visible", 1 );
}

void DomNode::addFrame( int left, int top, int right, int bottom,
            int autoCreateNewFrame, int newFrameBehaviour,
            int sheetSide )
{
    addNode( "FRAME" );
    addRect( left, top, right, bottom );
    setAttribute( "runaround", 1 );
    setAttribute( "runaroundGap", 2 );
    setAttribute( "autoCreateNewFrame", autoCreateNewFrame );
    setAttribute( "newFrameBehaviour", newFrameBehaviour );
    setAttribute( "sheetSide", sheetSide );
}

void DomNode::setAttribute( const TQString& attribute, const TQString& value )
{
    str += ' ';
    str += attribute;
    str += '=';
    str += '"';
    str += CheckAndEscapeXmlText( value );
    str += '"';
    hasAttributes = true;
}

void DomNode::setAttribute( const char *attribute, int value )
{
    char strvalue[32];
    sprintf( strvalue, "%d", value );
    setAttribute( attribute, (const char *)strvalue );
}

void DomNode::setAttribute( const char *attribute, double value )
{
    char strvalue[32];
    sprintf( strvalue, "%f", value );
    setAttribute( attribute, (const char *)strvalue );
}

void DomNode::closeNode( const char *name )
{
    if (!hasChildren)
    {
        str += '/';
    }
    else
    {
        str += "</";
        str += name;
    }
    str += ">\n";
 
    --documentLevel;
    for (int i=documentLevel-1; i>0; i--)
    {
        str += ' ';
    }
    hasChildren = true;
}

void DomNode::closeTag( bool nl )
{
    if (!hasChildren)
    {
        str += '>';
 
        if (nl)
        {
            str += '\n';
 
            for (int i=documentLevel-1; i>0; i--)
            {
                str += ' ';
            }
        }
        hasChildren = true;
    }
    hasAttributes = false;
}

void DomNode::appendNode( const DomNode &child )
{
    const TQString childStr ( child.toString() );
    closeTag( (childStr.length() >= 2 && (childStr[0] == '<' || childStr[1] == '<')) );
    str += childStr;
}

void DomNode::append( const TQString& _str)
{
    str += _str;
}
 
void DomNode::append( const TQCString& cstr)
{
    str += TQString::fromUtf8(cstr);
}
 
void DomNode::append( const char ch)
{
    str += ch;
}

bool DomNode::isEmpty( void ) const
{
    return str.isEmpty();
}

TQString DomNode::toString( void ) const
{
    return str;
}