Back to index

scribus-ng  1.3.4.dfsg+svn20071115
styleset.h
Go to the documentation of this file.
00001 
00002 
00003 #ifndef STYLESET_H
00004 #define STYLESET_H
00005 
00006 #include <assert.h>
00007 #include "style.h"
00008 
00009 
00010 template<class STYLE>
00011 class StyleSet : public StyleContext {
00012 public:
00013        STYLE& operator[] (uint index) { 
00014               assert(index < styles.count()); 
00015               return * styles[index]; 
00016        }
00017        
00018        const STYLE& operator[] (const QString& name) const { 
00019               return * dynamic_cast<const STYLE*>(resolve(name)); 
00020        }
00021        
00022        const STYLE& operator[] (uint index) const { 
00023               assert(index < styles.count()); 
00024               return * styles[index]; 
00025        }
00026        
00027        inline int find(const QString& name) const;
00028 
00029        inline const Style* resolve(const QString& name) const;
00030        
00031        uint count() const { 
00032               return (uint) styles.count(); 
00033        }
00034        
00035        STYLE* append(STYLE* style) { 
00036               styles.append(style); 
00037               style->setContext(this); 
00038               return style; 
00039        }
00040        
00041        inline void remove(uint index);
00042        
00043        inline void redefine(const StyleSet<STYLE>& defs, bool removeUnused=false);
00044        
00045        inline void rename(const QMap<QString,QString>& newNames);
00046        
00047        STYLE* create(const STYLE& proto) { 
00048               return append(new STYLE(proto)); 
00049        }
00050        
00051        void makeDefault(STYLE* def) { 
00052               m_default = def; 
00053               if(def) 
00054                      def->setContext(this);
00055               invalidate();
00056        }
00057        
00058        bool isDefault(const STYLE& style) const {
00059               return &style == m_default;
00060        }
00061        
00062        StyleSet() : styles(), m_context(NULL), m_default(NULL) {}
00063        
00064        ~StyleSet() { 
00065               clear(); 
00066        }
00067        
00068        void clear() { 
00069               while(styles.count()>0) 
00070               { 
00071                      delete styles.front(); 
00072                      styles.pop_front(); 
00073               }
00074               invalidate();
00075        }
00076 
00077        void setContext(const StyleContext* context) {
00078               bool reallyNew = m_context != context;
00079               m_context = context; 
00080               if (reallyNew)
00081                      invalidate();
00082        }
00083        
00084        const StyleContext* context() const { 
00085               return m_context; 
00086        }
00087        
00088 private:
00089        StyleSet(const StyleSet&)             { assert(false); }
00090        StyleSet& operator= (const StyleSet&) { assert(false); return *this; }
00091 
00092        QValueList<STYLE*> styles;
00093        const StyleContext* m_context;
00094        STYLE* m_default;
00095 };
00096 
00097 template<class STYLE>
00098 inline void StyleSet<STYLE>::remove(uint index)
00099 {
00100        assert(index < styles.count()); 
00101        typename QValueList<STYLE*>::Iterator it = styles.at(index);
00102        if (*it == m_default)
00103               return;
00104        delete (*it);
00105        styles.erase(it);
00106 }
00107 
00108 template<class STYLE>
00109 inline int StyleSet<STYLE>::find(const QString& name) const
00110 {
00111        for (uint i=0; i < styles.count(); ++i)
00112               if (styles[i]->name() == name)
00113                      return i;
00114        return -1;
00115 }
00116 
00117 template<class STYLE>
00118 inline const Style* StyleSet<STYLE>::resolve(const QString& name) const
00119 {
00120        if (name.isEmpty())
00121               return m_default;
00122        for (uint i=0; i < styles.count(); ++i)
00123        {
00124               if (styles[i]->name() == name)
00125                      return styles[i];
00126        }
00127        return m_context ? m_context->resolve(name) : NULL;
00128 }
00129 
00130 template<class STYLE>
00131 inline void StyleSet<STYLE>::redefine(const StyleSet<STYLE>& defs, bool removeUnused)
00132 {
00133        for (int i=signed(styles.count())-1; i >= 0; --i) 
00134        {
00135               bool found = false;
00136               for (uint j=0; j < defs.count(); ++j) 
00137               {
00138                      if (styles[i]->name() == defs[j].name()) 
00139                      {
00140                             found = true;
00141                             (*styles[i]) = defs[j];
00142                             (*styles[i]).setContext(this);
00143                             if (defs.m_default == defs.styles[j])
00144                                    makeDefault(styles[i]);
00145                             break;
00146                      }
00147               }
00148               if (!found && removeUnused) 
00149               {
00150                      if (styles[i] == m_default)
00151                             makeDefault(NULL);
00152                      remove(i);
00153               }
00154        }
00155        for (uint j=0; j < defs.count(); ++j) 
00156        {
00157               if (find(defs[j].name()) < 0) 
00158               {
00159                      STYLE* newStyle = create(defs[j]);
00160                      if (defs.m_default == defs.styles[j])
00161                             makeDefault(newStyle);
00162               }
00163        }
00164        invalidate();
00165 }
00166 
00167 template<class STYLE>
00168 inline void StyleSet<STYLE>::rename(const QMap<QString,QString>& newNames)
00169 {
00170        for (uint i=0; i < styles.count(); ++i)
00171        { 
00172               QMap<QString,QString>::ConstIterator it;
00173               
00174               it = newNames.find(styles[i]->name());
00175               if (it != newNames.end())
00176                      styles[i]->setName(it.data());
00177        
00178               it = newNames.find(styles[i]->parent());
00179               if (it != newNames.end())
00180                      styles[i]->setParent(it.data());
00181        }
00182        invalidate();
00183 }
00184        
00185 #endif
00186 
00187