mirror of
https://github.com/electronicarts/CnC_Remastered_Collection
synced 2024-04-27 00:43:00 +12:00
03416d24e1
Initial commit of original Tiberian Dawn and Red Alert source code converted to build as DLLs, and compatible with the release version of Command & Conquer Remastered.
717 lines
41 KiB
C++
717 lines
41 KiB
C++
//
|
|
// Copyright 2020 Electronic Arts Inc.
|
|
//
|
|
// TiberianDawn.DLL and RedAlert.dll and corresponding source code 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 3 of the License, or (at your option) any later version.
|
|
|
|
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed
|
|
// in the hope that it will be useful, but with permitted additional restrictions
|
|
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
|
|
// distributed with this program. You should have received a copy of the
|
|
// GNU General Public License along with permitted additional restrictions
|
|
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
|
|
|
|
/* $Header: /CounterStrike/FTIMER.H 1 3/03/97 10:24a Joe_bostic $ */
|
|
/***********************************************************************************************
|
|
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
|
|
***********************************************************************************************
|
|
* *
|
|
* Project Name : Command & Conquer *
|
|
* *
|
|
* File Name : FTIMER.H *
|
|
* *
|
|
* Programmer : Joe L. Bostic *
|
|
* *
|
|
* Start Date : 03/16/95 *
|
|
* *
|
|
* Last Update : July 6, 1996 [JLB] *
|
|
* *
|
|
* *
|
|
*---------------------------------------------------------------------------------------------*
|
|
* Functions: *
|
|
* BasicTimerClass<T>::BasicTimerClass -- Constructor for basic timer class. *
|
|
* BasicTimerClass<T>::operator () -- Function operator for timer object. *
|
|
* BasicTimerClass<T>::operator long -- Conversion to long operator. *
|
|
* BasicTimerClass<T>::~BasicTimerClass -- Destructor for basic timer object. *
|
|
* TTimerClass<T>::Is_Active -- Checks to see if the timer is counting. *
|
|
* TTimerClass<T>::Start -- Starts (resumes) a stopped timer. *
|
|
* TTimerClass<T>::Stop -- Stops the current timer from incrementing. *
|
|
* TTimerClass<T>::TTimerClass -- Constructor for timer class object. *
|
|
* TTimerClass<T>::operator () -- Function operator for timer object. *
|
|
* TTimerClass<T>::operator long -- Conversion operator for timer object. *
|
|
* CDTimerClass<T>::CDTimerClass -- Constructor for count down timer. *
|
|
* CDTimerClass<T>::Is_Active -- Checks to see if the timer object is active. *
|
|
* CDTimerClass<T>::Start -- Starts (resumes) the count down timer. *
|
|
* CDTimerClass<T>::Stop -- Stops (pauses) the count down timer. *
|
|
* CDTimerClass<T>::operator () -- Function operator for the count down timer. *
|
|
* CDTimerClass<T>::operator long -- Conversion to long operator function. *
|
|
* CDTimerClass<T>::~CDTimerClass -- Destructor for the count down timer object. *
|
|
* TTimerClass<T>::Value -- Returns with the current value of the timer. *
|
|
* CDTimerClass<T>::Value -- Fetches the current value of the countdown timer. *
|
|
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
|
|
|
#ifndef FTIMER_H
|
|
#define FTIMER_H
|
|
|
|
|
|
/*
|
|
** The "bool" integral type was defined by the C++ committee in
|
|
** November of '94. Until the compiler supports this, use the following
|
|
** definition.
|
|
*/
|
|
#ifndef __BORLANDC__
|
|
#ifndef TRUE_FALSE_DEFINED
|
|
#define TRUE_FALSE_DEFINED
|
|
enum {false=0,true=1};
|
|
typedef int bool;
|
|
#endif
|
|
#endif
|
|
|
|
|
|
/**********************************************************************
|
|
** This class is solely used as a parameter to a constructor that does
|
|
** absolutely no initialization to the object being constructed. By using
|
|
** this method, it is possible to load and save data directly from a
|
|
** class that has virtual functions. The construction process automatically
|
|
** takes care of initializing the virtual function table pointer and the
|
|
** rest of the constructor doesn't initialize any data members. After loading
|
|
** into a class object, simply perform an in-place new operation.
|
|
*/
|
|
#ifndef NOINITCLASS
|
|
#define NOINITCLASS
|
|
struct NoInitClass {
|
|
public:
|
|
void operator () (void) const {};
|
|
};
|
|
#endif
|
|
|
|
|
|
/*
|
|
** This is a timer class that watches a constant rate timer (specified by the parameter
|
|
** type class) and provides basic timer functionality. It is possible to set the start value
|
|
** WITHOUT damaging or otherwise affecting any other timer that may be built upon the same
|
|
** specified timer class object. Treat an object of this type as if it were a "magic" integral
|
|
** long that automatically advances at the speed of the timer class object controlling it.
|
|
*/
|
|
// Let lint know that non-virtual destructor is OK for this class.
|
|
//lint -esym(1509,BasicTimerClass)
|
|
template<class T>
|
|
class BasicTimerClass {
|
|
public:
|
|
// Constructor allows assignment as if class was integral 'long' type.
|
|
BasicTimerClass(unsigned long set=0);
|
|
BasicTimerClass(NoInitClass const & );
|
|
|
|
~BasicTimerClass(void);
|
|
|
|
// Fetch current value of timer.
|
|
unsigned long Value(void) const;
|
|
|
|
// Conversion operator to allow consistent treatment with integral types.
|
|
operator unsigned long(void) const;
|
|
|
|
// Function operator to allow timer object definition to be cascaded.
|
|
unsigned long operator () (void) const;
|
|
|
|
protected:
|
|
T Timer; // Timer regulator (ticks at constant rate).
|
|
unsigned long Started; // Time started.
|
|
};
|
|
|
|
|
|
template<class T>
|
|
inline BasicTimerClass<T>::BasicTimerClass(NoInitClass const & )
|
|
{
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* BasicTimerClass<T>::BasicTimerClass -- Constructor for basic timer class. *
|
|
* *
|
|
* This is the constructor for the basic timer class object. It sets the timer counting *
|
|
* up from zero at the rate of the controlling timer class object. *
|
|
* *
|
|
* INPUT: set -- Alternate initial start value for the counter. If not specified, then *
|
|
* the timer is assumed to start at zero and count upwards. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 02/05/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
//lint -esym(1403,BasicTimerClass<class FrameTimerClass>::Timer)
|
|
//lint -esym(1403,BasicTimerClass<class SystemTimerClass>::Timer)
|
|
template<class T>
|
|
inline BasicTimerClass<T>::BasicTimerClass(unsigned long set) :
|
|
Started(Timer()-set)
|
|
{
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* BasicTimerClass<T>::~BasicTimerClass -- Destructor for basic timer object. *
|
|
* *
|
|
* The destructor for the basic timer object doesn't have to do anything. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 02/05/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T>
|
|
inline BasicTimerClass<T>::~BasicTimerClass(void)
|
|
{
|
|
}
|
|
|
|
|
|
template<class T>
|
|
inline unsigned long BasicTimerClass<T>::Value(void) const
|
|
{
|
|
return(Timer()-Started);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* BasicTimerClass<T>::operator long -- Conversion to long operator. *
|
|
* *
|
|
* This conversion operator allows the basic timer object to function in much the same *
|
|
* manner as the integral "long" type. One can assign a long with a timer object and the *
|
|
* actual value of the timer is extracted from the object and used. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: Returns with the timer value expressed as a long. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 02/05/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T>
|
|
inline BasicTimerClass<T>::operator unsigned long(void) const
|
|
{
|
|
return(Timer()-Started);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* BasicTimerClass<T>::operator () -- Function operator for timer object. *
|
|
* *
|
|
* This function operator allows the timer to also serve as the parameter type class for *
|
|
* additional timer objects. This allows one to instantiate a controlling timer class that *
|
|
* can control (e.g., turn on or off) all timers that are based upon it. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: Returns the current timer value expressed as a long. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 02/05/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T>
|
|
inline unsigned long BasicTimerClass<T>::operator () (void) const
|
|
{
|
|
return(Timer()-Started);
|
|
}
|
|
|
|
|
|
/*
|
|
** This timer class functions similarly to the basic timer class. In addition to the
|
|
** normal timer operation, this class has the ability to be stopped and started at
|
|
** will. If you have no need to start or stop the timer, then use the basic timer
|
|
** class instead.
|
|
*/
|
|
template<class T>
|
|
class TTimerClass : public BasicTimerClass<T> {
|
|
public:
|
|
// Constructor allows assignment as if class was integral 'long' type.
|
|
TTimerClass(unsigned long set=0);
|
|
TTimerClass(NoInitClass const & x);
|
|
|
|
~TTimerClass(void) {};
|
|
|
|
// Fetches current value of timer.
|
|
unsigned long Value(void) const;
|
|
|
|
// Conversion operator to allow consistent treatment with integral types.
|
|
operator unsigned long(void) const;
|
|
|
|
// Function operator to allow timer object definition to be cascaded.
|
|
unsigned long operator () (void) const;
|
|
|
|
// Stops (pauses) the timer.
|
|
void Stop(void);
|
|
|
|
// Starts (resumes) the timer.
|
|
void Start(void);
|
|
|
|
// Queries whether the timer is currently active.
|
|
bool Is_Active(void) const;
|
|
|
|
private:
|
|
unsigned long Accumulated; // Total accumulated ticks.
|
|
};
|
|
|
|
|
|
template<class T>
|
|
inline TTimerClass<T>::TTimerClass(NoInitClass const & x) :
|
|
BasicTimerClass<T>(x)
|
|
{
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* TTimerClass<T>::TTimerClass -- Constructor for timer class object. *
|
|
* *
|
|
* This is the constructor for the advanced timer class object. This object class can start *
|
|
* or stop the timer under user control. *
|
|
* *
|
|
* INPUT: set -- The initial value to set the timer to. If no value is specified, then *
|
|
* the timer is assumed to start from zero. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 02/05/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T>
|
|
inline TTimerClass<T>::TTimerClass(unsigned long set) :
|
|
BasicTimerClass<T>(set),
|
|
Accumulated(0)
|
|
{
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* TTimerClass<T>::Value -- Returns with the current value of the timer. *
|
|
* *
|
|
* This routine will return with the current value of the timer. It takes into account *
|
|
* whether the timer has stopped or not so as to always return the correct value regardless *
|
|
* of that condition. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: Returns with the current value of the timer. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 07/06/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T>
|
|
inline unsigned long TTimerClass<T>::Value(void) const
|
|
{
|
|
unsigned long value = Accumulated;
|
|
if (Started != 0xFFFFFFFFU) {
|
|
value += BasicTimerClass<T>::Value();
|
|
}
|
|
return(value);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* TTimerClass<T>::operator long -- Conversion operator for timer object. *
|
|
* *
|
|
* This conversion operator allows this timer object to function as an "rvalue" of a "long" *
|
|
* type. This is consistent with the integral "long" value. It is possible to assign a *
|
|
* timer object to a long and have the long initialized with the current value of the *
|
|
* timer. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: Returns with the current time value expressed as a long. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 02/05/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T>
|
|
inline TTimerClass<T>::operator unsigned long(void) const
|
|
{
|
|
unsigned long value = Accumulated;
|
|
if (Started != 0xFFFFFFFFU) {
|
|
value += BasicTimerClass<T>::Value();
|
|
}
|
|
return(value);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* TTimerClass<T>::operator () -- Function operator for timer object. *
|
|
* *
|
|
* This function operator for the timer class allows this timer class to be used as the *
|
|
* template parameter for other timer class objects. With this ability, one can control *
|
|
* several timers (e.g., start or stop them) by using a single controlling timer class *
|
|
* that other timers are instantiated from. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: Returns with the current time expressed as a long. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 02/05/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T>
|
|
inline unsigned long TTimerClass<T>::operator () (void) const
|
|
{
|
|
unsigned long value = Accumulated;
|
|
if (Started != 0xFFFFFFFFU) {
|
|
value += BasicTimerClass<T>::Value();
|
|
}
|
|
return(value);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* TTimerClass<T>::Stop -- Stops the current timer from incrementing. *
|
|
* *
|
|
* This routine will stop (pause) the timer from further increments. To cause the timer *
|
|
* to begin anew, call the Start() function. *
|
|
* *
|
|
* *
|
|
* INPUT: *
|
|
* *
|
|
* OUTPUT: *
|
|
* *
|
|
* WARNINGS: *
|
|
* *
|
|
* HISTORY: *
|
|
* 02/05/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T>
|
|
void TTimerClass<T>::Stop(void)
|
|
{
|
|
if (Started != 0xFFFFFFFFU) {
|
|
Accumulated += BasicTimerClass<T>::operator unsigned long();
|
|
Started = 0xFFFFFFFFU;
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* TTimerClass<T>::Start -- Starts (resumes) a stopped timer. *
|
|
* *
|
|
* This routine will resume a timer that was previously stopped with the Stop() function. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 02/06/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T>
|
|
void TTimerClass<T>::Start(void)
|
|
{
|
|
if (Started == 0xFFFFFFFFU) {
|
|
Started = Timer();
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* TTimerClass<T>::Is_Active -- Checks to see if the timer is counting. *
|
|
* *
|
|
* Since this timer can be paused, this routine is used to examine the timer to see if it *
|
|
* is currently paused or active. If the timer is active, then the return value will be *
|
|
* true. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: bool; Is this timer currently active? *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 02/06/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T>
|
|
inline bool TTimerClass<T>::Is_Active(void) const
|
|
{
|
|
return(Started != 0xFFFFFFFFU);
|
|
}
|
|
|
|
|
|
/*
|
|
** This timer counts down from the specified (or constructed) value down towards zero.
|
|
** The countdown rate is controlled by the timer object specified. This timer object can
|
|
** be started or stopped. It can also be tested to see if it has expired or not. An expired
|
|
** count down timer is one that has value of zero. You can treat this class object as if it
|
|
** were an integral "magic" long that automatically counts down toward zero.
|
|
*/
|
|
template<class T>
|
|
class CDTimerClass : public BasicTimerClass<T> {
|
|
public:
|
|
// Constructor allows assignment as if class was integral 'long' type.
|
|
CDTimerClass(unsigned long set=0);
|
|
CDTimerClass(NoInitClass const & x);
|
|
|
|
~CDTimerClass(void);
|
|
|
|
// Fetches current value of count down timer.
|
|
unsigned long Value(void) const;
|
|
|
|
// Conversion operator to allow consistent treatment with integral types.
|
|
operator unsigned long(void) const;
|
|
|
|
// Function operator to allow timer object definition to be cascaded.
|
|
unsigned long operator () (void) const;
|
|
|
|
// Stops (pauses) the timer.
|
|
void Stop(void);
|
|
|
|
// Starts (resumes) the timer.
|
|
void Start(void);
|
|
|
|
// Queries whether the timer is currently active.
|
|
bool Is_Active(void) const;
|
|
|
|
bool Was_Started(void) const { return WasStarted; }
|
|
|
|
private:
|
|
unsigned long DelayTime; // Ticks remaining before countdown timer expires.
|
|
bool WasStarted;
|
|
};
|
|
|
|
|
|
template<class T>
|
|
inline CDTimerClass<T>::CDTimerClass(NoInitClass const & x) :
|
|
BasicTimerClass<T>(x), WasStarted(false)
|
|
{
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* CDTimerClass<T>::CDTimerClass -- Constructor for count down timer. *
|
|
* *
|
|
* This is the constructor for the count down timer object. The optional starting value *
|
|
* can be used to initiate the timer. Because of this constructor it is possible to assign *
|
|
* a long to a count down timer object in order to begin the countdown process. *
|
|
* *
|
|
* INPUT: set -- The initial starting value for the countdown timer. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 02/06/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T>
|
|
inline CDTimerClass<T>::CDTimerClass(unsigned long set) :
|
|
BasicTimerClass<T>(0),
|
|
DelayTime(set),
|
|
WasStarted(false)
|
|
{
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* CDTimerClass<T>::~CDTimerClass -- Destructor for the count down timer object. *
|
|
* *
|
|
* The destructor for the count down timer object does nothing. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 02/06/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T>
|
|
inline CDTimerClass<T>::~CDTimerClass(void)
|
|
{
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* CDTimerClass<T>::Value -- Fetches the current value of the countdown timer. *
|
|
* *
|
|
* Use this routine to fetch the current value of the timer. It takes into consideration *
|
|
* whether the timer has been stopped or not. It returns the correct value regardless of *
|
|
* this condition. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: Returns with the correct value of this count down timer. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 07/06/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T>
|
|
inline unsigned long CDTimerClass<T>::Value(void) const
|
|
{
|
|
unsigned long remain = DelayTime;
|
|
if (Started != 0xFFFFFFFFU) {
|
|
unsigned long value = BasicTimerClass<T>::Value();
|
|
if (value < remain) {
|
|
return(remain - value);
|
|
} else {
|
|
return(0);
|
|
}
|
|
}
|
|
return(remain);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* CDTimerClass<T>::operator long -- Conversion to long operator function. *
|
|
* *
|
|
* This conversion operator allows the count down timer object to be used as if it were *
|
|
* a "magic" long that automatically counted downward at the controller class tick rate. *
|
|
* The count down object can be used in any place that an rvalue long could be used. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: Returns with the current count down time expressed in the form of a long value. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 02/06/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T>
|
|
inline CDTimerClass<T>::operator unsigned long(void) const
|
|
{
|
|
unsigned long remain = DelayTime;
|
|
if (Started != 0xFFFFFFFFU) {
|
|
unsigned long value = BasicTimerClass<T>::Value();
|
|
if (value < remain) {
|
|
return(remain - value);
|
|
} else {
|
|
return(0);
|
|
}
|
|
}
|
|
return(remain);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* CDTimerClass<T>::operator () -- Function operator for the count down timer. *
|
|
* *
|
|
* This is the function operator for the count down timer object. By supporting this *
|
|
* function operator, this class (or one derived from this class) could be used as the *
|
|
* controlling timer to the timer templates. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: Returns with the current count down time expressed in the form of a long. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 02/06/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T>
|
|
inline unsigned long CDTimerClass<T>::operator () (void) const
|
|
{
|
|
unsigned long remain = DelayTime;
|
|
if (Started != 0xFFFFFFFFU) {
|
|
unsigned long value = BasicTimerClass<T>::Value();
|
|
if (value < remain) {
|
|
return(remain - value);
|
|
} else {
|
|
return(0);
|
|
}
|
|
}
|
|
return(remain);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* CDTimerClass<T>::Stop -- Stops (pauses) the count down timer. *
|
|
* *
|
|
* This routine is used to stop (pause) the count down timer object. A timer object paused *
|
|
* in this fashion will be resumed by a call to Start() or by assigning a new count down *
|
|
* value to the timer. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 02/06/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T>
|
|
void CDTimerClass<T>::Stop(void)
|
|
{
|
|
if (Started != 0xFFFFFFFFU) {
|
|
DelayTime = *this;
|
|
Started = 0xFFFFFFFFU;
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* CDTimerClass<T>::Start -- Starts (resumes) the count down timer. *
|
|
* *
|
|
* This routine is used to start (resume) the count down timer that was previously stopped *
|
|
* with the Stop() function. The timer will also resume when a new timer value is assigned. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 02/06/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T>
|
|
void CDTimerClass<T>::Start(void)
|
|
{
|
|
WasStarted = true;
|
|
|
|
if (Started == 0xFFFFFFFFU) {
|
|
Started = Timer();
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* CDTimerClass<T>::Is_Active -- Checks to see if the timer object is active. *
|
|
* *
|
|
* Because the timer object counting can be stopped, this routine is used to determine *
|
|
* if the timer is currently paused or active. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: bool; Is the timer currently active? *
|
|
* *
|
|
* WARNINGS: Note that if the timer has counted down to zero, then it may be active, but *
|
|
* the value will, naturally, not change. *
|
|
* *
|
|
* HISTORY: *
|
|
* 02/06/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T>
|
|
inline bool CDTimerClass<T>::Is_Active(void) const
|
|
{
|
|
return(Started != 0xFFFFFFFFU);
|
|
}
|
|
|
|
#endif
|