More GOS module changes

GQUEUE as a seperate module
GOS changes including basic Win32 O/S support

9 files changed, 513 insertions, 189 deletions

diff --git a/include/gfx.h b/include/gfx.h
index 84aec39f..ac9a5382 100644
--- a/include/gfx.h
+++ b/include/gfx.h
@@ -87,6 +87,14 @@
 		#define GFX_USE_GTIMER	FALSE
 	#endif
 	/**
+	 * @brief   GFX Queue API
+	 * @details	Defaults to FALSE
+	 * @details	Provides queue management.
+	 */
+	#ifndef GFX_USE_GQUEUE
+		#define GFX_USE_GQUEUE	FALSE
+	#endif
+	/**
 	 * @brief   GFX Input Device API
 	 * @details	Defaults to FALSE
 	 * @note	Also add the specific hardware drivers to your makefile.
@@ -143,6 +151,7 @@
  */
 #include "gos/options.h"
 #include "gmisc/options.h"
+#include "gqueue/options.h"
 #include "gevent/options.h"
 #include "gtimer/options.h"
 #include "gdisp/options.h"
@@ -164,6 +173,7 @@
  */
 #include "gos/gos.h"
 #include "gmisc/gmisc.h"
+#include "gqueue/gqueue.h"
 #include "gevent/gevent.h"
 #include "gtimer/gtimer.h"
 #include "gdisp/gdisp.h"
diff --git a/include/gfx_rules.h b/include/gfx_rules.h
index 4fff2d21..4b7e9506 100644
--- a/include/gfx_rules.h
+++ b/include/gfx_rules.h
@@ -101,6 +101,15 @@
 	#if GDISP_NEED_MULTITHREAD && GDISP_NEED_ASYNC
 		#error "GDISP: Only one of GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC should be defined."
 	#endif
+	#if GDISP_NEED_ASYNC && !(GFX_USE_GQUEUE && GQUEUE_NEED_GSYNC)
+		#if GFX_DISPLAY_RULE_WARNINGS
+			#warning "GDISP: GFX_USE_GQUEUE or GQUEUE_NEED_GSYNC is not TRUE. It has been turned on for you."
+		#endif
+		#undef GFX_USE_GQUEUE
+		#define	GFX_USE_GQUEUE		TRUE
+		#undef GQUEUE_NEED_GSYNC
+		#define	GQUEUE_NEED_GSYNC	TRUE
+	#endif
 #endif
 
 #if GFX_USE_TDISP
@@ -141,6 +150,9 @@
 #if GFX_USE_GAUDOUT
 #endif
 
+#if GFX_USE_GQUEUE
+#endif
+
 #if GFX_USE_GMISC
 #endif
 
diff --git a/include/gos/chibios.h b/include/gos/chibios.h
index 37bf93ee..1fa93141 100644
--- a/include/gos/chibios.h
+++ b/include/gos/chibios.h
@@ -67,17 +67,6 @@ typedef struct {
 
 #define gfxMutex	Mutex
 
-typedef struct gfxQueue {
-	struct gfxQueueItem *head;
-	struct gfxQueueItem *tail;
-	Semaphore			sem;
-	} gfxQueue;
-
-typedef struct gfxQueueItem {
-	struct gfxQueueItem *next;
-	Semaphore			sem;
-	} gfxQueueItem;
-
 /*===========================================================================*/
 /* Function declarations.                                                    */
 /*===========================================================================*/
@@ -90,30 +79,24 @@ extern "C" {
 #define gfxExit()					chSysHalt()
 #define gfxAlloc(sz)				chHeapAlloc(NULL, sz)
 #define gfxFree(ptr)				chHeapFree(ptr)
+#define gfxYield()					chThdYield()
+#define gfxSystemTicks()			chTimeNow()
+#define gfxMillisecondsToTicks(ms)	MS2ST(ms)
+#define gfxSystemLock()				chSysLock()
+#define gfxSystemUnlock()			chSysUnlock()
+#define gfxMutexInit(pmutex)		chMtxInit(pmutex)
+#define gfxMutexDestroy(pmutex)		;
+#define gfxMutexEnter(pmutex)		chMtxLock(pmutex)
+#define gfxMutexExit(pmutex)		chMtxUnlock()
 void gfxSleepMilliseconds(delaytime_t ms);
 void gfxSleepMicroseconds(delaytime_t ms);
 void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit);
+void gfxSemDestroy(gfxSem *psem);
 bool_t gfxSemWait(gfxSem *psem, delaytime_t ms);
 void gfxSemSignal(gfxSem *psem);
 void gfxSemSignalI(gfxSem *psem);
 #define gfxSemCounterI(psem)		((psem)->sem.s_cnt)
 #define gfxSemCounter(psem)			((psem)->sem.s_cnt)
-#define gfxSystemTicks()			chTimeNow()
-#define gfxMillisecondsToTicks(ms)	MS2ST(ms)
-#define gfxYield()					chThdYield()
-#define gfxSystemLock()				chSysLock()
-#define gfxSystemUnlock()			chSysUnlock()
-#define gfxMutexInit(pmutex)		chMtxInit(pmutex)
-#define gfxMutexEnter(pmutex)		chMtxLock(pmutex)
-#define gfxMutexExit(pmutex)		chMtxUnlock()
-void gfxQueueInit(gfxQueue *pqueue);
-gfxQueueItem * gfxQueueGet(gfxQueue *pqueue, delaytime_t ms);
-bool_t gfxQueuePut(gfxQueue *pqueue, gfxQueueItem *pitem, delaytime_t ms);
-#define gfxQueuePop(q)	gfxQueueGet(q)
-bool_t gfxQueuePush(gfxQueue *pqueue, gfxQueueItem *pitem, delaytime_t ms);
-void gfxQueueRemove(gfxQueue *pqueue, gfxQueueItem *pitem);
-bool_t gfxQueueIsEmpty(gfxQueue *pqueue);
-bool_t gfxQueueIsIn(gfxQueue *pqueue, gfxQueueItem *pitem);
 bool_t gfxCreateThread(void *stackarea, size_t stacksz, threadpriority_t prio, gfxThreadFunction fn, void *param);
 
 #ifdef __cplusplus
diff --git a/include/gos/gos.h b/include/gos/gos.h
index 04799540..d979cd27 100644
--- a/include/gos/gos.h
+++ b/include/gos/gos.h
@@ -37,11 +37,6 @@
 	/*===========================================================================*/
 
 	/**
-	 * @brief	A function for a new thread to execute.
-	 */
-	typedef threadreturn_t (*gfxThreadFunction)(void *param);
-
-	/**
 	 * @brief	Various integer sizes
 	 * @note	Your platform may use slightly different definitions to these
 	 * @{
@@ -67,6 +62,10 @@
 	typedef int				threadreturn_t;
 	typedef int				threadpriority_t;
 	/**
+	 * @brief	A function for a new thread to execute.
+	 */
+	typedef threadreturn_t (*gfxThreadFunction)(void *param);
+	/**
 	 * @}
 	 *
 	 * @brief	Various platform (and operating system) constants
@@ -77,7 +76,7 @@
 	#define TRUE						1
 	#define TIME_IMMEDIATE				0
 	#define TIME_INFINITE				((delaytime_t)-1)
-	#define MAX_SEMAPHORE_COUNT			((semcount_t)-1)
+	#define MAX_SEMAPHORE_COUNT			((semcount_t)(((unsigned long)((semcount_t)(-1))) >> 1))
 	#define LOW_PRIORITY				0
 	#define NORMAL_PRIORITY				1
 	#define HIGH_PRIORITY				2
@@ -96,18 +95,6 @@
 	 */
 	typedef struct {} gfxMutex;
 
-	/**
-	 * @brief	A queue
-	 * @note	Your operating system will have a proper definition for this structure
-	 */
-	typedef struct {} gfxQueue;
-
-	/**
-	 * @brief	A queue item
-	 * @note	Your operating system will have a proper definition for this structure
-	 */
-	typedef struct {} gfxQueueItem;
-
 	/*===========================================================================*/
 	/* Function declarations.                                                    */
 	/*===========================================================================*/
@@ -152,6 +139,15 @@
 	void gfxFree(void *ptr);
 
 	/**
+	 * @brief	Yield the current thread
+	 * @details	Give up the rest of the current time slice for this thread in order to give other threads
+	 * 			a chance to run.
+	 *
+	 * @api
+	 */
+	void gfxYield(void);
+
+	/**
 	 * @brief	Put the current thread to sleep for the specified period in milliseconds
 	 *
 	 * @param[in] ms	The number milliseconds to sleep
@@ -177,83 +173,6 @@
 	void gfxSleepMicroseconds(delaytime_t ms);
 
 	/**
-	 * @brief	Initialise a Counted Semaphore
-	 *
-	 * @param[in] psem		A pointer to the semaphore
-	 * @param[in] val		The initial value of the semaphore
-	 * @param[in] limit		The maxmimum value of the semaphore
-	 *
-	 * @note	Operations defined for counted semaphores:
-	 * 				Signal: The semaphore counter is increased and if the result is non-positive then a waiting thread
-	 * 						 is queued for execution. Note that once the thread reaches "limit", further signals are
-	 * 						 ignored.
-	 * 				Wait: The semaphore counter is decreased and if the result becomes negative the thread is queued
-	 * 						in the semaphore and suspended.
-	 *
-	 * @api
-	 */
-	void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit);
-
-	/**
-	 * @brief	Wait on a semaphore
-	 * @details	The semaphore counter is decreased and if the result becomes negative the thread waits for it to become
-	 * 				non-negative again
-	 * @return	FALSE if the wait timeout occurred otherwise TRUE
-	 *
-	 * @param[in] psem		A pointer to the semaphore
-	 * @param[in] ms		The maxmimum time to wait for the semaphore
-	 *
-	 * @api
-	 */
-	bool_t gfxSemWait(gfxSem *psem, delaytime_t ms);
-
-	/**
-	 * @brief	Signal a semaphore
-	 * @details	The semaphore counter is increased and if the result is non-positive then a waiting thread
-	 * 						 is queued for execution. Note that once the thread reaches "limit", further signals are
-	 * 						 ignored.
-	 *
-	 * @param[in] psem		A pointer to the semaphore
-	 *
-	 * @api
-	 */
-	void gfxSemSignal(gfxSem *psem);
-
-	/**
-	 * @brief	Signal a semaphore
-	 * @details	The semaphore counter is increased and if the result is non-positive then a waiting thread
-	 * 						 is queued for execution. Note that once the thread reaches "limit", further signals are
-	 * 						 ignored.
-	 *
-	 * @param[in] psem		A pointer to the semaphore
-	 *
-	 * @iclass
-	 * @api
-	 */
-	void gfxSemSignalI(gfxSem *psem);
-
-	/**
-	 * @brief	Get the current semaphore count
-	 * @return	The current semaphore count
-	 *
-	 * @param[in] psem		A pointer to the semaphore
-	 *
-	 * @api
-	 */
-	semcount_t gfxSemCounter(gfxSem *pSem);
-
-	/**
-	 * @brief	Get the current semaphore count
-	 * @return	The current semaphore count
-	 *
-	 * @param[in] psem		A pointer to the semaphore
-	 *
-	 * @iclass
-	 * @api
-	 */
-	semcount_t gfxSemCounterI(gfxSem *pSem);
-
-	/**
 	 * @brief	Get the current operating system tick time
 	 * @return	The current tick time
 	 *
@@ -283,15 +202,6 @@
 	systemticks_t gfxMillisecondsToTicks(delaytime_t ms);
 
 	/**
-	 * @brief	Yield the current thread
-	 * @details	Give up the rest of the current time slice for this thread in order to give other threads
-	 * 			a chance to run.
-	 *
-	 * @api
-	 */
-	void gfxYield(void);
-
-	/**
 	 * @brief	Lock the operating system to protect a sequence of code
 	 *
 	 * @note	Calling this will lock out all other threads from executing even at interrupt level
@@ -327,6 +237,15 @@
 	void gfxMutexInit(gfxMutex *pmutex);
 
 	/**
+	 * @brief	Destroy a Mutex.
+	 *
+	 * @param[in]	pmutex	A pointer to the mutex
+	 *
+	 * @api
+	 */
+	void gfxMutexDestroy(gfxMutex *pmutex);
+
+	/**
 	 * @brief	Enter the critical code region protected by the mutex.
 	 * @details	Blocks until there is no other thread in the critical region.
 	 *
@@ -347,104 +266,92 @@
 	void gfxMutexExit(gfxMutex *pmutex);
 
 	/**
-	 * @brief	Initialise a queue.
-	 *
-	 * @param[in]	pqueue	A pointer to the queue
-	 *
-	 * @note	Whilst queues are normally FIFO, a GFX queue also supports push and pop operations.
-	 * 			A pop operation is the same as normal get from the queue but a push places the item
-	 * 			at the head of the queue instead of the tail (as a put would).
+	 * @brief	Initialise a Counted Semaphore
 	 *
-	 * @api
-	 */
-	void gfxQueueInit(gfxQueue *pqueue);
-
-	/**
-	 * @brief	Get an item from the head of the queue.
-	 * @return	NULL if the timeout expires before an item is available
+	 * @param[in] psem		A pointer to the semaphore
+	 * @param[in] val		The initial value of the semaphore
+	 * @param[in] limit		The maxmimum value of the semaphore
 	 *
-	 * @param[in]	pqueue	A pointer to the queue
-	 * @param[in]	ms		The maxmimum time to wait for an item
+	 * @note	Operations defined for counted semaphores:
+	 * 				Signal: The semaphore counter is increased and if the result is non-positive then a waiting thread
+	 * 						 is queued for execution. Note that once the thread reaches "limit", further signals are
+	 * 						 ignored.
+	 * 				Wait: The semaphore counter is decreased and if the result becomes negative the thread is queued
+	 * 						in the semaphore and suspended.
 	 *
 	 * @api
 	 */
-	gfxQueueItem * gfxQueueGet(gfxQueue *pqueue, delaytime_t ms);
+	void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit);
 
 	/**
-	 * @brief	Put an item on the end of the queue.
-	 * @return	FALSE on timeout, otherwise TRUE
+	 * @brief	Destroy a Counted Semaphore
 	 *
-	 * @param[in]	pqueue	A pointer to the queue
-	 * @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
+	 * @param[in] psem		A pointer to the semaphore
 	 *
-	 * @note		Use a delay time of TIME_IMMEDIATE if you don't want to wait until the
-	 * 				item is removed from the queue
+	 * @note	Any threads waiting on the semaphore will be released
 	 *
 	 * @api
 	 */
-	bool_t gfxQueuePut(gfxQueue *pqueue, gfxQueueItem *pitem, delaytime_t ms);
+	void gfxSemDestroy(gfxSem *psem);
 
 	/**
-	 * @brief	Pop an item from the head of the queue.
-	 * @return	NULL if there are no more items on the queue
+	 * @brief	Wait on a semaphore
+	 * @details	The semaphore counter is decreased and if the result becomes negative the thread waits for it to become
+	 * 				non-negative again
+	 * @return	FALSE if the wait timeout occurred otherwise TRUE
 	 *
-	 * @param[in]	pqueue	A pointer to the queue
+	 * @param[in] psem		A pointer to the semaphore
+	 * @param[in] ms		The maxmimum time to wait for the semaphore
 	 *
 	 * @api
 	 */
-	#define gfxQueuePop(pqueue, ms)		gfxQueueGet(pqueue, ms)
+	bool_t gfxSemWait(gfxSem *psem, delaytime_t ms);
 
 	/**
-	 * @brief	Push an item into the start of the queue.
-	 * @return	FALSE on timeout, otherwise TRUE
-	 *
-	 * @param[in]	pqueue	A pointer to the queue
-	 * @param[in]	pitem	A pointer to the queue item
-	 * @param[in]	ms		The maxmimum time to wait for an item to be popped
+	 * @brief	Signal a semaphore
+	 * @details	The semaphore counter is increased and if the result is non-positive then a waiting thread
+	 * 						 is queued for execution. Note that once the thread reaches "limit", further signals are
+	 * 						 ignored.
 	 *
-	 * @note		Use a delay time of TIME_IMMEDIATE if you don't want to wait until the
-	 * 				item is removed from the queue
+	 * @param[in] psem		A pointer to the semaphore
 	 *
 	 * @api
 	 */
-	bool_t gfxQueuePush(gfxQueue *pqueue, gfxQueueItem *pitem, delaytime_t ms);
+	void gfxSemSignal(gfxSem *psem);
 
 	/**
-	 * @brief	Remove an item from the queue.
-	 * @note	Removes the specified item from the queue whereever it is in the queue
-	 *
-	 * @param[in]	pqueue	A pointer to the queue
-	 * @param[in]	pitem	A pointer to the queue item
+	 * @brief	Signal a semaphore
+	 * @details	The semaphore counter is increased and if the result is non-positive then a waiting thread
+	 * 						 is queued for execution. Note that once the thread reaches "limit", further signals are
+	 * 						 ignored.
 	 *
-	 * @note	If the item isn't in the queue the routine just returns.
+	 * @param[in] psem		A pointer to the semaphore
 	 *
+	 * @iclass
 	 * @api
 	 */
-	void gfxQueueRemove(gfxQueue *pqueue, gfxQueueItem *pitem);
+	void gfxSemSignalI(gfxSem *psem);
 
 	/**
-	 * @brief	Is the queue empty?
-	 * @return	TRUE if the queue is empty
+	 * @brief	Get the current semaphore count
+	 * @return	The current semaphore count
 	 *
-	 * @param[in]	pqueue	A pointer to the queue
+	 * @param[in] psem		A pointer to the semaphore
 	 *
 	 * @api
 	 */
-	bool_t gfxQueueIsEmpty(gfxQueue *pqueue);
+	semcount_t gfxSemCounter(gfxSem *pSem);
 
 	/**
-	 * @brief	Is an item in the queue?
-	 * @return	TRUE if the item is in the queue?
-	 *
-	 * @param[in]	pqueue	A pointer to the queue
-	 * @param[in]	pitem	A pointer to the queue item
+	 * @brief	Get the current semaphore count
+	 * @return	The current semaphore count
 	 *
-	 * @note	This operation may be expensive.
+	 * @param[in] psem		A pointer to the semaphore
 	 *
+	 * @iclass
 	 * @api
 	 */
-	bool_t gfxQueueIsIn(gfxQueue *pqueue, gfxQueueItem *pitem);
+	semcount_t gfxSemCounterI(gfxSem *pSem);
 
 	/**
 	 * @brief	Start a new thread.
diff --git a/include/gos/win32.h b/include/gos/win32.h
index a6f28865..80a1f430 100644
--- a/include/gos/win32.h
+++ b/include/gos/win32.h
@@ -26,6 +26,80 @@
 #define _GOS_WIN32_H
 
 #if GFX_USE_OS_WIN32
+
+//#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+/**
+ * size_t
+ * TRUE, FALSE
+ * are already defined by Win32
+ */
+typedef __int8				bool_t;
+typedef __int8				int8_t;
+typedef unsigned __int8		uint8_t;
+typedef __int16				int16_t;
+typedef unsigned __int16	uint16_t;
+typedef __int32				int32_t;
+typedef unsigned __int32	uint32_t;
+typedef DWORD				delaytime_t;
+typedef DWORD				systemticks_t;
+typedef LONG				semcount_t;
+#define threadreturn_t	DWORD WINAPI
+typedef int					threadpriority_t;
+
+typedef threadreturn_t (*gfxThreadFunction)(void *param);
+
+#define TIME_IMMEDIATE				0
+#define TIME_INFINITE				INFINITE
+#define MAX_SEMAPHORE_COUNT			((semcount_t)(((unsigned long)((semcount_t)(-1))) >> 1))
+#define LOW_PRIORITY				THREAD_PRIORITY_BELOW_NORMAL
+#define NORMAL_PRIORITY				THREAD_PRIORITY_NORMAL
+#define HIGH_PRIORITY				THREAD_PRIORITY_ABOVE_NORMAL
+#define DECLARESTACK(name, sz)		uint8_t name[0];
+
+typedef HANDLE gfxSem;
+typedef HANDLE gfxMutex;
+
+#define gfxExit()						ExitProcess(0)
+#define gfxAlloc(sz)					malloc(sz)
+#define gfxFree(ptr)					free(ptr)
+#define gfxSleepMilliseconds(ms)		Sleep(ms)
+#define gfxYield()						Sleep(0)
+#define gfxSystemTicks()				GetTickCount()
+#define gfxMillisecondsToTicks(ms)		(ms)
+#define gfxMutexInit(pmutex)			*(pmutex) = CreateMutex(NULL, FALSE, NULL)
+#define gfxMutexDestory(pmutex)			CloseHandle(*(pmutex))
+#define gfxMutexEnter(pmutex) 			WaitForSingleObject(*(pmutex), INFINITE)
+#define gfxMutexExit(pmutex)			ReleaseMutex(*(pmutex))
+#define gfxSemInit(psem, val, limit)	*(psem) = CreateSemaphore(NULL, val, limit, NULL)
+#define gfxSemDestory(psem)				CloseHandle(*(psem))
+#define gfxSemSignal(psem)				ReleaseSemaphore(*(psem), 1, NULL)
+#define gfxSemSignalI(psem)				ReleaseSemaphore(*(psem), 1, NULL)
+#define gfxSemCounterI(psem)			gfxSemCounter(psem)
+
+/*===========================================================================*/
+/* Function declarations.                                                    */
+/*===========================================================================*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void gfxHalt(const char *msg);
+void gfxSleepMicroseconds(delaytime_t ms);
+bool_t gfxSemWait(gfxSem *psem, delaytime_t ms);
+semcount_t gfxSemCounter(gfxSem *pSem);
+void gfxSystemLock(void);
+void gfxSystemUnlock(void);
+bool_t gfxCreateThread(void *stackarea, size_t stacksz, threadpriority_t prio, gfxThreadFunction fn, void *param);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
 #endif /* GFX_USE_OS_WIN32 */
 
 #endif /* _GOS_WIN32_H */
diff --git a/include/gqueue/gqueue.h b/include/gqueue/gqueue.h
new file mode 100644
index 00000000..deeca93b
--- /dev/null
+++ b/include/gqueue/gqueue.h
@@ -0,0 +1,229 @@
+/*
+    ChibiOS/GFX - Copyright (C) 2012, 2013
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS/GFX.
+
+    ChibiOS/GFX 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.
+
+    ChibiOS/GFX is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @file    include/gqueue/gqueue.h
+ * @brief   GQUEUE header file.
+ *
+ * @addtogroup GQUEUE
+ * @brief	GQUEUE provides queue management. There are 3 types of queues:
+ * 			<ul><li><b>Asynchronous Queues (ASync) </b> - Queue operations never block</li>
+ * 				<li><b>Get Synchronous Queues (GSync) </b> - Queue Get operations block until something is placed in the Queue</li>
+ * 				<li><b>Put Synchronous Queues (PSync)</b> - Queue Put operations block until the element is removed from the Queue</li>
+ * 				<li><b>Fully Synchronous Queues (FSync)</b> - Queue GET and Put operations block</li>
+ * 			</ul>
+ * 			We need 4 types of queues even though fully synchronous queues support all operations including asynchronous
+ * 			operations because fully synchronous queues have the highest storage requirements. The other queue types are
+ * 			optimizations. Efficiency IS important to use (particularly RAM efficiency).
+ * 			In practice we only implement ASync, GSync and FSync queues as PSync queues are of dubious value.
+ * @{
+ */
+
+#ifndef _GQUEUE_H
+#define _GQUEUE_H
+
+#if GFX_USE_GQUEUE || defined(__DOXYGEN__)
+
+/**
+ * @brief	A queue
+ * @{
+ */
+typedef struct gfxQueueASync {
+	struct gfxQueueASyncItem	*head;
+	struct gfxQueueASyncItem	*tail;
+	} gfxQueueAsync;
+typedef struct gfxQueueGSync {
+	struct gfxQueueGSyncItem	*head;
+	struct gfxQueueGSyncItem	*tail;
+	gfxSem						sem;
+	} gfxQueueGSync;
+typedef struct gfxQueueFSync {
+	struct gfxQueueFSyncItem	*head;
+	struct gfxQueueFSyncItem	*tail;
+	gfxSem						sem;
+	} gfxQueueGSync;
+/* @} */
+
+/**
+ * @brief	A queue item
+ * @{
+ */
+typedef struct gfxQueueASyncItem {
+	struct gfxQueueASyncItem	*next;
+	} gfxQueueASyncItem;
+typedef struct gfxQueueGSyncItem {
+	struct gfxQueueGSyncItem	*next;
+	} gfxQueueGSyncItem;
+typedef struct gfxQueueFSyncItem {
+	struct gfxQueueFSyncItem	*next;
+	gfxSem						sem;
+	} gfxQueueFSyncItem;
+/* @} */
+
+
+/*===========================================================================*/
+/* Function declarations.                                                    */
+/*===========================================================================*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief	Initialise a queue.
+ *
+ * @param[in]	pqueue	A pointer to the queue
+ *
+ * @note	Whilst queues are normally FIFO, a GFX queue also supports push and pop operations.
+ * 			A pop operation is the same as normal get from the queue but a push places the item
+ * 			at the head of the queue instead of the tail (as a put would).
+ *
+ * @api
+ * @{
+ */
+void gfxQueueASyncInit(gfxQueueASync *pqueue);
+void gfxQueueGSyncInit(gfxQueueGSync *pqueue);
+void gfxQueueFSyncInit(gfxQueueFSync *pqueue);
+/* @} */
+
+/**
+ * @brief	Get an item from the head of the queue.
+ * @return	NULL if the timeout expires before an item is available
+ *
+ * @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.
+ *
+ * @api
+ * @{
+ */
+gfxQueueASyncItem *gfxQueueASyncGet(gfxQueueASync *pqueue);
+gfxQueueGSyncItem *gfxQueueGSyncGet(gfxQueueGSync *pqueue, delaytime_t ms);
+gfxQueueFSyncItem *gfxQueueFSyncGet(gfxQueueFSync *pqueue, delaytime_t ms);
+/* @} */
+
+/**
+ * @brief	Put an item on the end of the queue.
+ * @return	none for ASync and GSync queues; For FSync queues - FALSE on timeout, otherwise TRUE
+ *
+ * @param[in]	pqueue	A pointer to the queue
+ * @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
+ * 				item is removed from the queue. Note that even if the timeout occurs - the item
+ * 				remains in the queue.
+ *
+ * @api
+ * @{
+ */
+void gfxQueueASyncPut(gfxQueueASync *pqueue, gfxQueueASyncItem *pitem);
+void gfxQueueGSyncPut(gfxQueueGSync *pqueue, gfxQueueGSyncItem *pitem);
+bool_t gfxQueueFSyncPut(gfxQueueFSync *pqueue, gfxQueueFSyncItem *pitem, delaytime_t ms);
+/* @} */
+
+/**
+ * @brief	Pop an item from the head of the queue.
+ * @detail	This is exactly the same as the Get operation above.
+ *
+ * @api
+ * @{
+ */
+#define gfxQueueASyncPop(pqueue)			gfxQueueASyncGet(pqueue)
+#define gfxQueueGSyncPop(pqueue, ms)		gfxQueueGSyncGet(pqueue, ms)
+#define gfxQueueFSyncPop(pqueue, ms)		gfxQueueFSyncGet(pqueue, ms)
+/* @} */
+
+/**
+ * @brief	Push an item into the start of the queue.
+ * @return	none for ASync and GSync queues; For FSync queues - FALSE on timeout, otherwise TRUE
+ *
+ * @param[in]	pqueue	A pointer to the queue
+ * @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
+ * 				item is removed from the queue. Note that even if the timeout occurs - the item
+ * 				remains in the queue.
+ *
+ * @api
+ * @{
+ */
+void gfxQueueASyncPush(gfxQueueASync *pqueue, gfxQueueASyncItem *pitem);
+void gfxQueueGSyncPush(gfxQueueGSync *pqueue, gfxQueueGSyncItem *pitem);
+bool_t gfxQueueFSyncPush(gfxQueueFSync *pqueue, gfxQueueFSyncItem *pitem, delaytime_t ms);
+/* @} */
+
+/**
+ * @brief	Remove an item from the queue.
+ * @note	Removes the specified item from the queue where-ever it is in the queue
+ *
+ * @param[in]	pqueue	A pointer to the queue
+ * @param[in]	pitem	A pointer to the queue item
+ *
+ * @note	If the item isn't in the queue the routine just returns.
+ * @note	If a process is waiting on the Put/Push operation for the item, that process
+ * 			will be signaled.
+ *
+ * @api
+ * @{
+ */
+void gfxQueueASyncRemove(gfxQueueASync *pqueue, gfxQueueASyncItem *pitem);
+void gfxQueueGSyncRemove(gfxQueueGSync *pqueue, gfxQueueGSyncItem *pitem);
+void gfxQueueFSyncRemove(gfxQueueFSync *pqueue, gfxQueueFSyncItem *pitem);
+/* @} */
+
+/**
+ * @brief	Is the queue empty?
+ * @return	TRUE if the queue is empty
+ *
+ * @param[in]	pqueue	A pointer to the queue
+ *
+ * @api
+ * @{
+ */
+bool_t gfxQueueASyncIsEmpty(gfxQueueASync *pqueue);
+bool_t gfxQueueGSyncIsEmpty(gfxQueueGSync *pqueue);
+bool_t gfxQueueFSyncIsEmpty(gfxQueueFSync *pqueue);
+/* @} */
+
+/**
+ * @brief	Is an item in the queue?
+ * @return	TRUE if the item is in the queue?
+ *
+ * @param[in]	pqueue	A pointer to the queue
+ * @param[in]	pitem	A pointer to the queue item
+ *
+ * @note	This operation may be expensive.
+ *
+ * @api
+ * @{
+ */
+bool_t gfxQueueASyncIsIn(gfxQueueASync *pqueue, gfxQueueASyncItem *pitem);
+bool_t gfxQueueGSyncIsIn(gfxQueueGSync *pqueue, gfxQueueGSyncItem *pitem);
+bool_t gfxQueueFSyncIsIn(gfxQueueFSync *pqueue, gfxQueueFSyncItem *pitem);
+/* @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GFX_USE_GQUEUE */
+#endif /* _GQUEUE_H */
+/** @} */
diff --git a/include/gqueue/options.h b/include/gqueue/options.h
new file mode 100644
index 00000000..30ccdb46
--- /dev/null
+++ b/include/gqueue/options.h
@@ -0,0 +1,66 @@
+/*
+    ChibiOS/GFX - Copyright (C) 2012, 2013
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS/GFX.
+
+    ChibiOS/GFX 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.
+
+    ChibiOS/GFX is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ * @file    include/gqueue/options.h
+ * @brief   GQUEUE - Queue options header file.
+ *
+ * @addtogroup GQUEUE
+ * @{
+ */
+
+#ifndef _GQUEUE_OPTIONS_H
+#define _GQUEUE_OPTIONS_H
+
+/**
+ * @name    GQUEUE Functions to include.
+ * @{
+ */
+	/**
+	 * @brief   Enable Asynchronous Queues
+	 * @details	Defaults to FALSE
+	 */
+	#ifndef GQUEUE_NEED_ASYNC
+		#define GQUEUE_NEED_ASYNC		FALSE
+	#endif
+	/**
+	 * @brief   Enable Get-Synchronous Queues
+	 * @details	Defaults to FALSE
+	 */
+	#ifndef GQUEUE_NEED_GSYNC
+		#define GQUEUE_NEED_GSYNC		FALSE
+	#endif
+	/**
+	 * @brief   Enable Fully Synchronous Queues
+	 * @details	Defaults to FALSE
+	 */
+	#ifndef GQUEUE_NEED_FSYNC
+		#define GQUEUE_NEED_FSYNC		FALSE
+	#endif
+/**
+ * @}
+ *
+ * @name    GQUEUE Optional Sizing Parameters
+ * @{
+ */
+/** @} */
+
+#endif /* _GQUEUE_OPTIONS_H */
+/** @} */
diff --git a/include/gwin/console.h b/include/gwin/console.h
index 1fc19e42..4c317cdb 100644
--- a/include/gwin/console.h
+++ b/include/gwin/console.h
@@ -40,7 +40,7 @@
 typedef struct GConsoleObject_t {
 	GWindowObject		gwin;
 	
-	#if GFX_USE_OS_CHIBIOS
+	#if GFX_USE_OS_CHIBIOS && GWIN_CONSOLE_USE_BASESTREAM
 		struct GConsoleWindowStream_t {
 			const struct GConsoleWindowVMT_t *vmt;
 			_base_asynchronous_channel_data
@@ -80,7 +80,7 @@ extern "C" {
  */
 GHandle gwinCreateConsole(GConsoleObject *gc, coord_t x, coord_t y, coord_t width, coord_t height, font_t font);
 
-#if GFX_USE_OS_CHIBIOS
+#if GFX_USE_OS_CHIBIOS && GWIN_CONSOLE_USE_BASESTREAM
 	/**
 	 * @brief   Get a stream from a console window suitable for use with chprintf().
 	 * @return	The stream handle or NULL if this is not a console window.
@@ -128,6 +128,31 @@ void gwinPutString(GHandle gh, const char *str);
  */
 void gwinPutCharArray(GHandle gh, const char *str, size_t n);
 
+/**
+ * @brief   Print a formatted string at the cursor position in the window. It will wrap lines as required.
+ * @details This function implements a minimal printf() like functionality
+ *          The general parameters format is: %[-][width|*][.precision|*][l|L]p.
+ *          The following parameter types (p) are supported:
+ *          - <b>x</b> hexadecimal integer.
+ *          - <b>X</b> hexadecimal long.
+ *          - <b>o</b> octal integer.
+ *          - <b>O</b> octal long.
+ *          - <b>d</b> decimal signed integer.
+ *          - <b>D</b> decimal signed long.
+ *          - <b>u</b> decimal unsigned integer.
+ *          - <b>U</b> decimal unsigned long.
+ *          - <b>c</b> character.
+ *          - <b>s</b> string.
+ * @note	Uses the current foreground color to draw the string and fills the background using the background drawing color
+ *
+ * @param[in] gh	The window handle (must be a console window)
+ * @param[in] fmt	The format string (as per printf)
+ * @param[in] ...	The format string arguments.
+ *
+ * @api
+ */
+void gwinPrintf(GHandle gh, const char *fmt, ...);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/gwin/options.h b/include/gwin/options.h
index 8d78a751..683a6e55 100644
--- a/include/gwin/options.h
+++ b/include/gwin/options.h
@@ -59,9 +59,27 @@
  * @name    GWIN Optional Parameters
  * @{
  */
+	/**
+	 * @brief   Buttons should not insist the mouse is over the button on mouse release
+	 * @details	Defaults to FALSE
+	 */
 	#ifndef GWIN_BUTTON_LAZY_RELEASE
 		#define GWIN_BUTTON_LAZY_RELEASE		FALSE
 	#endif
+	/**
+	 * @brief   Console Windows need floating point support in @p gwinPrintf
+	 * @details	Defaults to FALSE
+	 */
+	#ifndef GWIN_CONSOLE_USE_FLOAT
+		#define GWIN_CONSOLE_USE_FLOAT			FALSE
+	#endif
+	/**
+	 * @brief   Console Windows need BaseStreamSequential support (ChibiOS only)
+	 * @details	Defaults to FALSE
+	 */
+	#ifndef GWIN_CONSOLE_USE_BASESTREAM
+		#define GWIN_CONSOLE_USE_BASESTREAM		FALSE
+	#endif
 /** @} */
 
 #endif /* _GWIN_OPTIONS_H */