RPropertyAttributes.h

Go to the documentation of this file.

 
#ifndef RPROPERTYATTRIBUTES_H
#define RPROPERTYATTRIBUTES_H
 
#include "core_global.h"
 
#include <QString>
#include <QSet>
#include <QPair>
#include <QVariant>
 
class QCADCORE_EXPORT RPropertyAttributes {
public:
    enum Option {
        NoOptions = 0x0,
        ReadOnly = 0x1,                  
        Invisible = 0x2,                 
        Angle = 0x4,                     
        AffectsOtherProperties = 0x8,    
        IgnoreCase = 0x10,               
        AllowMixedValue = 0x20,          
        List = 0x40,                     
        Mixed = 0x80,                    
        RichText = 0x100,                
        Style = 0x200,                   
        DimensionLabel = 0x400,          
        Label = 0x800,                   
        Pattern = 0x1000,                
        Custom = 0x2000,                 
        Integer = 0x4000,                
        Redundant = 0x8000,              
        VisibleToParent = 0x10000,       
        KnownVariable = 0x20000,         
        NumericallySorted = 0x40000,     
        Percentage = 0x80000 | Integer,  
        Sum = 0x100000 | ReadOnly | Redundant,  
        Undeletable = 0x200000,          
        OnRequest = 0x400000,            
        Location = 0x800000,             
        RefPoint = 0x1000000,            
        Geometry = Location | RefPoint,  
        Scale = 0x2000000,               
        Area = 0x4000000,                
        UnitLess = 0x8000000,            
        DimStyleOverride = 0x10000000,   
        CustomApp001 = 0x20000000,       
        StoreIndex = 0x40000000          
    };
    Q_DECLARE_FLAGS(Options, Option)
 
public:
    RPropertyAttributes() : options(NoOptions) {}
 
    RPropertyAttributes(RPropertyAttributes::Options options) :
        options(options) {
    }
 
    void setOption(RPropertyAttributes::Option option, bool on);
 
    bool isReadOnly() const {
        return options.testFlag(ReadOnly);
    }
 
    void setReadOnly(bool readOnly) {
        setOption(ReadOnly, readOnly);
    }
 
    bool isInvisible() const {
        return options.testFlag(Invisible);
    }
 
    void setInvisible(bool invisible) {
        setOption(Invisible, invisible);
    }
 
    bool isUndeletable() const {
        return options.testFlag(Undeletable);
    }
 
    void setUndeletable(bool undeletable) {
        setOption(Undeletable, undeletable);
    }
 
    bool isList() const {
        return options.testFlag(List);
    }
 
    void setList(bool on) {
        setOption(List, on);
    }
 
    bool isAngleType() const {
        return options.testFlag(Angle);
    }
 
    void setAngleType(bool angle) {
        setOption(Angle, angle);
    }
 
    bool getIgnoreCase() const {
        return options.testFlag(IgnoreCase);
    }
 
    void setIgnoreCase(bool ignoreCase) {
        setOption(IgnoreCase, ignoreCase);
    }
 
    bool affectsOtherProperties() const {
        return options.testFlag(AffectsOtherProperties);
    }
 
    void setAffectsOtherProperties(bool affectsOtherProperties) {
        setOption(AffectsOtherProperties, affectsOtherProperties);
    }
 
    void setAllowMixedValue(bool allowMixedValue) {
        setOption(AllowMixedValue, allowMixedValue);
    }
 
    bool getAllowMixedValue() {
        return options.testFlag(AllowMixedValue);
    }
 
    QStringList getChoices() const {
        return choices;
    }
 
    void setChoices(const QStringList& choices, bool storeIndex = false) {
        this->choices = choices;
        setOption(StoreIndex, storeIndex);
    }
 
    bool hasChoices() {
        return !choices.isEmpty();
    }
 
    bool getStoreIndex() const {
        return options.testFlag(StoreIndex);
    }
 
//    QList<QVariant> getEnumChoices() const {
//        return enumChoices;
//    }
 
//    void setEnumChoices(QList<QVariant> ec) {
//        enumChoices = ec;
//    }
 
//    bool hasEnumChoices() const {
//        return !enumChoices.isEmpty();
//    }
 
    bool isRichText() const {
        return options.testFlag(RichText);
    }
 
    void setRichText(bool on) {
        setOption(RichText, on);
    }
 
    bool isStyle() const {
        return options.testFlag(Style);
    }
 
    void setStyle(bool on) {
        setOption(Style, on);
    }
 
    void mixWith(const RPropertyAttributes & other);
 
    bool isMixed() const {
        return options.testFlag(Mixed);
    }
 
    void setMixed(bool mixed) {
        setOption(Mixed, mixed);
    }
 
    bool isSum() const {
        return options.testFlag(Sum);
    }
 
    void setSum(bool sum) {
        setOption(Sum, sum);
    }
 
    bool isOnRequest() const {
        return options.testFlag(OnRequest);
    }
 
    void setOnRequest(bool onRequest) {
        setOption(OnRequest, onRequest);
    }
 
    bool isLabel() const {
        return options.testFlag(Label);
    }
 
    bool isCustom() const {
        return options.testFlag(Custom);
    }
 
    bool isDimensionLabel() const {
        return options.testFlag(DimensionLabel);
    }
 
    void setInteger(bool i) {
        setOption(Integer, i);
    }
 
    bool isInteger() const {
        return options.testFlag(Integer);
    }
 
    bool isRedundant() const {
        return options.testFlag(Redundant);
    }
 
    void setRedundant(bool on) {
        setOption(Redundant, on);
    }
 
    bool isVisibleToParent() const {
        return options.testFlag(VisibleToParent);
    }
 
    bool isNumericallySorted() const {
        return options.testFlag(NumericallySorted);
    }
 
    void setNumericallySorted(bool on) {
        setOption(NumericallySorted, on);
    }
 
    bool isScaleType() const {
        return options.testFlag(Scale);
    }
 
    void setScaleType(bool v) {
        setOption(Scale, v);
    }
 
    bool isAreaType() const {
        return options.testFlag(Area);
    }
 
    void setAreaType(bool v) {
        setOption(Area, v);
    }
 
    bool isUnitLess() const {
        return options.testFlag(UnitLess);
    }
 
    void setUnitLess(bool v) {
        setOption(UnitLess, v);
    }
 
    bool isPercentage() const {
        return options.testFlag(Percentage);
    }
 
    bool isCustomApp001() const {
        return options.testFlag(CustomApp001);
    }
 
    void setCustomApp001(bool v) {
        setOption(CustomApp001, v);
    }
 
    QString getLabel() const {
        return label;
    }
 
    void setLabel(const QString& l) {
        label = l;
    }
 
    bool operator == (const RPropertyAttributes& other) const {
        if (isInvisible() != other.isInvisible()) {
            return false;
        }
        if (isAngleType() != other.isAngleType()) {
            return false;
        }
        if (affectsOtherProperties() != other.affectsOtherProperties()) {
            return false;
        }
        if (isList() != other.isList()) {
            return false;
        }
        if (choices != other.choices) {
            return false;
        }
 
        return true;
    }
 
    bool operator !=(const RPropertyAttributes& other) const {
        return !operator ==(other);
    }
 
 
private:
    RPropertyAttributes::Options options;
    QStringList choices;
    QString label;
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS(RPropertyAttributes::Options)
 
typedef QPair<QVariant, RPropertyAttributes> _RPairVariantPropertyAttributes;
Q_DECLARE_METATYPE(RPropertyAttributes)
Q_DECLARE_METATYPE(RPropertyAttributes*)
Q_DECLARE_METATYPE(QFlags<RPropertyAttributes::Option>*)
Q_DECLARE_METATYPE(RPropertyAttributes::Option)
Q_DECLARE_METATYPE(RPropertyAttributes::Option*)
Q_DECLARE_METATYPE(_RPairVariantPropertyAttributes*)
Q_DECLARE_METATYPE(_RPairVariantPropertyAttributes)
 
#endif