clock.cpp

#include "clock.h"

#include "taskmanagerdata.h"

using namespace domain;

Clock::Clock() : m_time(QDateTime::currentDateTime())
{
    m_timer.setInterval(1000);
    connect(&m_timer, SIGNAL(timeout()), this, SLOT(tick()));
}

const QDateTime& Clock::time() const
{
    return m_time;
}

void Clock::setTime(const QDateTime& time)
{
    m_time = time;

    QList<StorableData*> notified;

    Q_FOREACH (QDateTime eventTime, m_events.keys())
    {
        if (eventTime > time)
            break;

        Q_FOREACH (StorableData* data, m_events.values(eventTime))
        {
            if (!notified.contains(data))
            {
                data->notify();
                notified << data;
            }
        }

        m_events.remove(eventTime);
    }

    emit timeChanged(time);
}

void Clock::addEvent(const QDateTime& time, StorableData* data)
{
    if (time > m_time)
        m_events.insert(time, data);
    else if (time == m_time)
        data->notify();
}

void Clock::removeEvents(StorableData* data)
{
    Q_FOREACH (QDateTime time, m_events.keys())
        m_events.remove(time, data);
}

void Clock::deleteEvents(StorableData* data)
{
    TaskManagerData::instance()->clock()->removeEvents(data);
}

QDateTime Clock::currentTime()
{
    return TaskManagerData::instance()->clock()->time();
}

void Clock::newEvent(const QDateTime& time, StorableData* data)
{
    TaskManagerData::instance()->clock()->addEvent(time, data);
}

void Clock::setTicking(bool enable)
{
    if (enable)
    {
        if (!m_timer.isActive())
            m_timer.start();
    }
    else
        m_timer.stop();
}

bool Clock::isTicking() const
{
    return m_timer.isActive();
}

void Clock::tick()
{
    setTime(m_time.addSecs(1));
}

---