kstars/kstars/simclock.cpp

   1 /***************************************************************************
   2                           simclock.cpp  -  description
   3                              -------------------
   4     begin                : Mon Feb 18 2002
   5     copyright          : (C) 2002 by Mark Hollomon
   6     email                : mhh@mindspring.com
   7  ***************************************************************************/
   8
   9 /***************************************************************************
  10  *                                                                         *
  11  *   This program is free software; you can redistribute it and/or modify  *
  12  *   it under the terms of the GNU General Public License as published by  *
  13  *   the Free Software Foundation; either version 2 of the License, or     *
  14  *   (at your option) any later version.                                   *
  15  *                                                                         *
  16  ***************************************************************************/
  17
  18 #include <kdebug.h>
  19 #include <klocale.h>
  20
  21 #include "simclock.h"
  22 #include "kstars.h"
  23
  24 int SimClock::idgen = 1;
  25
  26 int SimClock::TimerInterval = 100; //msec
  27
  28 SimClock::SimClock(QObject *parent, const KStarsDateTime &when) :
  29                 DCOPObject("clock#" + QCString().setNum(idgen++)),
  30                 QObject(parent),
  31                 tmr(this)
  32 {
  33         if (! when.isValid() ) tmr.stop();
  34         setUTC(when);
  35         julianmark = UTC.djd();
  36
  37         Scale = 1.0;
  38         ManualMode = false;
  39         ManualActive = false;
  40
  41         QObject::connect(&tmr, SIGNAL(timeout()), this, SLOT(tick()));
  42 }
  43
  44 SimClock::SimClock (const SimClock &old) :
  45                 DCOPObject("clock#" + QCString().setNum(idgen++)),
  46                 QObject(old.parent()),
  47                 SimClockInterface(),
  48                 tmr(this)
  49 {
  50         UTC = old.UTC;
  51         julianmark = old.julianmark;
  52
  53         Scale = old.Scale;
  54         ManualMode = old.ManualMode;
  55         ManualActive = old.ManualActive;
  56
  57         QObject::connect(&tmr, SIGNAL(timeout()), this, SLOT(tick()));
  58 }
  59
  60 void SimClock::tick() {
  61         if ( ! ManualMode ) { //only tick if ManualMode is false
  62                 long mselapsed = sysmark.elapsed();
  63                 if (mselapsed < lastelapsed) {
  64                         // The sysmark timer has wrapped after 24 hours back to 0 ms.
  65                         // Reset sysmark and julianmark
  66                         julianmark = UTC.djd();
  67                         sysmark.start();
  68                         lastelapsed = 0;
  69                 } else {
  70                         lastelapsed = mselapsed;
  71                 }
  72
  73                 long double scaledsec = (long double)mselapsed * (long double)Scale / 1000.0;
  74                 UTC.setDJD( julianmark + scaledsec / (24. * 3600.) );
  75
  76 //              kdDebug() << "tick() : JD = " << KGlobal::locale()->formatNumber( UTC.djd(), 7 ) <<
  77 //                      " mselapsed = " << mselapsed << " scale = " << Scale <<
  78 //                      "  scaledsec = " << double(scaledsec) << endl;
  79
  80                 emit timeAdvanced();
  81         }
  82 }
  83
  84 void SimClock::setManualMode( bool on ) {
  85         if ( on ) {
  86                 //Turn on manual ticking.
  87                 //If the timer was active, stop the timer and set ManualActive=true.
  88                 //Otherwise, set ManualActive=false.
  89                 //Finally, set ManualMode=true.
  90                 if ( tmr.isActive() ) {
  91                         tmr.stop();
  92                         ManualActive = true;
  93                 } else {
  94                         ManualActive = false;
  95                 }
  96                 ManualMode = true;
  97         } else {
  98                 //Turn off manual ticking.  If the Manual clock was active, start the timer.
  99                 //Then set ManualMode=false.
 100                 if ( isActive() ) {
 101                         sysmark.start();
 102                         julianmark = UTC.djd();
 103                         lastelapsed = 0;
 104                         tmr.start(TimerInterval);
 105                 }
 106                 ManualMode = false;
 107         }
 108 }
 109
 110 void SimClock::manualTick( bool force ) {
 111         if ( force || (ManualMode && ManualActive) ) {
 112                 setUTC( UTC.addSecs( (long double)Scale ) );
 113         } else if ( ! ManualMode ) tick();
 114 }
 115
 116 bool SimClock::isActive() {
 117         if ( ManualMode ) return ManualActive;
 118         else return tmr.isActive();
 119 }
 120
 121 // The SimClockInterface
 122 void SimClock::stop() {
 123         if ( ManualMode && ManualActive ) {
 124                 ManualActive = false;
 125                 emit clockStopped();
 126         }
 127
 128         if (!ManualMode && tmr.isActive()) {
 129                 kdDebug() << i18n( "Stopping the timer" ) << endl;
 130                 tmr.stop();
 131                 emit clockStopped();
 132         }
 133 }
 134
 135 void SimClock::start() {
 136         if ( ManualMode && !ManualActive ) {
 137                 ManualActive = true;
 138                 sysmark.start();
 139                 julianmark = UTC.djd();
 140                 lastelapsed = 0;
 141                 emit clockStarted();
 142                 //emit timeChanged() in order to restart calls to updateTime()
 143                 emit timeChanged();
 144         }
 145
 146         if (! ManualMode && ! tmr.isActive()) {
 147                 kdDebug() << i18n( "Starting the timer" ) << endl;
 148                 sysmark.start();
 149                 julianmark = UTC.djd();
 150                 lastelapsed = 0;
 151                 tmr.start(TimerInterval);
 152                 emit clockStarted();
 153         }
 154 }
 155
 156 void SimClock::setUTC(const KStarsDateTime &newtime) {
 157         if ( newtime.isValid() ) {
 158                 UTC = newtime;
 159                 if (tmr.isActive()) {
 160                         julianmark = UTC.djd();
 161                         sysmark.start();
 162                         lastelapsed = 0;
 163                 }
 164
 165                 kdDebug() << i18n( "Setting clock:  UTC: %1  JD: %2" )
 166                                 .arg( UTC.toString() ).arg( KGlobal::locale()->formatNumber( UTC.djd() ) ) << endl;
 167                 emit timeChanged();
 168         } else {
 169                 kdDebug() << i18n( "Cannot set SimClock:  Invalid Date/Time." ) << endl;
 170         }
 171 }
 172
 173 void SimClock::setScale(float s) {
 174         if (Scale != s ) {
 175                 kdDebug() << i18n( "New clock scale: %1 sec" ).arg( s ) << endl;
 176                 Scale = s;
 177                 if (tmr.isActive()) {
 178                         julianmark = UTC.djd();
 179                         sysmark.start();
 180                         lastelapsed = 0;
 181                 }
 182                 emit scaleChanged(s);
 183         }
 184 }
 185
 186 //DCOP function to set clock scale
 187 void SimClock::setClockScale(float s) {
 188         setScale(s);
 189 }
 190
 191 #include "simclock.moc"