TransmittableProperty.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2008 by Matthias Nagl   *
 *   mnagl@uni-goettingen.de   *
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 *   This program 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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef TRANSMITTABLEPROPERTY_H
#define TRANSMITTABLEPROPERTY_H

#include <QtCore/QtGlobal>
#include <QString>
#include <QByteArray>
#include <QVariant>
#include <QStringList>

#if defined(TRANSMITTABLEPROPERTIES_LIBRARY)
#  define TP_EXPORT Q_DECL_EXPORT
#else
#  define TP_EXPORT Q_DECL_IMPORT
#endif

class QtVariantPropertyManager;
class QtVariantProperty;
class PropertyBranchInterface;
class TransmittablePropertyData;

class TP_EXPORT TransmittableProperty // : public TransmittablePropertyInterface
{
  public:
    enum TransmittableDataType {
      Invalid,
      Group,
      Enum,
      Flag,
      Int,
      Double,
      Bool,
      String,

      Size // helper to determine enums max value
    };

    TransmittableProperty();
    TransmittableProperty(QString name, TransmittableDataType type);
    TransmittableProperty(QByteArray &serialized);
    // TransmittableProperty(const TransmittableProperty *original);
    ~TransmittableProperty();

    virtual void setName(const QString &name) { n = name; }
    virtual QString name() const { return n; }
    virtual void setValue(const QVariant &value);
    virtual void setValue(const QVariant &value, TransmittableDataType type);
    virtual void updateValue(const QVariant &value);
    virtual bool updateValue(const TransmittablePropertyData &u);
    virtual bool updated() const { return valueupdated; }
    virtual QVariant value(bool sendconfirmation = true) const;
    virtual void setAttribute(const QString &name, const QVariant & value);
    virtual QVariant attribute(const QString &name) const { return attr[name]; }
    static QStringList allowedAttributes(TransmittableDataType type);
    virtual void setDisplayMagnitude(qreal divider) { div = divider; }
    virtual void setToolTip(const QString &tt) { tooltip = tt; }
    virtual QString toolTip() const { return tooltip; }
    virtual void setDataType(TransmittableDataType type);
    virtual TransmittableDataType dataType() const { return t; }
    virtual void setQSettingsKey(const QString &key) { qskey = key; }
    virtual QString qSettingsKey() const { return qskey; }

    virtual void setDefaultValue(const QVariant &def) { defaultval = def; }
    virtual void loadFromQSettings();
    virtual void saveToQSettings() const;

    virtual QByteArray serialize() const;
    virtual TransmittablePropertyData transmittablePropertyUpdate() const;
    virtual QtVariantProperty * addToPropertyManager(QtVariantPropertyManager *manager);
    virtual QtVariantProperty * qtProperty() const { return p; }

    virtual void setParentBranch(PropertyBranchInterface *p);
    virtual const PropertyBranchInterface * parentBranch() { return pb; }
    virtual quint64 parentPropertyHash() const { return parentprophash; }
    virtual quint64 hash() const { return ownhash; }

    virtual void addDependentProperty(TransmittableProperty *dependent);
    virtual QList<quint64> dependentPropertyHashes() const { return dephashes; }

    virtual operator double() const;
    virtual operator int() const;
    virtual operator unsigned int() const;
    virtual operator bool() const;
    virtual operator QString() const;

  private:
    static QVariant::Type dataTypeToVariantType(TransmittableDataType type);
    static int dataTypeToPropertyType(TransmittableDataType type, QtVariantPropertyManager *manager);
    static int variantTypeToDataType(QVariant::Type type);
    void sendConfirmation() const;
    QString n;
    TransmittableDataType t;
    QVariant val;
    QVariant defaultval;
    QMap<QString, QVariant> attr;
    QString qskey;
    mutable QString qspath;
    quint64 ownhash;
    mutable quint64 parentprophash;
    QtVariantProperty *p;
    mutable const PropertyBranchInterface *pb;
    qreal div;
    QString tooltip;
    mutable bool valueupdated;
    QList<TransmittableProperty*> dependents;
    QList<quint64> dephashes;
    QList<TransmittableProperty*> determinatives;
};

class TP_EXPORT TransmittablePropertyData
{
  public:
    TransmittablePropertyData(QByteArray &d);
    TransmittablePropertyData(quint64 hash, const QVariant &value);
    ~TransmittablePropertyData() {}
    virtual quint64 hash() const { return ownhash; }
    virtual QVariant value() const { return val; }
    virtual operator QByteArray() const { return d; }
  private:
    QByteArray d;
    quint64 ownhash;
    QVariant val;
};

#endif