SyncServerEventSenders.hpp

/*
 * Stellarium Remote Sync plugin
 * Copyright (C) 2015 Florian Schaukowitsch
 *
 * 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., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
 */

#ifndef SYNCSERVEREVENTSENDERS_HPP_
#define SYNCSERVEREVENTSENDERS_HPP_

#include "SyncProtocol.hpp"
#include "SyncMessages.hpp"

class SyncServer;
class StelCore;
class StelObjectMgr;

class SyncServerEventSender : public QObject
{
    Q_OBJECT
public:
    SyncServerEventSender();
    virtual ~SyncServerEventSender() {}

protected slots:

    virtual void reactToStellariumEvent() { isDirty = true; }

    virtual void newClientConnected(SyncRemotePeer& client) { Q_UNUSED(client); }
protected:
    virtual void update() {}

    void broadcastMessage(const SyncProtocol::SyncMessage& msg);
    bool isDirty;
    StelCore* core;
private:
    SyncServer* server;
    friend class SyncServer;
};

template<class T>
class TypedSyncServerEventSender : public SyncServerEventSender
{
protected:
    virtual T constructMessage() = 0;

    virtual void newClientConnected(SyncRemotePeer& client) Q_DECL_OVERRIDE;

    virtual void update() Q_DECL_OVERRIDE;
};

template<class T>
void TypedSyncServerEventSender<T>::newClientConnected(SyncRemotePeer& client)
{
    client.writeMessage(constructMessage());
}

template<class T>
void TypedSyncServerEventSender<T>::update()
{
    if(isDirty)
    {
        broadcastMessage(constructMessage());
        isDirty = false;
    }
}

class TimeEventSender : public TypedSyncServerEventSender<SyncProtocol::Time>
{
    Q_OBJECT

public:
    TimeEventSender();
protected:
    SyncProtocol::Time constructMessage() Q_DECL_OVERRIDE;
};

class LocationEventSender : public TypedSyncServerEventSender<SyncProtocol::Location>
{
    Q_OBJECT
public:
    LocationEventSender();
protected:
    SyncProtocol::Location constructMessage() Q_DECL_OVERRIDE;
};

class SelectionEventSender : public TypedSyncServerEventSender<SyncProtocol::Selection>
{
    Q_OBJECT
public:
    SelectionEventSender();
protected:
    SyncProtocol::Selection constructMessage() Q_DECL_OVERRIDE;
private:
    StelObjectMgr* objMgr;
};

class StelProperty;
class StelPropertyMgr;
class StelPropertyEventSender : public SyncServerEventSender
{
    Q_OBJECT
public:
    StelPropertyEventSender();
protected slots:
    virtual void newClientConnected(SyncRemotePeer& client) Q_DECL_OVERRIDE;
    void sendStelPropChange(StelProperty* prop, const QVariant& val);
private:
    StelPropertyMgr* propMgr;
};

class StelMovementMgr;
class ViewEventSender : public TypedSyncServerEventSender<SyncProtocol::View>
{
    Q_OBJECT
public:
    ViewEventSender();
protected:
    SyncProtocol::View constructMessage() Q_DECL_OVERRIDE;

    void update() Q_DECL_OVERRIDE;
private:
    StelMovementMgr* mvMgr;
    Vec3d lastView;
};

class FovEventSender : public TypedSyncServerEventSender<SyncProtocol::Fov>
{
    Q_OBJECT
public:
    FovEventSender();
protected:
    SyncProtocol::Fov constructMessage() Q_DECL_OVERRIDE;

    void update() Q_DECL_OVERRIDE;
private:
    StelMovementMgr* mvMgr;
    double lastFov;
};

#endif