Kstars

simclock.h
1 /*
2  SPDX-FileCopyrightText: 2002 Mark Hollomon <[email protected]>
3 
4  SPDX-License-Identifier: GPL-2.0-or-later
5 */
6 
7 #pragma once
8 
9 #include "kstarsdatetime.h"
10 
11 #include <QTime>
12 #include <QElapsedTimer>
13 #include <QTimer>
14 #include <qtdbusglobal.h>
15 
16 /** @class SimClock
17  *@short kstars simulation clock
18  *@author Mark Hollomon
19  *@version 1.0
20  */
21 
22 class SimClock : public QObject
23 {
24  Q_OBJECT
25  Q_CLASSINFO("D-Bus Interface", "org.kde.kstars.SimClock")
26  public:
27  /**
28  * Constructor
29  * @param parent parent object for the clock
30  * @param when the date/time to which the SimClock should be initialized in UTC
31  */
32  explicit SimClock(QObject *parent = nullptr, const KStarsDateTime &when = KStarsDateTime::currentDateTimeUtc());
33 
34  /** @return const reference to the current simulation Universal Time. */
35  const KStarsDateTime &utc() const
36  {
37  return m_UTC;
38  }
39 
40  /** Whether the clock is active or not is a bit complicated by the
41  *introduction of "manual mode". In manual mode, SimClock's internal timer
42  *is stopped, because the clock is ticked manually when the current update
43  *has finished. So, if ManualMode is true, then isActive() checks
44  *whether ManualActive is true. Otherwise, it checks whether the timer is
45  *running.
46  *@returns true if the Simulation clock is actively running.
47  */
48  Q_INVOKABLE bool isActive();
49 
50  /** @returns the current timestep setting */
51  double scale() const
52  {
53  return m_Scale;
54  }
55 
56  /** Manual Mode is a new (04/2002) addition to the SimClock. It is
57  *intended to be activated for large timesteps, when we want each frame
58  *drawn to the screen to be precisely Scale seconds later than the
59  *previous frame. (i.e., if the timescale is 1 year, then each successive
60  *frame should be 1 year later than the previous frame). ManualMode
61  *accomplishes this by stopping the internal timer and allowing the clock
62  *to be advanced manually (the manualTick() slot is called at the end of each
63  *KStars::updateTime()).
64  *@returns whether Manual Mode is active.
65  */
66  bool isManualMode() const
67  {
68  return m_ManualMode;
69  }
70 
71  /**Sets Manual Mode on/off according to the bool argument. */
72  void setManualMode(bool on = true);
73 
74  public Q_SLOTS:
75 #ifndef KSTARS_LITE
76  /** DBUS function to stop the SimClock. */
77  Q_SCRIPTABLE Q_NOREPLY void stop();
78 
79  /** DBUS function to start the SimClock. */
80  Q_SCRIPTABLE Q_NOREPLY void start();
81 
82  /** DBUS function to set the time of the SimClock. */
83  Q_SCRIPTABLE Q_NOREPLY void setUTC(const KStarsDateTime &newtime);
84 
85  /** DBUS function to set the current time of the SimClock. */
86  Q_SCRIPTABLE Q_NOREPLY void setNow()
87  {
89  }
90 
91  /** DBUS function to set scale of simclock. */
92  /**
93  * @brief setClockScale Set simulation clock scale per second.
94  * @param scale Scale per second. 1 means normal scale, each 1 simulation
95  * second equals 1 real second. Value less than one *slows* the simulation clock,
96  * while values over 1 speeds it up. A scale of 0.5 makes the simulation clock ticks
97  * once every 2 actual seconds (or half-ticks per one actual second),
98  * while a value of 60 make the simulation clock ticks 60 simulation seconds (1 simulation minute)
99  * for every 1 actual second.
100  */
101  Q_SCRIPTABLE Q_NOREPLY void setClockScale(double scale);
102 #else
103  // Define non-DBUS versions of functions above for use within KStarsLite
104  /** Function to stop the SimClock. */
105  void stop();
106 
107  /** Function to start the SimClock. */
108  void start();
109 
110  /** Function to set the time of the SimClock. */
111  void setUTC(const KStarsDateTime &newtime);
112 
113  /** Function to set scale of simclock. */
114  void setClockScale(float s);
115 #endif
116 
117  /** Respond to the QTimer::timeout signal */
118  void tick();
119 
120  /** Equivalent of tick() for manual mode.
121  * If ManualActive is true, add Scale seconds to the SimClock time.
122  * (we may want to modify this slightly...e.g., the number of seconds in a
123  * year is not constant (leap years), so it is better to increment the
124  * year, instead of adding 31 million seconds.
125  * set backward to true to reverse sign of Scale value
126  */
127 
128  void manualTick(bool force = false, bool backward = false);
129 
130  signals:
131  /** The time has changed (emitted by setUTC() ) */
132  void timeChanged();
133 
134  /** The clock has ticked (emitted by tick() )*/
135  void timeAdvanced();
136 
137  /** The timestep has changed*/
138  void scaleChanged(float);
139 
140  /** This is an signal that is called on either clock start or
141  clock stop with an appropriate boolean argument. Required so
142  that we can bind it to KToggleAction::slotToggled(bool) */
143  void clockToggled(bool);
144 
145  private:
146  long double m_JulianMark { 0 };
147  KStarsDateTime m_UTC;
148  QTimer m_InternalTimer;
149  double m_Scale { 1 };
150  QElapsedTimer m_SystemMark;
151  int m_LastElapsed { 0 };
152  bool m_ManualMode { false };
153  bool m_ManualActive { false };
154 
155  // used to generate names for dcop interfaces
156  //static int idgen;
157  // how often to update
158  static int TimerInterval;
159 
160  // Disallow copying
161  SimClock(const SimClock &);
162  SimClock &operator=(const SimClock &);
163 };
Q_OBJECTQ_OBJECT
Extension of QDateTime for KStars KStarsDateTime can represent the date/time as a Julian Day,...
SimClock(QObject *parent=nullptr, const KStarsDateTime &when=KStarsDateTime::currentDateTimeUtc())
Constructor.
Definition: simclock.cpp:18
Q_SLOTSQ_SLOTS
Q_CLASSINFO(Name, Value)
void clockToggled(bool)
This is an signal that is called on either clock start or clock stop with an appropriate boolean argu...
Q_SCRIPTABLE Q_NOREPLY void setNow()
DBUS function to set the current time of the SimClock.
Definition: simclock.h:86
void timeChanged()
The time has changed (emitted by setUTC() )
static KStarsDateTime currentDateTimeUtc()
double scale() const
Definition: simclock.h:51
void timeAdvanced()
The clock has ticked (emitted by tick() )
void tick()
Respond to the QTimer::timeout signal.
Definition: simclock.cpp:32
bool isManualMode() const
Manual Mode is a new (04/2002) addition to the SimClock.
Definition: simclock.h:66
Q_INVOKABLEQ_INVOKABLE
kstars simulation clock
Definition: simclock.h:22
Q_SCRIPTABLE Q_NOREPLY void stop()
DBUS function to stop the SimClock.
Definition: simclock.cpp:104
Q_SCRIPTABLE Q_NOREPLY void start()
DBUS function to start the SimClock.
Definition: simclock.cpp:120
void setManualMode(bool on=true)
Sets Manual Mode on/off according to the bool argument.
Definition: simclock.cpp:61
Q_SCRIPTABLE Q_NOREPLY void setUTC(const KStarsDateTime &newtime)
DBUS function to set the time of the SimClock.
Definition: simclock.cpp:143
void scaleChanged(float)
The timestep has changed.
Q_SCRIPTABLE Q_NOREPLY void setClockScale(double scale)
DBUS function to set scale of simclock.
Definition: simclock.cpp:169
void manualTick(bool force=false, bool backward=false)
Equivalent of tick() for manual mode.
Definition: simclock.cpp:83
Q_INVOKABLE bool isActive()
Whether the clock is active or not is a bit complicated by the introduction of "manual mode".
Definition: simclock.cpp:96
const KStarsDateTime & utc() const
Definition: simclock.h:35
QObject * parent() const const
This file is part of the KDE documentation.
Documentation copyright © 1996-2023 The KDE developers.
Generated on Fri Sep 29 2023 03:56:58 by doxygen 1.8.17 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.