TelescopeControl.hpp

/*
 * Stellarium Telescope Control Plug-in
 * 
 * Copyright (C) 2006 Johannes Gajdosik
 * Copyright (C) 2009-2010 Bogdan Marinov
 * 
 * This module was originally written by Johannes Gajdosik in 2006
 * as a core module of Stellarium. In 2009 it was significantly extended with
 * GUI features and later split as an external plug-in module by Bogdan Marinov.
 *
 * This class used to be called TelescopeMgr before the split.
 *
 * 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 _TELESCOPE_CONTROL_HPP_
#define _TELESCOPE_CONTROL_HPP_

#include "StelFader.hpp"
#include "StelGui.hpp"
#include "StelJsonParser.hpp"
#include "StelObjectModule.hpp"
#include "StelProjectorType.hpp"
#include "TelescopeControlGlobals.hpp"
#include "VecMath.hpp"

#include <QFile>
#include <QFont>
#include <QHash>
#include <QMap>
#include <QProcess>
#include <QSettings>
#include <QString>
#include <QStringList>
#include <QTextStream>
#include <QVariant>

class StelObject;
class StelProjector;
class TelescopeClient;
class TelescopeDialog;
class SlewDialog;

using namespace TelescopeControlGlobals;

typedef QSharedPointer<TelescopeClient> TelescopeClientP;

class TelescopeControl : public StelObjectModule
{
    Q_OBJECT

public:
    TelescopeControl();
    virtual ~TelescopeControl();
    
    // Methods defined in the StelModule class
    virtual void init();
    virtual void deinit();
    virtual void update(double deltaTime);
    virtual void draw(StelCore * core, class StelRenderer* renderer);
    virtual double getCallOrder(StelModuleActionName actionName) const;
    
    // Methods defined in the StelObjectModule class
    virtual QList<StelObjectP> searchAround(const Vec3d& v, double limitFov, const StelCore* core) const;
    virtual StelObjectP searchByNameI18n(const QString& nameI18n) const;
    virtual StelObjectP searchByName(const QString& name) const;
    virtual QStringList listMatchingObjectsI18n(const QString& objPrefix, int maxNbItem=5) const;
    virtual QStringList listMatchingObjects(const QString& objPrefix, int maxNbItem=5) const;
    // empty as its not celestial objects
    virtual QStringList listAllObjects(bool inEnglish) const { Q_UNUSED(inEnglish) return QStringList(); }
    virtual QString getName() const { return "Telescope Control"; }
    virtual bool configureGui(bool show = true);
    
    // Methods specific to TelescopeControl
    void telescopeGoto(int telescopeNr, const Vec3d &j2000Pos);
    
    void deleteAllTelescopes();
    
    const QHash<QString, DeviceModel>& getDeviceModels();
    
    void loadConfiguration();
    void saveConfiguration();
    
    void saveTelescopes();
    void loadTelescopes();
    
    //These are public, but not slots, because they don't use sufficient validation. Scripts shouldn't be able to add/remove telescopes, only to point them.
    bool addTelescopeAtSlot(int slot, ConnectionType connectionType, QString name, QString equinox, QString host = QString("localhost"), int portTCP = DEFAULT_TCP_PORT, int delay = DEFAULT_DELAY, bool connectAtStartup = false, QList<double> circles = QList<double>(), QString serverName = QString(), QString portSerial = QString());
    bool getTelescopeAtSlot(int slot, ConnectionType& connectionType, QString& name, QString& equinox, QString& host, int& portTCP, int& delay, bool& connectAtStartup, QList<double>& circles, QString& serverName, QString& portSerial);
    bool removeTelescopeAtSlot(int slot);
    
    bool startTelescopeAtSlot(int slot);
    bool stopTelescopeAtSlot(int slot);
    bool stopAllTelescopes();
    
    bool isExistingClientAtSlot(int slot);
    bool isConnectedClientAtSlot(int slot);

    QHash<int, QString> getConnectedClientsNames();
    
    bool getFlagUseServerExecutables() {return useServerExecutables;}
    void setFlagUseServerExecutables(bool b);
    const QString& getServerExecutablesDirectoryPath();
    bool setServerExecutablesDirectoryPath(const QString& newPath);
    
    bool getFlagUseTelescopeServerLogs () {return useTelescopeServerLogs;}

public slots:
    void setFlagTelescopeReticles(bool b) {reticleFader = b;}
    bool getFlagTelescopeReticles() const {return (bool)reticleFader;}
    
    void setFlagTelescopeLabels(bool b) {labelFader = b;}
    bool getFlagTelescopeLabels() const {return labelFader==true;}

    void setFlagTelescopeCircles(bool b) {circleFader = b;}
    bool getFlagTelescopeCircles() const {return circleFader==true;}
    
    void setReticleColor(const Vec3f &c) {reticleColor = c;}
    const Vec3f& getReticleColor() const {return reticleColor;}
    
    const Vec3f& getLabelColor() const {return labelColor;}
    void setLabelColor(const Vec3f &c) {labelColor = c;}

    void setCircleColor(const Vec3f &c) {circleColor = c;}
    const Vec3f& getCircleColor() const {return circleColor;}
    
    void setFontSize(int fontSize);
    
    void slewTelescopeToSelectedObject();

    void slewTelescopeToViewDirection();
    
    void setFlagUseTelescopeServerLogs (bool b) {useTelescopeServerLogs = b;}

signals:
    void clientConnected(int slot, QString name);
    void clientDisconnected(int slot);

private slots:
    void setStelStyle(const QString& section);
    void translateActionDescriptions();

private:
    void drawPointer(const StelProjectorP& prj, const StelCore* core, class StelRenderer* renderer);

    void communicate(void);
    
    LinearFader labelFader;
    LinearFader reticleFader;
    LinearFader circleFader;
    Vec3f reticleColor;
    Vec3f labelColor;
    Vec3f circleColor;
    Vec3f reticleNormalColor;
    Vec3f reticleNightColor;
    Vec3f labelNormalColor;
    Vec3f labelNightColor;
    Vec3f circleNormalColor;
    Vec3f circleNightColor;
    
    QFont labelFont;
    
    //Toolbar button to toggle the Slew window
    QPixmap* pixmapHover;
    QPixmap* pixmapOnIcon;
    QPixmap* pixmapOffIcon;
    StelButton* toolbarButton;
    
    class StelTextureNew* reticleTexture;
    class StelTextureNew* selectionTexture;
    
    QMap<int, TelescopeClientP> telescopeClients;
    QHash<int, QProcess*> telescopeServerProcess;
    QStringList telescopeServers;
    QVariantMap telescopeDescriptions;
    QHash<QString, DeviceModel> deviceModels;
    
    QHash<ConnectionType, QString> connectionTypeNames;
    
    bool useTelescopeServerLogs;
    QHash<int, QFile*> telescopeServerLogFiles;
    QHash<int, QTextStream*> telescopeServerLogStreams;
    
    bool useServerExecutables;
    QString serverExecutablesDirectoryPath;
    
    //GUI
    TelescopeDialog * telescopeDialog;
    SlewDialog * slewDialog;
    
    bool isValidSlotNumber(int slot);
    bool isValidPort(uint port);
    bool isValidDelay(int delay);
    
    bool startServerAtSlot(int slot, QString serverName, int tcpPort, QString serialPort);
    bool stopServerAtSlot(int slot);

    bool startClientAtSlot(int slot, ConnectionType connectionType, QString name, QString equinox, QString host, int portTCP, int delay, QList<double> circles, QString serverName = QString(), QString portSerial = QString());
    
    bool stopClientAtSlot(int slot);
    
    void loadTelescopeServerExecutables();
    
    void loadDeviceModels();
    
    bool restoreDeviceModelsListTo(QString deviceModelsListPath);
    
    void addLogAtSlot(int slot);
    void logAtSlot(int slot);
    void removeLogAtSlot(int slot);
    
    QString actionGroupId;
    QString moveToSelectedActionId;
    QString moveToCenterActionId;
};


#include "fixx11h.h"
#include <QObject>
#include "StelPluginInterface.hpp"

class TelescopeControlStelPluginInterface : public QObject, public StelPluginInterface
{
    Q_OBJECT
    Q_INTERFACES(StelPluginInterface)
public:
    virtual StelModule* getStelModule() const;
    virtual StelPluginInfo getPluginInfo() const;
};

#endif /*_TELESCOPE_CONTROL_HPP_*/