µGFX  2.9
version 2.9
GOS

Detailed Description

Module to build a uniform abstraction layer between uGFX and the underlying system.

Note
Some of the routines specified below may be implemented simply as a macro to the real operating system call.

Data Structures

struct  gSem
 A semaphore. More...
 
struct  gMutex
 A mutex. More...
 

Functions

void gfxHalt (const char *msg)
 Halt the GFX application due to an error. More...
 
void gfxExit (void)
 Exit the GFX application. More...
 
void * gfxAlloc (gMemSize sz)
 Allocate memory. More...
 
void * gfxRealloc (void *ptr, gMemSize oldsz, gMemSize newsz)
 Re-allocate memory. More...
 
void gfxFree (void *ptr)
 Free memory. More...
 
void gfxYield (void)
 Yield the current thread. More...
 
void gfxSleepMilliseconds (gDelay ms)
 Put the current thread to sleep for the specified period in milliseconds. More...
 
void gfxSleepMicroseconds (gDelay us)
 Put the current thread to sleep for the specified period in microseconds. More...
 
gTicks gfxSystemTicks (void)
 Get the current operating system tick time. More...
 
gTicks gfxMillisecondsToTicks (gDelay ms)
 Convert a given number of millseconds to a number of operating system ticks. More...
 
void gfxSystemLock (void)
 Lock the operating system to protect a sequence of code. More...
 
void gfxSystemUnlock (void)
 Unlock the operating system previous locked by gfxSystemLock() More...
 
void gfxMutexInit (gMutex *pmutex)
 Initialise a mutex to protect a region of code from other threads. More...
 
void gfxMutexDestroy (gMutex *pmutex)
 Destroy a Mutex. More...
 
void gfxMutexEnter (gMutex *pmutex)
 Enter the critical code region protected by the mutex. More...
 
void gfxMutexExit (gMutex *pmutex)
 Exit the critical code region protected by the mutex. More...
 
void gfxSemInit (gSem *psem, gSemcount val, gSemcount limit)
 Initialise a Counted Semaphore. More...
 
void gfxSemDestroy (gSem *psem)
 Destroy a Counted Semaphore. More...
 
gBool gfxSemWait (gSem *psem, gDelay ms)
 Wait on a semaphore. More...
 
gBool gfxSemWaitI (gSem *psem)
 Test if a wait on a semaphore can be satisfied immediately. More...
 
void gfxSemSignal (gSem *psem)
 Signal a semaphore. More...
 
void gfxSemSignalI (gSem *psem)
 Signal a semaphore. More...
 
gThread gfxThreadCreate (void *stackarea, gMemSize stacksz, gThreadpriority prio, GFX_THREAD_FUNCTION((*fn), p), void *param)
 Start a new thread. More...
 
gThreadreturn gfxThreadWait (gThread thread)
 Wait for a thread to finish. More...
 
gThread gfxThreadMe (void)
 Get the current thread handle. More...
 
void gfxThreadClose (gThread thread)
 Close the thread handle. More...
 

Various integer sizes

Note
Your platform may define these differently to these.
These sizes are guaranteed minimum sizes for the type. It might actually be larger. eg gI8 may actually be 9 bits.
typedef unsigned char gBool
 
typedef signed char gI8
 
typedef unsigned char gU8
 
typedef short gI16
 
typedef unsigned short gU16
 
typedef long gI32
 
typedef unsigned long gU32
 

More integer sizes

Precondition
These are only available if GFX_TYPE_64 is GFXON as not all compilers support 64 bit.
Note
GFX_TYPE_64 is set to GFXON or GFXOFF by the compiler detector. It is not a user configuration macro.
typedef long long gI64
 
typedef unsigned long long gU64
 

Various platform (and operating system) dependent types

Note
Your platform may use slightly different definitions to these
typedef unsigned long gDelay
 
typedef unsigned long gTicks
 
typedef short gSemcount
 
typedef int gThreadreturn
 
typedef int gThreadpriority
 

Various platform (and operating system) constants

Note
Your platform may use slightly different definitions to these
#define gDelayNone   0
 
#define gDelayForever   ((gDelay)-1)
 
#define gSemMaxCount   ((gSemcount)(((unsigned long)((gSemcount)(-1))) >> 1))
 
#define gThreadpriorityLow   0
 
#define gThreadpriorityNormal   1
 
#define gThreadpriorityHigh   2
 

The operating system to use. One (and only one) of these must be defined.

#define GFX_USE_OS_CHIBIOS   GFXOFF
 Use ChibiOS. More...
 
#define GFX_USE_OS_FREERTOS   GFXOFF
 Use FreeRTOS. More...
 
#define GFX_USE_OS_WIN32   GFXOFF
 Use Win32. More...
 
#define GFX_USE_OS_LINUX   GFXOFF
 Use a linux based system running X11. More...
 
#define GFX_USE_OS_OSX   GFXOFF
 Use a Mac OS-X based system. More...
 
#define GFX_USE_OS_RAW32   GFXOFF
 Use a Raw 32-bit CPU based system (Bare Metal) More...
 
#define GFX_USE_OS_ECOS   GFXOFF
 Use a eCos. More...
 
#define GFX_USE_OS_RAWRTOS   GFXOFF
 Use RAWRTOS. More...
 
#define GFX_USE_OS_ARDUINO   GFXOFF
 Use Arduino. More...
 
#define GFX_USE_OS_CMSIS   GFXOFF
 Use CMSIS RTOS compatible OS. More...
 
#define GFX_USE_OS_CMSIS2   GFXOFF
 Use CMSIS2 RTOS compatible OS. More...
 
#define GFX_USE_OS_KEIL   GFXOFF
 Use Keil CMSIS 1.x (RTOS, RTX4) More...
 
#define GFX_USE_OS_RTX5   GFXOFF
 Use Keil RTX5. More...
 
#define GFX_USE_OS_NIOS   GFXOFF
 Use NIOS-II. More...
 
#define GFX_USE_OS_ZEPHYR   GFXOFF
 Use Zephyr. More...
 
#define GFX_USE_OS_QT   GFXOFF
 Use Qt. More...
 

GFX_OS_EXTRA_DEINIT_FUNCTION

A macro that defines a function that uGFX calls as part of gfxDeInit() just before de-initializing the operating system.

Defaults to undefined

Note
If defined the specified function is called just before the operating system is de-initialized by gfxDeInit().
Eg. In your source: void myOSDeInitRoutine(void); In gfxconf.h: #define GFX_OS_EXTRA_DEINIT_FUNCTION myOSDeInitRoutine
#define GFX_OS_NO_INIT   GFXOFF
 Should uGFX avoid initializing the operating system. More...
 
#define GFX_OS_INIT_NO_WARNING   GFXOFF
 Turn off warnings about initializing the operating system. More...
 
#define GFX_OS_CALL_UGFXMAIN   GFXOFF
 Call uGFXMain() after all initialisation. More...
 
#define GFX_OS_UGFXMAIN_STACKSIZE   0
 When uGFXMain() is started as a thread, what stack size should be used. More...
 
#define GFX_FREERTOS_USE_TRACE   GFXOFF
 Should uGFX stuff be added to the FreeRTOS+Tracer. More...
 
#define GFX_OS_HEAP_SIZE   0
 How much RAM should uGFX use for the heap when using its own internal heap allocator. More...
 
#define GFX_EMULATE_MALLOC   GFXOFF
 Enable wrappers for malloc() and free() More...
 
#define GFX_MEM_LT64K   GFXOFF
 Is the maximum memory allocation less than 64K. More...
 

Macros

#define GFX_THREAD_FUNCTION(fnName, param)   gThreadreturn fnName(void *param)
 Declare a thread function. More...
 
#define GFX_THREAD_STACK(name, sz)   gU8 name[sz];
 Declare a thread stack. More...
 
#define GFX_EMULATE_MALLOC   GFXOFF
 Use gfxAlloc and gfxFree to implement malloc() and free() More...
 

Typedefs

typedef void * gThread
 A thread handle. More...
 

Function Documentation

◆ gfxAlloc()

void* gfxAlloc ( gMemSize  sz)

Allocate memory.

Returns
A pointer to the memory allocated or NULL if there is no more memory available
Parameters
[in]szThe size in bytes of the area to allocate
Function Class: Normal API, this function can be invoked by regular system threads.

Referenced by gdriverRegister().

◆ gfxExit()

void gfxExit ( void  )

Exit the GFX application.

Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxFree()

void gfxFree ( void *  ptr)

Free memory.

Parameters
[in]ptrThe memory to free
Function Class: Normal API, this function can be invoked by regular system threads.

Referenced by gdriverRegister(), and gdriverUnRegister().

◆ gfxHalt()

void gfxHalt ( const char *  msg)

Halt the GFX application due to an error.

Parameters
[in]msgAn optional debug message to show (Can be NULL)
Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxMillisecondsToTicks()

gTicks gfxMillisecondsToTicks ( gDelay  ms)

Convert a given number of millseconds to a number of operating system ticks.

Returns
The period in system ticks.
Note
A "tick" is an arbitrary period of time that the operating system uses to mark time.
Parameters
[in]msThe number of millseconds
Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxMutexDestroy()

void gfxMutexDestroy ( gMutex pmutex)

Destroy a Mutex.

Parameters
[in]pmutexA pointer to the mutex
Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxMutexEnter()

void gfxMutexEnter ( gMutex pmutex)

Enter the critical code region protected by the mutex.

Blocks until there is no other thread in the critical region.

Parameters
[in]pmutexA pointer to the mutex
Function Class: Normal API, this function can be invoked by regular system threads.

Referenced by geventDetachSourceListeners(), geventGetEventBuffer(), geventGetSourceListener(), geventSendEvent(), gtimerJab(), and gtimerStop().

◆ gfxMutexExit()

void gfxMutexExit ( gMutex pmutex)

Exit the critical code region protected by the mutex.

May cause another thread waiting on the mutex to now be placed into the run queue.

Parameters
[in]pmutexA pointer to the mutex
Function Class: Normal API, this function can be invoked by regular system threads.

Referenced by geventDetachSourceListeners(), geventGetEventBuffer(), geventGetSourceListener(), geventSendEvent(), gtimerJab(), and gtimerStop().

◆ gfxMutexInit()

void gfxMutexInit ( gMutex pmutex)

Initialise a mutex to protect a region of code from other threads.

Parameters
[in]pmutexA pointer to the mutex
Note
Whilst a counting semaphore with a limit of 1 can be used for similiar purposes on many operating systems using a seperate mutex structure is more efficient.
Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxRealloc()

void* gfxRealloc ( void *  ptr,
gMemSize  oldsz,
gMemSize  newsz 
)

Re-allocate memory.

Returns
A pointer to the new memory area or NULL if there is no more memory available
Parameters
[in]ptrThe old memory area to be increased/decreased in size
[in]oldszThe size in bytes of the old memory area
[in]newszThe size in bytes of the new memory area
Note
Some operating systems don't use the oldsz parameter as they implicitly know the size of old memory area. The parameter must always be supplied however for API compatibility.
gfxRealloc() can make the area smaller or larger but may have to return a different pointer. If this occurs the new area contains a copy of the data from the old area. The old memory pointer should not be used after this routine as the original area may have been freed.
If there is insufficient memory to create the new memory region, NULL is returned and the old memory area is left unchanged.
Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxSemDestroy()

void gfxSemDestroy ( gSem psem)

Destroy a Counted Semaphore.

Parameters
[in]psemA pointer to the semaphore
Note
Any threads waiting on the semaphore will be released
Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxSemInit()

void gfxSemInit ( gSem psem,
gSemcount  val,
gSemcount  limit 
)

Initialise a Counted Semaphore.

Parameters
[in]psemA pointer to the semaphore
[in]valThe initial value of the semaphore
[in]limitThe 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.
Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxSemSignal()

void gfxSemSignal ( gSem psem)

Signal a semaphore.

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.

Parameters
[in]psemA pointer to the semaphore
Function Class: Normal API, this function can be invoked by regular system threads.

Referenced by geventSendEvent(), and gtimerJab().

◆ gfxSemSignalI()

void gfxSemSignalI ( gSem psem)

Signal a semaphore.

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.

Parameters
[in]psemA pointer to the semaphore
Function Class: This is an I-Class API, this function can be invoked from within a system lock zone by both threads and interrupt handlers.
Function Class: Normal API, this function can be invoked by regular system threads.

Referenced by gtimerJabI().

◆ gfxSemWait()

gBool gfxSemWait ( gSem psem,
gDelay  ms 
)

Wait on a semaphore.

The semaphore counter is decreased and if the result becomes negative the thread waits for it to become non-negative again

Returns
gFalse if the wait timeout occurred otherwise gTrue
Parameters
[in]psemA pointer to the semaphore
[in]msThe maximum time to wait for the semaphore
Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxSemWaitI()

gBool gfxSemWaitI ( gSem psem)

Test if a wait on a semaphore can be satisfied immediately.

Equivalent to gfxSemWait(psem, gDelayNone) except it can be called at interrupt level

Returns
gFalse if the wait would occur occurred otherwise gTrue
Parameters
[in]psemA pointer to the semaphore
Function Class: This is an I-Class API, this function can be invoked from within a system lock zone by both threads and interrupt handlers.
Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxSleepMicroseconds()

void gfxSleepMicroseconds ( gDelay  us)

Put the current thread to sleep for the specified period in microseconds.

Parameters
[in]usThe number microseconds to sleep
Note
Specifying gDelayNone will return immediately (no sleeping)
Specifying gDelayForever will sleep forever.
Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxSleepMilliseconds()

void gfxSleepMilliseconds ( gDelay  ms)

Put the current thread to sleep for the specified period in milliseconds.

Parameters
[in]msThe number milliseconds to sleep
Note
Specifying gDelayNone will yield the current thread but return on the next time slice.
Specifying gDelayForever will sleep forever.
Function Class: Normal API, this function can be invoked by regular system threads.

Referenced by ginputGetToggleStatus().

◆ gfxSystemLock()

void gfxSystemLock ( void  )

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 within the GFX system. On hardware this may be implemented as a disabling of interrupts, however in an operating system which hides real interrupt level code it may simply use a mutex lock.
The thread MUST NOT block whilst the system is locked. It must execute in this state for as short a period as possible as this can seriously affect interrupt latency on some platforms.
While locked only interrupt level (iclass) GFX routines may be called.
Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxSystemTicks()

gTicks gfxSystemTicks ( void  )

Get the current operating system tick time.

Returns
The current tick time
Note
A "tick" is an arbitrary period of time that the operating system uses to mark time.
The absolute value of this call is relatively meaningless. Its usefulness is in calculating periods between two calls to this function.
As the value from this function can wrap it is important that any periods are calculated as t2 - t1 and then compared to the desired period rather than comparing t1 + period to t2
Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxSystemUnlock()

void gfxSystemUnlock ( void  )

Unlock the operating system previous locked by gfxSystemLock()

Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxThreadClose()

void gfxThreadClose ( gThread  thread)

Close the thread handle.

Parameters
[in]threadThe Thread Handle
Note
This does not affect the thread, it just closes our handle to the thread.
Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxThreadCreate()

gThread gfxThreadCreate ( void *  stackarea,
gMemSize  stacksz,
gThreadpriority  prio,
GFX_THREAD_FUNCTION((*fn), p)  ,
void *  param 
)

Start a new thread.

Returns
Returns a thread handle if the thread was started, NULL on an error
Parameters
[in]stackareaA pointer to the area for the new threads stack or NULL to dynamically allocate it
[in]stackszThe size of the thread stack. 0 means the default operating system size although this is only valid when stackarea is dynamically allocated.
[in]prioThe priority of the new thread
[in]fnThe function the new thread will run
[in]paramA parameter to pass the thread function.
Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxThreadMe()

gThread gfxThreadMe ( void  )

Get the current thread handle.

Returns
A thread handle
Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxThreadWait()

gThreadreturn gfxThreadWait ( gThread  thread)

Wait for a thread to finish.

Returns
Returns the thread exit code.
Parameters
[in]threadThe Thread Handle
Note
This will also close the thread handle as it is no longer useful once the thread has ended.
Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxYield()

void gfxYield ( void  )

Yield the current thread.

Give up the rest of the current time slice for this thread in order to give other threads a chance to run.

Function Class: Normal API, this function can be invoked by regular system threads.

Macro Definition Documentation

◆ GFX_EMULATE_MALLOC [1/2]

#define GFX_EMULATE_MALLOC   GFXOFF

Use gfxAlloc and gfxFree to implement malloc() and free()

Note
Sometimes your application will include functions that want to internally use malloc() and free(). As the default implementations of these in your C library are almost invariably incorrect for an embedded platform, this option allows you to emulate those calls with gfxAlloc() and gfxFree(). An example is the C library routine rand() which on many implementations internally uses malloc().
Function Class: Normal API, this function can be invoked by regular system threads.

Definition at line 191 of file gos.h.

◆ GFX_EMULATE_MALLOC [2/2]

#define GFX_EMULATE_MALLOC   GFXOFF

Enable wrappers for malloc() and free()

Defaults to GFXOFF

Note
If enabled, malloc() and free() will be implemented as wrappers that call gfxAlloc() and gfxFree() in order to provide portability to libraries using these function.
Enabling this can solve 'unresolved _sbrk' issues
It is strongly recommended to always use gfxAlloc() and gfxFree() directy to ensure portability of uGFX applications across all platforms.

Definition at line 261 of file gos_options.h.

◆ GFX_FREERTOS_USE_TRACE

#define GFX_FREERTOS_USE_TRACE   GFXOFF

Should uGFX stuff be added to the FreeRTOS+Tracer.

Defaults to GFXOFF

Definition at line 234 of file gos_options.h.

◆ GFX_MEM_LT64K

#define GFX_MEM_LT64K   GFXOFF

Is the maximum memory allocation less than 64K.

Defaults to GFXOFF

Note
Many CPU's cannot allocate memory blocks larger than 64K. Note that this is not necessarily mean that a pointer is 16 bit but a 16 bit pointer will definitely impose this restriction. An example is the x86 processor running in "FAR" mode. Pointers are 32 bit but the maximum size memory block is 64K.
Specifying this only leads to code and memory optimisations. uGFX should still work on these processors even if it is not set although obviously an attempted memory allocation larger than 64K will fail.

Definition at line 275 of file gos_options.h.

◆ GFX_OS_CALL_UGFXMAIN

#define GFX_OS_CALL_UGFXMAIN   GFXOFF

Call uGFXMain() after all initialisation.

Defaults to GFXOFF

Note
uGFXMain() is a function defined by the user in their project that contains the application main code. This is not expected to return and thus gfxInit() will also never return. This is required for some operating systems whose main thread never returns after starting the scheduler.
Its prototype is:
void uGFXMain(void);

Definition at line 216 of file gos_options.h.

◆ GFX_OS_HEAP_SIZE

#define GFX_OS_HEAP_SIZE   0

How much RAM should uGFX use for the heap when using its own internal heap allocator.

Defaults to 0.

Note
Only used when the internal ugfx heap allocator is used (GFX_USE_OS_RAW32, GFX_USE_OS_ARDUINO, GFX_US_OS_KEIL, GFX_USE_OS_CMSIS)
If 0 then the standard C runtime malloc(), free() and realloc() are used.
If it is non-zero then this is the number of bytes of RAM to use for the heap (gfxAlloc() and gfxFree()). No C runtime routines will be used and a new routine gfxAddHeapBlock() is added allowing the user to add extra memory blocks to the heap.

Definition at line 249 of file gos_options.h.

◆ GFX_OS_INIT_NO_WARNING

#define GFX_OS_INIT_NO_WARNING   GFXOFF

Turn off warnings about initializing the operating system.

Defaults to GFXOFF

Note
This is only relevant where GOS cannot initialize the operating system automatically or the operating system initialization has been explicitly turned off.

Definition at line 202 of file gos_options.h.

◆ GFX_OS_NO_INIT

#define GFX_OS_NO_INIT   GFXOFF

Should uGFX avoid initializing the operating system.

Defaults to GFXOFF

Note
This is not relevant to all operating systems eg Win32 never initializes the operating system as uGFX runs as an application outside the boot process.
Operating system initialization is not necessarily implemented for all operating systems yet even when it is relevant. These operating systems will display a compile warning reminding you to initialize the operating system in your application code. Note that on these operating systems the demo applications will not work without modification.

Definition at line 192 of file gos_options.h.

◆ GFX_OS_UGFXMAIN_STACKSIZE

#define GFX_OS_UGFXMAIN_STACKSIZE   0

When uGFXMain() is started as a thread, what stack size should be used.

Defaults to 0

Note
uGFXMain() contains the application main code. Some operating systems will start this as a thread. eg FreeRTOS. When it is started as a thread this defines how many bytes should be used for the thread stack.
0 means to use the operating systems default stack size.

Definition at line 227 of file gos_options.h.

◆ GFX_THREAD_FUNCTION

#define GFX_THREAD_FUNCTION (   fnName,
  param 
)    gThreadreturn fnName(void *param)

Declare a thread function.

Parameters
[in]fnNameThe name of the function
[in]paramA custom parameter that is passed to the function

Definition at line 73 of file gos.h.

◆ GFX_THREAD_STACK

#define GFX_THREAD_STACK (   name,
  sz 
)    gU8 name[sz];

Declare a thread stack.

Parameters
[in]nameThe name of the stack
[in]szThe size of the stack in bytes
Note
The size provided is just a suggestion to the required stack size. Many platforms will round the size to ensure correct stack alignment. Other platforms may entirely ignore the suggested size.

Definition at line 85 of file gos.h.

◆ GFX_USE_OS_ARDUINO

#define GFX_USE_OS_ARDUINO   GFXOFF

Use Arduino.

Defaults to GFXOFF

Definition at line 84 of file gos_options.h.

◆ GFX_USE_OS_CHIBIOS

#define GFX_USE_OS_CHIBIOS   GFXOFF

Use ChibiOS.

Defaults to GFXOFF

Definition at line 28 of file gos_options.h.

◆ GFX_USE_OS_CMSIS

#define GFX_USE_OS_CMSIS   GFXOFF

Use CMSIS RTOS compatible OS.

Defaults to GFXOFF

Definition at line 91 of file gos_options.h.

◆ GFX_USE_OS_CMSIS2

#define GFX_USE_OS_CMSIS2   GFXOFF

Use CMSIS2 RTOS compatible OS.

Defaults to GFXOFF

Definition at line 98 of file gos_options.h.

◆ GFX_USE_OS_ECOS

#define GFX_USE_OS_ECOS   GFXOFF

Use a eCos.

Defaults to GFXOFF

Definition at line 70 of file gos_options.h.

◆ GFX_USE_OS_FREERTOS

#define GFX_USE_OS_FREERTOS   GFXOFF

Use FreeRTOS.

Defaults to GFXOFF

Definition at line 35 of file gos_options.h.

◆ GFX_USE_OS_KEIL

#define GFX_USE_OS_KEIL   GFXOFF

Use Keil CMSIS 1.x (RTOS, RTX4)

Defaults to GFXOFF

Definition at line 105 of file gos_options.h.

◆ GFX_USE_OS_LINUX

#define GFX_USE_OS_LINUX   GFXOFF

Use a linux based system running X11.

Defaults to GFXOFF

Definition at line 49 of file gos_options.h.

◆ GFX_USE_OS_NIOS

#define GFX_USE_OS_NIOS   GFXOFF

Use NIOS-II.

Defaults to GFXOFF

Definition at line 119 of file gos_options.h.

◆ GFX_USE_OS_OSX

#define GFX_USE_OS_OSX   GFXOFF

Use a Mac OS-X based system.

Defaults to GFXOFF

Definition at line 56 of file gos_options.h.

◆ GFX_USE_OS_QT

#define GFX_USE_OS_QT   GFXOFF

Use Qt.

Defaults to GFXOFF

Definition at line 133 of file gos_options.h.

◆ GFX_USE_OS_RAW32

#define GFX_USE_OS_RAW32   GFXOFF

Use a Raw 32-bit CPU based system (Bare Metal)

Defaults to GFXOFF

Definition at line 63 of file gos_options.h.

◆ GFX_USE_OS_RAWRTOS

#define GFX_USE_OS_RAWRTOS   GFXOFF

Use RAWRTOS.

Defaults to GFXOFF

Definition at line 77 of file gos_options.h.

◆ GFX_USE_OS_RTX5

#define GFX_USE_OS_RTX5   GFXOFF

Use Keil RTX5.

Defaults to GFXOFF

Definition at line 112 of file gos_options.h.

◆ GFX_USE_OS_WIN32

#define GFX_USE_OS_WIN32   GFXOFF

Use Win32.

Defaults to GFXOFF

Definition at line 42 of file gos_options.h.

◆ GFX_USE_OS_ZEPHYR

#define GFX_USE_OS_ZEPHYR   GFXOFF

Use Zephyr.

Defaults to GFXOFF

Definition at line 126 of file gos_options.h.

Typedef Documentation

◆ gThread

typedef void* gThread

A thread handle.

Note
Your operating system will have a proper definition for this.

Definition at line 116 of file gos.h.