MAC SDL_AddTimer Code

sorry about the big paste, i don’t have diff accessable where i’m at. But
it’s only the one file :slight_smile:
It could probably do with a little cleaning up, but it works.

//--------------------------------sdl_timer.c
#ifdef SAVE_RCSID
static char rcsid =
"@(#) $Id: SDL_timer.c,v 1.1 2001/04/26 16:50:18 hercules Exp $";
#endif

#include <stdlib.h>
#include <stdio.h> /* For the definition of NULL */

#if (defined(MACOS) || defined(macintosh))
#include <Types.h>
#include <Timer.h>
#include <OSUtils.h>
#include <Gestalt.h>
#include <Processes.h>
#include <LowMem.h>
#endif

#include “SDL_error.h”
#include “SDL_timer.h”
#include “SDL_timer_c.h”
#include “SDL_mutex.h”
#include “SDL_systimer.h”

/* #define DEBUG_TIMERS */

int SDL_timer_started = 0;
int SDL_timer_running = 0;

/* Data to handle a single periodic alarm */
Uint32 SDL_alarm_interval = 0;
SDL_TimerCallback SDL_alarm_callback;

static SDL_bool list_changed = SDL_FALSE;

/* Data used for a thread-based timer */
static int SDL_timer_threaded = 0;

#if (defined(MACOS) || defined(macintosh))
struct _SDL_TimerID {
TMTask tmTask; /the dummytask that then calls our
real task
/
Uint32 interval; /the time interval before FIRST
run
/
SDL_NewTimerCallback cb;
void * param;
/these are not used, just to satisfy other functions/
struct _SDL_TimerID *next;
Uint32 last_alarm;
};

#else
struct _SDL_TimerID {
Uint32 interval;
SDL_NewTimerCallback cb;
void *param;
Uint32 last_alarm;
struct _SDL_TimerID *next;
};
#endif

static SDL_TimerID SDL_timers = NULL;
static Uint32 num_timers = 0;
static SDL_mutex *SDL_timer_mutex;

/* Set whether or not the timer should use a thread.
This should not be called while the timer subsystem is running.
*/
int SDL_SetTimerThreaded(int value)
{
int retval;

if ( SDL_timer_started ) {
SDL_SetError(“Timer already initialized”);
retval = -1;
} else {
retval = 0;
SDL_timer_threaded = value;
}
return retval;
}

int SDL_TimerInit(void)
{
int retval;

SDL_timer_running = 0;
SDL_SetTimer(0, NULL);
retval = 0;
if ( ! SDL_timer_threaded ) {
retval = SDL_SYS_TimerInit();
}
if ( SDL_timer_threaded ) {
SDL_timer_mutex = SDL_CreateMutex();
}
SDL_timer_started = 1;
return(retval);
}

void SDL_TimerQuit(void)
{
SDL_SetTimer(0, NULL);
if ( SDL_timer_threaded < 2 ) {
SDL_SYS_TimerQuit();
}
if ( SDL_timer_threaded ) {
SDL_DestroyMutex(SDL_timer_mutex);
}
SDL_timer_started = 0;
SDL_timer_threaded = 0;
}

void SDL_ThreadedTimerCheck(void)
{
Uint32 now, ms;
SDL_TimerID t, prev, next;
int removed;

now = SDL_GetTicks();

SDL_mutexP(SDL_timer_mutex);
for ( prev = NULL, t = SDL_timers; t; t = next ) {
removed = 0;
ms = t->interval - SDL_TIMESLICE;
next = t->next;
if ( (t->last_alarm < now) && ((now - t->last_alarm) > ms) ) {
if ( (now - t->last_alarm) < t->interval ) {
t->last_alarm += t->interval;
} else {
t->last_alarm = now;
}
list_changed = SDL_FALSE;
#ifdef DEBUG_TIMERS
printf(“Executing timer %p (thread = %d)\n”,
t, SDL_ThreadID());
#endif
SDL_mutexV(SDL_timer_mutex);
ms = t->cb(t->interval, t->param);
SDL_mutexP(SDL_timer_mutex);
if ( list_changed ) {
/* Abort, list of timers has been modified /
break;
}
if ( ms != t->interval ) {
if ( ms ) {
t->interval = ROUND_RESOLUTION(ms);
} else { /
Remove the timer from the linked list /
#ifdef DEBUG_TIMERS
printf(“SDL: Removing timer %p\n”, t);
#endif
if ( prev ) {
prev->next = next;
} else {
SDL_timers = next;
}
free(t);
– num_timers;
removed = 1;
}
}
}
/
Don’t update prev if the timer has disappeared */
if ( ! removed ) {
prev = t;
}
}
SDL_mutexV(SDL_timer_mutex);
}

#if (defined(MACOS) || defined(macintosh))
/--------------------------------------------------------------------------
-------------
/
pascal void TM_DummyRoutine(SDL_TimerID taskptr) {

/* Call the task the user really wanted*/
if (taskptr->cb != NULL)
 taskptr->cb(taskptr->interval, taskptr->param);

/reschedule the event to run again after the same interval/
PrimeTime((QElemPtr)(SDL_TimerID)taskptr, taskptr->interval);
}

SDL_TimerID SDL_AddTimer(Uint32 interval, SDL_NewTimerCallback callback,
void *param){

SDL_TimerID tminfo=NULL;

/* see if the timer has been started. if not, return. note however that

with
the mac we do not have to call the start timer function in order to
created
timed events. */
if (!SDL_timer_started){
SDL_SetError(“You must call SDL_Init(SDL_INIT_TIMER) first”);
return NULL;
}

/* Allocate space for the structure*/
tminfo= malloc(sizeof(struct _SDL_TimerID));
if (tminfo==NULL) return NULL;

/* Init some fields*/
tminfo->tmTask.tmAddr= NewTimerProc(TM_DummyRoutine);  /* a front end

routine*/
tminfo->tmTask.tmCount = 0;
tminfo->tmTask.qLink = NULL;
tminfo->tmTask.qType = 0;
tminfo->tmTask.tmWakeUp =0; /* You always set this to 0*/
tminfo->tmTask.tmReserved = 0; /* You always set this to 0*/
tminfo->cb = callback; /* The routine we want to run*/
tminfo->param = param;
tminfo->interval = interval;

InsXTime((QElemPtr)tminfo);             /* Install the task*/
PrimeTime((QElemPtr)tminfo, interval);
return tminfo;

}

SDL_bool SDL_RemoveTimer(SDL_TimerID tmtask){

long remaining_count;

RmvTime((QElemPtr)tmtask);          /* remove the task from the time

manager*/
free(tmtask); /* Dispose the TMInfoPtr we
allocated*/

return SDL_TRUE;

}

void SDL_ScheduleTask(SDL_TimerID task, long count){
PrimeTime((QElemPtr)task,count);
}
/--------------------------------------------------------------------------
-------------------
/
#else
SDL_TimerID SDL_AddTimer(Uint32 interval, SDL_NewTimerCallback callback,
void *param)
{
SDL_TimerID t;
if ( ! SDL_timer_mutex ) {
if ( SDL_timer_started ) {
SDL_SetError(“This platform doesn’t support multiple timers”);
} else {
SDL_SetError(“You must call SDL_Init(SDL_INIT_TIMER) first”);
}
return NULL;
}
if ( ! SDL_timer_threaded ) {
SDL_SetError(“Multiple timers require threaded events!”);
return NULL;
}
SDL_mutexP(SDL_timer_mutex);
t = (SDL_TimerID) malloc(sizeof(struct _SDL_TimerID));
if ( t ) {
t->interval = ROUND_RESOLUTION(interval);
t->cb = callback;
t->param = param;
t->last_alarm = SDL_GetTicks();
t->next = SDL_timers;
SDL_timers = t;
++ num_timers;
list_changed = SDL_TRUE;
SDL_timer_running = 1;
}
#ifdef DEBUG_TIMERS
printf(“SDL_AddTimer(%d) = %08x num_timers = %d\n”, interval, (Uint32)t,
num_timers);
#endif
SDL_mutexV(SDL_timer_mutex);
return t;
}

SDL_bool SDL_RemoveTimer(SDL_TimerID id)
{
SDL_TimerID t, prev = NULL;
SDL_bool removed;

removed = SDL_FALSE;
SDL_mutexP(SDL_timer_mutex);
/* Look for id in the linked list of timers */
for (t = SDL_timers; t; prev=t, t = t->next ) {
if ( t == id ) {
if(prev) {
prev->next = t->next;
} else {
SDL_timers = t->next;
}
free(t);
– num_timers;
removed = SDL_TRUE;
list_changed = SDL_TRUE;
break;
}
}
#ifdef DEBUG_TIMERS
printf(“SDL_RemoveTimer(%08x) = %d num_timers = %d thread = %d\n”,
(Uint32)id, removed, num_timers, SDL_ThreadID());
#endif
SDL_mutexV(SDL_timer_mutex);
return removed;
}

#endif /MACOS/

static void SDL_RemoveAllTimers(SDL_TimerID t)
{
SDL_TimerID freeme;

/* Changed to non-recursive implementation.
The recursive implementation is elegant, but subject to
stack overflow if there are lots and lots of timers.
*/
while ( t ) {
freeme = t;
t = t->next;
free(freeme);
}
}

/* Old style callback functions are wrapped through this */
static Uint32 callback_wrapper(Uint32 ms, void *param)
{
SDL_TimerCallback func = (SDL_TimerCallback) param;
return (*func)(ms);
}

int SDL_SetTimer(Uint32 ms, SDL_TimerCallback callback)
{
int retval;

#ifdef DEBUG_TIMERS
printf(“SDL_SetTimer(%d)\n”, ms);
#endif
retval = 0;
if ( SDL_timer_running ) { /* Stop any currently running timer */
SDL_timer_running = 0;
if ( SDL_timer_threaded ) {
SDL_mutexP(SDL_timer_mutex);
SDL_RemoveAllTimers(SDL_timers);
SDL_timers = NULL;
SDL_mutexV(SDL_timer_mutex);
} else {
SDL_SYS_StopTimer();
}
}
if ( ms ) {
if ( SDL_timer_threaded ) {
retval = (SDL_AddTimer(ms, callback_wrapper,
(void *)callback) != NULL);
} else {
SDL_timer_running = 1;
SDL_alarm_interval = ms;
SDL_alarm_callback = callback;
retval = SDL_SYS_StartTimer();
}
}
return retval;
}
//---------------------------------------------------------------------------------------------