Ok, do you want to give these a go - I’ve not got any code that would use it, so haven’t tried them yet:
[code]//==============================================================================
/**
A type of timer class that can run multiple timers with different frequencies,
all of which share a single callback.
This class is very similar to the Timer class, but allows you run multiple
separate timers, where each one has a unique ID number. The methods in this
class are exactly equivalent to those in Timer, but with the addition of
this ID number.
To use it, you need to create a subclass of MultiTimer, implementing the
timerCallback() method. Then you can start timers with startTimer(), and
each time the callback is triggered, it passes in the ID of the timer that
caused it.
@see Timer
/
class JUCE_API MultiTimer
{
protected:
//==============================================================================
/* Creates a MultiTimer.
When created, no timers are running, so use startTimer() to start things off.
*/
MultiTimer() throw();
/** Creates a copy of another timer.
Note that this timer will not contain any running timers, even if the one you're
copying from was running.
*/
MultiTimer (const MultiTimer& other) throw();
public:
//==============================================================================
/** Destructor. */
virtual ~MultiTimer();
//==============================================================================
/** The user-defined callback routine that actually gets called periodically.
It's perfectly ok to call startTimer() or stopTimer() from within this
callback to change the subsequent intervals.
*/
virtual void timerCallback (const int timerId) = 0;
//==============================================================================
/** Starts a timer and sets the length of interval required.
If the timer is already started, this will reset it, so the
time between calling this method and the next timer callback
will not be less than the interval length passed in.
@param timerId a unique Id number that identifies the timer to
start. This is the id that will be passed back
to the timerCallback() method when this timer is
triggered
@param intervalInMilliseconds the interval to use (any values less than 1 will be
rounded up to 1)
*/
void startTimer (const int timerId, const int intervalInMilliseconds) throw();
/** Stops a timer.
If a timer has been started with the given ID number, it will be cancelled.
No more callbacks will be made for the specified timer after this method returns.
If this is called from a different thread, any callbacks that may
be currently executing may be allowed to finish before the method
returns.
*/
void stopTimer (const int timerId) throw();
//==============================================================================
/** Checks whether a timer has been started for a specified ID.
@returns true if a timer with the given ID is running.
*/
bool isTimerRunning (const int timerId) const throw();
/** Returns the interval for a specified timer ID.
@returns the timer's interval in milliseconds if it's running, or 0 if it's no timer
is running for the ID number specified.
*/
int getTimerInterval (const int timerId) const throw();
//==============================================================================
private:
CriticalSection timerListLock;
VoidArray timers;
const MultiTimer& operator= (const MultiTimer&);
};[/code]
//==============================================================================
class InternalMultiTimerCallback : public Timer
{
public:
InternalMultiTimerCallback (const int id_, MultiTimer& owner_)
: id (id_),
owner (owner_)
{
}
~InternalMultiTimerCallback()
{
}
void timerCallback()
{
owner.timerCallback (id);
}
const int id;
private:
MultiTimer& owner;
};
//==============================================================================
MultiTimer::MultiTimer() throw()
{
}
MultiTimer::MultiTimer (const MultiTimer&) throw()
{
}
MultiTimer::~MultiTimer()
{
const ScopedLock sl (timerListLock);
for (int i = timers.size(); --i >= 0;)
delete (InternalMultiTimerCallback*) timers.getUnchecked(i);
timers.clear();
}
//==============================================================================
void MultiTimer::startTimer (const int timerId, const int intervalInMilliseconds) throw()
{
const ScopedLock sl (timerListLock);
for (int i = timers.size(); --i >= 0;)
{
InternalMultiTimerCallback* const t = (InternalMultiTimerCallback*) timers.getUnchecked(i);
if (t->id == timerId)
{
t->startTimer (intervalInMilliseconds);
return;
}
}
InternalMultiTimerCallback* const newTimer = new InternalMultiTimerCallback (timerId, *this);
timers.add (newTimer);
newTimer->startTimer (intervalInMilliseconds);
}
void MultiTimer::stopTimer (const int timerId) throw()
{
const ScopedLock sl (timerListLock);
for (int i = timers.size(); --i >= 0;)
{
InternalMultiTimerCallback* const t = (InternalMultiTimerCallback*) timers.getUnchecked(i);
if (t->id == timerId)
t->stopTimer();
}
}
bool MultiTimer::isTimerRunning (const int timerId) const throw()
{
const ScopedLock sl (timerListLock);
for (int i = timers.size(); --i >= 0;)
{
const InternalMultiTimerCallback* const t = (InternalMultiTimerCallback*) timers.getUnchecked(i);
if (t->id == timerId)
return t->isTimerRunning();
}
return false;
}
int MultiTimer::getTimerInterval (const int timerId) const throw()
{
const ScopedLock sl (timerListLock);
for (int i = timers.size(); --i >= 0;)
{
const InternalMultiTimerCallback* const t = (InternalMultiTimerCallback*) timers.getUnchecked(i);
if (t->id == timerId)
return t->getTimerInterval();
}
return 0;
}