gDelayNone/gDelayForever to replace TIME_IMMEDIATE/TIME_INFINITE

36 files changed, 128 insertions, 125 deletions

diff --git a/src/gadc/gadc.c b/src/gadc/gadc.c
index ee5b9fdf..d3b8fb70 100644
--- a/src/gadc/gadc.c
+++ b/src/gadc/gadc.c
@@ -214,7 +214,7 @@ void gadcHighSpeedInit(uint32_t physdev, uint32_t frequency)
 #if GFX_USE_GEVENT
 	GSourceHandle gadcHighSpeedGetSource(void) {
 		if (!gtimerIsActive(&hsGTimer))
-			gtimerStart(&hsGTimer, HighSpeedGTimerCallback, 0, gTrue, TIME_INFINITE);
+			gtimerStart(&hsGTimer, HighSpeedGTimerCallback, 0, gTrue, gDelayForever);
 		hsFlags |= GADC_HSADC_GTIMER;
 		return (GSourceHandle)&hsGTimer;
 	}
@@ -285,7 +285,7 @@ static void LowSpeedGTimerCallback(void *param) {
 	NonTimerData		*pdata;
 
 	// Look for completed non-timer jobs and call the call-backs for each
-	while ((pdata = (NonTimerData *)gfxQueueGSyncGet(&lsListDone, TIME_IMMEDIATE))) {
+	while ((pdata = (NonTimerData *)gfxQueueGSyncGet(&lsListDone, gDelayNone))) {
 		pdata->callback(pdata->job.buffer, pdata->param);
 		gfxFree(pdata);
 	}
@@ -315,7 +315,7 @@ void gadcLowSpeedGet(uint32_t physdev, adcsample_t *buffer) {
 	gfxSystemUnlock();
 
 	// Wait for it to complete
-	gfxSemWait(&ndata.sigdone, TIME_INFINITE);
+	gfxSemWait(&ndata.sigdone, gDelayForever);
 	gfxSemDestroy(&ndata.sigdone);
 }
 
@@ -324,7 +324,7 @@ gBool gadcLowSpeedStart(uint32_t physdev, adcsample_t *buffer, GADCCallbackFunct
 
 	/* Start the Low Speed Timer */
 	if (!gtimerIsActive(&lsGTimer))
-		gtimerStart(&lsGTimer, LowSpeedGTimerCallback, 0, gTrue, TIME_INFINITE);
+		gtimerStart(&lsGTimer, LowSpeedGTimerCallback, 0, gTrue, gDelayForever);
 
 	// Prepare the job
 	if (!(pdata = gfxAlloc(sizeof(NonTimerData))))
diff --git a/src/gaudio/gaudio.c b/src/gaudio/gaudio.c
index 273e927f..c08f1d85 100644
--- a/src/gaudio/gaudio.c
+++ b/src/gaudio/gaudio.c
@@ -152,7 +152,7 @@ void _gaudioDeinit(void)
 
 		GSourceHandle gaudioPlayGetSource(void) {
 			if (!gtimerIsActive(&playTimer))
-				gtimerStart(&playTimer, PlayTimerCallback, 0, gTrue, TIME_INFINITE);
+				gtimerStart(&playTimer, PlayTimerCallback, 0, gTrue, gDelayForever);
 			playFlags |= PLAYFLG_USEEVENTS;
 			return (GSourceHandle)&playTimer;
 		}
@@ -209,7 +209,7 @@ void _gaudioDeinit(void)
 		if ((recordFlags & (RECORDFLG_RECORDING|RECORDFLG_STALLED)) == RECORDFLG_RECORDING)
 			gaudio_record_lld_stop();
 		recordFlags &= ~(RECORDFLG_RECORDING|RECORDFLG_STALLED);
-		while((pd = (GDataBuffer *)gfxQueueGSyncGet(&recordList, TIME_IMMEDIATE)))
+		while((pd = (GDataBuffer *)gfxQueueGSyncGet(&recordList, gDelayNone)))
 			gfxBufferRelease(pd);
 	}
 
@@ -245,7 +245,7 @@ void _gaudioDeinit(void)
 
 		GSourceHandle gaudioRecordGetSource(void) {
 			if (!gtimerIsActive(&recordTimer))
-				gtimerStart(&recordTimer, RecordTimerCallback, 0, gTrue, TIME_INFINITE);
+				gtimerStart(&recordTimer, RecordTimerCallback, 0, gTrue, gDelayForever);
 			recordFlags |= RECORDFLG_USEEVENTS;
 			return (GSourceHandle)&recordTimer;
 		}
diff --git a/src/gdisp/gdisp_image.h b/src/gdisp/gdisp_image.h
index 1f0acffb..03ddb459 100644
--- a/src/gdisp/gdisp_image.h
+++ b/src/gdisp/gdisp_image.h
@@ -227,20 +227,20 @@ gdispImageError gdispGImageDraw(GDisplay *g, gdispImage *img, gCoord x, gCoord y
 /**
  * @brief	Prepare for the next frame/page in the image file.
  * @return	A time in milliseconds to keep displaying the current frame before trying to draw
- * 			the next frame. Watch out for the special values TIME_IMMEDIATE and TIME_INFINITE.
+ * 			the next frame. Watch out for the special values gDelayNone and gDelayForever.
  *
  * @param[in] img   The image structure
  *
  * @pre		gdispImageOpen() must have returned successfully.
  *
- * @note	It will return TIME_IMMEDIATE if the first frame/page hasn't been drawn or if the next frame
+ * @note	It will return gDelayNone if the first frame/page hasn't been drawn or if the next frame
  * 			should be drawn immediately.
- * @note	It will return TIME_INFINITE if another image frame doesn't exist or an error has occurred.
- * @note	Images that support multiple pages (eg TIFF files) will return TIME_IMMEDIATE between pages
- * 			and then TIME_INFINITE when there are no more pages.
- * @note	An image that displays a looped animation will never return TIME_INFINITE unless it
+ * @note	It will return gDelayForever if another image frame doesn't exist or an error has occurred.
+ * @note	Images that support multiple pages (eg TIFF files) will return gDelayNone between pages
+ * 			and then gDelayForever when there are no more pages.
+ * @note	An image that displays a looped animation will never return gDelayForever unless it
  * 			gets an error.
- * @note	Calling gdispImageDraw() after getting a TIME_INFINITE will go back to drawing the first
+ * @note	Calling gdispImageDraw() after getting a gDelayForever will go back to drawing the first
  * 			frame/page.
  */
 gDelay gdispImageNext(gdispImage *img);
diff --git a/src/gdisp/gdisp_image_bmp.c b/src/gdisp/gdisp_image_bmp.c
index 0647e9ab..3066d9ef 100644
--- a/src/gdisp/gdisp_image_bmp.c
+++ b/src/gdisp/gdisp_image_bmp.c
@@ -819,7 +819,7 @@ gDelay gdispImageNext_BMP(gdispImage *img) {
 	(void) img;
 
 	/* No more frames/pages */
-	return TIME_INFINITE;
+	return gDelayForever;
 }
 
 uint16_t gdispImageGetPaletteSize_BMP(gdispImage *img) {
diff --git a/src/gdisp/gdisp_image_gif.c b/src/gdisp/gdisp_image_gif.c
index bad2a150..5ee76130 100644
--- a/src/gdisp/gdisp_image_gif.c
+++ b/src/gdisp/gdisp_image_gif.c
@@ -1122,7 +1122,7 @@ gDelay gdispImageNext_GIF(gdispImage *img) {
 		gfileSetPos(img->f, priv->frame.posimg+1);				// Skip the code size byte too
 		while(1) {
 			if (gfileRead(img->f, &blocksz, 1) != 1)
-				return TIME_INFINITE;
+				return gDelayForever;
 			if (!blocksz)
 				break;
 			gfileSetPos(img->f, gfileGetPos(img->f) + blocksz);
@@ -1145,10 +1145,10 @@ gDelay gdispImageNext_GIF(gdispImage *img) {
 		case GDISP_IMAGE_ERR_NOMEMORY:				// Out of Memory
 		case GDISP_IMAGE_ERR_UNSUPPORTED:			// Unsupported
 		default:
-			return TIME_INFINITE;
+			return gDelayForever;
 		}
 	}
-	return TIME_INFINITE;
+	return gDelayForever;
 }
 
 #endif /* GFX_USE_GDISP && GDISP_NEED_IMAGE && GDISP_NEED_IMAGE_GIF */
diff --git a/src/gdisp/gdisp_image_jpg.c b/src/gdisp/gdisp_image_jpg.c
index 1deaaa0b..7a684eb7 100644
--- a/src/gdisp/gdisp_image_jpg.c
+++ b/src/gdisp/gdisp_image_jpg.c
@@ -202,7 +202,7 @@ gDelay gdispImageNext_JPG(gdispImage *img) {
 	(void) img;
 
 	/* No more frames/pages */
-	return TIME_INFINITE;
+	return gDelayForever;
 }
 
 /*----------------------------------------------------------------------------/
diff --git a/src/gdisp/gdisp_image_native.c b/src/gdisp/gdisp_image_native.c
index 3ac5eb36..ec596856 100644
--- a/src/gdisp/gdisp_image_native.c
+++ b/src/gdisp/gdisp_image_native.c
@@ -144,7 +144,7 @@ gDelay gdispImageNext_NATIVE(gdispImage *img) {
 	(void) img;
 
 	/* No more frames/pages */
-	return TIME_INFINITE;
+	return gDelayForever;
 }
 
 #endif /* GFX_USE_GDISP && GDISP_NEED_IMAGE && GDISP_NEED_IMAGE_NATIVE */
diff --git a/src/gdisp/gdisp_image_png.c b/src/gdisp/gdisp_image_png.c
index f714b779..b977d8f3 100644
--- a/src/gdisp/gdisp_image_png.c
+++ b/src/gdisp/gdisp_image_png.c
@@ -1625,7 +1625,7 @@ gDelay gdispImageNext_PNG(gdispImage *img) {
 	(void) img;
 
 	/* No more frames/pages */
-	return TIME_INFINITE;
+	return gDelayForever;
 }
 
 #endif /* GFX_USE_GDISP && GDISP_NEED_IMAGE && GDISP_NEED_IMAGE_PNG */
diff --git a/src/gevent/gevent.h b/src/gevent/gevent.h
index 203fbb9a..187a8b6e 100644
--- a/src/gevent/gevent.h
+++ b/src/gevent/gevent.h
@@ -142,8 +142,8 @@ void geventDetachSource(GListener *pl, GSourceHandle gsh);
  * @brief	Wait for an event on a listener from an assigned source.
  * @details	The type of the event should be checked (pevent->type) and then pevent should
  *			be typecast to the actual event type if it needs to be processed.
- *			TIME_INFINITE means no timeout - wait forever for an event.
- *			TIME_IMMEDIATE means return immediately
+ *			gDelayForever means no timeout - wait forever for an event.
+ *			gDelayNone means return immediately
  * @note	The returned GEvent is released when this routine is called again
  * 			or when optionally @p geventEventComplete() is called. Calling @p geventEventComplete()
  * 			allows the GEvent object to be reused earlier which can reduce missed events. The GEvent
diff --git a/src/ginput/ginput_driver_toggle.h b/src/ginput/ginput_driver_toggle.h
index 0dced07b..01c79546 100644
--- a/src/ginput/ginput_driver_toggle.h
+++ b/src/ginput/ginput_driver_toggle.h
@@ -41,12 +41,12 @@ extern "C" {
 	unsigned ginput_lld_toggle_getbits(const GToggleConfig *ptc);
 
 	/* This routine is provided to low level drivers to wakeup a value read from a thread context.
-	 *	Particularly useful if GINPUT_TOGGLE_POLL_PERIOD = TIME_INFINITE
+	 *	Particularly useful if GINPUT_TOGGLE_POLL_PERIOD = gDelayForever
 	 */
 	void ginputToggleWakeup(void);
 
 	/* This routine is provided to low level drivers to wakeup a value read from an ISR
-	 *	Particularly useful if GINPUT_TOGGLE_POLL_PERIOD = TIME_INFINITE
+	 *	Particularly useful if GINPUT_TOGGLE_POLL_PERIOD = gDelayForever
 	 */
 	void ginputToggleWakeupI(void);
 
diff --git a/src/gos/gos.h b/src/gos/gos.h
index 5db10fef..e8684d6f 100644
--- a/src/gos/gos.h
+++ b/src/gos/gos.h
@@ -99,8 +99,8 @@
 	 * @note	Your platform may use slightly different definitions to these
 	 * @{
 	 */
-	#define TIME_IMMEDIATE				0
-	#define TIME_INFINITE				((gDelay)-1)
+	#define gDelayNone				0
+	#define gDelayForever				((gDelay)-1)
 	#define MAX_SEMAPHORE_COUNT			((gSemcount)(((unsigned long)((gSemcount)(-1))) >> 1))
 	#define LOW_PRIORITY				0
 	#define NORMAL_PRIORITY				1
@@ -215,9 +215,9 @@
 	 *
 	 * @param[in] ms	The number milliseconds to sleep
 	 *
-	 * @note		Specifying TIME_IMMEDIATE will yield the current thread but return
+	 * @note		Specifying gDelayNone will yield the current thread but return
 	 * 				on the next time slice.
-	 * @note		Specifying TIME_INFINITE will sleep forever.
+	 * @note		Specifying gDelayForever will sleep forever.
 	 *
 	 * @api
 	 */
@@ -228,8 +228,8 @@
 	 *
 	 * @param[in] us	The number microseconds to sleep
 	 *
-	 * @note		Specifying TIME_IMMEDIATE will return immediately (no sleeping)
-	 * @note		Specifying TIME_INFINITE will sleep forever.
+	 * @note		Specifying gDelayNone will return immediately (no sleeping)
+	 * @note		Specifying gDelayForever will sleep forever.
 	 *
 	 * @api
 	 */
@@ -372,7 +372,7 @@
 
 	/**
 	 * @brief	Test if a wait on a semaphore can be satisfied immediately
-	 * @details	Equivalent to @p gfxSemWait(psem, TIME_IMMEDIATE) except it can be called at interrupt level
+	 * @details	Equivalent to @p gfxSemWait(psem, gDelayNone) except it can be called at interrupt level
 	 * @return	gFalse if the wait would occur occurred otherwise gTrue
 	 *
 	 * @param[in] psem		A pointer to the semaphore
@@ -498,6 +498,11 @@
 	typedef gTicks			systemticks_t;
 	typedef gThreadreturn	threadreturn_t;
 	typedef gThreadpriority	threadpriority_t;
+	#if !GFX_USE_OS_CHIBIOS
+		// These are defined by ChibiOS itself
+		#define TIME_IMMEDIATE	gDelayNone
+		#define TIME_INFINITE	gDelayForever
+	#endif
 #endif
 
 #endif /* _GOS_H */
diff --git a/src/gos/gos_chibios.c b/src/gos/gos_chibios.c
index ef7a3336..c5a89b5a 100644
--- a/src/gos/gos_chibios.c
+++ b/src/gos/gos_chibios.c
@@ -84,8 +84,8 @@ void *gfxRealloc(void *ptr, size_t oldsz, size_t newsz)
 void gfxSleepMilliseconds(gDelay ms)
 {
 	switch(ms) {
-		case TIME_IMMEDIATE:	chThdYield();				return;
-		case TIME_INFINITE:		chThdSleep(TIME_INFINITE);	return;
+		case gDelayNone:		chThdYield();				return;
+		case gDelayForever:		chThdSleep(TIME_INFINITE);	return;
 		default:				chThdSleepMilliseconds(ms);	return;
 	}
 }
@@ -93,8 +93,8 @@ void gfxSleepMilliseconds(gDelay ms)
 void gfxSleepMicroseconds(gDelay ms)
 {
 	switch(ms) {
-		case TIME_IMMEDIATE:								return;
-		case TIME_INFINITE:		chThdSleep(TIME_INFINITE);	return;
+		case gDelayNone:									return;
+		case gDelayForever:		chThdSleep(TIME_INFINITE);	return;
 		default:				chThdSleepMicroseconds(ms);	return;
 	}
 }
@@ -122,14 +122,14 @@ gBool gfxSemWait(gfxSem *psem, gDelay ms)
 {
 	#if CH_KERNEL_MAJOR <= 2
 		switch(ms) {
-		case TIME_IMMEDIATE:	return chSemWaitTimeout(&psem->sem, TIME_IMMEDIATE) != RDY_TIMEOUT;
-		case TIME_INFINITE:		chSemWait(&psem->sem);	return gTrue;
+		case gDelayNone:		return chSemWaitTimeout(&psem->sem, TIME_IMMEDIATE) != RDY_TIMEOUT;
+		case gDelayForever:		chSemWait(&psem->sem);	return gTrue;
 		default:				return chSemWaitTimeout(&psem->sem, gfxMillisecondsToTicks(ms)) != RDY_TIMEOUT;
 		}
 	#else
 		switch(ms) {
-		case TIME_IMMEDIATE:	return chSemWaitTimeout(&psem->sem, TIME_IMMEDIATE) != MSG_TIMEOUT;
-		case TIME_INFINITE:		chSemWait(&psem->sem);	return gTrue;
+		case gDelayNone:		return chSemWaitTimeout(&psem->sem, TIME_IMMEDIATE) != MSG_TIMEOUT;
+		case gDelayForever:		chSemWait(&psem->sem);	return gTrue;
 		default:				return chSemWaitTimeout(&psem->sem, gfxMillisecondsToTicks(ms)) != MSG_TIMEOUT;
 		}
 	#endif
diff --git a/src/gos/gos_chibios.h b/src/gos/gos_chibios.h
index 77680a9c..450603c7 100644
--- a/src/gos/gos_chibios.h
+++ b/src/gos/gos_chibios.h
@@ -25,10 +25,8 @@
 /* Type definitions                                                          */
 /*===========================================================================*/
 
-/**
- * TIME_IMMEDIATE, TIME_INFINITE
- * are already defined by ChibiOS
- */
+#define gDelayNone		TIME_IMMEDIATE
+#define gDelayForever	TIME_INFINITE
 
 #if CH_KERNEL_MAJOR <= 4
 	typedef systime_t      gDelay;
diff --git a/src/gos/gos_cmsis.h b/src/gos/gos_cmsis.h
index 4473b9d1..0f2d66f5 100644
--- a/src/gos/gos_cmsis.h
+++ b/src/gos/gos_cmsis.h
@@ -25,8 +25,8 @@
 /* Type definitions                                                          */
 /*===========================================================================*/
 
-#define TIME_IMMEDIATE		0
-#define TIME_INFINITE		osWaitForever
+#define gDelayNone			0
+#define gDelayForever		osWaitForever
 typedef uint32_t			gDelay;
 typedef uint32_t			gTicks;
 typedef uint16_t			gSemcount;
@@ -69,7 +69,7 @@ typedef osThreadId			gfxThreadHandle;
 
 void gfxMutexInit(gfxMutex* pmutex);
 #define gfxMutexDestroy(pmutex)		osMutexDelete((pmutex)->id)
-#define gfxMutexEnter(pmutex)		osMutexWait((pmutex)->id, TIME_INFINITE)
+#define gfxMutexEnter(pmutex)		osMutexWait((pmutex)->id, gDelayForever)
 #define gfxMutexExit(pmutex)		osMutexRelease((pmutex)->id)
 
 void gfxSemInit(gfxSem* psem, gSemcount val, gSemcount limit);
diff --git a/src/gos/gos_cmsis2.h b/src/gos/gos_cmsis2.h
index a6cde139..49c6cee2 100644
--- a/src/gos/gos_cmsis2.h
+++ b/src/gos/gos_cmsis2.h
@@ -25,8 +25,8 @@
 /* Type definitions                                                          */
 /*===========================================================================*/
 
-#define TIME_IMMEDIATE		0
-#define TIME_INFINITE		osWaitForever
+#define gDelayNone			0
+#define gDelayForever		osWaitForever
 typedef uint32_t			gDelay;
 typedef uint32_t			gTicks;
 typedef uint16_t			gSemcount;
@@ -62,7 +62,7 @@ typedef osThreadId_t		gfxThreadHandle;
 
 void gfxMutexInit(gfxMutex* pmutex);
 #define gfxMutexDestroy(pmutex)		osMutexDelete(*(pmutex))
-#define gfxMutexEnter(pmutex)		osMutexAcquire(*(pmutex), TIME_INFINITE)
+#define gfxMutexEnter(pmutex)		osMutexAcquire(*(pmutex), gDelayForever)
 #define gfxMutexExit(pmutex)		osMutexRelease(*(pmutex))
 
 void gfxSemInit(gfxSem* psem, gSemcount val, gSemcount limit);
diff --git a/src/gos/gos_ecos.c b/src/gos/gos_ecos.c
index 9b38d3b0..92ba6526 100644
--- a/src/gos/gos_ecos.c
+++ b/src/gos/gos_ecos.c
@@ -35,8 +35,8 @@ void _gosDeinit(void)
 void gfxSleepMilliseconds(gDelay ms)
 {
 	switch(ms) {
-		case TIME_IMMEDIATE:	cyg_thread_yield();								return;
-		case TIME_INFINITE:		cyg_thread_suspend(cyg_thread_self());			return;
+		case gDelayNone:	cyg_thread_yield();								return;
+		case gDelayForever:		cyg_thread_suspend(cyg_thread_self());			return;
 		default:				cyg_thread_delay(gfxMillisecondsToTicks(ms));	return;
 	}
 }
@@ -44,8 +44,8 @@ void gfxSleepMilliseconds(gDelay ms)
 void gfxSleepMicroseconds(gDelay ms)
 {
 	switch(ms) {
-		case TIME_IMMEDIATE:														return;
-		case TIME_INFINITE:		cyg_thread_suspend(cyg_thread_self());				return;
+		case gDelayNone:														return;
+		case gDelayForever:		cyg_thread_suspend(cyg_thread_self());				return;
 		default:				cyg_thread_delay(gfxMillisecondsToTicks(ms/1000));	return;
 	}
 }
@@ -67,8 +67,8 @@ void gfxSemDestroy(gfxSem *psem)
 gBool gfxSemWait(gfxSem *psem, gDelay ms)
 {
 	switch(ms) {
-	case TIME_IMMEDIATE:	return cyg_semaphore_trywait(&psem->sem);
-	case TIME_INFINITE:		return cyg_semaphore_wait(&psem->sem);
+	case gDelayNone:	return cyg_semaphore_trywait(&psem->sem);
+	case gDelayForever:		return cyg_semaphore_wait(&psem->sem);
 	default:				return cyg_semaphore_timed_wait(&psem->sem, gfxMillisecondsToTicks(ms)+cyg_current_time());
 	}
 }
diff --git a/src/gos/gos_ecos.h b/src/gos/gos_ecos.h
index 6f360ba1..c7f4f1df 100644
--- a/src/gos/gos_ecos.h
+++ b/src/gos/gos_ecos.h
@@ -18,8 +18,8 @@
 /* Type definitions                                                          */
 /*===========================================================================*/
 
-#define TIME_IMMEDIATE		0
-#define TIME_INFINITE		0xFFFFFFFF
+#define gDelayNone			0
+#define gDelayForever		0xFFFFFFFF
 
 typedef cyg_ucount32		gDelay;
 typedef cyg_tick_count_t	gTicks;
diff --git a/src/gos/gos_freertos.h b/src/gos/gos_freertos.h
index 68831d02..b65efdac 100644
--- a/src/gos/gos_freertos.h
+++ b/src/gos/gos_freertos.h
@@ -24,8 +24,8 @@
 /* Type definitions                                                          */
 /*===========================================================================*/
 
-#define TIME_IMMEDIATE		0
-#define TIME_INFINITE		((gDelay)-1)
+#define gDelayNone			0
+#define gDelayForever		((gDelay)-1)
 typedef uint32_t			gDelay;
 typedef portTickType		gTicks;
 typedef int32_t				gSemcount;
diff --git a/src/gos/gos_linux.c b/src/gos/gos_linux.c
index ca6b2576..43e85b3e 100644
--- a/src/gos/gos_linux.c
+++ b/src/gos/gos_linux.c
@@ -64,11 +64,11 @@ void gfxSleepMilliseconds(gDelay ms) {
 	struct timespec	ts;
 
 	switch(ms) {
-		case TIME_IMMEDIATE:
+		case gDelayNone:
 			linuxyield();
 			return;
 
-		case TIME_INFINITE:
+		case gDelayForever:
 			while(1)
 				sleep(60);
 			return;
@@ -85,11 +85,11 @@ void gfxSleepMicroseconds(gDelay us) {
 	struct timespec	ts;
 
 	switch(us) {
-		case TIME_IMMEDIATE:
+		case gDelayNone:
 			linuxyield();
 			return;
 
-		case TIME_INFINITE:
+		case gDelayForever:
 			while(1)
 				sleep(60);
 			return;
@@ -147,10 +147,10 @@ gThreadreturn gfxThreadWait(gfxThreadHandle thread) {
 	}
 	gBool gfxSemWait(gfxSem *pSem, gDelay ms) {
 		switch (ms) {
-		case TIME_INFINITE:
+		case gDelayForever:
 			return sem_wait(&pSem->sem) ? gFalse : gTrue;
 
-		case TIME_IMMEDIATE:
+		case gDelayNone:
 			return sem_trywait(&pSem->sem) ? gFalse : gTrue;
 
 		default:
@@ -189,12 +189,12 @@ gThreadreturn gfxThreadWait(gfxThreadHandle thread) {
 		pthread_mutex_lock(&pSem->mtx);
 
 		switch (ms) {
-			case TIME_INFINITE:
+			case gDelayForever:
 				while (!pSem->cnt)
 					pthread_cond_wait(&pSem->cond, &pSem->mtx);
 				break;
 
-			case TIME_IMMEDIATE:
+			case gDelayNone:
 				if (!pSem->cnt) {
 					pthread_mutex_unlock(&pSem->mtx);
 					return gFalse;
diff --git a/src/gos/gos_linux.h b/src/gos/gos_linux.h
index 201ee61c..1e7ff392 100644
--- a/src/gos/gos_linux.h
+++ b/src/gos/gos_linux.h
@@ -46,11 +46,11 @@ typedef pthread_mutex_t		gfxMutex;
 #define gfxMutexDestroy(pmtx)			pthread_mutex_destroy(pmtx)
 #define gfxMutexEnter(pmtx)				pthread_mutex_lock(pmtx)
 #define gfxMutexExit(pmtx)				pthread_mutex_unlock(pmtx)
-#define gfxSemWaitI(psem)				gfxSemWait(psem, TIME_IMMEDIATE)
+#define gfxSemWaitI(psem)				gfxSemWait(psem, gDelayNone)
 #define gfxSemSignalI(psem)				gfxSemSignal(psem)
 
-#define TIME_IMMEDIATE				0
-#define TIME_INFINITE				((gDelay)-1)
+#define gDelayNone					0
+#define gDelayForever				((gDelay)-1)
 #define MAX_SEMAPHORE_COUNT			((gSemcount)-1)
 #define LOW_PRIORITY				10
 #define NORMAL_PRIORITY				0
diff --git a/src/gos/gos_osx.c b/src/gos/gos_osx.c
index 5aae802f..a0676d96 100644
--- a/src/gos/gos_osx.c
+++ b/src/gos/gos_osx.c
@@ -57,8 +57,8 @@ void gfxSleepMilliseconds(gDelay ms) {
 	struct timespec	ts;
 
 	switch(ms) {
-	case TIME_IMMEDIATE:	gfxYield();			return;
-	case TIME_INFINITE:		while(1) sleep(60);			return;
+	case gDelayNone:	gfxYield();			return;
+	case gDelayForever:		while(1) sleep(60);			return;
 	default:
 		ts.tv_sec = ms / 1000;
 		ts.tv_nsec = (ms % 1000) * 1000000;
@@ -71,8 +71,8 @@ void gfxSleepMicroseconds(gDelay us) {
 	struct timespec	ts;
 
 	switch(us) {
-	case TIME_IMMEDIATE:	gfxYield();			return;
-	case TIME_INFINITE:		while(1) sleep(60);			return;
+	case gDelayNone:	gfxYield();			return;
+	case gDelayForever:		while(1) sleep(60);			return;
 	default:
 		ts.tv_sec = us / 1000000;
 		ts.tv_nsec = (us % 1000000) * 1000;
@@ -135,11 +135,11 @@ void gfxSemDestroy(gfxSem *pSem) {
 gBool gfxSemWait(gfxSem *pSem, gDelay ms) {
 	pthread_mutex_lock(&pSem->mtx);
 	switch (ms) {
-	case TIME_INFINITE:
+	case gDelayForever:
 		while (!pSem->cnt)
 			pthread_cond_wait(&pSem->cond, &pSem->mtx);
 		break;
-	case TIME_IMMEDIATE:
+	case gDelayNone:
 		if (!pSem->cnt) {
 			pthread_mutex_unlock(&pSem->mtx);
 			return gFalse;
diff --git a/src/gos/gos_osx.h b/src/gos/gos_osx.h
index 33ead2b4..3f693258 100644
--- a/src/gos/gos_osx.h
+++ b/src/gos/gos_osx.h
@@ -38,11 +38,11 @@ typedef pthread_mutex_t		gfxMutex;
 #define gfxMutexDestroy(pmtx)			pthread_mutex_destroy(pmtx)
 #define gfxMutexEnter(pmtx)				pthread_mutex_lock(pmtx)
 #define gfxMutexExit(pmtx)				pthread_mutex_unlock(pmtx)
-#define gfxSemWaitI(psem)				gfxSemWait(psem, TIME_IMMEDIATE)
+#define gfxSemWaitI(psem)				gfxSemWait(psem, gDelayNone)
 #define gfxSemSignalI(psem)				gfxSemSignal(psem)
 
-#define TIME_IMMEDIATE				0
-#define TIME_INFINITE				((gDelay)-1)
+#define gDelayNone					0
+#define gDelayForever				((gDelay)-1)
 #define MAX_SEMAPHORE_COUNT			((gSemcount)-1)
 #define LOW_PRIORITY				10
 #define NORMAL_PRIORITY				0
diff --git a/src/gos/gos_qt.h b/src/gos/gos_qt.h
index fe9c5e34..cd2dbbb4 100644
--- a/src/gos/gos_qt.h
+++ b/src/gos/gos_qt.h
@@ -14,8 +14,8 @@
 #define DECLARE_THREAD_STACK(name, sz)          uint8_t name[0]
 #define THREAD_RETURN(retval)					return retval
 
-#define TIME_IMMEDIATE				0
-#define TIME_INFINITE				((gDelay)-1)
+#define gDelayNone					0
+#define gDelayForever				((gDelay)-1)
 #define MAX_SEMAPHORE_COUNT			((gSemcount)(((unsigned long)((gSemcount)(-1))) >> 1))
 #define LOW_PRIORITY				2
 #define NORMAL_PRIORITY				3
diff --git a/src/gos/gos_rawrtos.c b/src/gos/gos_rawrtos.c
index b39b0701..d9d31df3 100644
--- a/src/gos/gos_rawrtos.c
+++ b/src/gos/gos_rawrtos.c
@@ -70,7 +70,7 @@ gBool gfxSemWait(gfxSem* psem, gDelay ms)
 
 gBool gfxSemWaitI(gfxSem* psem)
 {
-	if(raw_semaphore_get((psem), TIME_IMMEDIATE)==RAW_SUCCESS)
+	if(raw_semaphore_get((psem), RAW_NO_WAIT)==RAW_SUCCESS)
 		return gTrue;
 	return gFalse;
 }
diff --git a/src/gos/gos_rawrtos.h b/src/gos/gos_rawrtos.h
index 355c766f..1fb20f90 100644
--- a/src/gos/gos_rawrtos.h
+++ b/src/gos/gos_rawrtos.h
@@ -5,8 +5,8 @@
 
 #include "raw_api.h"
 
-#define TIME_IMMEDIATE		(RAW_NO_WAIT)
-#define TIME_INFINITE		(RAW_WAIT_FOREVER)
+#define gDelayNone			(RAW_NO_WAIT)
+#define gDelayForever		(RAW_WAIT_FOREVER)
 typedef uint32_t			gDelay;
 typedef RAW_TICK_TYPE		gTicks;
 typedef int32_t				gSemcount;
@@ -38,7 +38,7 @@ typedef RAW_TASK_OBJ*		gfxThreadHandle;
 #define gfxSystemUnlock()				{}
 #define gfxMutexInit(pmutex)			raw_mutex_create(pmutex, (RAW_U8 *)"", RAW_MUTEX_INHERIT_POLICY, 3)
 #define gfxMutexDestroy(pmutex)			raw_mutex_delete(pmutex)
-#define gfxMutexEnter(pmutex) 			raw_mutex_get(pmutex, TIME_INFINITE)
+#define gfxMutexEnter(pmutex) 			raw_mutex_get(pmutex, gDelayForever)
 #define gfxMutexExit(pmutex)			raw_mutex_put(pmutex)
 #define gfxSemInit(psem, val, limit)	raw_semaphore_create(psem, "", val)
 #define gfxSemDestroy(psem)				raw_semaphore_delete(psem)
diff --git a/src/gos/gos_win32.c b/src/gos/gos_win32.c
index c2511dfa..8e822c9e 100644
--- a/src/gos/gos_win32.c
+++ b/src/gos/gos_win32.c
@@ -43,10 +43,10 @@ void gfxSleepMicroseconds(gDelay ms) {
     LARGE_INTEGER t1, t2, tdiff;
 
     switch(ms) {
-		case TIME_IMMEDIATE:
+		case gDelayNone:
 			return;
 
-		case TIME_INFINITE:
+		case gDelayForever:
 			while(1)
 				Sleep(1000);
 			return;
diff --git a/src/gos/gos_win32.h b/src/gos/gos_win32.h
index 10412119..c4033f5c 100644
--- a/src/gos/gos_win32.h
+++ b/src/gos/gos_win32.h
@@ -35,8 +35,8 @@ typedef int					gThreadpriority;
 #define DECLARE_THREAD_STACK(name, sz)			uint8_t name[1];
 #define THREAD_RETURN(retval)					return retval
 
-#define TIME_IMMEDIATE				0
-#define TIME_INFINITE				INFINITE
+#define gDelayNone					0
+#define gDelayForever				INFINITE
 #define MAX_SEMAPHORE_COUNT			((gSemcount)(((unsigned long)((gSemcount)(-1))) >> 1))
 #define LOW_PRIORITY				THREAD_PRIORITY_BELOW_NORMAL
 #define NORMAL_PRIORITY				THREAD_PRIORITY_NORMAL
@@ -60,7 +60,7 @@ typedef HANDLE gfxThreadHandle;
 #define gfxMutexExit(pmutex)			ReleaseMutex(*(pmutex))
 #define gfxSemInit(psem, val, limit)	*(psem) = CreateSemaphore(0, val, limit, 0)
 #define gfxSemDestroy(psem)				CloseHandle(*(psem))
-#define gfxSemWaitI(psem)				gfxSemWait((psem), TIME_IMMEDIATE)
+#define gfxSemWaitI(psem)				gfxSemWait((psem), gDelayNone)
 #define gfxSemSignal(psem)				ReleaseSemaphore(*(psem), 1, 0)
 #define gfxSemSignalI(psem)				ReleaseSemaphore(*(psem), 1, 0)
 #define gfxThreadMe()					GetCurrentThread()
diff --git a/src/gos/gos_x_threads.c b/src/gos/gos_x_threads.c
index a4a3eb31..5b81b25a 100644
--- a/src/gos/gos_x_threads.c
+++ b/src/gos/gos_x_threads.c
@@ -56,11 +56,11 @@ gBool gfxSemWait(gfxSem *psem, gDelay ms) {
 	// Convert our delay to ticks
 	starttm = 0;
 	switch (ms) {
-	case TIME_IMMEDIATE:
-		delay = TIME_IMMEDIATE;
+	case gDelayNone:
+		delay = gDelayNone;
 		break;
-	case TIME_INFINITE:
-		delay = TIME_INFINITE;
+	case gDelayForever:
+		delay = gDelayForever;
 		break;
 	default:
 		delay = gfxMillisecondsToTicks(ms);
@@ -73,9 +73,9 @@ gBool gfxSemWait(gfxSem *psem, gDelay ms) {
 		INTERRUPTS_ON();
 		// Check if we have exceeded the defined delay
 		switch (delay) {
-		case TIME_IMMEDIATE:
+		case gDelayNone:
 			return gFalse;
-		case TIME_INFINITE:
+		case gDelayForever:
 			break;
 		default:
 			if (gfxSystemTicks() - starttm >= delay)
@@ -117,9 +117,9 @@ void gfxSleepMilliseconds(gDelay ms) {
 
 	// Safety first
 	switch (ms) {
-	case TIME_IMMEDIATE:
+	case gDelayNone:
 		return;
-	case TIME_INFINITE:
+	case gDelayForever:
 		while(1)
 			gfxYield();
 		return;
@@ -139,9 +139,9 @@ void gfxSleepMicroseconds(gDelay ms) {
 
 	// Safety first
 	switch (ms) {
-	case TIME_IMMEDIATE:
+	case gDelayNone:
 		return;
-	case TIME_INFINITE:
+	case gDelayForever:
 		while(1)
 			gfxYield();
 		return;
diff --git a/src/gos/gos_x_threads.h b/src/gos/gos_x_threads.h
index 69b586c6..a1ba67a1 100644
--- a/src/gos/gos_x_threads.h
+++ b/src/gos/gos_x_threads.h
@@ -34,8 +34,8 @@ typedef int				gThreadpriority;
 #define DECLARE_THREAD_STACK(name, sz)			uint8_t name[(sz) & ~3];
 #define THREAD_RETURN(retval)					return retval
 
-#define TIME_IMMEDIATE				0
-#define TIME_INFINITE				((gDelay)-1)
+#define gDelayNone					0
+#define gDelayForever				((gDelay)-1)
 #define MAX_SEMAPHORE_COUNT			0x7FFF
 #define LOW_PRIORITY				0
 #define NORMAL_PRIORITY				1
diff --git a/src/gos/gos_zephyr.h b/src/gos/gos_zephyr.h
index 1bfccf8b..662a0c82 100644
--- a/src/gos/gos_zephyr.h
+++ b/src/gos/gos_zephyr.h
@@ -30,8 +30,8 @@ typedef int	gThreadpriority;
 

 #define THREAD_RETURN(retval)		return

 

-#define TIME_IMMEDIATE			K_NO_WAIT

-#define TIME_INFINITE			K_FOREVER

+#define gDelayNone				K_NO_WAIT

+#define gDelayForever			K_FOREVER

 #define MAX_SEMAPHORE_COUNT		((gSemcount)(((unsigned long)((gSemcount)(-1))) >> 1))

 #define LOW_PRIORITY			CONFIG_NUM_PREEMPT_PRIORITIES-1

 #define NORMAL_PRIORITY			1

diff --git a/src/gqueue/gqueue.c b/src/gqueue/gqueue.c
index e761c238..77a7647b 100644
--- a/src/gqueue/gqueue.c
+++ b/src/gqueue/gqueue.c
@@ -297,7 +297,7 @@ void _gqueueDeinit(void)
 		gfxSemInit(&pqueue->sem, 0, MAX_SEMAPHORE_COUNT);
 	}
 	void gfxQueueFSyncDeinit(gfxQueueGSync *pqueue) {
-		while(gfxQueueFSyncGet(pqueue, TIME_IMMEDIATE));
+		while(gfxQueueFSyncGet(pqueue, gDelayNone));
 		pqueue->head = pqueue->tail = 0;
 		gfxSemDestroy(&pqueue->sem);
 	}
diff --git a/src/gqueue/gqueue.h b/src/gqueue/gqueue.h
index fa4a31e5..9cde670d 100644
--- a/src/gqueue/gqueue.h
+++ b/src/gqueue/gqueue.h
@@ -124,7 +124,7 @@ void gfxQueueFSyncDeinit(gfxQueueFSync *pqueue);
  *
  * @param[in]	pqueue	A pointer to the queue
  * @param[in]	ms		The maxmimum time to wait for an item. For ASync queues this parameter is
- * 						not specified as TIME_IMMEDIATE is assumed.
+ * 						not specified as gDelayNone is assumed.
  *
  * @note		The routines ending in "I" are interrupt/system/iclass level routines.
  *
@@ -147,7 +147,7 @@ gfxQueueFSyncItem *gfxQueueFSyncGet(gfxQueueFSync *pqueue, gDelay ms);
  * @param[in]	pitem	A pointer to the queue item
  * @param[in]	ms		The maxmimum time to wait for an item to be removed from the queue (only for FSync queues)
  *
- * @note		FSync: Use a delay time of TIME_IMMEDIATE if you don't want to wait until the
+ * @note		FSync: Use a delay time of gDelayNone if you don't want to wait until the
  * 				item is removed from the queue. Note that even if the timeout occurs - the item
  * 				remains in the queue.
  * @note		The routines ending in "I" are interrupt/system/iclass level routines.
@@ -185,7 +185,7 @@ gBool gfxQueueFSyncPut(gfxQueueFSync *pqueue, gfxQueueFSyncItem *pitem, gDelay m
  * @param[in]	pitem	A pointer to the queue item
  * @param[in]	ms		The maxmimum time to wait for an item to be popped (only for FSync queues)
  *
- * @note		FSync: Use a delay time of TIME_IMMEDIATE if you don't want to wait until the
+ * @note		FSync: Use a delay time of gDelayNone if you don't want to wait until the
  * 				item is removed from the queue. Note that even if the timeout occurs - the item
  * 				remains in the queue.
  * @note		The routines ending in "I" are interrupt/system/iclass level routines.
@@ -211,7 +211,7 @@ gBool gfxQueueFSyncPush(gfxQueueFSync *pqueue, gfxQueueFSyncItem *pitem, gDelay
  * 							pafter can't be found in the queue, it puts the new item at the end of the queue.
  * @param[in]	ms		The maxmimum time to wait for an item to be removed from the queue (only for FSync queues)
  *
- * @note		FSync: Use a delay time of TIME_IMMEDIATE if you don't want to wait until the
+ * @note		FSync: Use a delay time of gDelayNone if you don't want to wait until the
  * 				item is removed from the queue. Note that even if the timeout occurs - the item
  * 				remains in the queue.
  * @note		The routines ending in "I" are interrupt/system/iclass level routines.
diff --git a/src/gtimer/gtimer.c b/src/gtimer/gtimer.c
index 93e93b6f..6dc0d6f8 100644
--- a/src/gtimer/gtimer.c
+++ b/src/gtimer/gtimer.c
@@ -38,7 +38,7 @@ static DECLARE_THREAD_FUNCTION(GTimerThreadHandler, arg) {
 	void			*param;
 	(void)			arg;
 
-	nxtTimeout = TIME_INFINITE;
+	nxtTimeout = gDelayForever;
 	lastTime = 0;
 	while(1) {
 		/* Wait for work to do. */
@@ -49,7 +49,7 @@ static DECLARE_THREAD_FUNCTION(GTimerThreadHandler, arg) {
 	
 		// Our reference time
 		tm = gfxSystemTicks();
-		nxtTimeout = TIME_INFINITE;
+		nxtTimeout = gDelayForever;
 		
 		/* We need to obtain the mutex */
 		gfxMutexEnter(&mutex);
@@ -61,7 +61,7 @@ static DECLARE_THREAD_FUNCTION(GTimerThreadHandler, arg) {
 				if ((pt->flags & GTIMER_FLG_JABBED) || (!(pt->flags & GTIMER_FLG_INFINITE) && TimeIsWithin(pt->when, lastTime, tm))) {
 				
 					// Is this timer periodic?
-					if ((pt->flags & GTIMER_FLG_PERIODIC) && pt->period != TIME_IMMEDIATE) {
+					if ((pt->flags & GTIMER_FLG_PERIODIC) && pt->period != gDelayNone) {
 						// Yes - Update ready for the next period
 						if (!(pt->flags & GTIMER_FLG_INFINITE)) {
 							// We may have skipped a period.
@@ -164,9 +164,9 @@ void gtimerStart(GTimer *pt, GTimerFunction fn, void *param, gBool periodic, gDe
 	pt->flags = GTIMER_FLG_SCHEDULED;
 	if (periodic)
 		pt->flags |= GTIMER_FLG_PERIODIC;
-	if (millisec == TIME_INFINITE) {
+	if (millisec == gDelayForever) {
 		pt->flags |= GTIMER_FLG_INFINITE;
-		pt->period = TIME_INFINITE;
+		pt->period = gDelayForever;
 	} else {
 		pt->period = gfxMillisecondsToTicks(millisec);
 		pt->when = gfxSystemTicks() + pt->period;
diff --git a/src/gtimer/gtimer.h b/src/gtimer/gtimer.h
index 67c7539f..aeae880f 100644
--- a/src/gtimer/gtimer.h
+++ b/src/gtimer/gtimer.h
@@ -89,9 +89,9 @@ void gtimerDeinit(GTimer* pt);
  * @param[in] param		The parameter to pass to the callback function
  * @param[in] periodic	Is the timer a periodic timer? gFalse is a once-only timer.
  * @param[in] millisec	The timer period. The following special values are allowed:
- *							TIME_IMMEDIATE	causes the callback function to be called asap.
+ *							gDelayNone	causes the callback function to be called asap.
  *											A periodic timer with this value will fire once only.
- *							TIME_INFINITE	never timeout (unless triggered by gtimerJab or gtimerJabI)
+ *							gDelayForever	never timeout (unless triggered by gtimerJab or gtimerJabI)
  *
  * @note				If the timer is already active its properties are updated with the new parameters.
  *						The current period will be immediately canceled (without the callback function being
diff --git a/src/gwin/gwin_image.c b/src/gwin/gwin_image.c
index d19c4d30..c40ecc81 100644
--- a/src/gwin/gwin_image.c
+++ b/src/gwin/gwin_image.c
@@ -99,10 +99,10 @@ static void ImageRedraw(GHandle gh) {
 
 		// Wait for that delay if required
 		switch(delay) {
-		case TIME_INFINITE:
+		case gDelayForever:
 			// Everything is done
 			break;
-		case TIME_IMMEDIATE:
+		case gDelayNone:
 			// We can't allow a continuous loop here as it would lock the system up so we delay for the minimum period
 			delay = 1;
 			// Fall through
diff --git a/src/gwin/gwin_wm.c b/src/gwin/gwin_wm.c
index 2c9f25d9..6d48cd36 100644
--- a/src/gwin/gwin_wm.c
+++ b/src/gwin/gwin_wm.c
@@ -190,7 +190,7 @@ void _gwmInit(void)
 	#endif
 	#if !GWIN_REDRAW_IMMEDIATE
 		gtimerInit(&RedrawTimer);
-		gtimerStart(&RedrawTimer, RedrawTimerFn, 0, gTrue, TIME_INFINITE);
+		gtimerStart(&RedrawTimer, RedrawTimerFn, 0, gTrue, gDelayForever);
 	#endif
 	_GWINwm = (GWindowManager *)&GNullWindowManager;
 	_GWINwm->vmt->Init();
@@ -231,8 +231,8 @@ void _gwinFlushRedraws(GRedrawMethod how) {
 
 	// Obtain the drawing lock
 	if (how == REDRAW_WAIT)
-		gfxSemWait(&gwinsem, TIME_INFINITE);
-	else if (how == REDRAW_NOWAIT && !gfxSemWait(&gwinsem, TIME_IMMEDIATE))
+		gfxSemWait(&gwinsem, gDelayForever);
+	else if (how == REDRAW_NOWAIT && !gfxSemWait(&gwinsem, gDelayNone))
 		// Someone is drawing - They will do the redraw when they are finished
 		return;
 
@@ -373,7 +373,7 @@ gBool _gwinDrawStart(GHandle gh) {
 		return gFalse;
 
 	// Obtain the drawing lock
-	gfxSemWait(&gwinsem, TIME_INFINITE);
+	gfxSemWait(&gwinsem, gDelayForever);
 
 	// Re-test visibility as we may have waited a while
 	if (!(gh->flags & GWIN_FLG_SYSVISIBLE)) {
@@ -742,7 +742,7 @@ static gBool WM_Add(GHandle gh, const GWindowInit *pInit) {
 
 static void WM_Delete(GHandle gh) {
 	// Remove it from the window list
-	gfxSemWait(&gwinsem, TIME_INFINITE);
+	gfxSemWait(&gwinsem, gDelayForever);
 	gfxQueueASyncRemove(&_GWINList, &gh->wmq);
 	gfxSemSignal(&gwinsem);
 }
@@ -986,7 +986,7 @@ static void WM_Raise(GHandle gh) {
 	// Take it off the list and then put it back on top
 	// The order of the list then reflects the z-order.
 
-	gfxSemWait(&gwinsem, TIME_INFINITE);
+	gfxSemWait(&gwinsem, gDelayForever);
 	
 	gfxQueueASyncRemove(&_GWINList, &gh->wmq);
 	gfxQueueASyncPut(&_GWINList, &gh->wmq);