KoGenStyles.h

/* This file is part of the KDE project
   Copyright (C) 2004-2006 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 version 2 as published by the Free Software Foundation.
 
   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 KOGENSTYLES_H
#define KOGENSTYLES_H
 
#include <tqdict.h>
#include <tqmap.h>
#include <tqvaluevector.h>
 
#include <koffice_export.h>
 
class KoXmlWriter;
class KoGenStyle;

class KOFFICECORE_EXPORT KoGenStyles
{
public:
    KoGenStyles();
    ~KoGenStyles();

    enum Flags { // bitfield
        NoFlag = 0,
        ForceNumbering = 0, // it's the default anyway
        DontForceNumbering = 1
    };
    // KDE4 TODO: use TQFlags and change the arg type in lookup

    TQString lookup( const KoGenStyle& style, const TQString& name = TQString(), int flags = NoFlag );
 
    typedef TQMap<KoGenStyle, TQString> StyleMap;
    const StyleMap& styles() const { return m_styleMap; }
 
    struct NamedStyle {
        const KoGenStyle* style; 
        TQString name;
    };
    TQValueList<NamedStyle> styles( int type, bool markedForStylesXml = false ) const;

    const KoGenStyle* style( const TQString& name ) const;

    KoGenStyle* styleForModification( const TQString& name );

    void markStyleForStylesXml( const TQString& name );

    void dump();
 
private:
    TQString makeUniqueName( const TQString& base, int flags ) const;

    StyleMap m_styleMap;

    typedef TQMap<TQString, bool> NameMap; // KDE4: TQSet
    NameMap m_styleNames;
    NameMap m_autoStylesInStylesDotXml;

    typedef TQValueVector<NamedStyle> StyleArray;
    StyleArray m_styleArray;
 
    class Private;
    Private *d;
};

class KOFFICECORE_EXPORT KoGenStyle
{
public:
    enum { STYLE_PAGELAYOUT = 0,
           STYLE_USER = 1,
           STYLE_AUTO = 2,
           STYLE_MASTER = 3,
           STYLE_LIST = 4,
           STYLE_AUTO_LIST = 5,
           STYLE_NUMERIC_NUMBER = 6,
           STYLE_NUMERIC_DATE = 7,
           STYLE_NUMERIC_TIME = 8,
           STYLE_NUMERIC_FRACTION = 9,
           STYLE_NUMERIC_PERCENTAGE = 10,
           STYLE_NUMERIC_SCIENTIFIC = 11,
           STYLE_NUMERIC_CURRENCY = 12,
           STYLE_NUMERIC_TEXT = 13,
           STYLE_HATCH = 14,
           STYLE_GRAPHICAUTO = 15};

    explicit KoGenStyle( int type = 0, const char* familyName = 0,
                         const TQString& parentName = TQString() );
    ~KoGenStyle();
 
    /*
     * setAutoStyleInStylesDotXml(true) marks a given automatic style as being needed in styles.xml.
     * For instance styles used by headers and footers need to go there, since
     * they are saved in styles.xml, and styles.xml must be independent from content.xml.
     *
     * The application should use KoGenStyles::styles( type, true ) in order to retrieve
     * those styles and save them separately.
     */
    void setAutoStyleInStylesDotXml( bool b ) { m_autoStyleInStylesDotXml = b; }
    bool autoStyleInStylesDotXml() const { return m_autoStyleInStylesDotXml; }
 
    /*
     * setDefaultStyle(true) marks a given style as being the default style.
     * This means we expect that you will call writeStyle( ...,"style:default-style"),
     * and its name will be ommitted in the output.
     */
    void setDefaultStyle( bool b ) { m_defaultStyle = b; }
    bool isDefaultStyle() const { return m_defaultStyle; }

    int type() const { return m_type; }

    const char* familyName() const { return m_familyName.data(); }

    TQString parentName() const { return m_parentName; }

    enum PropertyType
    {
        DefaultType = 0,
        TextType,
        ParagraphType,
        GraphicType,
        Reserved1, 
        Reserved2, 
        ChildElement, 
        N_NumTypes 
    };

    void addProperty( const TQString& propName, const TQString& propValue, PropertyType type = DefaultType ) {
        m_properties[type].insert( propName, propValue );
    }

    void addProperty( const TQString& propName, const char* propValue, PropertyType type = DefaultType ) {
        m_properties[type].insert( propName, TQString::fromUtf8( propValue ) );
    }

    void addProperty( const TQString& propName, int propValue, PropertyType type = DefaultType ) {
        m_properties[type].insert( propName, TQString::number( propValue ) );
    }

    void addProperty( const TQString& propName, bool propValue, PropertyType type = DefaultType ) {
        m_properties[type].insert( propName, propValue ? "true" : "false" );
    }

    void addPropertyPt( const TQString& propName, double propValue, PropertyType type = DefaultType );

    void addAttribute( const TQString& attrName, const TQString& attrValue ) {
        m_attributes.insert( attrName, attrValue );
    }

    void addAttribute( const TQString& attrName, const char* attrValue ) {
        m_attributes.insert( attrName, TQString::fromUtf8( attrValue ) );
    }

    void addAttribute( const TQString& attrName, int attrValue ) {
        m_attributes.insert( attrName, TQString::number( attrValue ) );
    }

    void addAttribute( const TQString& attrName, bool attrValue ) {
        m_attributes.insert( attrName, attrValue ? "true" : "false" );
    }

    void addAttributePt( const TQString& attrName, double attrValue );

    void addChildElement( const TQString& elementName, const TQString& elementContents ) {
        m_properties[ChildElement].insert( elementName, elementContents );
    }

    void addStyleMap( const TQMap<TQString, TQString>& styleMap ) {
        m_maps.append( styleMap );
    }

    bool isEmpty() const {
        if ( !m_attributes.isEmpty() || ! m_maps.isEmpty() )
            return false;
        for ( uint i = 0 ; i < N_NumTypes ; ++i )
            if ( ! m_properties[i].isEmpty() )
                return false;
        return true;
    }

    void writeStyle( KoXmlWriter* writer, KoGenStyles& styles, const char* elementName, const TQString& name,
                     const char* propertiesElementName, bool closeElement = true, bool drawElement = false ) const;

    bool operator<( const KoGenStyle &other ) const;

    bool operator==( const KoGenStyle &other ) const;
 
private:
    TQString property( const TQString& propName, PropertyType type ) const {
        TQMap<TQString, TQString>::const_iterator it = m_properties[type].find( propName );
        if ( it != m_properties[type].end() )
            return it.data();
        return TQString();
    }
 
    TQString attribute( const TQString& propName ) const {
        TQMap<TQString, TQString>::const_iterator it = m_attributes.find( propName );
        if ( it != m_attributes.end() )
            return it.data();
        return TQString();
    }
 
    void writeStyleProperties( KoXmlWriter* writer, PropertyType i,
                               const char* elementName, const KoGenStyle* parentStyle ) const;
 
#ifndef NDEBUG
    void printDebug() const;
#endif
 
private:
    // Note that the copy constructor and assignment operator are allowed.
    // Better not use pointers below!
    int m_type;
    TQCString m_familyName;
    TQString m_parentName;
    TQMap<TQString, TQString> m_properties[N_NumTypes];
    TQMap<TQString, TQString> m_attributes;
    typedef TQMap<TQString, TQString> StyleMap;
    TQValueVector<StyleMap> m_maps; // we can't really sort the maps between themselves...
 
    bool m_autoStyleInStylesDotXml;
    bool m_defaultStyle;
    short m_unused2;
 
    // For lookup
    friend class KoGenStyles;
};
 
#endif /* KOGENSTYLES_H */