tool.h

Go to the documentation of this file.

/* This file is part of StepCore library.
   Copyright (C) 2007 Vladimir Kuznetsov <ks.vladimir@gmail.com>

   StepCore library 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.

   StepCore 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 General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with StepCore; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

// TODO: split this file

#ifndef STEPCORE_TOOL_H
#define STEPCORE_TOOL_H

#include "world.h"
#include "types.h"
#include <QHash>
#include <QByteArray>
#include <QStringList>

namespace StepCore
{

class NoteImage: public Item
{
    STEPCORE_OBJECT(NoteImage)

public:
    explicit NoteImage(const QString& name = QString(),
                       const QByteArray& image = QByteArray())
                            : Item(name), _image(image) {}

    const QByteArray& image() const { return _image; }

    void setImage(const QByteArray& image) { _image = image; }

protected:
    QByteArray _image;
};

class NoteFormula: public NoteImage
{
    STEPCORE_OBJECT(NoteFormula)

public:
    explicit NoteFormula(const QString& name = QString(),
                         const QByteArray& image = QByteArray(),
                         const QString& code = QString())
                            : NoteImage(name, image), _code(code) {}

    const QString& code() const { return _code; }
    void setCode(const QString& code) { _code = code; }

protected:
    QString    _code;
};

class Note: public ItemGroup, public Tool
{
    STEPCORE_OBJECT(Note)

public:
    explicit Note(Vector2d position = Vector2d::Zero(),
            Vector2d size = Vector2d(250,100), QString text = QString());

    const Vector2d& position() const { return _position; }
    void setPosition(const Vector2d& position) { _position = position; }

    const Vector2d& size() const { return _size; }
    void setSize(const Vector2d& size) { _size = size.cwise().abs(); }

    const QString& text() const { return _text; }
    void setText(const QString& text) { _text = text; }

protected:
    Vector2d _position;
    Vector2d _size;
    QString  _text;
};

class Graph: public Item, public Tool
{
    STEPCORE_OBJECT(Graph)

public:
    explicit Graph(Vector2d position = Vector2d::Zero(), Vector2d size = Vector2d(400,300));

    const Vector2d& position() const { return _position; }
    void setPosition(const Vector2d& position) { _position = position; }

    const Vector2d& size() const { return _size; }
    void setSize(const Vector2d& size) { _size = size.cwise().abs(); }

    Object* objectX() const { return _objectX; }
    void setObjectX(Object* objectX) { _objectX = objectX; }

    QString propertyX() const { return _propertyX; }
    void setPropertyX(const QString& propertyX) { _propertyX = propertyX; }

    int indexX() const { return _indexX; }
    void setIndexX(int indexX) { _indexX = indexX; }

    Object* objectY() const { return _objectY; }
    void setObjectY(Object* objectY) { _objectY = objectY; }

    QString propertyY() const { return _propertyY; }
    void setPropertyY(const QString& propertyY) { _propertyY = propertyY; }

    int indexY() const { return _indexY; }
    void setIndexY(int indexY) { _indexY = indexY; }

    bool autoLimitsX() const { return _autoLimitsX; }
    void setAutoLimitsX(bool autoLimitsX) { _autoLimitsX = autoLimitsX; }

    bool autoLimitsY() const { return _autoLimitsY; }
    void setAutoLimitsY(bool autoLimitsY) { _autoLimitsY = autoLimitsY; }

    const Vector2d& limitsX() const { return _limitsX; }
    void setLimitsX(const Vector2d& limitsX) { _limitsX = limitsX; }

    const Vector2d& limitsY() const { return _limitsY; }
    void setLimitsY(const Vector2d& limitsY) { _limitsY = limitsY; }

    bool showLines() const { return _showLines; }
    void setShowLines(bool showLines) { _showLines = showLines; }

    bool showPoints() const { return _showPoints; }
    void setShowPoints(bool showPoints) { _showPoints = showPoints; }

    const Vector2dList& points() const { return _points; }
    void setPoints(const Vector2dList& points) { _points = points; }

    const MetaProperty* propertyXPtr() const {
        return _objectX ? _objectX->metaObject()->property(_propertyX) : 0;
    }

    const MetaProperty* propertyYPtr() const {
        return _objectY ? _objectY->metaObject()->property(_propertyY) : 0;
    }

    bool isValidX() const;
    bool isValidY() const;
    bool isValid() const { return isValidX() && isValidY(); }

    Vector2d currentValue() const { return currentValue(0); }

    Vector2d currentValue(bool* ok) const;

    Vector2d recordPoint(bool* ok = 0);

    void clearPoints() { _points.clear(); }

    QString unitsX() const;

    QString unitsY() const;

    //void worldItemRemoved(Item* item);
    //void setWorld(World* world);

protected:
    Vector2d _position;
    Vector2d _size;

    Object* _objectX;
    QString       _propertyX;
    int           _indexX;

    Object* _objectY;
    QString       _propertyY;
    int           _indexY;

    bool        _autoLimitsX;
    bool        _autoLimitsY;

    Vector2d    _limitsX;
    Vector2d    _limitsY;

    bool _showLines;
    bool _showPoints;

    Vector2dList _points;
};

class Meter: public Item, public Tool
{
    STEPCORE_OBJECT(Meter)

public:
    explicit Meter(Vector2d position = Vector2d::Zero(), Vector2d size = Vector2d(70,24));

    const Vector2d& position() const { return _position; }
    void setPosition(const Vector2d& position) { _position = position; }

    const Vector2d& size() const { return _size; }
    void setSize(const Vector2d& size) { _size = size.cwise().abs(); }

    Object* object() const { return _object; }
    void setObject(Object* object) { _object = object; }

    QString property() const { return _property; }
    void setProperty(const QString& property) { _property = property; }

    int index() const { return _index; }
    void setIndex(int index) { _index = index; }

    int digits() const { return _digits; }
    void setDigits(int digits) { _digits = digits; }

    bool isValid() const;

    const MetaProperty* propertyPtr() const {
        return _object ? _object->metaObject()->property(_property) : 0;
    }

    double value() const { return value(0); }

    virtual void setValue(double) {}

    double value(bool* ok) const;

    QString units() const;

    //void worldItemRemoved(Item* item);
    //void setWorld(World* world);

protected:
    Vector2d _position;
    Vector2d _size;

    Object*  _object;
    QString  _property;
    int      _index;

    int      _digits;
};

class Controller: public Item, public Tool
{
    STEPCORE_OBJECT(Controller)

public:
    explicit Controller(Vector2d position = Vector2d::Zero(), Vector2d size = Vector2d(200,60));

    const Vector2d& position() const { return _position; }
    void setPosition(const Vector2d& position) { _position = position; }

    const Vector2d& size() const { return _size; }
    void setSize(const Vector2d& size) { _size = size.cwise().abs(); }

    Object* object() const { return _object; }
    void setObject(Object* object) { _object = object; }

    QString property() const { return _property; }
    void setProperty(const QString& property) { _property = property; }

    int index() const { return _index; }
    void setIndex(int index) { _index = index; }

    const Vector2d& limits() const { return _limits; }
    void setLimits(const Vector2d& limits) { _limits = limits; }

    const QString& decreaseShortcut() const { return _decreaseShortcut; }
    void setDecreaseShortcut(const QString& decreaseShortcut) { _decreaseShortcut = decreaseShortcut; }

    const QString& increaseShortcut() const { return _increaseShortcut; }
    void setIncreaseShortcut(const QString& increaseShortcut) { _increaseShortcut = increaseShortcut; }

    double increment() const { return _increment; }
    void setIncrement(double increment) { _increment = increment; }

    bool isValid() const;

    const MetaProperty* propertyPtr() const {
        return _object ? _object->metaObject()->property(_property) : 0;
    }

    double value() const { return value(0); }
    void setValue(double value) { setValue(value, 0); }

    double value(bool* ok) const;
    void setValue(double value, bool* ok);

    QString units() const;

    //void worldItemRemoved(Item* item);
    //void setWorld(World* world);

protected:
    Vector2d _position;
    Vector2d _size;

    Object*  _object;
    QString  _property;
    int      _index;

    Vector2d _limits;
    QString  _decreaseShortcut;
    QString  _increaseShortcut;

    double   _increment;
};

class Particle;
class RigidBody;

class Tracer: public Item, public Tool
{
    STEPCORE_OBJECT(Tracer)

public:
    explicit Tracer(Object* body = 0, const Vector2d& localPosition = Vector2d::Zero());

    Object* body() const { return _body; }
    void setBody(Object* body);

    Vector2d localPosition() const { return _localPosition; }
    void setLocalPosition(const Vector2d& localPosition) { _localPosition = localPosition; }

    Vector2d position() const;

    const Vector2dList& points() const { return _points; }
    void setPoints(const Vector2dList& points) { _points = points; }

    Vector2d recordPoint() { Vector2d p = position(); _points.push_back(p); return p; }

    void clearPoints() { _points.clear(); }

    //void worldItemRemoved(Item* item);
    //void setWorld(World* world);

protected:
    Object* _body;
    Vector2d _localPosition;
    Vector2dList _points;

    Particle*  _p;
    RigidBody* _r;
};

} // namespace StepCore

#endif