File indexing completed on 2024-04-14 03:43:37

 /*
     SPDX-FileCopyrightText: 2016 Artem Fedoskin <afedoskin3@gmail.com>
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include "skyobjects/skypoint.h"
 #include "skyobjects/skyline.h"
 
 #include <QTimer>
 #include <QPainter>
 
 #include <config-kstars.h>
 #include <QQuickItem>
 #include <QPolygonF>
 #include <QLinkedList>
 #include "kstarsdata.h"
 #include "kstarslite/skyitems/rootnode.h"
 
 #include <basedevice.h>
 
 class DeviceOrientation;
 
 class dms;
 class KStarsData;
 class SkyObject;
 class Projector;
 class SolarSystemSingleComponent;
 class PlanetsItem;
 class AsteroidsItem;
 class CometsItem;
 class PlanetMoonsComponent;
 class HorizonItem;
 class LinesItem;
 class SkyNode;
 class RootNode;
 class TelescopeLite;
 
 class SkyObjectLite;
 class SkyPointLite;
 
 class QSGTexture;
 
 /** @class SkyMapLite
 *
 *This is the main item that displays all SkyItems. After its instantiation it is reparanted
 *to an object with objectName SkyMapLiteWrapper in main.qml. To display SkyItems they are reparanted
 *to instance of SkyMapLite.
 *
 *SkyMapLite handles most user interaction events (both mouse and keyboard).
 *
 *@short Item for displaying sky objects; also handles user interaction events.
 *@author Artem Fedoskin
 *@version 1.0
 */
 
 class SkyMapLite : public QQuickItem
 {
         Q_OBJECT
         /** magnitude limit. Used in QML **/
         Q_PROPERTY(double magLim READ getMagLim WRITE setMagLim NOTIFY magLimChanged)
 
         /** wrappers for clickedPoint and clickedObject. Used to set clicked object and point from QML **/
         Q_PROPERTY(SkyPointLite *clickedPointLite READ getClickedPointLite NOTIFY pointLiteChanged)
         Q_PROPERTY(SkyObjectLite *clickedObjectLite READ getClickedObjectLite NOTIFY objectLiteChanged)
         /** list of FOVSymbols that are currently available **/
         Q_PROPERTY(QStringList FOVSymbols READ getFOVSymbols NOTIFY symbolsFOVChanged)
         /** true if SkyMapLite is being panned **/
         Q_PROPERTY(bool slewing READ getSlewing WRITE setSlewing NOTIFY slewingChanged)
         /**
              * @short true if SkyMapLite is centered on an object and only pinch-to-zoom needs to be available
             **/
         Q_PROPERTY(bool centerLocked READ getCenterLocked WRITE setCenterLocked NOTIFY centerLockedChanged)
         Q_PROPERTY(bool automaticMode READ getAutomaticMode WRITE setAutomaticMode NOTIFY automaticModeChanged)
         Q_PROPERTY(double skyRotation READ getSkyRotation WRITE setSkyRotation NOTIFY skyRotationChanged)
 
         enum class SkyMapOrientation
         {
             Top0,
             Right90,
             Bottom180,
             Left270
         };
 
     protected:
         SkyMapLite();
 
         /** Updates SkyMapLite by calling RootNode::update(), which in turn initiates update of all child nodes. **/
         virtual QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *updatePaintNodeData) override;
 
     public:
         /** Creates instance of SkyMapLite (delete the old one if any) **/
         static SkyMapLite *createInstance();
 
         /** Bind size to parent's size and initialize star images **/
         void initialize(QQuickItem *parent);
 
         static SkyMapLite *Instance()
         {
             return pinstance;
         }
 
         static bool IsSlewing()
         {
             return pinstance->isSlewing();
         }
 
         /** Destructor. Clear star images.*/
         ~SkyMapLite();
 
         /**
              * @short skyNode will be deleted on the next call to updatePaintNode (currently used only in
              * StarNode(struct in StarBlock))
              */
         void deleteSkyNode(SkyNode *skyNode);
 
         /** @short Update the focus position according to current options. */
         void updateFocus();
 
         /** @short Retrieve the Focus point; the position on the sky at the
              *center of the skymap.
              *@return a pointer to the central focus point of the sky map
              */
         SkyPoint *focus()
         {
             return &Focus;
         }
 
         /** @short retrieve the Destination position.
              *
              *The Destination is the point on the sky to which the focus will be moved.
              *@return a pointer to the destination point of the sky map
              */
         SkyPoint *destination()
         {
             return &Destination;
         }
 
         /** @short retrieve the FocusPoint position.
              *
              *The FocusPoint stores the position on the sky that is to be
              *focused next.  This is not exactly the same as the Destination
              *point, because when the Destination is set, it will begin slewing
              *immediately.
              *
              *@return a pointer to the sky point which is to be focused next.
              */
         SkyPoint *focusPoint()
         {
             return &FocusPoint;
         }
 
         /** @short sets the central focus point of the sky map.
              *@param f a pointer to the SkyPoint the map should be centered on
              */
         void setFocus(SkyPoint *f);
 
         /** @short sets the focus point of the skymap, using ra/dec coordinates
              *
              *@note This function behaves essentially like the above function.
              *It differs only in the data types of its arguments.
              *
              *@param ra the new right ascension
              *@param dec the new declination
              */
         void setFocus(const dms &ra, const dms &dec);
 
         /** @short sets the focus point of the sky map, using its alt/az coordinates
              *@param alt the new altitude (actual, i.e. without refraction correction)
              *@param az the new azimuth
              */
         void setFocusAltAz(const dms &alt, const dms &az);
 
         /** @short sets the destination point of the sky map.
              *@note setDestination() emits the destinationChanged() SIGNAL,
              *which triggers the SLOT function SkyMap::slewFocus().  This
              *function iteratively steps the Focus point toward Destination,
              *repainting the sky at each step (if Options::useAnimatedSlewing()==true).
              *@param f a pointer to the SkyPoint the map should slew to
              */
         void setDestination(const SkyPoint &f);
 
         /** @short sets the destination point of the skymap, using ra/dec coordinates.
              *
              *@note This function behaves essentially like the above function.
              *It differs only in the data types of its arguments.
              *
              *@param ra the new right ascension
              *@param dec the new declination
              */
         void setDestination(const dms &ra, const dms &dec);
 
         /** @short sets the destination point of the sky map, using its alt/az coordinates.
              *@param alt the new altitude
              *@param az the new azimuth
              *@param altIsRefracted set to true if the altitude supplied is apparent
              */
         void setDestinationAltAz(const dms &alt, const dms &az, bool altIsRefracted);
 
         /** @short set the FocusPoint; the position that is to be the next Destination.
              *@param f a pointer to the FocusPoint SkyPoint.
              */
         void setFocusPoint(SkyPoint *f)
         {
             if (f)
                 FocusPoint = *f;
         }
 
         /** @short Retrieve the ClickedPoint position.
              *
              *When the user clicks on a point in the sky map, the sky coordinates of the mouse
              *cursor are stored in the private member ClickedPoint.  This function retrieves
              *a pointer to ClickedPoint.
              *@return a pointer to ClickedPoint, the sky coordinates where the user clicked.
              */
         SkyPoint *clickedPoint()
         {
             return &ClickedPoint;
         }
 
         /** @short Set the ClickedPoint to the skypoint given as an argument.
              *@param f pointer to the new ClickedPoint.
              */
         void setClickedPoint(SkyPoint *f);
 
         /** @short Retrieve the object nearest to a mouse click event.
              *
              *If the user clicks on the sky map, a pointer to the nearest SkyObject is stored in
              *the private member ClickedObject.  This function returns the ClickedObject pointer,
              *or nullptr if there is no CLickedObject.
              *@return a pointer to the object nearest to a user mouse click.
              */
         SkyObject *clickedObject() const
         {
             return ClickedObject;
         }
 
         /** @short Set the ClickedObject pointer to the argument.
              *@param o pointer to the SkyObject to be assigned as the ClickedObject
              */
         void setClickedObject(SkyObject *o);
 
         /** @short Retrieve the object which is centered in the sky map.
              *
              *If the user centers the sky map on an object (by double-clicking or using the
              *Find Object dialog), a pointer to the "focused" object is stored in
              *the private member FocusObject.  This function returns a pointer to the
              *FocusObject, or nullptr if there is not FocusObject.
              *@return a pointer to the object at the center of the sky map.
              */
         SkyObject *focusObject() const
         {
             return FocusObject;
         }
 
         /** @short Set the FocusObject pointer to the argument.
              *@param o pointer to the SkyObject to be assigned as the FocusObject
              */
         void setFocusObject(SkyObject *o);
 
         /** @ Set zoom factor.
              *@param factor zoom factor
              */
         void setZoomFactor(double factor);
 
         /** @short Call to set up the projector before update of SkyItems positions begins. */
         void setupProjector();
 
         /** @short Returns index for a Harvard spectral classification */
         int harvardToIndex(char c);
 
         /** @short returns cache of star images
              *  @return star images cache
              */
         QVector<QVector<QPixmap *>> getImageCache();
 
         /**
              * @short creates QImage from text and converts it to QSGTexture
              * @param text the text string
              * @param color text color
              * @param zoomFont if true zoom-dependent font from SkyLabeler will be used else standart
              * font is used
              * @return QSGTexture with text
              * @note font size is set in SkyLabeler::SkyLabeler() by initializing m_stdFont with default font
              */
         QSGTexture *textToTexture(QString text, QColor color = QColor(255, 255, 255), bool zoomFont = false);
 
         /**
              * @short returns cached texture from textureCache.
              *
              * Use outside of scene graph rendering thread (e.g. not during call to updatePaintNode)
              * is prohibited!
              * @param size size of the star
              * @param spType spectral class
              * @return cached QSGTexture from textureCache
              */
         QSGTexture *getCachedTexture(int size, char spType);
 
         /** @short called when SkyMapComposite finished loading all SkyComponents */
         inline void loadingFinished()
         {
             m_loadingFinished = true;
         }
 
         /** @return true if the map is in slewing mode or clock is active **/
         bool isSlewing() const;
 
         /** @return current magnitude limit **/
         inline double getMagLim()
         {
             return m_magLim;
         }
 
         /** @short set magnitude limit **/
         void setMagLim(double magLim);
 
         /** @short Convenience function for shutting off tracking mode.  Just calls KStars::slotTrack() **/
         void stopTracking();
 
         /** Get the current projector.
                 @return a pointer to the current projector. */
         inline const Projector *projector() const
         {
             return m_proj;
         }
 
         /**
              * @short used in QML
              * @return type of current projection system
              */
         Q_INVOKABLE uint projType() const;
 
         /** Set magnitude limit for size of stars. Used in StarItem **/
         inline void setSizeMagLim(float sizeMagLim)
         {
             m_sizeMagLim = sizeMagLim;
         }
 
         /** Used in PointSourceNode **/
         inline float sizeMagLim() const
         {
             return m_sizeMagLim;
         }
 
         static inline RootNode *rootNode()
         {
             return m_rootNode;
         }
 
         static inline void setRootNode(RootNode *root)
         {
             m_rootNode = root;
         }
 
         /** return limit of hides for the node to delete it **/
         static double deleteLimit();
 
         /**
              * @short adds FOV symbol to m_FOVSymbols
              * @param FOVName name of a FOV symbol
              * @param initialState defines whether the state is initial
              */
         Q_INVOKABLE void addFOVSymbol(const QString &FOVName, bool initialState = false);
 
         /**
              * @param index of FOVSymbol in m_FOVSymbols
              * @return true if FOV symbol with name FOVName should be drawn.
              */
         bool isFOVVisible(int index);
 
         /**
               * @param index of FOVSymbol in m_FOVSymbols
               * @param visible defines whether the FOV symbol should be visible
               * @short updates visibility of FOV symbol according to visible
               */
         Q_INVOKABLE void setFOVVisible(int index, bool visible);
 
         /**
               * @short this QList should be used as a model in QML to switch on/off FOV symbols
               **/
         Q_INVOKABLE inline QStringList getFOVSymbols()
         {
             return m_FOVSymbols;
         }
 
         /** @short Initializes images of Stars and puts them in cache (copied from SkyQPainter)*/
         void initStarImages();
 
         /**
              * @short getter for clickedPointLite
              */
         SkyPointLite *getClickedPointLite()
         {
             return m_ClickedPointLite;
         }
 
         /**
              * @short getter for clickedObjectLite
              */
         SkyObjectLite *getClickedObjectLite()
         {
             return m_ClickedObjectLite;
         }
 
         /**
              * @short getter for centerLocked
              */
         bool getCenterLocked()
         {
             return m_centerLocked;
         }
 
         /**
              * @short Proxy method for SkyMapDrawAbstract::drawObjectLabels()
              */
         //inline void drawObjectLabels( QList< SkyObject* >& labelObjects ) { dynamic_cast<SkyMapDrawAbstract *>(m_SkyMapDraw)->drawObjectLabels( labelObjects ); }
 
         /**
              * @return true if SkyMapLite is being slewed
              */
         bool getSlewing() const
         {
             return m_slewing;
         }
 
         /**
              * @short sets whether SkyMapLite is being slewed
              */
         void setSlewing(bool newSlewing);
 
         /**
              * @short sets whether SkyMapLite is centered on an object and locked(olny pinch-to-zoom is available)
              */
         void setCenterLocked(bool centerLocked);
 
         /** True if automatic mode is on (SkyMapLite is controlled by smartphones accelerometer magnetometer) **/
         bool getAutomaticMode() const
         {
             return m_automaticMode;
         }
 
         /**
              * @short switch automatic mode on/off according to isOn parameter
              */
         Q_INVOKABLE void setAutomaticMode(bool automaticMode);
 
         double getSkyRotation() const
         {
             return m_skyRotation;
         }
 
     public slots:
         /** Called whenever wrappers' width or height are changed. Probably will be used to
             * update positions of items.
             */
         void resizeItem();
 
         /** Recalculates the positions of objects in the sky, and then repaints the sky map.
              */
         void forceUpdate();
 
         /** @short Left for compatibility reasons
              * @see forceUpdate()
              */
         void forceUpdateNow()
         {
             forceUpdate();
         }
 
         /**
              * @short Update the focus point and call forceUpdate()
              * @param now is saved for compatibility reasons
              */
         void slotUpdateSky(bool now);
 
         /** Step the Focus point toward the Destination point.  Do this iteratively, redrawing the Sky
              * Map after each step, until the Focus point is within 1 step of the Destination point.
              * For the final step, snap directly to Destination, and redraw the map.
              */
         void slewFocus();
 
         /** @short Center the display at the point ClickedPoint.
              *
              * The essential part of the function is to simply set the Destination point, which will emit
              * the destinationChanged() SIGNAL, which triggers the slewFocus() SLOT.  Additionally, this
              * function performs some bookkeeping tasks, such updating whether we are tracking the new
              * object/position, adding a Planet Trail if required, etc.
              *
              * @see destinationChanged()
              * @see slewFocus()
              */
         void slotCenter();
 
         /** Checks whether the timestep exceeds a threshold value.  If so, sets
              * ClockSlewing=true and sets the SimClock to ManualMode.
              */
         void slotClockSlewing();
 
         /** Zoom in one step. */
         void slotZoomIn();
 
         /** Zoom out one step. */
         void slotZoomOut();
 
         /** Set default zoom. */
         void slotZoomDefault();
         /**
              * @short centres skyObj in SkyMap and opens context drawer with skyObj
              * Used in FindDialogLite
              */
         void slotSelectObject(SkyObject *skyObj);
 
         /** @short updates focus of SkyMapLite according to data from DeviceOrientation
                 (Smartphone's sensors)*/
         void updateAutomaticMode();
 
         void setSkyRotation(double skyRotation);
 
     signals:
         /** Emitted by setDestination(), and connected to slewFocus().  Whenever the Destination
              * point is changed, slewFocus() will iteratively step the Focus toward Destination
              * until it is reached.
              * @see SkyMap::setDestination()
              * @see SkyMap::slewFocus()
              */
         void destinationChanged();
 
         /** Emitted when zoom level is changed. */
         void zoomChanged();
 
         /** Emitted when current object changed. */
         void objectChanged();
 
         /** Wrapper of ClickedObject for QML **/
         void objectLiteChanged();
 
         /** Wrapper of ClickedPoint for QML **/
         void pointLiteChanged();
 
         /** Emitted when pointing changed. (At least should) */
         void positionChanged();
 
         /** Emitted when position under mouse changed. */
         void mousePointChanged(SkyPoint *);
 
         /** Emitted when a position is clicked */
         void positionClicked(SkyPoint *);
 
         /** Emitted when user clicks on SkyMapLite (analogous to positionClicked but sends QPoint) */
         void posClicked(QPointF pos);
 
         /** Emitted when magnitude limit is changed */
         void magLimChanged(double magLim);
 
         /** Emitted when FOVSymbols list was changed (new value appended) **/
         void symbolsFOVChanged(QStringList);
 
         /** Emitted when SkyMapLite is being slewed or slewing is finished **/
         void slewingChanged(bool);
 
         void centerLockedChanged(bool);
 
         void automaticModeChanged(bool);
 
         /** Emitted when skyRotation used to rotate coordinates of SkyPoints is changed **/
         void skyRotationChanged(double skyRotation);
 
     protected:
         /** Process keystrokes:
              * @li arrow keys  Slew the map
              * @li +/- keys  Zoom in and out
              * @li <i>Space</i>  Toggle between Horizontal and Equatorial coordinate systems
              * @li 0-9  Go to a major Solar System body (0=Sun; 1-9 are the major planets, except 3=Moon)
              * @li [  Place starting point for measuring an angular distance
              * @li ]  End point for Angular Distance; display measurement.
              * @li <i>Escape</i>  Cancel Angular measurement
              * @li ,/<  Step backward one time step
              * @li ./>  Step forward one time step
              */
         //virtual void keyPressEvent( QKeyEvent *e );
 
         /** When keyRelease is triggered, just set the "slewing" flag to false,
              * and update the display (to draw objects that are hidden when slewing==true). */
         //virtual void keyReleaseEvent( QKeyEvent *e );
 
         /** Determine RA, Dec coordinates of clicked location.  Find the SkyObject
              * which is nearest to the clicked location.
              *
              * If left-clicked: Set set mouseButtonDown==true, slewing==true; display
              * nearest object name in status bar.
              * If right-clicked: display popup menu appropriate for nearest object.
              */
         virtual void mousePressEvent(QMouseEvent *e) override;
 
         /** set mouseButtonDown==false, slewing==false */
         virtual void mouseReleaseEvent(QMouseEvent *e) override;
 
         /** Center SkyMap at double-clicked location  */
         virtual void mouseDoubleClickEvent(QMouseEvent *e) override;
 
         /** This function does several different things depending on the state of the program:
              * @li If Angle-measurement mode is active, update the end-ruler point to the mouse cursor,
              *     and continue this function.
              * @li If we are defining a ZoomBox, update the ZoomBox rectangle, redraw the screen,
              *     and return.
              * @li If dragging the mouse in the map, update focus such that RA, Dec under the mouse
              *     cursor remains constant.
              * @li If just moving the mouse, simply update the curso coordinates in the status bar.
              */
         virtual void mouseMoveEvent(QMouseEvent *e) override;
 
         /** Zoom in and out with the mouse wheel. */
         virtual void wheelEvent(QWheelEvent *e) override;
 
         /**
              * @short this function handles zooming in and out using "pinch to zoom" gesture
              */
         virtual void touchEvent(QTouchEvent *e) override;
 
     private slots:
         /** @short display tooltip for object under cursor. It's called by m_HoverTimer.
              *  if mouse didn't moved for last HOVER_INTERVAL milliseconds.
              */
         //void slotTransientLabel();
 
         /** Set the shape of mouse cursor to a cross with 4 arrows. */
         void setMouseMoveCursor();
 
     private:
         /** @short Sets the shape of the default mouse cursor to a cross. */
         void setDefaultMouseCursor();
 
         /** @short Sets the shape of the mouse cursor to a magnifying glass. */
         void setZoomMouseCursor();
 
         /** Calculate the zoom factor for the given keyboard modifier
              */
         double zoomFactor(const int modifier);
 
         /** calculate the magnitude factor (1, .5, .2, or .1) for the given
              * keyboard modifier.
              */
         double magFactor(const int modifier);
 
         /** Decrease the magnitude limit by a step size determined by the
              * keyboard modifier.
              * @param modifier
              */
         void decMagLimit(const int modifier);
 
         /** Increase the magnitude limit by a step size determined by the
             * keyboard modifier.
             * @param modifier
             */
         void incMagLimit(const int modifier);
 
         /** Convenience routine to either zoom in or increase mag limit
              * depending on the Alt modifier.  The Shift and Control modifiers
              * will adjust the size of the zoom or the mag step.
              * @param modifier
              */
         void zoomInOrMagStep(const int modifier);
 
         /** Convenience routine to either zoom out or decrease mag limit
              * depending on the Alt modifier.  The Shift and Control modifiers
              * will adjust the size of the zoom or the mag step.
              * @param modifier
              */
         void zoomOutOrMagStep(const int modifier);
 
         /**
          * pointer to RootNode. Use it to universally access RootNode
          * @warning RootNode should be used solely during updatePaintNode! See Qt Quick Scene Graph documentation.
          **/
         static RootNode *m_rootNode;
         static SkyMapLite *pinstance;
         static int starColorMode;
 
         /// True if SkyMapLite was initialized (star images were initialized etc.)
         bool isInitialized { false };
         bool mouseButtonDown { false };
         bool midMouseButtonDown { false };
         /// True if mouseMoveEvent; needed by setMouseMoveCursor
         bool mouseMoveCursor { false };
         bool m_slewing { false };
         bool clockSlewing { false };
         /// True if pinch to zoom or pinch to rotate is performed
         bool pinch { false };
         /// If false only old pixmap will repainted with bitBlt() to save a lot of CPU usage
         bool computeSkymap { false };
         double y0 { 0 };
         int count { 0 };
         KStarsData *data { nullptr };
         /// True if SkyMapComposite has finished loading of SkyComponents
         bool m_loadingFinished { false };
         /// Coordinates of point under cursor. It's update in function mouseMoveEvent
         SkyPoint m_MousePoint;
         SkyPoint Focus, ClickedPoint, FocusPoint, Destination;
         SkyObject *ClickedObject { nullptr };
         SkyObject *FocusObject { nullptr };
         SkyPointLite *m_ClickedPointLite { nullptr };
         SkyObjectLite *m_ClickedObjectLite { nullptr };
         bool m_centerLocked { false };
         //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;
         bool m_objPointingMode { false };
         bool m_fovCaptureMode { false };
         Projector *m_proj { nullptr };
         QQuickItem *m_SkyMapLiteWrapper { nullptr };
         /// Holds SkyNodes that need to be deleted
         QLinkedList<SkyNode *> m_deleteNodes;
         /// Used in PointSourceNode
         float m_sizeMagLim { 10 };
         /// Mag limit for all objects
         double m_magLim { 0 };
         /// Used to notify zoom-dependent labels about font size change
         bool m_fontSizeChanged { false };
         /// Used for drawing labels
         QPainter m_painter;
         /**
          * This timer is triggered every time user touches the screen with one finger.
          * If touch was released within 500 milliseconds than it is a tap, otherwise we pan.
          **/
         QTimer m_tapBeganTimer;
         /// Good to keep the original ruler start-point for purposes of dynamic_cast
         const SkyPoint *m_rulerStartPoint;
         QStringList m_FOVSymbols;
         QList<bool> m_FOVSymVisible;
         /// Total number of sizes of stars.
         const int nStarSizes { 15 };
         /// Total number of spectral classes (N.B. Must be in sync with harvardToIndex)
         const int nSPclasses { 7 };
         /// Cache for star images.
         QVector<QVector<QPixmap *>> imageCache;
         /// Textures created from cached star images
         QVector<QVector<QSGTexture *>> textureCache;
         bool clearTextures { false };
         bool tapBegan { false };
         QList<INDI::BaseDevice *> m_newTelescopes;
         QList<INDI::BaseDevice *> m_delTelescopes;
         bool m_automaticMode { false };
         double m_skyRotation { 0 };
         SkyMapOrientation m_skyMapOrientation { SkyMapOrientation::Top0 };
 #if defined(Q_OS_ANDROID)
         QTimer automaticModeTimer;
         DeviceOrientation *m_deviceOrientation { nullptr };
 #endif
 };