• Skip to content
• Skip to link menu

KDE 3.5 API Reference

• KDE API Reference
• API Reference

• Sitemap
• Contact Us

 

kstars

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

#include <qtimer.h>
#include <qwidget.h>

#include "skypoint.h"
#include "starpixmap.h"

#define HOVER_INTERVAL 500 

class QPainter;
class QPaintDevice;
class QPoint;
class QPointArray;
class QPixmap;

class dms;
class InfoBoxes;
class KStars;
class KStarsData;
class KSPlanetBase;
class KSPopupMenu;
class SkyObject;
class DeepSkyObject;

class SkyMap : public QWidget  {
   Q_OBJECT
public:
    SkyMap( KStarsData *d, QWidget *parent=0, const char *name=0);

    ~SkyMap();

    InfoBoxes* infoBoxes() const { return IBoxes; }

    void showFocusCoords( bool coordsOnly = false );

    void updateFocus();

    SkyPoint* focus() { return &Focus; }

    SkyPoint* destination() { return &Destination; }

    SkyPoint* focusPoint() { return &FocusPoint; }

    SkyPoint* oldfocus() { return &OldFocus; }

    void setFocus( SkyPoint *f );

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

    void setFocus(double ra, double dec);

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

    void setFocusAltAz(double alt, double az);

    void setDestination( SkyPoint *f );

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

    void setDestination(double ra, double dec);

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

    void setDestinationAltAz(double alt, double az);

    void setOldFocus( SkyPoint *f ) { OldFocus.set( f->ra(), f->dec() ); }

    void setFocusPoint( SkyPoint *f ) { if ( f ) FocusPoint.set( f->ra(), f->dec() ); }

    SkyPoint* clickedPoint() { return &ClickedPoint; }

    void setClickedPoint( SkyPoint *f ) { ClickedPoint.set( f->ra(), f->dec() ); }

    SkyPoint* previousClickedPoint() { return &PreviousClickedPoint; }

    void setPreviousClickedPoint( SkyPoint *f ) { PreviousClickedPoint.set( f->ra(), f->dec() ); }

    SkyPoint* mousePoint() { return &MousePoint; }

    void setMousePoint( SkyPoint f ) { MousePoint.set( f.ra(), f.dec() ); }

    SkyObject* objectNearest( SkyPoint *p );

    SkyObject* clickedObject( void ) const { return ClickedObject; }

    void setClickedObject( SkyObject *o ) { ClickedObject = o; }

    SkyObject* focusObject( void ) const { return FocusObject; }

    void setFocusObject( SkyObject *o );

    SkyObject* transientObject( void ) const { return TransientObject; }
    
    void setTransientObject( SkyObject *o ) { TransientObject = o; }

    int starColorMode( void ) const { return starpix->mode(); }

    void setStarColorMode( int mode ) { starpix->setColorMode( mode ); }

    int starColorIntensity( void ) const { return starpix->intensity(); }

    void setStarColorIntensity( int value ) { starpix->setIntensity( value ); }

    void setMapGeometry( void );

    void invokeKey( int key );

    bool isAngleMode() const {return angularDistanceMode;}

    void updateAngleRuler();


    bool isObjectLabeled( SkyObject *o );

    void stopTracking();

    void exportSkyImage( const QPaintDevice *pd );

public slots:
    virtual void setGeometry( int x, int y, int w, int h );
    
    virtual void setGeometry( const QRect &r );

    void forceUpdate( bool now=false );

    void forceUpdateNow() { forceUpdate( true ); }

    dms refract( const dms *alt, bool findApparent );

    void slewFocus( void );

    void slotCenter( void );

    void slotDSS( void );

    void slotDSS2( void );

    void slotInfo( int id );

    void slotImage( int id );

    void slotDetail( void );

    void slotAddObjectLabel( void );

    void slotRemoveObjectLabel( void );

    void slotAddPlanetTrail( void );
    
    void slotRemovePlanetTrail( void );

    void addLink( void );

    void slotClockSlewing();

    void slotBeginAngularDistance(void);

    void slotEndAngularDistance(void);

    void slotCancelAngularDistance(void);

signals:
    void destinationChanged();
    
    void linkAdded();

protected:
    virtual void paintEvent( QPaintEvent *e );

    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 slotTransientTimeout();

    void slotTransientLabel();

    void setMouseMoveCursor();

private:
// Drawing functions.  Each takes a QPainter reference and a scaling factor as arguments.
// The QPainter is usually the Sky pixmap, but it can also be the Export-to-Image pixmap, or the 
// Printer device.  The scaling factors are 1.0 by default (for screen images).  The scale factor
// is used to resize the image to fit the page when printing or exporting to a file.

    void drawMilkyWay( QPainter& psky, double scale = 1.0 );
    
    void drawCoordinateGrid( QPainter& psky, double scale = 1.0 );
    
    void drawEquator( QPainter& psky, double scale = 1.0 );
    
    void drawEcliptic( QPainter& psky, double scale = 1.0 );
    
    void drawHorizon( QPainter& psky, double scale = 1.0 );
    void drawConstellationLines( QPainter& psky, double scale = 1.0 );
    
    void drawConstellationBoundaries( QPainter& psky, double scale = 1.0 );
    
    void drawConstellationNames( QPainter& psky, double scale = 1.0 );
    
    void drawStars( QPainter& psky, double scale = 1.0 );
    
    void drawDeepSkyObjects( QPainter& psky, double scale = 1.0 );
    
    void drawDeepSkyCatalog( QPainter& psky, QPtrList<DeepSkyObject>& catalog, QColor& color, bool drawObject, bool drawImage, double scale = 1.0 );
    
    void drawPlanetTrail( QPainter& psky, KSPlanetBase *ksp, double scale = 1.0 );
    
    void drawSolarSystem( QPainter& psky, bool drawPlanets, double scale = 1.0 );
    
    void drawAttachedLabels( QPainter &psky, double scale = 1.0 );
    
    void drawNameLabel( QPainter &psky, SkyObject *obj, int x, int y, double scale );

    void drawPlanet(QPainter &psky, KSPlanetBase *p, QColor c,
            double zoommin, int resize_mult = 1, double scale = 1.0 );
    
    void drawOverlays( QPixmap *pm );
    
    void drawBoxes( QPainter &p );
    
    void drawTelescopeSymbols(QPainter &psky);
    
    void drawObservingList( QPainter &psky, double scale = 1.0 );

    void drawZoomBox( QPainter &psky);
    
    void drawTransientLabel( QPainter &psky );

    void drawAngleRuler( QPainter &psky );


    QPoint getXY( SkyPoint *o, bool Horiz, bool doRefraction=true, double scale = 1.0 );

    SkyPoint dXdYToRaDec( double dx, double dy, bool Horiz, dms *LST, const dms *lat, bool doRefraction=true );

    float fov();

    bool checkVisibility( SkyPoint *p, float fov, double XMax );

    void fadeTransientLabel() { TransientTimer.start( TransientTimeout ); }

    double findPA( SkyObject *o, int x, int y, double scale=1.0 );

    void setDefaultMouseCursor();

    void setZoomMouseCursor();

    bool unusablePoint (double dx, double dy);

    bool mouseButtonDown, midMouseButtonDown;
    bool mouseMoveCursor;  // true if mouseMoveEvent; needed by setMouseMoveCursor
    bool slewing, clockSlewing;
    bool computeSkymap;  //if false only old pixmap will repainted with bitBlt(), this saves a lot of cpu usage
    bool angularDistanceMode;
    int idSolInfo, idMessHST, idMoonInfo, idMoonImages, idMessInfo, idNGCHST;
    int scrollCount;
    double Range;
    double RefractCorr1[184], RefractCorr2[184];
    double y0;

    //data for checkVisibility
    bool isPoleVisible;
    int guidemax;
    float guideFOV;
    double XRange, Ymax;
    double guideXRange;

    QString sURL;
    
    KStars *ksw;
    KStarsData *data;
    KSPopupMenu *pmenu;
    QPixmap *sky, *sky2;
    InfoBoxes  *IBoxes;
    SkyPoint  Focus, OldFocus, ClickedPoint, FocusPoint, MousePoint, Destination, PreviousClickedPoint;
    SkyObject *ClickedObject, *FocusObject, *TransientObject;
    StarPixmap *starpix;    // the pixmap of the stars

    QPointArray *pts;   // needed in paintEvent() so it should not every event call reallocated (save time)
    SkyPoint *sp;           // see line above

    QPoint beginRulerPoint, endRulerPoint;  // used in angle mode
    QRect ZoomRect; //The manual-focus circle.

    //data for transient object labels
    QTimer TransientTimer, HoverTimer;
    QColor TransientColor;
    unsigned int TransientTimeout;
};

#endif

kstars

Skip menu "kstars"

• Main Page
• Modules
• Class Hierarchy
• Alphabetical List
• Class List
• File List
• Class Members
• Related Pages

API Reference

Skip menu "API Reference"

• keduca
• kstars

Generated for API Reference by doxygen 1.5.9
This website is maintained by Adriaan de Groot and Allen Winter.
KDE^® and the K Desktop Environment^® logo are registered trademarks of KDE e.V. | Legal