rtfimport.h

/*
   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>
   Copyright (C) 2003, 2004 Nicolas GOUTTE <goutte@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.
*/
 
// ### FIXME: copyright holders/date
 
#ifndef __RTFIMPORT_H__
#define __RTFIMPORT_H__
 
#include <KoFilter.h>
#include <tqasciidict.h>
#include <tqcolor.h>
#include <tqcstring.h>
#include <tqfile.h>
#include <tqfont.h>
#include <tqmap.h>
#include <tqstring.h>
#include <tqvaluelist.h>
#include <tqvaluestack.h>
#include <tqtextcodec.h>
#include "rtfimport_dom.h"
#include "rtfimport_tokenizer.h"
#include <tqptrlist.h>
 
 
class DomNode;
class RTFImport;
 

struct RTFProperty
{
    const char *onlyValidIn;
    const char *name;
    void (RTFImport::*cwproc)( struct RTFProperty * );
    int offset;
    int value;
};

struct RTFField
{
    const char *id;
    int     type;
    int     subtype;
    const char *value;
};
 
struct RTFTextState;

struct RTFDestination
{
    const char *group;
    const char *name;
    void (RTFImport::*destproc)( RTFProperty * );
    RTFTextState* target;
};

struct RTFBorder
{
    enum BorderStyle { Solid, Dashes, Dots, DashDot, DashDotDot, None = 16 };
 
    BorderStyle style;
    int color;
    int width;
    int space;
};

struct RTFTab
{
    enum TabType { Left, Centered, FlushRight, Decimal };
    enum LeaderType { None, Dots, Hyphens, Underline, ThickLine };
 
    TabType type;
    LeaderType leader;
    int position;
};

struct RTFFont
{
    TQString name;
    TQFont::StyleHint styleHint;
    int fixedPitch;
    int number;
};

struct RTFPicture
{
    enum PictureType { BMP, WMF, MacPict, EMF, PNG, JPEG };
 
    TQByteArray bits;
    PictureType type;
    int width, height;
    int cropLeft, cropTop, cropRight, cropBottom;
    int desiredWidth, desiredHeight;
    int scalex, scaley;
    int nibble;
    bool scaled;
    TQString identifier;
};

struct RTFLayout
{
    enum Alignment { Left, Right, Justified, Centered };
 
    TQValueStack<RTFTab> tablist;
    RTFTab tab;
    RTFBorder borders[4];
    RTFBorder *border;
    Alignment alignment;
    int style;
    int firstIndent, leftIndent, rightIndent;
    int spaceBefore, spaceAfter;
    int spaceBetween; 
    bool spaceBetweenMultiple; 
    bool inTable;
    bool keep, keepNext;
    bool pageBB, pageBA;
};

struct RTFFormat
{
    enum VertAlign { Normal = 0, SubScript, SuperScript };
    enum Underline { UnderlineNone=0, UnderlineSimple, UnderlineThick, UnderlineDouble, UnderlineWordByWord,
        UnderlineWave, UnderlineDash, UnderlineDot, UnderlineDashDot, UnderlineDashDotDot };
 
    VertAlign vertAlign;
    Underline underline;
    int font, fontSize, baseline;
    int color, bgcolor, underlinecolor;
    int uc;
    bool bold, italic, strike, striked;
    bool hidden, caps, smallCaps;
};

inline bool operator == ( const RTFFormat& f1, const RTFFormat& f2 )
{
    return f1.vertAlign == f2.vertAlign && f1.underline == f2.underline
        && f1.font == f2.font && f1.fontSize == f2.fontSize && f1.baseline == f2.baseline
        && f1.color == f2.color && f1.bgcolor == f2.color && f1.underlinecolor == f2.underlinecolor
        && f1.uc == f2.uc
        && f1.bold == f2.bold && f1.italic == f2.italic && f1.strike == f2.strike && f1.striked == f2.striked
        && f1.hidden == f2.hidden && f1.caps == f2.caps && f1.smallCaps == f2.smallCaps
        ;
}
inline bool operator != ( const RTFFormat& f1, const RTFFormat& f2 )
{
    return ! ( f1 == f2 );
}

struct RTFStyle
{
    TQString name;
    RTFFormat format;
    RTFLayout layout;
    int next;
};

struct RTFSectionLayout
{
    int headerMargin;
    int footerMargin;
    bool titlePage;
};

struct RTFTableCell
{
    RTFBorder borders[4];
    int bgcolor;
    int x;
};

struct RTFTableRow
{
    TQValueList<RTFTableCell> cells;
    TQStringList frameSets;
    RTFLayout::Alignment alignment;
    int height;
    int left;
};

struct KWFormat
{
    RTFFormat fmt;
    TQString xmldata;
    uint id, pos, len;
};

struct RTFTextState
{
    DomNode node;
    DomNode cell;
    DomNode text;
    TQValueList<KWFormat> formats;
    TQStringList frameSets;
    TQValueList<RTFTableRow> rows;
    uint table, length;
};

struct RTFGroupState
{
    RTFTableRow tableRow;
    RTFTableCell tableCell;
    RTFFormat format;
    RTFLayout layout;
    RTFSectionLayout section;
    bool brace0;
    bool ignoreGroup;
};
 
 
class RTFImport : public KoFilter
{
    TQ_OBJECT
  
 
public:
    RTFImport( KoFilter *parent, const char *name, const TQStringList& );

    virtual KoFilter::ConversionStatus convert( const TQCString& from, const TQCString& to );

    void ignoreKeyword( RTFProperty * );
    void setCodepage( RTFProperty * );
    void setMacCodepage( RTFProperty * );
    void setAnsiCodepage( RTFProperty * );
    void setPcaCodepage( RTFProperty * );
    void setPcCodepage( RTFProperty * );
    void setToggleProperty( RTFProperty * );
    void setFlagProperty( RTFProperty *property );
    void setCharset( RTFProperty *property );
    void setNumericProperty( RTFProperty *property );
    void setEnumProperty( RTFProperty *property );
    void setFontStyleHint( RTFProperty* property );
    void setPictureType( RTFProperty* property );
    void setSimpleUnderlineProperty( RTFProperty* );
    void setUnderlineProperty( RTFProperty* property );
    void setBorderProperty( RTFProperty *property );
    void setBorderColor( RTFProperty * );
    void setBorderStyle( RTFProperty *property );
    void setUpProperty( RTFProperty * );
    void setPlainFormatting( RTFProperty * = 0L );
    void setParagraphDefaults( RTFProperty * = 0L );
    void setSectionDefaults( RTFProperty * = 0L );
    void setTableRowDefaults( RTFProperty * = 0L );
    void selectLayoutBorder( RTFProperty * property );
    void selectLayoutBorderFromCell( RTFProperty * property );
    void insertParagraph( RTFProperty * = 0L );
    void insertPageBreak( RTFProperty * );
    void insertTableCell( RTFProperty * );
    void insertTableRow( RTFProperty * = 0L );
    void insertCellDef( RTFProperty * );
    void insertTabDef( RTFProperty * );
    void insertUTF8( int ch );
    void insertSymbol( RTFProperty *property );
    void insertHexSymbol( RTFProperty * );
    void insertUnicodeSymbol( RTFProperty * );
    void insertDateTime( RTFProperty *property );
    void insertPageNumber( RTFProperty * );
    void parseBlipUid( RTFProperty* );
    void parseField( RTFProperty* );
    void parseFldinst( RTFProperty* );
    void parseFldrslt( RTFProperty* );
    void parseFontTable( RTFProperty * );
    void parseFootNote( RTFProperty * );
    void parseStyleSheet( RTFProperty * );
    void parseColorTable( RTFProperty * );
    void parsePicture( RTFProperty * );
    void parseRichText( RTFProperty * );
    void parsePlainText( RTFProperty * );
    void parseGroup( RTFProperty * );
    void skipGroup( RTFProperty * );
    void changeDestination( RTFProperty *property );

    void resetState();
    void addAnchor( const char *instance );
    void addFormat( DomNode &node, const KWFormat& format, const RTFFormat* baseFormat );
    void addLayout( DomNode &node, const TQString &name, const RTFLayout &layout, bool frameBreak );
    void addParagraph( DomNode &node, bool frameBreak );
    void addVariable(const DomNode& spec, int type, const TQString& key, const RTFFormat* fmt=0);
    void addImportedPicture( const TQString& rawFileName );
    void addDateTime( const TQString& format, const bool isDate, RTFFormat& fmt );
    void finishTable();
    void writeOutPart( const char *name, const DomNode &node );
 
 
    RTFTokenizer token;
    DomNode frameSets;
    DomNode pictures;
    DomNode author, company, title, doccomm;
    RTFTextState bodyText;
    TQPtrList<RTFTextState> footnotes; 
    int fnnum; 
    RTFTextState firstPageHeader, oddPagesHeader, evenPagesHeader;
    RTFTextState firstPageFooter, oddPagesFooter, evenPagesFooter;
    RTFTextState m_dummyTextState;
    TQMap<int,TQString> fontTable;
    TQValueList<RTFStyle> styleSheet;
    TQValueList<TQColor> colorTable;
    TQValueStack<RTFGroupState> stateStack;
    TQValueStack<RTFDestination> destinationStack;
    RTFGroupState state;
    RTFDestination destination;
    RTFTextState *textState;
    RTFFont font;
    RTFStyle style;
    RTFPicture picture;
    RTFTableCell emptyCell;
    KWFormat kwFormat;
    TQAsciiDict<RTFProperty> properties;
    TQAsciiDict<RTFProperty> destinationProperties;
    uint table;
    uint pictureNumber; 
 
    // Color table and document-formatting properties
    int red, green, blue;
    int paperWidth, paperHeight;
    int leftMargin, topMargin, rightMargin, bottomMargin;
    int defaultTab, defaultFont;
    bool landscape, facingPages;
 
    // Field support
    TQCString fldinst, fldrslt;
    RTFFormat fldfmt;
    int flddst; 
    TQString inFileName; 
protected:
    TQTextCodec* textCodec; 
    TQTextCodec* utf8TextCodec; 
    TQMap<TQString,int> debugUnknownKeywords;
    bool m_batch; 
};
 
#endif