DataStructure.h

Go to the documentation of this file.

/*
    This file is part of Rocs.
    Copyright 2004-2011  Tomaz Canabrava <tomaz.canabrava@gmail.com>
    Copyright 2010-2011  Wagner Reck <wagner.reck@gmail.com>
    Copyright 2011-2012  Andreas Cord-Landwehr <cola@uni-paderborn.de>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef DATASTRUCTURE_H
#define DATASTRUCTURE_H

#include <QObject>
#include <QList>
#include <QString>
#include <QtScript>
#include <QColor>

#include "RocsCoreExport.h"
#include "CoreTypes.h"
#include "Document.h"

class Group;
class Document;
class Data;
class Pointer;
class DataStructurePrivate;

class ROCSLIB_EXPORT DataStructure : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QString name READ name WRITE setName)

    // interal deleter class
    class deleter;
    friend class deleter;

public:
    static DataStructurePtr create(Document *parent = 0);
    static DataStructurePtr create(DataStructurePtr other, Document *parent = 0);

    virtual DataStructurePtr getDataStructure() const;

    Document *document() const;

    void setReadOnly(bool r);
    bool readOnly() const;

    QScriptValue scriptValue() const;
    virtual void setEngine(QScriptEngine *engine);
    QScriptEngine *engine() const;

    void updateData(DataPtr data);

    void updatePointer(PointerPtr pointer);

    bool isDataVisible(int dataType) const;

    bool isPointerVisible(int pointerType) const;

    QString name() const;

    const DataList dataList(int dataType) const;

    DataList dataListAll() const;

    const PointerList pointers(int pointerType) const;

    PointerList pointerListAll() const;

    const QList<GroupPtr> groups() const;

    virtual void cleanUpBeforeConvert();

    virtual QMap<QString,QString> pluginProperties() const;

    virtual void setPluginProperty(const QString& /*identifier*/, const QString& /*property*/);

public Q_SLOTS:
    virtual DataPtr createData(const QString& name, int dataType);
    virtual DataPtr createData(const QString& name, const QPointF& point, int dataType);

    virtual DataList addDataList(DataList dataList);

    virtual PointerPtr createPointer(DataPtr from, DataPtr to, int pointerType);

    DataPtr getData(int uniqueIdentifier);

    virtual void remove(DataPtr data);

    virtual void remove(PointerPtr pointer);

    virtual void remove(GroupPtr group);

    virtual GroupPtr addGroup(const QString& name);
    virtual DataList addDataList(QList< QPair<QString, QPointF> > dataList, int dataType);

    void addDynamicProperty(const QString& property, const QVariant& value = QVariant(0));
    void removeDynamicProperty(const QString& property);
    void renameDynamicProperty(const QString& oldName, const QString& newName);

    void add_property(const QString& name, const QVariant& value);

    void remove_property(const QString& name);

    void remove();

    // setters
    void setName(const QString& s);

private Q_SLOTS:
    void registerDataType(int identifier);

    void registerPointerType(int identifier);

    void removeDataType(int identifier);

    void removePointerType(int identifier);

Q_SIGNALS:
    void dataCreated(DataPtr n);
    void dataPositionChanged(const QPointF);
    void pointerCreated(PointerPtr e);
    void nameChanged(const QString &name);
    void changed();
    void scriptError(const QString &message);

protected:
    DataPtr addData(DataPtr data);
    PointerPtr addPointer(PointerPtr pointer);
    int generateUniqueIdentifier();

    DataStructure(Document *parent = 0);

    virtual ~DataStructure();

    virtual void importStructure(DataStructurePtr other);

    void initialize();
    template<typename T> static DataStructurePtr create(Document *parent = 0) {
        DataStructurePtr pi(new T(parent), deleter());
        pi->setQpointer(pi);
        pi->initialize();
        return pi;
    }
    template<typename T> static DataStructurePtr create(DataStructurePtr other, Document *parent = 0) {
        DataStructurePtr pi(new T(parent), deleter());
        pi->setQpointer(pi);
        pi->initialize();
        pi->importStructure(other);
        return pi;
    }

private:
    const QScopedPointer<DataStructurePrivate> d;

    DataStructure(const DataStructure&);
    DataStructure& operator=(const DataStructure&);

    void setQpointer(DataStructurePtr q);

    class deleter
    {
        public:
        void operator()(DataStructure * p) { delete p; }
    };
};

#endif