globaltimeconstraint.h

Go to the documentation of this file.

#ifndef TIMECONSTRAINT_H
#define TIMECONSTRAINT_H

#include <QDebug>
#include <QObject>
#include <QDateTime>
class TimeConstraintToolBar;

#include <QMutex>
#include <QMutexLocker>

class TimeConstraint: public QObject{
    Q_OBJECT
public:
    enum ConstraintType {
        TypeBeginTime = Qt::UserRole + 600,
        TypeEndTime
    };

    static TimeConstraint* instance(){
        static TimeConstraint timeConstraint;
        return &timeConstraint;
    }

    QDateTime getTimeConstraint(const TimeConstraint::ConstraintType &type) const {
        switch (type){
        case TimeConstraint::TypeBeginTime: return beginTime;
        case TimeConstraint::TypeEndTime: return endTime;
        }
        Q_ASSERT_X(false, "TimeConstraint::getTimeConstraint()", "type undefined");
        return QDateTime();
    }

public slots:
    void setTimeConstraint(const TimeConstraint::ConstraintType &type, const QDateTime &timestamp){
        switch (type){
        case TimeConstraint::TypeBeginTime:{
                if (beginTime != timestamp){
                    beginTime = timestamp;
                    emit signalOnTimeConstraintChange(TimeConstraint::TypeBeginTime, beginTime);
                }
                break;
            }
        case TimeConstraint::TypeEndTime:{
                if (endTime != timestamp){
                    endTime = timestamp;
                    emit signalOnTimeConstraintChange(TimeConstraint::TypeEndTime, endTime);
                }
                break;
            }
        }
    }

protected:
    TimeConstraint(){
        // initialize values
        QDateTime now = QDateTime::currentDateTime();
        //beginTime = now.addDays(-1);
        beginTime = QDateTime::fromString("2009-07-01T00:00:00", Qt::ISODate);
        //endTime = now;
        endTime = QDateTime::fromString("2009-07-08T00:00:00", Qt::ISODate);
    };
    TimeConstraint(const TimeConstraint &){} //makes copying impossible

signals:
    void signalOnTimeConstraintChange(const TimeConstraint::ConstraintType &, const QDateTime &data);

private:
    QDateTime beginTime;
    QDateTime endTime;
};

#include <QToolBar>
#include <QDateTimeEdit>
#include <QLabel>
#include <QAction>

class TimeConstraintToolBar : public QToolBar{
    Q_OBJECT
public:
    TimeConstraintToolBar(QWidget *parent = 0) : QToolBar("Global time-constraint on data", parent){
        setObjectName("TimeConstraintToolBar");
        setWindowTitle("Global time constraint");
        setToolTip(tr("This constraint is applied to all the data fetched from the database.\n"
                      "Note that for large intervals, fetching might take a considerable amount of time."));

        // setup layout
        moveLeft = new QAction("<<", this);
        addAction(moveLeft);
        addWidget(new QLabel("From: ", this));
        beginTimeEditor = new QDateTimeEdit(this);
        beginTimeEditor->setDisplayFormat("yyyy-MM-dd hh:mm");
        beginTimeEditor->setCalendarPopup(true);
        addWidget(beginTimeEditor);
        addWidget(new QLabel("To: ", this));
        endTimeEditor = new QDateTimeEdit(this);
        endTimeEditor->setDisplayFormat("yyyy-MM-dd hh:mm");
        endTimeEditor->setCalendarPopup(true);
        addWidget(endTimeEditor);
        moveRight = new QAction(">>",this);
        addAction(moveRight);

        // setup values
        syncThis(TimeConstraint::TypeBeginTime);
        syncThis(TimeConstraint::TypeEndTime);

        // setup sync connections
        connect(TimeConstraint::instance(), SIGNAL(signalOnTimeConstraintChange(TimeConstraint::ConstraintType, QDateTime)),
                this, SLOT(onTimeConstraintChange(TimeConstraint::ConstraintType, QDateTime)));
        connect(beginTimeEditor, SIGNAL(dateTimeChanged(QDateTime)), this, SLOT(onBeginTimeEdit(QDateTime)));
        connect(endTimeEditor, SIGNAL(dateTimeChanged(QDateTime)), this, SLOT(onEndTimeEdit(QDateTime)));
        connect(moveLeft, SIGNAL(triggered()), this, SLOT(onMoveLeftActionTrigger()));
        connect(moveRight, SIGNAL(triggered()), this, SLOT(onMoveRightActionTrigger()));
    }

private:
    void syncThis(const TimeConstraint::ConstraintType &type){
        switch(type){
        case TimeConstraint::TypeBeginTime:
            beginTimeEditor->setDateTime(TimeConstraint::instance()->getTimeConstraint(TimeConstraint::TypeBeginTime)); break;
        case TimeConstraint::TypeEndTime:
            endTimeEditor->setDateTime(TimeConstraint::instance()->getTimeConstraint(TimeConstraint::TypeEndTime)); break;
        }
    }

    void writeToTimeConstraint(const TimeConstraint::ConstraintType &type, const QDateTime &data){
        switch(type){
        case TimeConstraint::TypeBeginTime:
            TimeConstraint::instance()->setTimeConstraint(TimeConstraint::TypeBeginTime, data); break;
        case TimeConstraint::TypeEndTime:
            TimeConstraint::instance()->setTimeConstraint(TimeConstraint::TypeEndTime, data); break;
        }
        sanityCheck();
    }

    uint interval() const {
        int interval = beginTimeEditor->dateTime().secsTo(endTimeEditor->dateTime());
        Q_ASSERT(interval >= 0);
        return interval;
    }

private slots:
    void onBeginTimeEdit(const QDateTime &data){
        writeToTimeConstraint(TimeConstraint::TypeBeginTime, data);
        sanityCheck();
    }

    void onEndTimeEdit(const QDateTime &data){
        writeToTimeConstraint(TimeConstraint::TypeEndTime, data);
        sanityCheck();
    }

    void onTimeConstraintChange(const TimeConstraint::ConstraintType &type, const QDateTime &){
        syncThis(type);
        sanityCheck();
    }

    void onMoveLeftActionTrigger(){
        uint old_interval = interval();
        beginTimeEditor->setDateTime(beginTimeEditor->dateTime().addSecs(-old_interval));
        endTimeEditor->setDateTime(endTimeEditor->dateTime().addSecs(-old_interval));
    }

    void onMoveRightActionTrigger(){
        uint old_interval = interval();
        beginTimeEditor->setDateTime(beginTimeEditor->dateTime().addSecs(old_interval));
        endTimeEditor->setDateTime(endTimeEditor->dateTime().addSecs(old_interval));
    }

    void sanityCheck(){
        // sanity check
        Q_ASSERT(endTimeEditor->dateTime() == TimeConstraint::instance()->getTimeConstraint(TimeConstraint::TypeEndTime));
        Q_ASSERT(beginTimeEditor->dateTime() == TimeConstraint::instance()->getTimeConstraint(TimeConstraint::TypeBeginTime));
    }

private:
    QDateTimeEdit *beginTimeEditor;
    QDateTimeEdit *endTimeEditor;
    QAction *moveLeft;
    QAction *moveRight;
};


#endif // TIMECONSTRAINT_H