skymap.h

Go to the documentation of this file.

/***************************************************************************
                          skymap.h  -  K Desktop Planetarium
                             -------------------
    begin                : Sat Feb 10 2001
    copyright            : (C) 2001 by Jason Harris
    email                : jharris@30doradus.org
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef SKYMAP_H_
#define SKYMAP_H_

#define USEGL

#include <QTimer>
#include <QGraphicsView>
#include <QPixmap>
#include <QTime>


#include "skyobjects/skypoint.h"
#include "skyobjects/skyline.h"

#include "skymapdrawabstract.h"
#include "skymapqdraw.h"
#include "printing/legend.h"

#include <config-kstars.h>

class QPainter;
class QPaintDevice;
class QPixmap;

class dms;
class KStarsData;
class KSPopupMenu;
class SkyObject;
class InfoBoxWidget;
class InfoBoxes;
class Projector;

class QGraphicsScene;

#ifdef HAVE_OPENGL
class SkyMapGLDraw;
class SkyMapQDraw;
#endif

class SkyMap : public QGraphicsView {

    Q_OBJECT
        
    friend class SkyMapDrawAbstract; // FIXME: SkyMapDrawAbstract requires a lot of access to SkyMap
    friend class SkyMapQDraw; // FIXME: SkyMapQDraw requires access to computeSkymap

 protected:
    explicit SkyMap();

 public:
    static SkyMap* Create();

    static SkyMap* Instance();

    static bool IsSlewing() { return pinstance->isSlewing(); }

    ~SkyMap();

    enum Projection { Lambert,
                      AzimuthalEquidistant,
                      Orthographic,
                      Equirectangular,
                      Stereographic,
                      Gnomonic,
                      UnknownProjection };
              
    float fov();

    void showFocusCoords();

    void updateFocus();

    SkyPoint* focus() { return &Focus; }

    SkyPoint* destination() { return &Destination; }

    SkyPoint* focusPoint() { return &FocusPoint; }

    void setFocus( SkyPoint *f );

    void setFocus( const dms &ra, const dms &dec );

    void setFocusAltAz( const dms &alt, const dms & az);

    void setDestination( const SkyPoint& f );

    void setDestination( const dms &ra, const dms &dec );

    void setDestinationAltAz( const dms &alt, const dms & az);

    void setFocusPoint( SkyPoint *f ) { if ( f ) FocusPoint = *f; }

    SkyPoint* clickedPoint() { return &ClickedPoint; }

    void setClickedPoint( SkyPoint *f );

    SkyObject* clickedObject() const { return ClickedObject; }

    void setClickedObject( SkyObject *o );

    SkyObject* focusObject() const { return FocusObject; }

    void setFocusObject( SkyObject *o );

    void setupProjector();

    void setZoomFactor(double factor);

    bool isSlewing() const;

    // NOTE: This method is draw-backend independent.
    void updateAngleRuler();

    bool isObjectLabeled( SkyObject *o );

    /*@*@short Convenience function for shutting off tracking mode.  Just calls KStars::slotTrack().
        */
    void stopTracking();

    inline const Projector * projector() const { return m_proj; }

    // NOTE: These dynamic casts must not segfault. If they do, it's good because we know that there is a problem.
    inline void exportSkyImage( QPaintDevice *pd, bool scale = false ) { dynamic_cast<SkyMapDrawAbstract *>(m_SkyMapDraw)->exportSkyImage( pd, scale ); }

    inline void exportSkyImage( SkyQPainter *painter, bool scale = false ) { dynamic_cast<SkyMapDrawAbstract *>(m_SkyMapDraw)->exportSkyImage( painter, scale ); }

    SkyMapDrawAbstract* getSkyMapDrawAbstract() { return dynamic_cast<SkyMapDrawAbstract *>(m_SkyMapDraw); }

    inline void drawObjectLabels( QList< SkyObject* >& labelObjects ) { dynamic_cast<SkyMapDrawAbstract *>(m_SkyMapDraw)->drawObjectLabels( labelObjects ); }

    void setPreviewLegend(bool preview) { m_previewLegend = preview; }

    void setLegend(const Legend &legend) { m_legend = legend; }

    bool isInObjectPointingMode() { return m_objPointingMode; }

    void setObjectPointingMode(bool enabled) { m_objPointingMode = enabled; }

    void setFovCaptureMode(bool enabled) { m_fovCaptureMode = enabled; }

    bool isInFovCaptureMode() { return m_fovCaptureMode; }

    SkyPoint getCenterPoint();

public slots:
    void forceUpdate( bool now=false );

    void forceUpdateNow() { forceUpdate( true ); }

    void slotToggleGeoBox(bool);

    void slotToggleFocusBox(bool);

    void slotToggleTimeBox(bool);

    void slotToggleInfoboxes(bool);

    void slewFocus();

    void slotCenter();

    void slotDSS();

    void slotSDSS();

    void slotInfo();

    void slotImage();

    void slotDetail();

    void slotAddObjectLabel();

    void slotRemoveObjectLabel();

    void slotAddPlanetTrail();

    void slotRemovePlanetTrail();

    void addLink();

    void slotClockSlewing();

    // NOTE: This method is draw-backend independent.
    void slotBeginAngularDistance();

    void slotBeginStarHop(); // TODO: Add docs
    
    // NOTE: This method is draw-backend independent.
    void slotEndRulerMode();

    void slotCancelRulerMode();

    void slotAddFlag();

    void slotEditFlag( int flagIdx );

    void slotDeleteFlag( int flagIdx );

#ifdef HAVE_OPENGL
    void slotToggleGL();
#endif

#ifdef HAVE_XPLANET

    void slotXplanetToScreen();

    void slotXplanetToFile();
#endif

    void slotZoomIn();

    void slotZoomOut();

    void slotZoomDefault();

    void slotObjectSelected();

    void slotCancelLegendPreviewMode();

    void slotFinishFovCaptureMode();

    void slotCaptureFov();

signals:
    void destinationChanged();

    void linkAdded();

    void zoomChanged();

    void objectChanged(SkyObject*);

    void positionChanged(SkyPoint*);

    void mousePointChanged(SkyPoint*);

protected:
    virtual void keyPressEvent( QKeyEvent *e );

    virtual void keyReleaseEvent( QKeyEvent *e );

    virtual void mousePressEvent( QMouseEvent *e );

    virtual void mouseReleaseEvent( QMouseEvent *e );

    virtual void mouseDoubleClickEvent( QMouseEvent *e );

    virtual void mouseMoveEvent( QMouseEvent *e );

    virtual void wheelEvent( QWheelEvent *e );

    virtual void resizeEvent( QResizeEvent * );

private slots:
    void slotTransientLabel();

    void setMouseMoveCursor();

private:

    void setDefaultMouseCursor();

    void setZoomMouseCursor();

    double zoomFactor( const int modifier );

    double magFactor( const int modifier );

    void decMagLimit( const int modifier );

    void incMagLimit( const int modifier );

    void zoomInOrMagStep( const int modifier );

    void zoomOutOrMagStep( const int modifier );

    void beginRulerMode( bool starHopRuler ); // TODO: Add docs


#ifdef HAVE_XPLANET

    void startXplanet ( const QString & outputFile="" );
#endif

    bool mouseButtonDown, midMouseButtonDown;
    // true if mouseMoveEvent; needed by setMouseMoveCursor
    bool mouseMoveCursor;
    bool slewing, clockSlewing;
    //if false only old pixmap will repainted with bitBlt(), this
    // saves a lot of cpu usage
    bool computeSkymap;
    // True if we are either looking for angular distance or star hopping directions
    bool rulerMode;
    // True only if we are looking for star hopping directions. If
    // false while rulerMode is true, it means we are measuring angular
    // distance. FIXME: Find a better way to do this
    bool starHopDefineMode;
    double y0;

    double m_Scale;

    KStarsData *data;
    KSPopupMenu *pmenu;

    SkyPoint m_MousePoint;
    
    SkyPoint  Focus, ClickedPoint, FocusPoint, Destination;
    SkyObject *ClickedObject, *FocusObject;

    Projector *m_proj;

    SkyLine AngularRuler; //The line for measuring angles in the map
    QRect ZoomRect; //The manual-focus circle.

    // Mouse should not move for that interval to display tooltip
    static const int HOVER_INTERVAL = 500;
    // Timer for tooltips
    QTimer m_HoverTimer;

    // InfoBoxes. Used in desctructor to save state
    InfoBoxWidget* m_timeBox;
    InfoBoxWidget* m_geoBox;
    InfoBoxWidget* m_objBox;
    InfoBoxes*     m_iboxes;

    // legend
    bool m_previewLegend;
    Legend m_legend;

    bool m_objPointingMode;
    bool m_fovCaptureMode;


    QWidget *m_SkyMapDraw; // Can be dynamic_cast<> to SkyMapDrawAbstract

    // NOTE: These are pointers to the individual widgets
    #ifdef HAVE_OPENGL
    SkyMapQDraw *m_SkyMapQDraw;
    SkyMapGLDraw *m_SkyMapGLDraw;
    #endif

    QGraphicsScene *m_Scene;

    static SkyMap* pinstance;

};

#endif