property_data.h

Go to the documentation of this file.

#ifndef PROPERTY_DATA_H
#define PROPERTY_DATA_H

#include <QtGui>

class PropertyData
{
        public:
                enum DataType { MinRange=0, MaxRange, ActiveIndex, ImagePath, User, numDataType };
                inline void init(bool enable = true)
                {
                        PropertyItem* prop = new PropertyItem;
                        prop->enable = enable;

                        m_properties.insert(m_name, prop);
                }
                inline void init(const QString& label, const QIcon& icon = QIcon())
                {
                        init();
                        setLabel(label);
                        setIcon(icon);
                }

                inline void setLabel(const QString& label) { m_properties.value(m_name)->label = label; }
                inline void setIcon(const QIcon& icon) { m_properties.value(m_name)->icon = icon; }
                inline void setName(const char* name) { m_name = name; }
                inline void setData(DataType type, const QVariant& value) { m_properties.value(m_name)->data[type] = value; }
                inline void setEnable(bool enable) { m_properties.value(m_name)->enable = enable; }
                inline QString label() { return m_properties.value(m_name)->label; }
                inline bool isEnable() { return m_properties.value(m_name)->enable; }
                inline bool isInit() { return m_properties.contains(m_name); }
                inline QVariant data(DataType type) const { return m_properties.value(m_name)->data[type]; }

        private:
                struct PropertyItem
                {
                        QString label;
                        QIcon icon;
                        bool enable;
                        QMap <DataType, QVariant> data;
                };
                
                QString m_name; 
                QHash<QString, PropertyItem*> m_properties;
};

class IProperty
{
        public:
                virtual ~IProperty(){};
                virtual QWidget* createEditor(QWidget*) = 0;
                virtual void updateEditor(QWidget*) = 0;
                
                virtual const char* name() = 0;
                virtual QString label() const = 0;
                virtual QVariant value() const = 0;
                virtual QString valueToString() const = 0;
                virtual QString status() const = 0;
                
                virtual void addChild(IProperty*) = 0;
                virtual void clearChildren() = 0;
                virtual int children() = 0;
                virtual IProperty* child(int) const = 0;
                virtual IProperty* child(const QString&) const = 0;

                virtual int indexOf(IProperty*) = 0;
                virtual IProperty* parent() = 0;
                virtual void setParent(IProperty* parent) = 0;
                virtual void setFake(bool) = 0;
                virtual void setValue(const QVariant&) = 0;
                virtual bool isFake() = 0;
};

class AbstractProperty : public IProperty
{
        public:
                AbstractProperty(const char* name, const QString& label, PropertyData* propertyData, const QVariant& value)
                                :  m_name(name), m_label(label), m_value(value), m_propertyData(propertyData), m_fake(false){};

                inline ~AbstractProperty() { clearChildren(); }
                inline QWidget* createEditor(QWidget*){ return 0; }
                inline void updateEditor(QWidget*) {}
                
                inline const char* name() { return m_name; }
                inline QString label() const { return m_label; }
                inline QVariant value() const { return m_value; }
                inline QString valueToString() const { return m_value.toString(); }
                QString status() const;

                inline int children() { return m_children.count(); }
                inline void addChild(IProperty* child) { m_children.append(child); }
                inline void clearChildren() { qDeleteAll(m_children); m_children.clear(); }
                inline IProperty* child(int index) const { return m_children.value(index); }
                IProperty* child(const QString&) const;

                inline int indexOf(IProperty* child) { return m_children.indexOf(child); }
                inline IProperty* parent() { return m_parent; }
                inline void setParent(IProperty* parent) { m_parent = parent; }
                inline void setFake(bool fake) { m_fake = fake; }
                inline void setValue(const QVariant& value) { m_value = value; }
                inline bool isFake() { return m_fake; }

        protected:
                inline PropertyData* propertyData() const { m_propertyData->setName(m_name); return m_propertyData; }

                const char* m_name;
                QString m_label;
                QVariant m_value;

                QList<IProperty*> m_children;

        private:
                IProperty* m_parent;
                PropertyData* m_propertyData;
                bool m_fake;
};

class IntProperty : public AbstractProperty
{
        public:
                IntProperty(const char*, const QString&, PropertyData*, int);
                QWidget* createEditor(QWidget*);
                void updateEditor(QWidget*);
                void setRange(int, int);

        private:
                int m_min;
                int m_max;
};

class DoubleProperty : public AbstractProperty
{
        public:
                DoubleProperty(const char*, const QString&, PropertyData*, double);
                QWidget* createEditor(QWidget*);
                void updateEditor(QWidget*);
                void setRange(double, double);

        private:
                double m_min;
                double m_max;
};

class BoolProperty : public AbstractProperty
{
        public:
                BoolProperty(const char*, const QString&, PropertyData*, bool);
                QWidget* createEditor(QWidget*);
                void updateEditor(QWidget*);
};

class StringProperty : public AbstractProperty
{
        public:
                StringProperty(const char*, const QString&, PropertyData*, const QString&);
                QWidget* createEditor(QWidget*);
                void updateEditor(QWidget*);
};

class ListProperty : public AbstractProperty
{
        public:
                ListProperty(const char*, const QString&, PropertyData*, const QStringList&);
                QWidget* createEditor(QWidget*);
                void updateEditor(QWidget*);
                void setCurrentIndex(int);
                void setValue(const QVariant&);
                QString status() const;
                QVariant value() const;
                QString valueToString() const;
        
        private:
                QStringList m_list;
                int m_index;
};

class PixmapProperty : public AbstractProperty
{
        public:
                PixmapProperty(const char*, const QString&, PropertyData*, const QPixmap&);
                QWidget* createEditor(QWidget*);
                void updateEditor(QWidget*);
                void setValue(const QVariant&);
                QString status() const;
                QVariant value() const;
                QString valueToString() const;
                void setPath(const QString&);

        private:
                QString m_path;
};

class FamilyProperty : public AbstractProperty
{
        public:
                FamilyProperty(const char*, const QString&, PropertyData*, const QFont&);
                QWidget* createEditor(QWidget*);
                void updateEditor(QWidget*);
                QString status() const;
};

class EnumProperty : public AbstractProperty
{
        public:
                EnumProperty(const char*, const QString&, PropertyData*, const QMetaEnum&);
                QWidget* createEditor(QWidget*);
                void updateEditor(QWidget*);
                void setValue(const QVariant&);
                QString status() const;
                QVariant value() const;
                QString valueToString() const;
                void setCurrentIndex(int);

        private:
                QMetaEnum m_enums;
                QStringList m_keys;
                int m_index;
};

class PointProperty : public AbstractProperty
{
        public:
                PointProperty(const char*, const QString&, PropertyData*, const QPoint&);
                QVariant value() const;
};

class SizeProperty : public AbstractProperty
{
        public:
                SizeProperty(const char*, const QString&, PropertyData*, const QSize&);
                QVariant value() const;
};

class RectProperty : public AbstractProperty
{
        public:
                RectProperty(const char*, const QString&, PropertyData*, const QRect&);
                QVariant value() const;
};

class LineProperty : public AbstractProperty
{
        public:
                LineProperty(const char*, const QString&, PropertyData*, const QLine&);
                QVariant value() const;
};

class PolygonProperty : public AbstractProperty
{
        public:
                PolygonProperty(const char*, const QString&, PropertyData*, const QPolygon&);
                QVariant value() const;
};

class PenProperty : public AbstractProperty
{
        public:
                PenProperty(const char*, const QString&, PropertyData*, const QPen&);
                QVariant value() const;

        private:
                QStringList m_penStyle;
};

class BrushProperty : public AbstractProperty
{
        public:
                BrushProperty(const char*, const QString&, PropertyData*, const QBrush&);
                QVariant value() const;

        private:
                QStringList m_brushStyle;
};

class FontProperty : public AbstractProperty
{
        public:
                FontProperty(const char*, const QString&, PropertyData*, const QFont&);
                QVariant value() const;
};

class MatrixProperty : public AbstractProperty
{
        public:
                MatrixProperty(const char*, const QString&, PropertyData*, const QMatrix&);
                QVariant value() const;
};

class PixmapBox : public QWidget
{
        Q_OBJECT
        
        private slots:
                void openDialog();

        public:
                PixmapBox(QWidget*);
                
                void setPixmap(const QPixmap&);
                void setPath(const QString&);
                QPixmap pixmap() const;
                QString path() const;

        private:
                QPixmap m_pixmap;
                QString m_path;
                QHBoxLayout m_hbox;
                QLabel m_label;
                QPushButton m_button;
};

#endif

---