style.h

/*
 For general Scribus (>=1.3.2) copyright and licensing information please refer
 to the COPYING file provided with the program. Following this notice may exist
 a copyright and/or license notice that predates the release of Scribus 1.3.2
 for which a new license (GPL+exception) is in place.
 */
/***************************************************************************
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
***************************************************************************/


#ifndef STYLE_H
#define STYLE_H

#include <cassert>
#include <QString>
#include "scfonts.h"
#include "scribusapi.h"
#include "styles/stylecontext.h"
#include "desaxe/saxio.h"


class SCRIBUS_API Style : public SaxIO {
protected:
    bool m_isDefaultStyle;
    QString m_name;
    const StyleContext* m_context;
    int m_contextversion;
    QString m_parent;
    QString m_shortcut;
public:
//  static const short NOVALUE = -16000;

    Style(): m_isDefaultStyle(false), m_name(""), m_context(NULL), m_contextversion(-1), m_parent(""), m_shortcut() {}

    Style(StyleContext* b, QString n): m_isDefaultStyle(false), m_name(n), m_context(b), m_contextversion(-1), m_parent(""), m_shortcut() {}
    
    Style& operator=(const Style& o) 
    { //assert(typeinfo() == o.typeinfo()); 
        m_isDefaultStyle = o.m_isDefaultStyle;
        m_name = o.m_name;
//      m_context = o.m_context; 
        m_contextversion = -1; 
        m_parent = o.m_parent;
        m_shortcut = o.m_shortcut;
        return *this;
    }
    
    Style(const Style& o) : SaxIO(), m_isDefaultStyle(o.m_isDefaultStyle),m_name(o.m_name), 
        m_context(o.m_context), m_contextversion(o.m_contextversion), m_parent(o.m_parent), m_shortcut(o.m_shortcut) {} 
    
    virtual ~Style()                 {}

    
    // this is an abstract class, so:
    // static const Xml_string saxxDefaultElem; 
    template<class SUBSTYLE>
        static void  desaxeRules(const Xml_string& prefixPattern, desaxe::Digester& ruleset, Xml_string elemtag);
    
    void saxxAttributes(Xml_attr& attr) const;
    //virtual void saxx(SaxHandler& handler, const Xml_string& elemtag) const;
    //virtual void saxx(SaxHandler& handler)                     const { saxx(handler, saxxDefaultElem); }
    
    void setDefaultStyle(bool ids);
    bool isDefaultStyle() const      { return m_isDefaultStyle; }
    
    QString name() const             { return m_name; }
    void setName(const QString& n)   { m_name = n.isEmpty() ? "" : n; }
    bool hasName() const             { return ! m_name.isEmpty(); }

    virtual QString displayName() const = 0;/*{     
        if ( hasName() || !hasParent() || !m_context)
            return name();
        //  else if ( inheritsAll() )
        //      return parent()->displayName();
        else 
            return parentStyle()->displayName();
    }*/
    
    QString parent() const           { return m_parent; }
    void setParent(const QString& p);
    bool hasParent() const           { return ! m_parent.isEmpty(); }
    const Style* parentStyle() const;
    
    static const QString INHERIT_PARENT;
    
    virtual void setContext(const StyleContext* context);
    const StyleContext* context() const        { return m_context; }
    
    virtual void update(const StyleContext* b = NULL);
    
    inline void validate() const {
        if (m_context && m_contextversion != m_context->version()) {
            const_cast<Style*>(this)->update(m_context); 
            assert( m_context->checkConsistency() );
        }
    }

    QString shortcut() const { return m_shortcut; }
    void setShortcut(const QString &shortcut) { m_shortcut = shortcut; }

    virtual bool equiv(const Style& other) const = 0;
    virtual bool operator==(const Style& other) const { return name() == other.name() && equiv(other); }
    virtual bool operator!=(const Style& other) const { return ! ( (*this) == other ); }

    virtual void erase() = 0;
    void applyStyle(const Style& other) { 
        if (other.hasParent())
            setParent( other.parent() == INHERIT_PARENT? "" :other.parent());
        m_contextversion = -1;
    }
    void eraseStyle(const Style& other) {
        if (other.parent() == parent())
            setParent("");
        m_contextversion = -1;
    }
};

#endif