uGFX/ugfx
2
0
Fork 0
Code Issues 2 Pull requests Projects Releases Wiki Activity

Merge branch 'master' into freertos

Browse source
This commit is contained in:
inmarket 2014-02-03 18:23:53 +10:00
commit f26581dc7e
29 changed files with 272 additions and 184 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
demos/3rdparty/doom/i_system.c vendored
View file

@ -66,7 +66,7 @@ int I_GetHeapSize (void)
byte* I_ZoneBase (int* size) byte* I_ZoneBase (int* size)
{ {
*size = mb_used*1024*1024; *size = mb_used*1024*1024;
return (byte *) gfxAlloc (*size); return gfxAlloc (*size);
} }
@ -124,7 +124,7 @@ byte* I_Malloc(int length)
{ {
byte* mem; byte* mem;
mem = (byte *)gfxAlloc (length); mem = gfxAlloc (length);
memset (mem,0,length); memset (mem,0,length);
return mem; return mem;
} }

4
demos/modules/gadc/gwinosc.c
View file

@ -70,9 +70,9 @@ GHandle gwinGScopeCreate(GDisplay *g, GScopeObject *gs, GWindowInit *pInit, uint
return 0; return 0;
gfxSemInit(&gs->bsem, 0, 1); gfxSemInit(&gs->bsem, 0, 1);
gs->nextx = 0; gs->nextx = 0;
if (!(gs->lastscopetrace = (coord_t *)gfxAlloc(gs->g.width * sizeof(coord_t)))) if (!(gs->lastscopetrace = gfxAlloc(gs->g.width * sizeof(coord_t))))
return 0; return 0;
if (!(gs->audiobuf = (adcsample_t *)gfxAlloc(AUDIOBUFSZ * sizeof(adcsample_t)))) if (!(gs->audiobuf = gfxAlloc(AUDIOBUFSZ * sizeof(adcsample_t))))
return 0; return 0;
#if TRIGGER_METHOD == TRIGGER_POSITIVERAMP #if TRIGGER_METHOD == TRIGGER_POSITIVERAMP
gs->lasty = gs->g.height/2; gs->lasty = gs->g.height/2;

137
demos/modules/gwin/list/gfxconf.h
View file

@ -28,161 +28,45 @@
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
#define GFX_USE_GDISP TRUE #define GFX_USE_GDISP TRUE
#define GDISP_NEED_AUTOFLUSH FALSE
#define GDISP_NEED_TIMERFLUSH FALSE
#define GDISP_NEED_VALIDATION TRUE #define GDISP_NEED_VALIDATION TRUE
#define GDISP_NEED_CLIP TRUE #define GDISP_NEED_CLIP TRUE
#define GDISP_NEED_CIRCLE FALSE
#define GDISP_NEED_ELLIPSE FALSE
#define GDISP_NEED_ARC FALSE
#define GDISP_NEED_CONVEX_POLYGON TRUE #define GDISP_NEED_CONVEX_POLYGON TRUE
#define GDISP_NEED_SCROLL FALSE
#define GDISP_NEED_PIXELREAD FALSE
#define GDISP_NEED_CONTROL FALSE
#define GDISP_NEED_QUERY FALSE
#define GDISP_NEED_MULTITHREAD FALSE
#define GDISP_NEED_STREAMING FALSE
#define GDISP_NEED_TEXT TRUE #define GDISP_NEED_TEXT TRUE
#define GDISP_NEED_ANTIALIAS FALSE #define GDISP_INCLUDE_FONT_UI2 TRUE
#define GDISP_NEED_UTF8 FALSE
#define GDISP_NEED_TEXT_KERNING FALSE
#define GDISP_INCLUDE_FONT_UI1 FALSE
#define GDISP_INCLUDE_FONT_UI2 FALSE
#define GDISP_INCLUDE_FONT_LARGENUMBERS FALSE
#define GDISP_INCLUDE_FONT_DEJAVUSANS10 FALSE
#define GDISP_INCLUDE_FONT_DEJAVUSANS12 FALSE
#define GDISP_INCLUDE_FONT_DEJAVUSANS16 FALSE
#define GDISP_INCLUDE_FONT_DEJAVUSANS24 FALSE
#define GDISP_INCLUDE_FONT_DEJAVUSANS32 FALSE
#define GDISP_INCLUDE_FONT_DEJAVUSANSBOLD12 FALSE
#define GDISP_INCLUDE_FONT_FIXED_10x20 FALSE
#define GDISP_INCLUDE_FONT_FIXED_7x14 FALSE
#define GDISP_INCLUDE_FONT_FIXED_5x8 FALSE
#define GDISP_INCLUDE_FONT_DEJAVUSANS12_AA TRUE
#define GDISP_INCLUDE_FONT_DEJAVUSANS16_AA FALSE
#define GDISP_INCLUDE_FONT_DEJAVUSANS24_AA FALSE
#define GDISP_INCLUDE_FONT_DEJAVUSANS32_AA FALSE
#define GDISP_INCLUDE_FONT_DEJAVUSANSBOLD12_AA FALSE
#define GDISP_INCLUDE_USER_FONTS FALSE
#define GDISP_NEED_IMAGE TRUE #define GDISP_NEED_IMAGE TRUE
#define GDISP_NEED_IMAGE_NATIVE FALSE
#define GDISP_NEED_IMAGE_GIF TRUE #define GDISP_NEED_IMAGE_GIF TRUE
#define GDISP_NEED_IMAGE_BMP FALSE
#define GDISP_NEED_IMAGE_BMP_1 FALSE
#define GDISP_NEED_IMAGE_BMP_4 FALSE
#define GDISP_NEED_IMAGE_BMP_4_RLE FALSE
#define GDISP_NEED_IMAGE_BMP_8 FALSE
#define GDISP_NEED_IMAGE_BMP_8_RLE FALSE
#define GDISP_NEED_IMAGE_BMP_16 FALSE
#define GDISP_NEED_IMAGE_BMP_24 FALSE
#define GDISP_NEED_IMAGE_BMP_32 FALSE
#define GDISP_NEED_IMAGE_JPG FALSE
#define GDISP_NEED_IMAGE_PNG FALSE
#define GDISP_NEED_IMAGE_ACCOUNTING FALSE
#define GDISP_NEED_STARTUP_LOGO FALSE
#define GDISP_DEFAULT_ORIENTATION GDISP_ROTATE_LANDSCAPE
#define GDISP_LINEBUF_SIZE 128
#define GDISP_TOTAL_DISPLAYS 1
#if GDISP_TOTAL_DISPLAYS > 1
#define GDISP_HARDWARE_STREAM_WRITE FALSE
#define GDISP_HARDWARE_STREAM_READ FALSE
#define GDISP_HARDWARE_STREAM_POS FALSE
#define GDISP_HARDWARE_DRAWPIXEL FALSE
#define GDISP_HARDWARE_CLEARS FALSE
#define GDISP_HARDWARE_FILLS FALSE
#define GDISP_HARDWARE_BITFILLS FALSE
#define GDISP_HARDWARE_SCROLL FALSE
#define GDISP_HARDWARE_PIXELREAD FALSE
#define GDISP_HARDWARE_CONTROL FALSE
#define GDISP_HARDWARE_QUERY FALSE
#define GDISP_HARDWARE_CLIP FALSE
#endif
#define GDISP_TOTAL_CONTROLLERS 1
#if GDISP_TOTAL_CONTROLLERS > 1
#define GDISP_CONTROLLER_LIST GDISPVMT_Win32, GDISPVMT_Win32
#define GDISP_CONTROLLER_DISPLAYS 1, 1
#define GDISP_PIXELFORMAT GDISP_PIXELFORMAT_RGB888
#endif
#define GDISP_USE_GFXNET FALSE
#define GDISP_GFXNET_PORT 13001
#define GDISP_GFXNET_CUSTOM_LWIP_STARTUP FALSE
#define GDISP_DONT_WAIT_FOR_NET_DISPLAY FALSE
#define GDISP_GFXNET_UNSAFE_SOCKETS FALSE
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
// GWIN // // GWIN //
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
#define GFX_USE_GWIN TRUE #define GFX_USE_GWIN TRUE
#define GWIN_NEED_WINDOWMANAGER FALSE #define GWIN_NEED_WINDOWMANAGER TRUE
#define GWIN_NEED_CONSOLE FALSE
#define GWIN_CONSOLE_USE_HISTORY FALSE
#define GWIN_CONSOLE_HISTORY_AVERAGING FALSE
#define GWIN_CONSOLE_HISTORY_ATCREATE FALSE
#define GWIN_CONSOLE_USE_BASESTREAM FALSE
#define GWIN_CONSOLE_USE_FLOAT FALSE
#define GWIN_NEED_GRAPH FALSE
#define GWIN_NEED_WIDGET TRUE #define GWIN_NEED_WIDGET TRUE
#define GWIN_NEED_LABEL TRUE
#define GWIN_NEED_BUTTON FALSE
#define GWIN_BUTTON_LAZY_RELEASE FALSE
#define GWIN_NEED_SLIDER FALSE
#define GWIN_NEED_CHECKBOX FALSE
#define GWIN_NEED_IMAGE FALSE
#define GWIN_NEED_IMAGE_ANIMATION FALSE
#define GWIN_NEED_RADIO FALSE
#define GWIN_NEED_LIST TRUE #define GWIN_NEED_LIST TRUE
#define GWIN_NEED_LIST_IMAGES TRUE #define GWIN_NEED_LIST_IMAGES TRUE
#define GWIN_NEED_PROGRESSBAR FALSE
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
// GEVENT // // GEVENT //
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
#define GFX_USE_GEVENT FALSE #define GFX_USE_GEVENT TRUE
#define GEVENT_ASSERT_NO_RESOURCE FALSE
#define GEVENT_MAXIMUM_SIZE 32
#define GEVENT_MAX_SOURCE_LISTENERS 32
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
// GTIMER // // GTIMER //
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
#define GFX_USE_GTIMER FALSE #define GFX_USE_GTIMER TRUE
#define GTIMER_THREAD_PRIORITY HIGH_PRIORITY
#define GTIMER_THREAD_WORKAREA_SIZE 2048
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
// GQUEUE // // GQUEUE //
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
#define GFX_USE_GQUEUE FALSE #define GFX_USE_GQUEUE FALSE
#define GQUEUE_NEED_ASYNC FALSE
#define GQUEUE_NEED_GSYNC FALSE
#define GQUEUE_NEED_FSYNC FALSE
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
// GINPUT // // GINPUT //
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
#define GFX_USE_GINPUT TRUE #define GFX_USE_GINPUT TRUE
#define GINPUT_NEED_MOUSE TRUE #define GINPUT_NEED_MOUSE TRUE
#define GINPUT_NEED_KEYBOARD FALSE
#define GINPUT_NEED_TOGGLE FALSE
#define GINPUT_NEED_DIAL FALSE
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
@ -190,33 +74,20 @@
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
#define GFX_USE_GADC FALSE #define GFX_USE_GADC FALSE
#define GADC_MAX_LOWSPEED_DEVICES 4
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
// GAUDIN // // GAUDIN //
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
#define GFX_USE_GAUDIN FALSE #define GFX_USE_GAUDIN FALSE
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
// GAUDOUT // // GAUDOUT //
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
#define GFX_USE_GAUDOUT FALSE #define GFX_USE_GAUDOUT FALSE
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
// GMISC // // GMISC //
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
#define GFX_USE_GMISC FALSE #define GFX_USE_GMISC FALSE
#define GMISC_NEED_ARRAYOPS FALSE
#define GMISC_NEED_FASTTRIG FALSE
#define GMISC_NEED_FIXEDTRIG FALSE
#define GMISC_NEED_INVSQRT FALSE
#define GMISC_INVSQRT_MIXED_ENDIAN FALSE
#define GMISC_INVSQRT_REAL_SLOW FALSE
#endif /* _GFXCONF_H */ #endif /* _GFXCONF_H */

2
demos/modules/gwin/list/main.c
View file

@ -81,7 +81,7 @@ int main(void) {
gfxInit(); gfxInit();
// Set the widget defaults // Set the widget defaults
gwinSetDefaultFont(gdispOpenFont("DejaVuSans12_AA")); gwinSetDefaultFont(gdispOpenFont("UI2"));
gwinSetDefaultStyle(&WhiteWidgetStyle, FALSE); gwinSetDefaultStyle(&WhiteWidgetStyle, FALSE);
gdispClear(White); gdispClear(White);

2
drivers/gaudin/Win32/gaudin_lld.c
View file

@ -139,7 +139,7 @@ void gaudin_lld_init(const gaudin_params *paud) {
/* We need to allocate a wave header for each buffer */ /* We need to allocate a wave header for each buffer */
nBuffers = (paud->bufcount + paud->samplesPerEvent - 1) / paud->samplesPerEvent; nBuffers = (paud->bufcount + paud->samplesPerEvent - 1) / paud->samplesPerEvent;
if (!(pWaveHdrs = (WAVEHDR *)gfxAlloc(nBuffers * sizeof(WAVEHDR)))) { if (!(pWaveHdrs = gfxAlloc(nBuffers * sizeof(WAVEHDR)))) {
fprintf(stderr, "GAUDIN: Buffer header allocation failed\n"); fprintf(stderr, "GAUDIN: Buffer header allocation failed\n");
return; return;
} }

2
drivers/multiple/Win32/gdisp_lld_Win32.c
View file

@ -458,7 +458,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
#endif #endif
// Create a private area for this window // Create a private area for this window
priv = (winPriv *)gfxAlloc(sizeof(winPriv)); priv = gfxAlloc(sizeof(winPriv));
assert(priv != 0); assert(priv != 0);
memset(priv, 0, sizeof(winPriv)); memset(priv, 0, sizeof(winPriv));
g->priv = priv; g->priv = priv;

2
drivers/multiple/uGFXnet/gdisp_lld_uGFXnet.c
View file

@ -433,7 +433,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
#endif #endif
// Create a private area for this window // Create a private area for this window
if (!(priv = (netPriv *)gfxAlloc(sizeof(netPriv)))) if (!(priv = gfxAlloc(sizeof(netPriv))))
gfxHalt("GDISP: uGFXnet - Memory allocation failed"); gfxHalt("GDISP: uGFXnet - Memory allocation failed");
memset(priv, 0, sizeof(netPriv)); memset(priv, 0, sizeof(netPriv));
g->priv = priv; g->priv = priv;

11
include/gfx.h
View file

@ -204,8 +204,15 @@ extern "C" {
*/ */
void gfxInit(void); void gfxInit(void);
/* Compatibility for old programs */ /**
void DEPRECATED("Use gfxInit() instead") gdispInit(void); * @brief The one call to end it all
*
* @note This will deinitialise each sub-system that has been turned on.
* @note Do not call this without a previous @p gfxInit();
*
* @api
*/
void gfxDeinit(void);
#ifdef __cplusplus #ifdef __cplusplus
} }

13
include/gtimer/gtimer.h
View file

@ -68,14 +68,23 @@ extern "C" {
#endif #endif
/** /**
* @brief Initialise a timer. * @brief Initialise a timer
* *
* @param[in] pt pointer to a GTimer structure * @param[in] pt Pointer to a GTimer structure
* *
* @api * @api
*/ */
void gtimerInit(GTimer* pt); void gtimerInit(GTimer* pt);
/**
* @brief Deinitialise a timer
*
* @param[in] pt Pointer to a GTimer structure
*
* @api
*/
void gtimerDeinit(GTimer* pt);
/** /**
* @brief Set a timer going or alter its properties if it is already going. * @brief Set a timer going or alter its properties if it is already going.
* *

2
releases.txt
View file

@ -12,7 +12,9 @@ FIX: Console does not execute gwinPrintf() anymore if not visible
FEATURE: Added gwinGetColor() and gwinGetBgColor() FEATURE: Added gwinGetColor() and gwinGetBgColor()
FEATURE: Console does now have an optional buffer (GWIN_CONSOLE_USE_HISTORY) FEATURE: Console does now have an optional buffer (GWIN_CONSOLE_USE_HISTORY)
FEATURE: Added smooth scrolling to list widget FEATURE: Added smooth scrolling to list widget
FEATURE: Increased performance of gwinListAddItem()
FEATURE: Added FreeRTOS port FEATURE: Added FreeRTOS port
FEATURE: Added gfxDeinit()
*** changes after 1.9 *** *** changes after 1.9 ***

16
src/gadc/gadc.c
View file

@ -236,7 +236,8 @@ void GADC_ISR_ErrorI(ADCDriver *adcp, adcerror_t err) {
} }
/* Our module initialiser */ /* Our module initialiser */
void _gadcInit(void) { void _gadcInit(void)
{
gadc_lld_init(); gadc_lld_init();
gfxSemInit(&gadcsem, GADC_MAX_LOWSPEED_DEVICES, GADC_MAX_LOWSPEED_DEVICES); gfxSemInit(&gadcsem, GADC_MAX_LOWSPEED_DEVICES, GADC_MAX_LOWSPEED_DEVICES);
gfxMutexInit(&gadcmutex); gfxMutexInit(&gadcmutex);
@ -246,6 +247,19 @@ void _gadcInit(void) {
#endif #endif
} }
void _gadcDeinit(void)
{
/* commented stuff is ToDo */
// gadc_lld_deinit();
gfxSemDestroy(&gadcsem);
gfxMutexDestroy(&gadcmutex);
gtimerDeinit(&LowSpeedGTimer);
#if GFX_USE_GEVENT
gtimerDeinit(&HighSpeedGTimer);
#endif
}
static inline void StartADC(bool_t onNoHS) { static inline void StartADC(bool_t onNoHS) {
gfxSystemLock(); gfxSystemLock();
if (!(gflags & GADC_GFLG_ISACTIVE) || (onNoHS && !curlsdev)) if (!(gflags & GADC_GFLG_ISACTIVE) || (onNoHS && !curlsdev))

12
src/gaudin/gaudin.c
View file

@ -85,13 +85,21 @@ void GAUDIN_ISR_ErrorI(void) {
/* Ignore any errors for now */ /* Ignore any errors for now */
} }
/* The module initialiser */ void _gaudinInit(void)
void _gaudinInit(void) { {
#if GFX_USE_GEVENT #if GFX_USE_GEVENT
gtimerInit(&AudGTimer); gtimerInit(&AudGTimer);
#endif #endif
} }
void _gaudinDeinit(void)
{
// Commented stuff still ToDo
#if GFX_USE_GEVENT
gtimerDeinit(&AudGTimer);
#endif
}
bool_t gaudinInit(uint16_t channel, uint32_t frequency, audin_sample_t *buffer, size_t bufcount, size_t samplesPerEvent) { bool_t gaudinInit(uint16_t channel, uint32_t frequency, audin_sample_t *buffer, size_t bufcount, size_t samplesPerEvent) {
/* Check the channel is valid */ /* Check the channel is valid */
if (channel >= GAUDIN_NUM_CHANNELS || frequency > GAUDIN_MAX_SAMPLE_FREQUENCY) if (channel >= GAUDIN_NUM_CHANNELS || frequency > GAUDIN_MAX_SAMPLE_FREQUENCY)

10
src/gaudout/gaudout.c
View file

@ -18,6 +18,16 @@
#error "GAUDOUT: Not implemented yet" #error "GAUDOUT: Not implemented yet"
void _gaudoutInit(void)
{
/* ToDo */
}
void _gaudoutDeinit(void)
{
/* ToDo */
}
#endif /* GFX_USE_GAUDOUT */ #endif /* GFX_USE_GAUDOUT */
/** @} */ /** @} */

33
src/gdisp/gdisp.c
View file

@ -566,8 +566,8 @@ static void line_clip(GDisplay *g) {
/* Driver exported functions. */ /* Driver exported functions. */
/*===========================================================================*/ /*===========================================================================*/
/* Our module initialiser */ void _gdispInit(void)
void _gdispInit(void) { {
GDisplay *g; GDisplay *g;
uint16_t i; uint16_t i;
@ -627,6 +627,11 @@ void _gdispInit(void) {
#endif #endif
} }
void _gdispDeinit(void)
{
/* ToDo */
}
GDisplay *gdispGetDisplay(unsigned display) { GDisplay *gdispGetDisplay(unsigned display) {
if (display >= GDISP_TOTAL_DISPLAYS) if (display >= GDISP_TOTAL_DISPLAYS)
return 0; return 0;
@ -2764,8 +2769,14 @@ void gdispGDrawBox(GDisplay *g, coord_t x, coord_t y, coord_t cx, coord_t cy, co
#if GDISP_NEED_ANTIALIAS && GDISP_HARDWARE_PIXELREAD #if GDISP_NEED_ANTIALIAS && GDISP_HARDWARE_PIXELREAD
static void drawcharline(int16_t x, int16_t y, uint8_t count, uint8_t alpha, void *state) { static void drawcharline(int16_t x, int16_t y, uint8_t count, uint8_t alpha, void *state) {
#define GD ((GDisplay *)state) #define GD ((GDisplay *)state)
if (y < GD->t.clipy0 || y >= GD->t.clipy1) if (y < GD->t.clipy0 || y >= GD->t.clipy1 || x+count <= GD->t.clipx0 || x >= GD->t.clipx1)
return; return;
if (x < GD->t.clipx0) {
count -= GD->t.clipx0 - x;
x = GD->t.clipx0;
}
if (x+count > GD->t.clipx1)
count = GD->t.clipx1 - x;
if (alpha == 255) { if (alpha == 255) {
GD->p.x = x; GD->p.y = y; GD->p.x1 = x+count-1; GD->p.color = GD->t.color; GD->p.x = x; GD->p.y = y; GD->p.x1 = x+count-1; GD->p.color = GD->t.color;
hline_clip(GD); hline_clip(GD);
@ -2781,8 +2792,14 @@ void gdispGDrawBox(GDisplay *g, coord_t x, coord_t y, coord_t cx, coord_t cy, co
#else #else
static void drawcharline(int16_t x, int16_t y, uint8_t count, uint8_t alpha, void *state) { static void drawcharline(int16_t x, int16_t y, uint8_t count, uint8_t alpha, void *state) {
#define GD ((GDisplay *)state) #define GD ((GDisplay *)state)
if (y < GD->t.clipy0 || y >= GD->t.clipy1) if (y < GD->t.clipy0 || y >= GD->t.clipy1 || x+count <= GD->t.clipx0 || x >= GD->t.clipx1)
return; return;
if (x < GD->t.clipx0) {
count -= GD->t.clipx0 - x;
x = GD->t.clipx0;
}
if (x+count > GD->t.clipx1)
count = GD->t.clipx1 - x;
if (alpha > 0x80) { // A best approximation when using anti-aliased fonts but we can't actually draw them anti-aliased if (alpha > 0x80) { // A best approximation when using anti-aliased fonts but we can't actually draw them anti-aliased
GD->p.x = x; GD->p.y = y; GD->p.x1 = x+count-1; GD->p.color = GD->t.color; GD->p.x = x; GD->p.y = y; GD->p.x1 = x+count-1; GD->p.color = GD->t.color;
hline_clip(GD); hline_clip(GD);
@ -2794,8 +2811,14 @@ void gdispGDrawBox(GDisplay *g, coord_t x, coord_t y, coord_t cx, coord_t cy, co
#if GDISP_NEED_ANTIALIAS #if GDISP_NEED_ANTIALIAS
static void fillcharline(int16_t x, int16_t y, uint8_t count, uint8_t alpha, void *state) { static void fillcharline(int16_t x, int16_t y, uint8_t count, uint8_t alpha, void *state) {
#define GD ((GDisplay *)state) #define GD ((GDisplay *)state)
if (y < GD->t.clipy0 || y >= GD->t.clipy1) if (y < GD->t.clipy0 || y >= GD->t.clipy1 || x+count <= GD->t.clipx0 || x >= GD->t.clipx1)
return; return;
if (x < GD->t.clipx0) {
count -= GD->t.clipx0 - x;
x = GD->t.clipx0;
}
if (x+count > GD->t.clipx1)
count = GD->t.clipx1 - x;
if (alpha == 255) { if (alpha == 255) {
GD->p.color = GD->t.color; GD->p.color = GD->t.color;
} else { } else {

8
src/gevent/gevent.c
View file

@ -46,10 +46,16 @@ static void deleteAssignments(GListener *pl, GSourceHandle gsh) {
} }
} }
void _geventInit(void) { void _geventInit(void)
{
gfxMutexInit(&geventMutex); gfxMutexInit(&geventMutex);
} }
void _geventDeinit(void)
{
gfxMutexDestroy(&geventMutex);
}
void geventListenerInit(GListener *pl) { void geventListenerInit(GListener *pl) {
gfxSemInit(&pl->waitqueue, 0, MAX_SEMAPHORE_COUNT); // Next wait'er will block gfxSemInit(&pl->waitqueue, 0, MAX_SEMAPHORE_COUNT); // Next wait'er will block
gfxSemInit(&pl->eventlock, 1, 1); // Only one thread at a time looking at the event buffer gfxSemInit(&pl->eventlock, 1, 1); // Only one thread at a time looking at the event buffer

58
src/gfx.c
View file

@ -15,47 +15,57 @@
#include "gfx.h" #include "gfx.h"
void DEPRECATED("Use gfxInit() instead") gdispInit() { gfxInit(); } static bool_t initDone = FALSE;
/* These init functions are defined by each module but not published */ /* These init functions are defined by each module but not published */
extern void _gosInit(void); extern void _gosInit(void);
extern void _gosDeinit(void);
#if GFX_USE_GDISP #if GFX_USE_GDISP
extern void _gdispInit(void); extern void _gdispInit(void);
extern void _gdispDeinit(void);
#endif #endif
#if GFX_USE_GWIN #if GFX_USE_GWIN
extern void _gwinInit(void); extern void _gwinInit(void);
extern void _gwinDeinit(void);
#endif #endif
#if GFX_USE_GEVENT #if GFX_USE_GEVENT
extern void _geventInit(void); extern void _geventInit(void);
extern void _geventDeinit(void);
#endif #endif
#if GFX_USE_GTIMER #if GFX_USE_GTIMER
extern void _gtimerInit(void); extern void _gtimerInit(void);
extern void _gtimerDeinit(void);
#endif #endif
#if GFX_USE_GINPUT #if GFX_USE_GINPUT
extern void _ginputInit(void); extern void _ginputInit(void);
extern void _ginputDeinit(void);
#endif #endif
#if GFX_USE_GADC #if GFX_USE_GADC
extern void _gadcInit(void); extern void _gadcInit(void);
extern void _gadcDeinit(void);
#endif #endif
#if GFX_USE_GAUDIN #if GFX_USE_GAUDIN
extern void _gaudinInit(void); extern void _gaudinInit(void);
extern void _gaudinDeinit(void);
#endif #endif
#if GFX_USE_GAUDOUT #if GFX_USE_GAUDOUT
extern void _gaudoutInit(void); extern void _gaudoutInit(void);
extern void _gaudoutDeinit(void);
#endif #endif
#if GFX_USE_GMISC #if GFX_USE_GMISC
extern void _gmiscInit(void); extern void _gmiscInit(void);
extern void _gmiscDeinit(void);
#endif #endif
void gfxInit(void) { void gfxInit(void)
static bool_t initDone = FALSE; {
/* Ensure we only initialise once */ /* Ensure we only initialise once */
if (initDone) if (initDone)
return; return;
initDone = TRUE; initDone = TRUE;
/* These must be initialised in the order of their dependancies */ // These must be initialised in the order of their dependancies
_gosInit(); _gosInit();
#if GFX_USE_GMISC #if GFX_USE_GMISC
_gmiscInit(); _gmiscInit();
@ -85,3 +95,41 @@ void gfxInit(void) {
_gaudoutInit(); _gaudoutInit();
#endif #endif
} }
void gfxDeinit(void)
{
if (!initDone)
return;
initDone = FALSE;
// We deinitialise the opposite way as we initialised
#if GFX_USE_GAUDOUT
_gaudoutDeinit();
#endif
#if GFX_USE_GAUDIN
_gaoudinDeinit();
#endif
#if GFX_USE_GADC
_gadcDeinit();
#endif
#if GFX_USE_GINPUT
_ginputDeinit();
#endif
#if GFX_USE_GWIN
_gwinDeinit();
#endif
#if GFX_USE_GDISP
_gdispDeinit();
#endif
#if GFX_USE_GTIMER
_gtimerDeinit();
#endif
#if GFX_USE_GEVENT
_geventDeinit();
#endif
#if GFX_USE_GMISC
_gmiscInit();
#endif
_gosDeinit();
}

12
src/ginput/ginput.c
View file

@ -16,11 +16,21 @@
#if GFX_USE_GINPUT #if GFX_USE_GINPUT
void _ginputInit(void)
{
/* ToDo */
/** /**
* This should really call an init routine for each ginput sub-system. * This should really call an init routine for each ginput sub-system.
* Maybe we'll do this later. * Maybe we'll do this later.
*/ */
void _ginputInit(void) {} }
void _ginputDeinit(void)
{
}
#endif /* GFX_USE_GINPUT */ #endif /* GFX_USE_GINPUT */
/** @} */ /** @} */

9
src/gmisc/gmisc.c
View file

@ -14,7 +14,14 @@
#if GFX_USE_GMISC #if GFX_USE_GMISC
void _gmiscInit(void) { void _gmiscInit(void)
{
}
void _gmiscDeinit(void)
{
} }
#endif /* GFX_USE_GMISC */ #endif /* GFX_USE_GMISC */

9
src/gos/chibios.c
View file

@ -22,8 +22,8 @@
#error "GOS: CH_USE_SEMAPHORES must be defined in chconf.h" #error "GOS: CH_USE_SEMAPHORES must be defined in chconf.h"
#endif #endif
/* Our module initialiser */ void _gosInit(void)
void _gosInit(void) { {
/* Don't initialise if the user already has */ /* Don't initialise if the user already has */
if (!chThdSelf()) { if (!chThdSelf()) {
halInit(); halInit();
@ -31,6 +31,11 @@ void _gosInit(void) {
} }
} }
void _gosDeinit(void)
{
/* ToDo */
}
void *gfxRealloc(void *ptr, size_t oldsz, size_t newsz) { void *gfxRealloc(void *ptr, size_t oldsz, size_t newsz) {
void *np; void *np;

8
src/gos/linux.c
View file

@ -20,10 +20,16 @@
static gfxMutex SystemMutex; static gfxMutex SystemMutex;
void _gosInit(void) { void _gosInit(void)
{
gfxMutexInit(&SystemMutex); gfxMutexInit(&SystemMutex);
} }
void _gosDeinit(void)
{
/* ToDo */
}
void gfxSystemLock(void) { void gfxSystemLock(void) {
gfxMutexEnter(&SystemMutex); gfxMutexEnter(&SystemMutex);
} }

8
src/gos/osx.c
View file

@ -37,10 +37,16 @@ void get_ticks(mach_timespec_t *mts){
} }
void _gosInit(void) { void _gosInit(void)
{
gfxMutexInit(&SystemMutex); gfxMutexInit(&SystemMutex);
} }
void _gosDeinit(void)
{
/* ToDo */
}
void gfxSystemLock(void) { void gfxSystemLock(void) {
gfxMutexEnter(&SystemMutex); gfxMutexEnter(&SystemMutex);
} }

10
src/gos/raw32.c
View file

@ -26,7 +26,8 @@ static void _gosThreadsInit(void);
* Initialise * Initialise
*********************************************************/ *********************************************************/
void _gosInit(void) { void _gosInit(void)
{
// Set up the heap allocator // Set up the heap allocator
_gosHeapInit(); _gosHeapInit();
@ -34,6 +35,11 @@ void _gosInit(void) {
_gosThreadsInit(); _gosThreadsInit();
} }
void _gosDeinit(void)
{
/* ToDo */
}
/********************************************************* /*********************************************************
* For WIn32 emulation - automatically add the tick functions * For WIn32 emulation - automatically add the tick functions
* the user would normally have to provide for bare metal. * the user would normally have to provide for bare metal.
@ -542,7 +548,7 @@ static void _gosThreadsInit(void) {
char * framebase; char * framebase;
// Allocate a buffer to store our test data // Allocate a buffer to store our test data
pframeinfo = (saveloc *)gfxAlloc(sizeof(saveloc)*2); pframeinfo = gfxAlloc(sizeof(saveloc)*2);
// Get details of the stack frame from within a function // Get details of the stack frame from within a function
get_stack_state_in_fn(); get_stack_state_in_fn();

8
src/gos/win32.c
View file

@ -17,7 +17,13 @@
static HANDLE SystemMutex; static HANDLE SystemMutex;
void _gosInit(void) { void _gosInit(void)
{
}
void _gosDeinit(void)
{
} }

18
src/gtimer/gtimer.c
View file

@ -118,15 +118,29 @@ static DECLARE_THREAD_FUNCTION(GTimerThreadHandler, arg) {
return 0; return 0;
} }
void _gtimerInit(void) { void _gtimerInit(void)
{
gfxSemInit(&waitsem, 0, 1); gfxSemInit(&waitsem, 0, 1);
gfxMutexInit(&mutex); gfxMutexInit(&mutex);
} }
void gtimerInit(GTimer *pt) { void _gtimerDeinit(void)
{
gfxSemDestroy(&waitsem);
gfxMutexDestroy(&mutex);
// Need to destroy GTimer thread here
}
void gtimerInit(GTimer* pt)
{
pt->flags = 0; pt->flags = 0;
} }
void gtimerDeinit(GTimer* pt)
{
gtimerStop(pt);
}
void gtimerStart(GTimer *pt, GTimerFunction fn, void *param, bool_t periodic, delaytime_t millisec) { void gtimerStart(GTimer *pt, GTimerFunction fn, void *param, bool_t periodic, delaytime_t millisec) {
gfxMutexEnter(&mutex); gfxMutexEnter(&mutex);

2
src/gwin/console.c
View file

@ -285,7 +285,7 @@ GHandle gwinGConsoleCreate(GDisplay *g, GConsoleObject *gc, const GWindowInit *p
gcw->bufsize *= gh->height / gdispGetFontMetric(gh->font, fontHeight); gcw->bufsize *= gh->height / gdispGetFontMetric(gh->font, fontHeight);
// Allocate the buffer // Allocate the buffer
if (!(gcw->buffer = (char*)gfxAlloc(gcw->bufsize))) if (!(gcw->buffer = gfxAlloc(gcw->bufsize)))
return FALSE; return FALSE;
// All good! // All good!

10
src/gwin/gwidget.c
View file

@ -224,11 +224,17 @@ static void gwidgetEvent(void *param, GEvent *pe) {
} }
#endif #endif
void _gwidgetInit(void) { void _gwidgetInit(void)
{
geventListenerInit(&gl); geventListenerInit(&gl);
geventRegisterCallback(&gl, gwidgetEvent, 0); geventRegisterCallback(&gl, gwidgetEvent, 0);
} }
void _gwidgetDeinit(void)
{
/* ToDo */
}
GHandle _gwidgetCreate(GDisplay *g, GWidgetObject *pgw, const GWidgetInit *pInit, const gwidgetVMT *vmt) { GHandle _gwidgetCreate(GDisplay *g, GWidgetObject *pgw, const GWidgetInit *pInit, const gwidgetVMT *vmt) {
if (!(pgw = (GWidgetObject *)_gwindowCreate(g, &pgw->g, &pInit->g, &vmt->g, GWIN_FLG_WIDGET|GWIN_FLG_ENABLED))) if (!(pgw = (GWidgetObject *)_gwindowCreate(g, &pgw->g, &pInit->g, &vmt->g, GWIN_FLG_WIDGET|GWIN_FLG_ENABLED)))
return 0; return 0;
@ -338,7 +344,7 @@ void gwinSetText(GHandle gh, const char *text, bool_t useAlloc) {
else if (useAlloc) { else if (useAlloc) {
char *str; char *str;
if ((str = (char *)gfxAlloc(strlen(text)+1))) { if ((str = gfxAlloc(strlen(text)+1))) {
gh->flags |= GWIN_FLG_ALLOCTXT; gh->flags |= GWIN_FLG_ALLOCTXT;
strcpy(str, text); strcpy(str, text);
} }

21
src/gwin/gwin.c
View file

@ -84,7 +84,8 @@ static color_t defaultBgColor = Black;
* Class Routines * Class Routines
*-----------------------------------------------*/ *-----------------------------------------------*/
void _gwinInit(void) { void _gwinInit(void)
{
#if GWIN_NEED_WIDGET #if GWIN_NEED_WIDGET
extern void _gwidgetInit(void); extern void _gwidgetInit(void);
@ -97,12 +98,26 @@ void _gwinInit(void) {
#endif #endif
} }
void _gwinDeinit(void)
{
#if GWIN_NEED_WIDGET
extern void _gwidgetDeinit(void);
_gwidgetDeinit();
#endif
#if GWIN_NEED_WINDOWMANAGER
extern void _gwmDeinit(void);
_gwmDeinit();
#endif
}
// Internal routine for use by GWIN components only // Internal routine for use by GWIN components only
// Initialise a window creating it dynamically if required. // Initialise a window creating it dynamically if required.
GHandle _gwindowCreate(GDisplay *g, GWindowObject *pgw, const GWindowInit *pInit, const gwinVMT *vmt, uint16_t flags) { GHandle _gwindowCreate(GDisplay *g, GWindowObject *pgw, const GWindowInit *pInit, const gwinVMT *vmt, uint16_t flags) {
// Allocate the structure if necessary // Allocate the structure if necessary
if (!pgw) { if (!pgw) {
if (!(pgw = (GWindowObject *)gfxAlloc(vmt->size))) if (!(pgw = gfxAlloc(vmt->size)))
return 0; return 0;
pgw->flags = flags|GWIN_FLG_DYNAMIC; pgw->flags = flags|GWIN_FLG_DYNAMIC;
} else } else
@ -167,7 +182,9 @@ color_t gwinGetDefaultBgColor(void) {
GHandle gwinGWindowCreate(GDisplay *g, GWindowObject *pgw, const GWindowInit *pInit) { GHandle gwinGWindowCreate(GDisplay *g, GWindowObject *pgw, const GWindowInit *pInit) {
if (!(pgw = _gwindowCreate(g, pgw, pInit, &basegwinVMT, 0))) if (!(pgw = _gwindowCreate(g, pgw, pInit, &basegwinVMT, 0)))
return 0; return 0;
gwinSetVisible(pgw, pInit->show); gwinSetVisible(pgw, pInit->show);
return pgw; return pgw;
} }

8
src/gwin/gwm.c
View file

@ -60,7 +60,8 @@ GWindowManager * _GWINwm;
* Window Routines * Window Routines
*-----------------------------------------------*/ *-----------------------------------------------*/
void _gwmInit(void) { void _gwmInit(void)
{
gfxQueueASyncInit(&_GWINList); gfxQueueASyncInit(&_GWINList);
_GWINwm = (GWindowManager *)&GNullWindowManager; _GWINwm = (GWindowManager *)&GNullWindowManager;
_GWINwm->vmt->Init(); _GWINwm->vmt->Init();
@ -70,6 +71,11 @@ void _gwmInit(void) {
#endif #endif
} }
void _gwmDeinit(void)
{
/* ToDo */
}
void gwinSetWindowManager(struct GWindowManager *gwm) { void gwinSetWindowManager(struct GWindowManager *gwm) {
if (!gwm) if (!gwm)
gwm = (GWindowManager *)&GNullWindowManager; gwm = (GWindowManager *)&GNullWindowManager;

7
src/gwin/list.c
View file

@ -431,13 +431,14 @@ int gwinListAddItem(GHandle gh, const char* item_name, bool_t useAlloc) {
ListItem *newItem; ListItem *newItem;
if (useAlloc) { if (useAlloc) {
if (!(newItem = (ListItem *)gfxAlloc(sizeof(ListItem)+strlen(item_name)+1))) size_t len = strlen(item_name)+1;
if (!(newItem = gfxAlloc(sizeof(ListItem) + len)))
return -1; return -1;
strcpy((char *)(newItem+1), item_name); memcpy((char *)(newItem+1), item_name, len);
item_name = (const char *)(newItem+1); item_name = (const char *)(newItem+1);
} else { } else {
if (!(newItem = (ListItem *)gfxAlloc(sizeof(ListItem)))) if (!(newItem = gfxAlloc(sizeof(ListItem))))
return -1; return -1;
} }