removed GDISP_LLD() macro

6 files changed, 0 insertions, 2121 deletions

diff --git a/include/gdisp/fonts.h b/include/gdisp/fonts.h
deleted file mode 100644
index f92f1b81..00000000
--- a/include/gdisp/fonts.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/*

-    ChibiOS/GFX - Copyright (C) 2012

-                 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/gdisp/fonts.h

- * @brief   GDISP internal font definitions.

- * @details	This is not generally needed by an application. It is used

- * 			by the low level drivers that need to understand a font.

- *

- * @addtogroup GDISP

- * @{

- */

-

-#ifndef _GDISP_FONTS_H

-#define _GDISP_FONTS_H

-

-/* Don't test against GFX_USE_GDISP as we may want to use this in other non-GDISP utilities. */

-

-/**

- * @brief   The type of a font column.

- * @note	Set by defining @p GDISP_MAX_FNT_HEIGHT appropriately.

- */

-#if GDISP_MAX_FONT_HEIGHT == 16

-	typedef uint16_t	fontcolumn_t;

-#elif GDISP_MAX_FONT_HEIGHT == 32

-	typedef uint32_t	fontcolumn_t;

-#else

-	#error "GDISP: GDISP_MAX_FONT_HEIGHT must be either 16 or 32"

-#endif

-

-/**

- * @brief   Internal font structure.

- * @note	This structure is followed by:

- *				1. An array of character widths (uint8_t)

- *				2. An array of column data offsets (relative to the font structure)

- *				3. Each characters array of column data (fontcolumn_t)

- *			Each sub-structure must be padded to a multiple of 8 bytes

- *			to allow the tables to work across many different compilers.

- */

-struct font {

-	const char *		name;

-	uint8_t				height;

-	uint8_t				charPadding;

-	uint8_t				lineSpacing;

-	uint8_t				descenderHeight;

-	uint8_t				minWidth;

-	uint8_t				maxWidth;

-	char				minChar;

-	char				maxChar;

-	uint8_t				xscale;

-	uint8_t				yscale;

-	const uint8_t		*widthTable;

-	const uint16_t      *offsetTable;

-	const fontcolumn_t  *dataTable;

-};

-

-#define _getCharWidth(f,c)		(((c) < (f)->minChar || (c) > (f)->maxChar) ? 0 : (f)->widthTable[(c) - (f)->minChar])

-#define _getCharOffset(f,c)		((f)->offsetTable[(c) - (f)->minChar])

-#define _getCharData(f,c)		(&(f)->dataTable[_getCharOffset(f, c)])

-

-#endif /* _GDISP_FONTS_H */

-/** @} */

-

diff --git a/include/gdisp/gdisp.h b/include/gdisp/gdisp.h
deleted file mode 100644
index da6d859f..00000000
--- a/include/gdisp/gdisp.h
+++ /dev/null
@@ -1,291 +0,0 @@
-/*

-    ChibiOS/GFX - Copyright (C) 2012

-                 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/gdisp/gdisp.h

- * @brief   GDISP Graphic Driver subsystem header file.

- *

- * @addtogroup GDISP

- *

- * @details		The GDISP module provides high level abstraction to interface pixel oriented graphic displays.

- *

- * @pre			GFX_USE_GDISP must be set to TRUE in gfxconf.h

- *

- * @{

- */

-

-#ifndef _GDISP_H

-#define _GDISP_H

-

-#include "gfx.h"

-

-/* This type definition is defined here as it gets used in other gfx sub-systems even

- * if GFX_USE_GDISP is FALSE.

- */

-

-/**

- * @brief   The type for a coordinate or length on the screen.

- */

-typedef int16_t	coord_t;

-

-#if GFX_USE_GDISP || defined(__DOXYGEN__)

-

-/*===========================================================================*/

-/* Driver constants.														 */

-/*===========================================================================*/

-

-/**

- * @name   Some basic colors

- * @{

- */

-#define White			HTML2COLOR(0xFFFFFF)

-#define Black			HTML2COLOR(0x000000)

-#define Gray			HTML2COLOR(0x808080)

-#define Grey			Gray

-#define Blue			HTML2COLOR(0x0000FF)

-#define Red				HTML2COLOR(0xFF0000)

-#define Fuchsia			HTML2COLOR(0xFF00FF)

-#define Magenta			Fuchsia

-#define Green			HTML2COLOR(0x008000)

-#define Yellow			HTML2COLOR(0xFFFF00)

-#define Aqua			HTML2COLOR(0x00FFFF)

-#define Cyan			Aqua

-#define Lime			HTML2COLOR(0x00FF00)

-#define Maroon			HTML2COLOR(0x800000)

-#define Navy			HTML2COLOR(0x000080)

-#define Olive			HTML2COLOR(0x808000)

-#define Purple			HTML2COLOR(0x800080)

-#define Silver			HTML2COLOR(0xC0C0C0)

-#define Teal			HTML2COLOR(0x008080)

-#define Orange			HTML2COLOR(0xFFA500)

-#define Pink			HTML2COLOR(0xFFC0CB)

-#define SkyBlue			HTML2COLOR(0x87CEEB)

-/** @} */

-

-/*===========================================================================*/

-/* Low Level Driver details and error checks.                                */

-/*===========================================================================*/

-

-/* Include the low level driver information */

-#include "gdisp/lld/gdisp_lld.h"

-

-/*===========================================================================*/

-/* Type definitions                                                          */

-/*===========================================================================*/

-

-/**

- * @brief   Type for the text justification.

- */

-typedef enum justify {justifyLeft, justifyCenter, justifyRight} justify_t;

-/**

- * @brief   Type for the font metric.

- */

-typedef enum fontmetric {fontHeight, fontDescendersHeight, fontLineSpacing, fontCharPadding, fontMinWidth, fontMaxWidth} fontmetric_t;

-

-/*===========================================================================*/

-/* External declarations.                                                    */

-/*===========================================================================*/

-

-#if (GDISP_NEED_TEXT && GDISP_OLD_FONT_DEFINITIONS) || defined(__DOXYGEN__)

-	#if GDISP_INCLUDE_FONT_SMALL

-		extern const struct font fontSmall;

-		extern const struct font fontSmallDouble;

-		extern const struct font fontSmallNarrow;

-	#endif

-	#if GDISP_INCLUDE_FONT_LARGER

-		extern const struct font fontLarger;

-		extern const struct font fontLargerDouble;

-		extern const struct font fontLargerNarrow;

-	#endif

-	#if GDISP_INCLUDE_FONT_UI1

-		extern const struct font fontUI1;

-		extern const struct font fontUI1Double;

-		extern const struct font fontUI1Narrow;

-	#endif

-	#if GDISP_INCLUDE_FONT_UI2

-		extern const struct font fontUI2;

-		extern const struct font fontUI2Double;

-		extern const struct font fontUI2Narrow;

-	#endif

-	#if GDISP_INCLUDE_FONT_LARGENUMBERS

-		extern const struct font fontLargeNumbers;

-		extern const struct font fontLargeNumbersDouble;

-		extern const struct font fontLargeNumbersNarrow;

-	#endif

-#endif

-

-#ifdef __cplusplus

-extern "C" {

-#endif

-

-#if GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC

-	/* These routines can be hardware accelerated

-	 *	- Do not add a routine here unless it has also been added to the hardware acceleration layer

-	 */

-

-	/* Base Functions */

-	bool_t gdispInit(void);

-	bool_t gdispIsBusy(void);

-

-	/* Drawing Functions */

-	void gdispClear(color_t color);

-	void gdispDrawPixel(coord_t x, coord_t y, color_t color);

-	void gdispDrawLine(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color);

-	void gdispFillArea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);

-	void gdispBlitAreaEx(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer);

-

-	/* Clipping Functions */

-	#if GDISP_NEED_CLIP

-	void gdispSetClip(coord_t x, coord_t y, coord_t cx, coord_t cy);

-	#endif

-

-	/* Circle Functions */

-	#if GDISP_NEED_CIRCLE

-	void gdispDrawCircle(coord_t x, coord_t y, coord_t radius, color_t color);

-	void gdispFillCircle(coord_t x, coord_t y, coord_t radius, color_t color);

-	#endif

-	

-	/* Ellipse Functions */

-	#if GDISP_NEED_ELLIPSE

-	void gdispDrawEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);

-	void gdispFillEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);

-	#endif

-

-	/* Arc Functions */

-	#if GDISP_NEED_ARC

-	void gdispDrawArc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);

-	void gdispFillArc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);

-	#endif

-

-	/* Basic Text Rendering Functions */

-	#if GDISP_NEED_TEXT

-	void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color);

-	void gdispFillChar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor);

-	#endif

-	

-	/* Read a pixel Function */

-	#if GDISP_NEED_PIXELREAD

-	color_t gdispGetPixelColor(coord_t x, coord_t y);

-	#endif

-

-	/* Scrolling Function - clears the area scrolled out */

-	#if GDISP_NEED_SCROLL

-	void gdispVerticalScroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor);

-	#endif

-

-	/* Set driver specific control */

-	#if GDISP_NEED_CONTROL

-	void gdispControl(unsigned what, void *value);

-	#endif

-

-	/* Query driver specific data */

-	void *gdispQuery(unsigned what);

-

-#else

-

-	/* The same as above but use the low level driver directly if no multi-thread support is needed */

-	#define gdispInit(gdisp)									GDISP_LLD(init)()

-	#define gdispIsBusy()										FALSE

-	#define gdispClear(color)									GDISP_LLD(clear)(color)

-	#define gdispDrawPixel(x, y, color)							GDISP_LLD(drawpixel)(x, y, color)

-	#define gdispDrawLine(x0, y0, x1, y1, color)				GDISP_LLD(drawline)(x0, y0, x1, y1, color)

-	#define gdispFillArea(x, y, cx, cy, color)					GDISP_LLD(fillarea)(x, y, cx, cy, color)

-	#define gdispBlitAreaEx(x, y, cx, cy, sx, sy, scx, buf)		GDISP_LLD(blitareaex)(x, y, cx, cy, sx, sy, scx, buf)

-	#define gdispSetClip(x, y, cx, cy)							GDISP_LLD(setclip)(x, y, cx, cy)

-	#define gdispDrawCircle(x, y, radius, color)				GDISP_LLD(drawcircle)(x, y, radius, color)

-	#define gdispFillCircle(x, y, radius, color)				GDISP_LLD(fillcircle)(x, y, radius, color)

-	#define gdispDrawArc(x, y, radius, sangle, eangle, color)	GDISP_LLD(drawarc)(x, y, radius, sangle, eangle, color)

-	#define gdispFillArc(x, y, radius, sangle, eangle, color)	GDISP_LLD(fillarc)(x, y, radius, sangle, eangle, color)

-	#define gdispDrawEllipse(x, y, a, b, color)					GDISP_LLD(drawellipse)(x, y, a, b, color)

-	#define gdispFillEllipse(x, y, a, b, color)					GDISP_LLD(fillellipse)(x, y, a, b, color)

-	#define gdispDrawChar(x, y, c, font, color)					GDISP_LLD(drawchar)(x, y, c, font, color)

-	#define gdispFillChar(x, y, c, font, color, bgcolor)		GDISP_LLD(fillchar)(x, y, c, font, color, bgcolor)

-	#define gdispGetPixelColor(x, y)							GDISP_LLD(getpixelcolor)(x, y)

-	#define gdispVerticalScroll(x, y, cx, cy, lines, bgcolor)	GDISP_LLD(verticalscroll)(x, y, cx, cy, lines, bgcolor)

-	#define gdispControl(what, value)							GDISP_LLD(control)(what, value)

-	#define gdispQuery(what)									GDISP_LLD(query)(what)

-

-#endif

-

-/* These routines are not hardware accelerated

- *	- Do not add a hardware accelerated routines here.

- */

-

-/* Extra drawing functions */

-void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);

-

-/* Extra Text Functions */

-#if GDISP_NEED_TEXT

-	void gdispDrawString(coord_t x, coord_t y, const char *str, font_t font, color_t color);

-	void gdispFillString(coord_t x, coord_t y, const char *str, font_t font, color_t color, color_t bgcolor);

-	void gdispDrawStringBox(coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, font_t font, color_t color, justify_t justify);

-	void gdispFillStringBox(coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, font_t font, color_t color, color_t bgColor, justify_t justify);

-	coord_t gdispGetFontMetric(font_t font, fontmetric_t metric);

-	coord_t gdispGetCharWidth(char c, font_t font);

-	coord_t gdispGetStringWidth(const char* str, font_t font);

-	font_t gdispOpenFont(const char *name);

-	void gdispCloseFont(font_t font);

-	const char *gdispGetFontName(font_t font);

-#endif

-

-/* Extra Arc Functions */

-#if GDISP_NEED_ARC

-	void gdispDrawRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t radius, color_t color);

-	void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t radius, color_t color);

-#endif

-

-/* Support routine for packed pixel formats */

-#ifndef gdispPackPixels

-	void gdispPackPixels(const pixel_t *buf, coord_t cx, coord_t x, coord_t y, color_t color);

-#endif

-

-/* 

- * Macro definitions

- */

-

-/* Now obsolete functions */

-#define gdispBlitArea(x, y, cx, cy, buffer)		gdispBlitAreaEx(x, y, cx, cy, 0, 0, cx, buffer)

-

-/* Macro definitions for common gets and sets */

-#define gdispSetPowerMode(powerMode)			gdispControl(GDISP_CONTROL_POWER, (void *)(unsigned)(powerMode))

-#define gdispSetOrientation(newOrientation)		gdispControl(GDISP_CONTROL_ORIENTATION, (void *)(unsigned)(newOrientation))

-#define gdispSetBacklight(percent)				gdispControl(GDISP_CONTROL_BACKLIGHT, (void *)(unsigned)(percent))

-#define gdispSetContrast(percent)				gdispControl(GDISP_CONTROL_CONTRAST, (void *)(unsigned)(percent))

-

-#define gdispGetWidth()							((coord_t)(unsigned)gdispQuery(GDISP_QUERY_WIDTH))

-#define gdispGetHeight()						((coord_t)(unsigned)gdispQuery(GDISP_QUERY_HEIGHT))

-#define gdispGetPowerMode()						((gdisp_powermode_t)(unsigned)gdispQuery(GDISP_QUERY_POWER))

-#define gdispGetOrientation()					((gdisp_orientation_t)(unsigned)gdispQuery(GDISP_QUERY_ORIENTATION))

-#define gdispGetBacklight()						((coord_t)(unsigned)gdispQuery(GDISP_QUERY_BACKLIGHT))

-#define gdispGetContrast()						((coord_t)(unsigned)gdispQuery(GDISP_QUERY_CONTRAST))

-

-/* More interesting macro's */

-#define gdispUnsetClip()						gdispSetClip(0,0,gdispGetWidth(),gdispGetHeight())

-

-

-#ifdef __cplusplus

-}

-#endif

-

-#endif /* GFX_USE_GDISP */

-

-#endif /* _GDISP_H */

-/** @} */

-

diff --git a/include/gdisp/lld/emulation.c b/include/gdisp/lld/emulation.c
deleted file mode 100644
index a514458c..00000000
--- a/include/gdisp/lld/emulation.c
+++ /dev/null
@@ -1,772 +0,0 @@
-/*

-    ChibiOS/GFX - Copyright (C) 2012

-                 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/gdisp/lld/emulation.c

- * @brief	GDISP emulation routines for stuff the driver dosen't support

- *

- * @addtogroup GDISP

- *

- * @details	Even though this is a software emulation of a low level driver

- *			most validation doesn't need to happen here as eventually

- *			we call a real low level driver routine and if validation is

- *			required - it will do it.

- *

- * @{

- */

-#ifndef GDISP_EMULATION_C

-#define GDISP_EMULATION_C

-

-#if GFX_USE_GDISP /*|| defined(__DOXYGEN__) */

-

-#ifndef GDISP_LLD_NO_STRUCT

-	static struct GDISPDriver {

-		coord_t				Width;

-		coord_t				Height;

-		gdisp_orientation_t	Orientation;

-		gdisp_powermode_t	Powermode;

-		uint8_t				Backlight;

-		uint8_t				Contrast;

-		#if GDISP_NEED_CLIP || GDISP_NEED_VALIDATION

-			coord_t				clipx0, clipy0;

-			coord_t				clipx1, clipy1;		/* not inclusive */

-		#endif

-		} GDISP;

-#endif

-

-#if !GDISP_HARDWARE_CLEARS 

-	void GDISP_LLD(clear)(color_t color) {

-		GDISP_LLD(fillarea)(0, 0, GDISP.Width, GDISP.Height, color);

-	}

-#endif

-

-#if !GDISP_HARDWARE_LINES 

-	void GDISP_LLD(drawline)(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {

-		int16_t dy, dx;

-		int16_t addx, addy;

-		int16_t P, diff, i;

-

-		#if GDISP_HARDWARE_FILLS || GDISP_HARDWARE_SCROLL

-		// speed improvement if vertical or horizontal

-		if (x0 == x1) {

-			if (y1 > y0)

-				GDISP_LLD(fillarea)(x0, y0, 1, y1-y0+1, color);

-			else

-				GDISP_LLD(fillarea)(x0, y1, 1, y0-y1+1, color);

-			return;

-		}

-		if (y0 == y1) {

-			if (x1 > x0)

-				GDISP_LLD(fillarea)(x0, y0, x1-x0+1, 1, color);

-			else

-				GDISP_LLD(fillarea)(x0, y1, x0-x1+1, 1, color);

-			return;

-		}

-		#endif

-

-		if (x1 >= x0) {

-			dx = x1 - x0;

-			addx = 1;

-		} else {

-			dx = x0 - x1;

-			addx = -1;

-		}

-		if (y1 >= y0) {

-			dy = y1 - y0;

-			addy = 1;

-		} else {

-			dy = y0 - y1;

-			addy = -1;

-		}

-

-		if (dx >= dy) {

-			dy *= 2;

-			P = dy - dx;

-			diff = P - dx;

-

-			for(i=0; i<=dx; ++i) {

-				GDISP_LLD(drawpixel)(x0, y0, color);

-				if (P < 0) {

-					P  += dy;

-					x0 += addx;

-				} else {

-					P  += diff;

-					x0 += addx;

-					y0 += addy;

-				}

-			}

-		} else {

-			dx *= 2;

-			P = dx - dy;

-			diff = P - dy;

-

-			for(i=0; i<=dy; ++i) {

-				GDISP_LLD(drawpixel)(x0, y0, color);

-				if (P < 0) {

-					P  += dx;

-					y0 += addy;

-				} else {

-					P  += diff;

-					x0 += addx;

-					y0 += addy;

-				}

-			}

-		}

-	}

-#endif

-

-#if !GDISP_HARDWARE_FILLS

-	void GDISP_LLD(fillarea)(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {

-		#if GDISP_HARDWARE_SCROLL

-			GDISP_LLD(verticalscroll)(x, y, cx, cy, cy, color);

-		#elif GDISP_HARDWARE_LINES

-			coord_t x1, y1;

-			

-			x1 = x + cx - 1;

-			y1 = y + cy;

-			for(; y < y1; y++)

-				GDISP_LLD(drawline)(x, y, x1, y, color);

-		#else

-			coord_t x0, x1, y1;

-			

-			x0 = x;

-			x1 = x + cx;

-			y1 = y + cy;

-			for(; y < y1; y++)

-				for(x = x0; x < x1; x++)

-					GDISP_LLD(drawpixel)(x, y, color);

-		#endif

-	}

-#endif

-

-#if !GDISP_HARDWARE_BITFILLS

-	void GDISP_LLD(blitareaex)(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {

-			coord_t x0, x1, y1;

-			

-			x0 = x;

-			x1 = x + cx;

-			y1 = y + cy;

-			buffer += srcy*srccx+srcx;

-			srccx -= cx;

-			for(; y < y1; y++, buffer += srccx)

-				for(x=x0; x < x1; x++)

-					GDISP_LLD(drawpixel)(x, y, *buffer++);

-	}

-#endif

-

-#if GDISP_NEED_CLIP && !GDISP_HARDWARE_CLIP

-	void GDISP_LLD(setclip)(coord_t x, coord_t y, coord_t cx, coord_t cy) {

-		#if GDISP_NEED_VALIDATION

-			if (x >= GDISP.Width || y >= GDISP.Height || cx < 0 || cy < 0)

-				return;

-			if (x < 0) x = 0;

-			if (y < 0) y = 0;

-			if (x+cx > GDISP.Width) cx = GDISP.Width - x;

-			if (y+cy > GDISP.Height) cy = GDISP.Height - y;

-		#endif

-		GDISP.clipx0 = x;

-		GDISP.clipy0 = y;

-		GDISP.clipx1 = x+cx;

-		GDISP.clipy1 = y+cy;

-	}

-#endif

-

-#if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLES

-	void GDISP_LLD(drawcircle)(coord_t x, coord_t y, coord_t radius, color_t color) {

-		coord_t a, b, P;

-

-		a = 0;

-		b = radius;

-		P = 1 - radius;

-

-		do {

-			GDISP_LLD(drawpixel)(x+a, y+b, color);

-			GDISP_LLD(drawpixel)(x+b, y+a, color);

-			GDISP_LLD(drawpixel)(x-a, y+b, color);

-			GDISP_LLD(drawpixel)(x-b, y+a, color);

-			GDISP_LLD(drawpixel)(x+b, y-a, color);

-			GDISP_LLD(drawpixel)(x+a, y-b, color);

-			GDISP_LLD(drawpixel)(x-a, y-b, color);

-			GDISP_LLD(drawpixel)(x-b, y-a, color);

-			if (P < 0)

-				P += 3 + 2*a++;

-			else

-				P += 5 + 2*(a++ - b--);

-		} while(a <= b);

-	}

-#endif

-

-#if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLEFILLS

-	void GDISP_LLD(fillcircle)(coord_t x, coord_t y, coord_t radius, color_t color) {

-		coord_t a, b, P;

-		

-		a = 0;

-		b = radius;

-		P = 1 - radius;

-

-		do {

-			GDISP_LLD(drawline)(x-a, y+b, x+a, y+b, color);

-			GDISP_LLD(drawline)(x-a, y-b, x+a, y-b, color);

-			GDISP_LLD(drawline)(x-b, y+a, x+b, y+a, color);

-			GDISP_LLD(drawline)(x-b, y-a, x+b, y-a, color);

-			if (P < 0)

-				P += 3 + 2*a++;

-			else

-				P += 5 + 2*(a++ - b--);

-		} while(a <= b);

-	}

-#endif

-

-#if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSES

-	void GDISP_LLD(drawellipse)(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {

-		int  dx = 0, dy = b; /* im I. Quadranten von links oben nach rechts unten */

-		long a2 = a*a, b2 = b*b;

-		long err = b2-(2*b-1)*a2, e2; /* Fehler im 1. Schritt */

-

-		do {

-			GDISP_LLD(drawpixel)(x+dx, y+dy, color); /* I. Quadrant */

-			GDISP_LLD(drawpixel)(x-dx, y+dy, color); /* II. Quadrant */

-			GDISP_LLD(drawpixel)(x-dx, y-dy, color); /* III. Quadrant */

-			GDISP_LLD(drawpixel)(x+dx, y-dy, color); /* IV. Quadrant */

-

-			e2 = 2*err;

-			if(e2 <  (2*dx+1)*b2) {

-				dx++;

-				err += (2*dx+1)*b2;

-			}

-			if(e2 > -(2*dy-1)*a2) {

-				dy--;

-				err -= (2*dy-1)*a2;

-			}

-		} while(dy >= 0); 

-

-		while(dx++ < a) { /* fehlerhafter Abbruch bei flachen Ellipsen (b=1) */

-			GDISP_LLD(drawpixel)(x+dx, y, color); /* -> Spitze der Ellipse vollenden */

-			GDISP_LLD(drawpixel)(x-dx, y, color);

-	   }   

-	}

-#endif

-

-#if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSEFILLS

-	void GDISP_LLD(fillellipse)(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {

-		int  dx = 0, dy = b; /* im I. Quadranten von links oben nach rechts unten */

-		long a2 = a*a, b2 = b*b;

-		long err = b2-(2*b-1)*a2, e2; /* Fehler im 1. Schritt */

-

-		do {

-			GDISP_LLD(drawline)(x-dx,y+dy,x+dx,y+dy, color);

-			GDISP_LLD(drawline)(x-dx,y-dy,x+dx,y-dy, color);

-

-			e2 = 2*err;

-			if(e2 <  (2*dx+1)*b2) {

-				dx++;

-				err += (2*dx+1)*b2;

-			}

-			if(e2 > -(2*dy-1)*a2) {

-				dy--;

-				err -= (2*dy-1)*a2;

-			}

-		} while(dy >= 0); 

-

-		while(dx++ < a) { /* fehlerhafter Abbruch bei flachen Ellipsen (b=1) */

-			GDISP_LLD(drawpixel)(x+dx, y, color); /* -> Spitze der Ellipse vollenden */

-			GDISP_LLD(drawpixel)(x-dx, y, color);

-	   }   

-	}

-#endif

-

-#if GDISP_NEED_ARC && !GDISP_HARDWARE_ARCS

-

-	#include <math.h>

-

-	/*

-	 * @brief				Internal helper function for gdispDrawArc()

-	 *

-	 * @note				DO NOT USE DIRECTLY!

-	 *

-	 * @param[in] x, y		The middle point of the arc

-	 * @param[in] start		The start angle of the arc

-	 * @param[in] end		The end angle of the arc

-	 * @param[in] radius	The radius of the arc

-	 * @param[in] color		The color in which the arc will be drawn

-	 *

-	 * @notapi

-	 */

-	static void _draw_arc(coord_t x, coord_t y, uint16_t start, uint16_t end, uint16_t radius, color_t color) {

-	    if (/*start >= 0 && */start <= 180) {

-	        float x_maxI = x + radius*cos(start*M_PI/180);

-	        float x_minI;

-

-	        if (end > 180)

-	            x_minI = x - radius;

-	        else

-	            x_minI = x + radius*cos(end*M_PI/180);

-

-	        int a = 0;

-	        int b = radius;

-	        int P = 1 - radius;

-

-	        do {

-	            if(x-a <= x_maxI && x-a >= x_minI)

-	            	GDISP_LLD(drawpixel)(x-a, y-b, color);

-	            if(x+a <= x_maxI && x+a >= x_minI)

-	            	GDISP_LLD(drawpixel)(x+a, y-b, color);

-	            if(x-b <= x_maxI && x-b >= x_minI)

-	            	GDISP_LLD(drawpixel)(x-b, y-a, color);

-	            if(x+b <= x_maxI && x+b >= x_minI)

-	            	GDISP_LLD(drawpixel)(x+b, y-a, color);

-

-	            if (P < 0) {

-	                P = P + 3 + 2*a;

-	                a = a + 1;

-	            } else {

-	                P = P + 5 + 2*(a - b);

-	                a = a + 1;

-	                b = b - 1;

-	            }

-	        } while(a <= b);

-	    }

-

-	    if (end > 180 && end <= 360) {

-	        float x_maxII = x+radius*cos(end*M_PI/180);

-	        float x_minII;

-

-	        if(start <= 180)

-	            x_minII = x - radius;

-	        else

-	            x_minII = x+radius*cos(start*M_PI/180);

-

-	        int a = 0;

-	        int b = radius;

-	        int P = 1 - radius;

-

-	        do {

-	            if(x-a <= x_maxII && x-a >= x_minII)

-	            	GDISP_LLD(drawpixel)(x-a, y+b, color);

-	            if(x+a <= x_maxII && x+a >= x_minII)

-	            	GDISP_LLD(drawpixel)(x+a, y+b, color);

-	            if(x-b <= x_maxII && x-b >= x_minII)

-	            	GDISP_LLD(drawpixel)(x-b, y+a, color);

-	            if(x+b <= x_maxII && x+b >= x_minII)

-	            	GDISP_LLD(drawpixel)(x+b, y+a, color);

-

-	            if (P < 0) {

-	                P = P + 3 + 2*a;

-	                a = a + 1;

-	            } else {

-	                P = P + 5 + 2*(a - b);

-	                a = a + 1;

-	                b = b - 1;

-	            }

-	        } while (a <= b);

-	    }

-	}

-

-	void GDISP_LLD(drawarc)(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color) {

-		if(endangle < startangle) {

-	        _draw_arc(x, y, startangle, 360, radius, color);

-	        _draw_arc(x, y, 0, endangle, radius, color);

-	    } else {

-	        _draw_arc(x, y, startangle, endangle, radius, color);

-		}

-	}

-#endif

-

-#if GDISP_NEED_ARC && !GDISP_HARDWARE_ARCFILLS

-	/*

-	 * @brief				Internal helper function for gdispDrawArc()

-	 *

-	 * @note				DO NOT USE DIRECTLY!

-	 *

-	 * @param[in] x, y		The middle point of the arc

-	 * @param[in] start		The start angle of the arc

-	 * @param[in] end		The end angle of the arc

-	 * @param[in] radius	The radius of the arc

-	 * @param[in] color		The color in which the arc will be drawn

-	 *

-	 * @notapi

-	 */

-	static void _fill_arc(coord_t x, coord_t y, uint16_t start, uint16_t end, uint16_t radius, color_t color) {

-	    if (/*start >= 0 && */start <= 180) {

-	        float x_maxI = x + radius*cos(start*M_PI/180);

-	        float x_minI;

-

-	        if (end > 180)

-	            x_minI = x - radius;

-	        else

-	            x_minI = x + radius*cos(end*M_PI/180);

-

-	        int a = 0;

-	        int b = radius;

-	        int P = 1 - radius;

-

-	        do {

-	            if(x-a <= x_maxI && x-a >= x_minI)

-	            	GDISP_LLD(drawline)(x, y, x-a, y-b, color);

-	            if(x+a <= x_maxI && x+a >= x_minI)

-	            	GDISP_LLD(drawline)(x, y, x+a, y-b, color);

-	            if(x-b <= x_maxI && x-b >= x_minI)

-	            	GDISP_LLD(drawline)(x, y, x-b, y-a, color);

-	            if(x+b <= x_maxI && x+b >= x_minI)

-	            	GDISP_LLD(drawline)(x, y, x+b, y-a, color);

-

-	            if (P < 0) {

-	                P = P + 3 + 2*a;

-	                a = a + 1;

-	            } else {

-	                P = P + 5 + 2*(a - b);

-	                a = a + 1;

-	                b = b - 1;

-	            }

-	        } while(a <= b);

-	    }

-

-	    if (end > 180 && end <= 360) {

-	        float x_maxII = x+radius*cos(end*M_PI/180);

-	        float x_minII;

-

-	        if(start <= 180)

-	            x_minII = x - radius;

-	        else

-	            x_minII = x+radius*cos(start*M_PI/180);

-

-	        int a = 0;

-	        int b = radius;

-	        int P = 1 - radius;

-

-	        do {

-	            if(x-a <= x_maxII && x-a >= x_minII)

-	            	GDISP_LLD(drawline)(x, y, x-a, y+b, color);

-	            if(x+a <= x_maxII && x+a >= x_minII)

-	            	GDISP_LLD(drawline)(x, y, x+a, y+b, color);

-	            if(x-b <= x_maxII && x-b >= x_minII)

-	            	GDISP_LLD(drawline)(x, y, x-b, y+a, color);

-	            if(x+b <= x_maxII && x+b >= x_minII)

-	            	GDISP_LLD(drawline)(x, y, x+b, y+a, color);

-

-	            if (P < 0) {

-	                P = P + 3 + 2*a;

-	                a = a + 1;

-	            } else {

-	                P = P + 5 + 2*(a - b);

-	                a = a + 1;

-	                b = b - 1;

-	            }

-	        } while (a <= b);

-	    }

-	}

-

-	void GDISP_LLD(fillarc)(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color) {

-		if(endangle < startangle) {

-	        _fill_arc(x, y, startangle, 360, radius, color);

-	        _fill_arc(x, y, 0, endangle, radius, color);

-	    } else {

-	        _fill_arc(x, y, startangle, endangle, radius, color);

-		}

-	}

-#endif

-

-#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXT

-	#include "gdisp/fonts.h"

-#endif

-

-#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXT

-	void GDISP_LLD(drawchar)(coord_t x, coord_t y, char c, font_t font, color_t color) {

-		const fontcolumn_t	*ptr;

-		fontcolumn_t		column;

-		coord_t				width, height, xscale, yscale;

-		coord_t				i, j, xs, ys;

-

-		/* Check we actually have something to print */

-		width = _getCharWidth(font, c);

-		if (!width) return;

-		

-		xscale = font->xscale;

-		yscale = font->yscale;

-		height = font->height * yscale;

-		width *= xscale;

-

-		ptr = _getCharData(font, c);

-

-		/* Loop through the data and display. The font data is LSBit first, down the column */

-		for(i=0; i < width; i+=xscale) {

-			/* Get the font bitmap data for the column */

-			column = *ptr++;

-			

-			/* Draw each pixel */

-			for(j=0; j < height; j+=yscale, column >>= 1) {

-				if (column & 0x01) {

-					for(xs=0; xs < xscale; xs++)

-						for(ys=0; ys < yscale; ys++)

-							GDISP_LLD(drawpixel)(x+i+xs, y+j+ys, color);

-				}

-			}

-		}

-	}

-#endif

-

-#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXTFILLS

-	void GDISP_LLD(fillchar)(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor) {

-		coord_t			width, height;

-		coord_t			xscale, yscale;

-		

-		/* Check we actually have something to print */

-		width = _getCharWidth(font, c);

-		if (!width) return;

-

-		xscale = font->xscale;

-		yscale = font->yscale;

-		height = font->height * yscale;

-		width *= xscale;

-

-		/* Method 1: Use background fill and then draw the text */

-		#if GDISP_HARDWARE_TEXT || GDISP_SOFTWARE_TEXTFILLDRAW

-			

-			/* Fill the area */

-			GDISP_LLD(fillarea)(x, y, width, height, bgcolor);

-			

-			/* Draw the text */

-			GDISP_LLD(drawchar)(x, y, c, font, color);

-

-		/* Method 2: Create a single column bitmap and then blit it */

-		#elif GDISP_HARDWARE_BITFILLS && GDISP_SOFTWARE_TEXTBLITCOLUMN

-		{

-			const fontcolumn_t	*ptr;

-			fontcolumn_t		column;

-			coord_t				i, j, xs, ys;

-

-			/* Working buffer for fast non-transparent text rendering [patch by Badger]

-				This needs to be larger than the largest character we can print.

-				Assume the max is double sized by one column.

-			*/

-			static pixel_t		buf[sizeof(fontcolumn_t)*8*2];

-

-			#if GDISP_NEED_VALIDATION

-				/* Check our buffer is big enough */

-				if ((unsigned)height > sizeof(buf)/sizeof(buf[0]))	return;

-			#endif

-

-			ptr = _getCharData(font, c);

-

-			/* Loop through the data and display. The font data is LSBit first, down the column */

-			for(i = 0; i < width; i+=xscale) {

-				/* Get the font bitmap data for the column */

-				column = *ptr++;

-				

-				/* Draw each pixel */

-				for(j = 0; j < height; j+=yscale, column >>= 1) {

-					if (column & 0x01) {

-						for(ys=0; ys < yscale; ys++)

-							gdispPackPixels(buf, 1, j+ys, 0, color);

-					} else {

-						for(ys=0; ys < yscale; ys++)

-							gdispPackPixels(buf, 1, j+ys, 0, bgcolor);

-					}

-				}

-

-				for(xs=0; xs < xscale; xs++)

-					GDISP_LLD(blitareaex)(x+i+xs, y, 1, height, 0, 0, 1, buf);

-			}

-		}

-

-		/* Method 3: Create a character bitmap and then blit it */

-		#elif GDISP_HARDWARE_BITFILLS

-		{

-			const fontcolumn_t	*ptr;

-			fontcolumn_t		column;

-			coord_t				i, j, xs, ys;

-			

-			/* Working buffer for fast non-transparent text rendering [patch by Badger]

-				This needs to be larger than the largest character we can print.

-				Assume the max is double sized.

-			*/

-			static pixel_t		buf[20*(sizeof(fontcolumn_t)*8)*2];

-

-			#if GDISP_NEED_VALIDATION

-				/* Check our buffer is big enough */

-				if ((unsigned)(width * height) > sizeof(buf)/sizeof(buf[0]))	return;

-			#endif

-

-			ptr = _getCharData(font, c);

-

-			/* Loop through the data and display. The font data is LSBit first, down the column */

-			for(i = 0; i < width; i+=xscale) {

-				/* Get the font bitmap data for the column */

-				column = *ptr++;

-				

-				/* Draw each pixel */

-				for(j = 0; j < height; j+=yscale, column >>= 1) {

-					if (column & 0x01) {

-						for(xs=0; xs < xscale; xs++)

-							for(ys=0; ys < yscale; ys++)

-								gdispPackPixels(buf, width, i+xs, j+ys, color);

-					} else {

-						for(xs=0; xs < xscale; xs++)

-							for(ys=0; ys < yscale; ys++)

-								gdispPackPixels(buf, width, i+xs, j+ys, bgcolor);

-					}

-				}

-			}

-

-			/* [Patch by Badger] Write all in one stroke */

-			GDISP_LLD(blitareaex)(x, y, width, height, 0, 0, width, buf);

-		}

-

-		/* Method 4: Draw pixel by pixel */

-		#else

-		{

-			const fontcolumn_t	*ptr;

-			fontcolumn_t		column;

-			coord_t				i, j, xs, ys;

-

-			ptr = _getCharData(font, c);

-

-			/* Loop through the data and display. The font data is LSBit first, down the column */

-			for(i = 0; i < width; i+=xscale) {

-				/* Get the font bitmap data for the column */

-				column = *ptr++;

-				

-				/* Draw each pixel */

-				for(j = 0; j < height; j+=yscale, column >>= 1) {

-					if (column & 0x01) {

-						for(xs=0; xs < xscale; xs++)

-							for(ys=0; ys < yscale; ys++)

-								GDISP_LLD(drawpixel)(x+i+xs, y+j+ys, color);

-					} else {

-						for(xs=0; xs < xscale; xs++)

-							for(ys=0; ys < yscale; ys++)

-								GDISP_LLD(drawpixel)(x+i+xs, y+j+ys, bgcolor);

-					}

-				}

-			}

-		}

-		#endif

-	}

-#endif

-

-

-#if GDISP_NEED_CONTROL && !GDISP_HARDWARE_CONTROL

-	void GDISP_LLD(control)(unsigned what, void *value) {

-		(void)what;

-		(void)value;

-		/* Ignore everything */

-	}

-#endif

-

-#if !GDISP_HARDWARE_QUERY

-void *GDISP_LLD(query)(unsigned what) {

-	switch(what) {

-	case GDISP_QUERY_WIDTH:			return (void *)(unsigned)GDISP.Width;

-	case GDISP_QUERY_HEIGHT:		return (void *)(unsigned)GDISP.Height;

-	case GDISP_QUERY_POWER:			return (void *)(unsigned)GDISP.Powermode;

-	case GDISP_QUERY_ORIENTATION:	return (void *)(unsigned)GDISP.Orientation;

-	case GDISP_QUERY_BACKLIGHT:		return (void *)(unsigned)GDISP.Backlight;

-	case GDISP_QUERY_CONTRAST:		return (void *)(unsigned)GDISP.Contrast;

-	default:						return (void *)-1;

-	}

-}

-#endif

-

-#if GDISP_NEED_MSGAPI

-	void GDISP_LLD(msgdispatch)(gdisp_lld_msg_t *msg) {

-		switch(msg->action) {

-		case GDISP_LLD_MSG_NOP:

-			break;

-		case GDISP_LLD_MSG_INIT:

-			GDISP_LLD(init)();

-			break;

-		case GDISP_LLD_MSG_CLEAR:

-			GDISP_LLD(clear)(msg->clear.color);

-			break;

-		case GDISP_LLD_MSG_DRAWPIXEL:

-			GDISP_LLD(drawpixel)(msg->drawpixel.x, msg->drawpixel.y, msg->drawpixel.color);

-			break;

-		case GDISP_LLD_MSG_FILLAREA:

-			GDISP_LLD(fillarea)(msg->fillarea.x, msg->fillarea.y, msg->fillarea.cx, msg->fillarea.cy, msg->fillarea.color);

-			break;

-		case GDISP_LLD_MSG_BLITAREA:

-			GDISP_LLD(blitareaex)(msg->blitarea.x, msg->blitarea.y, msg->blitarea.cx, msg->blitarea.cy, msg->blitarea.srcx, msg->blitarea.srcy, msg->blitarea.srccx, msg->blitarea.buffer);

-			break;

-		case GDISP_LLD_MSG_DRAWLINE:

-			GDISP_LLD(drawline)(msg->drawline.x0, msg->drawline.y0, msg->drawline.x1, msg->drawline.y1, msg->drawline.color);

-			break;

-		#if GDISP_NEED_CLIP

-			case GDISP_LLD_MSG_SETCLIP:

-				GDISP_LLD(setclip)(msg->setclip.x, msg->setclip.y, msg->setclip.cx, msg->setclip.cy);

-				break;

-		#endif

-		#if GDISP_NEED_CIRCLE

-			case GDISP_LLD_MSG_DRAWCIRCLE:

-				GDISP_LLD(drawcircle)(msg->drawcircle.x, msg->drawcircle.y, msg->drawcircle.radius, msg->drawcircle.color);

-				break;

-			case GDISP_LLD_MSG_FILLCIRCLE:

-				GDISP_LLD(fillcircle)(msg->fillcircle.x, msg->fillcircle.y, msg->fillcircle.radius, msg->fillcircle.color);

-				break;

-		#endif

-		#if GDISP_NEED_ELLIPSE

-			case GDISP_LLD_MSG_DRAWELLIPSE:

-				GDISP_LLD(drawellipse)(msg->drawellipse.x, msg->drawellipse.y, msg->drawellipse.a, msg->drawellipse.b, msg->drawellipse.color);

-				break;

-			case GDISP_LLD_MSG_FILLELLIPSE:

-				GDISP_LLD(fillellipse)(msg->fillellipse.x, msg->fillellipse.y, msg->fillellipse.a, msg->fillellipse.b, msg->fillellipse.color);

-				break;

-		#endif

-		#if GDISP_NEED_ARC

-			case GDISP_LLD_MSG_DRAWARC:

-				GDISP_LLD(drawcircle)(msg->drawarc.x, msg->drawarc.y, msg->drawarc.radius, msg->drawarc.startangle, msg->drawarc.endangle, msg->drawarc.color);

-				break;

-			case GDISP_LLD_MSG_FILLARC:

-				GDISP_LLD(fillcircle)(msg->fillarc.x, msg->fillarc.y, msg->fillarc.radius, msg->fillarc.startangle, msg->fillarc.endangle, msg->fillarc.color);

-				break;

-		#endif

-		#if GDISP_NEED_TEXT

-			case GDISP_LLD_MSG_DRAWCHAR:

-				GDISP_LLD(drawchar)(msg->drawchar.x, msg->drawchar.y, msg->drawchar.c, msg->drawchar.font, msg->drawchar.color);

-				break;

-			case GDISP_LLD_MSG_FILLCHAR:

-				GDISP_LLD(fillchar)(msg->fillchar.x, msg->fillchar.y, msg->fillchar.c, msg->fillchar.font, msg->fillchar.color, msg->fillchar.bgcolor);

-				break;

-		#endif

-		#if GDISP_NEED_PIXELREAD

-			case GDISP_LLD_MSG_GETPIXELCOLOR:

-				msg->getpixelcolor.result = GDISP_LLD(getpixelcolor)(msg->getpixelcolor.x, msg->getpixelcolor.y);

-				break;

-		#endif

-		#if GDISP_NEED_SCROLL

-			case GDISP_LLD_MSG_VERTICALSCROLL:

-				GDISP_LLD(verticalscroll)(msg->verticalscroll.x, msg->verticalscroll.y, msg->verticalscroll.cx, msg->verticalscroll.cy, msg->verticalscroll.lines, msg->verticalscroll.bgcolor);

-				break;

-		#endif

-		#if GDISP_NEED_CONTROL

-			case GDISP_LLD_MSG_CONTROL:

-				GDISP_LLD(control)(msg->control.what, msg->control.value);

-				break;

-		#endif

-			case GDISP_LLD_MSG_QUERY:

-				msg->query.result = GDISP_LLD(query)(msg->query.what);

-				break;

-		}

-	}

-#endif

-

-#endif  /* GFX_USE_GDISP */

-#endif	/* GDISP_EMULATION_C */

-/** @} */

-

diff --git a/include/gdisp/lld/gdisp_lld.h b/include/gdisp/lld/gdisp_lld.h
deleted file mode 100644
index 6edaa0d4..00000000
--- a/include/gdisp/lld/gdisp_lld.h
+++ /dev/null
@@ -1,544 +0,0 @@
-/*

-    ChibiOS/GFX - Copyright (C) 2012

-                 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/gdisp/lld/gdisp_lld.h

- * @brief   GDISP Graphic Driver subsystem low level driver header.

- *

- * @addtogroup GDISP

- * @{

- */

-

-#ifndef _GDISP_LLD_H

-#define _GDISP_LLD_H

-

-#if GFX_USE_GDISP || defined(__DOXYGEN__)

-

-/*===========================================================================*/

-/* Low level driver configuration needs					                     */

-/*===========================================================================*/

-

-/*===========================================================================*/

-/* Include the low level driver configuration information                    */

-/*===========================================================================*/

-

-#include "gdisp_lld_config.h"

-

-/*===========================================================================*/

-/* Constants.                                                                */

-/*===========================================================================*/

-

-/**

- * @brief   Driver Control Constants

- * @details	Unsupported control codes are ignored.

- * @note	The value parameter should always be typecast to (void *).

- * @note	There are some predefined and some specific to the low level driver.

- * @note	GDISP_CONTROL_POWER			- Takes a gdisp_powermode_t

- * 			GDISP_CONTROL_ORIENTATION	- Takes a gdisp_orientation_t

- * 			GDISP_CONTROL_BACKLIGHT -	 Takes an int from 0 to 100. For a driver

- * 											that only supports off/on anything other

- * 											than zero is on.

- * 			GDISP_CONTROL_CONTRAST		- Takes an int from 0 to 100.

- * 			GDISP_CONTROL_LLD			- Low level driver control constants start at

- * 											this value.

- */

-#define GDISP_CONTROL_POWER			0

-#define GDISP_CONTROL_ORIENTATION	1

-#define GDISP_CONTROL_BACKLIGHT		2

-#define GDISP_CONTROL_CONTRAST		3

-#define GDISP_CONTROL_LLD			1000

-

-/**

- * @brief   Driver Query Constants

- * @details	Unsupported query codes return (void *)-1.

- * @note	There are some predefined and some specific to the low level driver.

- * @note	The result should be typecast the required type.

- * @note	GDISP_QUERY_WIDTH			- Gets the width of the screen

- * 			GDISP_QUERY_HEIGHT			- Gets the height of the screen

- * 			GDISP_QUERY_POWER			- Get the current powermode

- * 			GDISP_QUERY_ORIENTATION		- Get the current orientation

- * 			GDISP_QUERY_BACKLIGHT		- Get the backlight state (0 to 100)

- * 			GDISP_QUERY_CONTRAST		- Get the contrast.

- * 			GDISP_QUERY_LLD				- Low level driver control constants start at

- * 											this value.

- */

-#define GDISP_QUERY_WIDTH			0

-#define GDISP_QUERY_HEIGHT			1

-#define GDISP_QUERY_POWER			2

-#define GDISP_QUERY_ORIENTATION		3

-#define GDISP_QUERY_BACKLIGHT		4

-#define GDISP_QUERY_CONTRAST		5

-#define GDISP_QUERY_LLD				1000

-

-/**

- * @brief   Driver Pixel Format Constants

- */

-#define GDISP_PIXELFORMAT_RGB565	565

-#define GDISP_PIXELFORMAT_RGB888	888

-#define GDISP_PIXELFORMAT_RGB444	444

-#define GDISP_PIXELFORMAT_RGB332	332

-#define GDISP_PIXELFORMAT_RGB666	666

-#define GDISP_PIXELFORMAT_CUSTOM	99999

-#define GDISP_PIXELFORMAT_ERROR		88888

-

-/*===========================================================================*/

-/* Error checks.                                                             */

-/*===========================================================================*/

-

-/**

- * @name    GDISP hardware accelerated support

- * @{

- */

-	/**

-	 * @brief   Hardware accelerated line drawing.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_LINES

-		#define GDISP_HARDWARE_LINES			FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated screen clears.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_CLEARS

-		#define GDISP_HARDWARE_CLEARS			FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated rectangular fills.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_FILLS

-		#define GDISP_HARDWARE_FILLS			FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated fills from an image.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_BITFILLS

-		#define GDISP_HARDWARE_BITFILLS			FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated circles.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_CIRCLES

-		#define GDISP_HARDWARE_CIRCLES			FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated filled circles.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_CIRCLEFILLS

-		#define GDISP_HARDWARE_CIRCLEFILLS		FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated ellipses.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_ELLIPSES

-		#define GDISP_HARDWARE_ELLIPSES			FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated filled ellipses.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_ELLIPSEFILLS

-		#define GDISP_HARDWARE_ELLIPSEFILLS		FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated arc's.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_ARCS

-		#define GDISP_HARDWARE_ARCS			FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated filled arcs.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_ARCFILLS

-		#define GDISP_HARDWARE_ARCFILLS		FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated text drawing.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_TEXT

-		#define GDISP_HARDWARE_TEXT				FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated text drawing with a filled background.

-	 * @details If set to @p FALSE software emulation is used.

-	 */

-	#ifndef GDISP_HARDWARE_TEXTFILLS

-		#define GDISP_HARDWARE_TEXTFILLS		FALSE

-	#endif

-

-	/**

-	 * @brief   Hardware accelerated scrolling.

-	 * @details If set to @p FALSE there is no support for scrolling.

-	 */

-	#ifndef GDISP_HARDWARE_SCROLL

-		#define GDISP_HARDWARE_SCROLL			FALSE

-	#endif

-

-	/**

-	 * @brief   Reading back of pixel values.

-	 * @details If set to @p FALSE there is no support for pixel read-back.

-	 */

-	#ifndef GDISP_HARDWARE_PIXELREAD

-		#define GDISP_HARDWARE_PIXELREAD		FALSE

-	#endif

-

-	/**

-	 * @brief   The driver supports one or more control commands.

-	 * @details If set to @p FALSE there is no support for control commands.

-	 */

-	#ifndef GDISP_HARDWARE_CONTROL

-		#define GDISP_HARDWARE_CONTROL			FALSE

-	#endif

-

-	/**

-	 * @brief   The driver supports a non-standard query.

-	 * @details If set to @p FALSE there is no support for non-standard queries.

-	 */

-	#ifndef GDISP_HARDWARE_QUERY

-		#define GDISP_HARDWARE_QUERY			FALSE

-	#endif

-

-	/**

-	 * @brief   The driver supports a clipping in hardware.

-	 * @details If set to @p FALSE there is no support for non-standard queries.

-	 */

-	#ifndef GDISP_HARDWARE_CLIP

-		#define GDISP_HARDWARE_CLIP			FALSE

-	#endif

-/** @} */

-

-/**

- * @name    GDISP software algorithm choices

- * @{

- */

-	/**

-	 * @brief   For filled text drawing, use a background fill and then draw

-	 *			the text instead of using a blit or direct pixel drawing.

-	 * @details If set to @p TRUE background fill and then text draw is used.

-	 * @note    This is ignored if hardware accelerated text is supported.

-	 */

-	#ifndef GDISP_SOFTWARE_TEXTFILLDRAW

-		#define GDISP_SOFTWARE_TEXTFILLDRAW		FALSE

-	#endif

-

-	/**

-	 * @brief   For filled text drawing, when using a bitmap blit

-	 *			use a column by column buffer rather than a full character

-	 *			buffer to save memory at a small performance cost.

-	 * @details If set to @p TRUE background fill one character column at a time.

-	 * @note    This is ignored if software text using blit is not being used.

-	 */

-	#ifndef GDISP_SOFTWARE_TEXTBLITCOLUMN

-		#define GDISP_SOFTWARE_TEXTBLITCOLUMN	FALSE

-	#endif

-/** @} */

-

-/**

- * @name    GDISP pixel format choices

- * @{

- */

-	/**

-	 * @brief   The native pixel format for this device

-	 * @note	Should be set to one of the following:

-	 *				GDISP_PIXELFORMAT_RGB565

-	 *				GDISP_PIXELFORMAT_RGB888

-	 *				GDISP_PIXELFORMAT_RGB444

-	 *				GDISP_PIXELFORMAT_RGB332

-	 *				GDISP_PIXELFORMAT_RGB666

-	 *				GDISP_PIXELFORMAT_CUSTOM

-	 * @note	If you set GDISP_PIXELFORMAT_CUSTOM you need to also define

-	 *				color_t, RGB2COLOR(r,g,b), HTML2COLOR(h),

-	 *              RED_OF(c), GREEN_OF(c), BLUE_OF(c),

-	 *              COLOR(c) and MASKCOLOR.

-	 */

-	#ifndef GDISP_PIXELFORMAT

-		#define GDISP_PIXELFORMAT	GDISP_PIXELFORMAT_ERROR

-	#endif

-

-	/**

-	 * @brief   Do pixels require packing for a blit

-	 * @note	Is only valid for a pixel format that doesn't fill it's datatype. ie formats:

-	 *				GDISP_PIXELFORMAT_RGB888

-	 *				GDISP_PIXELFORMAT_RGB444

-	 *				GDISP_PIXELFORMAT_RGB666

-	 *				GDISP_PIXELFORMAT_CUSTOM

-	 * @note	If you use GDISP_PIXELFORMAT_CUSTOM and packed bit fills

-	 *				you need to also define @p gdispPackPixels(buf,cx,x,y,c)

-	 * @note	If you are using GDISP_HARDWARE_BITFILLS = FALSE then the pixel

-	 *				format must not be a packed format as the software blit does

-	 *				not support packed pixels

-	 * @note	Very few cases should actually require packed pixels as the low

-	 *				level driver can also pack on the fly as it is sending it

-	 *				to the graphics device.

-	 */

-	#ifndef GDISP_PACKED_PIXELS

-		#define GDISP_PACKED_PIXELS			FALSE

-	#endif

-

-	/**

-	 * @brief   Do lines of pixels require packing for a blit

-	 * @note	Ignored if GDISP_PACKED_PIXELS is FALSE

-	 */

-	#ifndef GDISP_PACKED_LINES

-		#define GDISP_PACKED_LINES			FALSE

-	#endif

-/** @} */

-

-/*===========================================================================*/

-/* Define the macro's for the various pixel formats */

-/*===========================================================================*/

-

-#if defined(__DOXYGEN__)

-	/**

-	 * @brief   The color of a pixel.

-	 */

-	typedef uint16_t color_t;

-	/**

-	 * @brief   Convert a number (of any type) to a color_t.

-	 * @details Masks any invalid bits in the color

-	 */

-	#define COLOR(c)			((color_t)(c))

-	/**

-	 * @brief   Does the color_t type contain invalid bits that need masking.

-	 */

-	#define MASKCOLOR			FALSE

-	/**

-	 * @brief   Convert red, green, blue (each 0 to 255) into a color value.

-	 */

-	#define RGB2COLOR(r,g,b)	((color_t)((((r) & 0xF8)<<8) | (((g) & 0xFC)<<3) | (((b) & 0xF8)>>3)))

-	/**

-	 * @brief   Convert a 6 digit HTML code (hex) into a color value.

-	 */

-	#define HTML2COLOR(h)		((color_t)((((h) & 0xF80000)>>8) | (((h) & 0x00FC00)>>5) | (((h) & 0x0000F8)>>3)))

-	/**

-	 * @brief   Extract the red component (0 to 255) of a color value.

-	 */

-	#define RED_OF(c)			(((c) & 0xF800)>>8)

-	/**

-	 * @brief   Extract the green component (0 to 255) of a color value.

-	 */

-	#define GREEN_OF(c)			(((c)&0x007E)>>3)

-	/**

-	 * @brief   Extract the blue component (0 to 255) of a color value.

-	 */

-	#define BLUE_OF(c)			(((c)&0x001F)<<3)

-

-#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB565

-	typedef uint16_t color_t;

-	#define COLOR(c)			((color_t)(c))

-	#define MASKCOLOR			FALSE

-	#define RGB2COLOR(r,g,b)	((color_t)((((r) & 0xF8)<<8) | (((g) & 0xFC)<<3) | (((b) & 0xF8)>>3)))

-	#define HTML2COLOR(h)		((color_t)((((h) & 0xF80000)>>8) | (((h) & 0x00FC00)>>5) | (((h) & 0x0000F8)>>3)))

-	#define RED_OF(c)			(((c) & 0xF800)>>8)

-	#define GREEN_OF(c)			(((c)&0x07E0)>>3)

-	#define BLUE_OF(c)			(((c)&0x001F)<<3)

-

-#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB888

-	typedef uint32_t color_t;

-	#define COLOR(c)			((color_t)(((c) & 0xFFFFFF)))

-	#define MASKCOLOR			TRUE

-	#define RGB2COLOR(r,g,b)	((color_t)((((r) & 0xFF)<<16) | (((g) & 0xFF) << 8) | ((b) & 0xFF)))

-	#define HTML2COLOR(h)		((color_t)(h))

-	#define RED_OF(c)			(((c) & 0xFF0000)>>16)

-	#define GREEN_OF(c)			(((c)&0x00FF00)>>8)

-	#define BLUE_OF(c)			((c)&0x0000FF)

-

-#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB444

-	typedef uint16_t color_t;

-	#define COLOR(c)			((color_t)(((c) & 0x0FFF)))

-	#define MASKCOLOR			TRUE

-	#define RGB2COLOR(r,g,b)	((color_t)((((r) & 0xF0)<<4) | ((g) & 0xF0) | (((b) & 0xF0)>>4)))

-	#define HTML2COLOR(h)		((color_t)((((h) & 0xF00000)>>12) | (((h) & 0x00F000)>>8) | (((h) & 0x0000F0)>>4)))

-	#define RED_OF(c)			(((c) & 0x0F00)>>4)

-	#define GREEN_OF(c)			((c)&0x00F0)

-	#define BLUE_OF(c)			(((c)&0x000F)<<4)

-

-#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB332

-	typedef uint8_t color_t;

-	#define COLOR(c)			((color_t)(c))

-	#define MASKCOLOR			FALSE

-	#define RGB2COLOR(r,g,b)	((color_t)(((r) & 0xE0) | (((g) & 0xE0)>>3) | (((b) & 0xC0)>>6)))

-	#define HTML2COLOR(h)		((color_t)((((h) & 0xE00000)>>16) | (((h) & 0x00E000)>>11) | (((h) & 0x0000C0)>>6)))

-	#define RED_OF(c)			((c) & 0xE0)

-	#define GREEN_OF(c)			(((c)&0x1C)<<3)

-	#define BLUE_OF(c)			(((c)&0x03)<<6)

-

-#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB666

-	typedef uint32_t color_t;

-	#define COLOR(c)			((color_t)(((c) & 0x03FFFF)))

-	#define MASKCOLOR			TRUE

-	#define RGB2COLOR(r,g,b)	((color_t)((((r) & 0xFC)<<10) | (((g) & 0xFC)<<4) | (((b) & 0xFC)>>2)))

-	#define HTML2COLOR(h)		((color_t)((((h) & 0xFC0000)>>6) | (((h) & 0x00FC00)>>4) | (((h) & 0x0000FC)>>2)))

-	#define RED_OF(c)			(((c) & 0x03F000)>>12)

-	#define GREEN_OF(c)			(((c)&0x00FC00)>>8)

-	#define BLUE_OF(c)			(((c)&0x00003F)<<2)

-

-#elif GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_CUSTOM

-	#error "GDISP: No supported pixel format has been specified."

-#endif

-

-/* Verify information for packed pixels and define a non-packed pixel macro */

-#if !GDISP_PACKED_PIXELS

-	#define gdispPackPixels(buf,cx,x,y,c)	{ ((color_t *)(buf))[(y)*(cx)+(x)] = (c); }

-#elif !GDISP_HARDWARE_BITFILLS

-	#error "GDISP: packed pixel formats are only supported for hardware accelerated drivers."

-#elif GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB888 \

-		&& GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB444 \

-		&& GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB666 \

-		&& GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_CUSTOM

-	#error "GDISP: A packed pixel format has been specified for an unsupported pixel format."

-#endif

-

-#if GDISP_NEED_SCROLL && !GDISP_HARDWARE_SCROLL

-	#error "GDISP: Hardware scrolling is wanted but not supported."

-#endif

-

-#if GDISP_NEED_PIXELREAD && !GDISP_HARDWARE_PIXELREAD

-	#error "GDISP: Pixel read-back is wanted but not supported."

-#endif

-

-/*===========================================================================*/

-/* Driver types.                                                             */

-/*===========================================================================*/

-

-/**

- * @brief   The type of a pixel.

- */

-typedef color_t		pixel_t;

-/**

- * @brief   The type of a font.

- */

-typedef const struct font *font_t;

-/**

- * @brief   Type for the screen orientation.

- */

-typedef enum orientation {GDISP_ROTATE_0, GDISP_ROTATE_90, GDISP_ROTATE_180, GDISP_ROTATE_270} gdisp_orientation_t;

-/**

- * @brief   Type for the available power modes for the screen.

- */

-typedef enum powermode {powerOff, powerSleep, powerDeepSleep, powerOn} gdisp_powermode_t;

-

-/*===========================================================================*/

-/* External declarations.                                                    */

-/*===========================================================================*/

-

-#ifndef GDISP_LLD_VMT

-	/* Special magic stuff for the VMT driver */

-	#define GDISP_LLD_VMT(x) GDISP_LLD(x)

-#endif

-

-#ifdef __cplusplus

-extern "C" {

-#endif

-

-	/* Core functions */

-	extern bool_t GDISP_LLD(init)(void);

-

-	/* Some of these functions will be implemented in software by the high level driver

-	   depending on the GDISP_HARDWARE_XXX macros defined in gdisp_lld_config.h.

-	 */

-

-	/* Drawing functions */

-	extern void GDISP_LLD_VMT(clear)(color_t color);

-	extern void GDISP_LLD_VMT(drawpixel)(coord_t x, coord_t y, color_t color);

-	extern void GDISP_LLD_VMT(fillarea)(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);

-	extern void GDISP_LLD_VMT(blitareaex)(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer);

-	extern void GDISP_LLD_VMT(drawline)(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color);

-

-	/* Circular Drawing Functions */

-	#if GDISP_NEED_CIRCLE

-	extern void GDISP_LLD_VMT(drawcircle)(coord_t x, coord_t y, coord_t radius, color_t color);

-	extern void GDISP_LLD_VMT(fillcircle)(coord_t x, coord_t y, coord_t radius, color_t color);

-	#endif

-

-	#if GDISP_NEED_ELLIPSE

-	extern void GDISP_LLD_VMT(drawellipse)(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);

-	extern void GDISP_LLD_VMT(fillellipse)(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);

-	#endif

-

-	/* Arc Drawing Functions */

-	#if GDISP_NEED_ARC

-	extern void GDISP_LLD_VMT(drawarc)(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);

-	extern void GDISP_LLD_VMT(fillarc)(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);

-	#endif

-

-	/* Text Rendering Functions */

-	#if GDISP_NEED_TEXT

-	extern void GDISP_LLD_VMT(drawchar)(coord_t x, coord_t y, char c, font_t font, color_t color);

-	extern void GDISP_LLD_VMT(fillchar)(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor);

-	#endif

-

-	/* Pixel readback */

-	#if GDISP_NEED_PIXELREAD

-	extern color_t GDISP_LLD_VMT(getpixelcolor)(coord_t x, coord_t y);

-	#endif

-

-	/* Scrolling Function - clears the area scrolled out */

-	#if GDISP_NEED_SCROLL

-	extern void GDISP_LLD_VMT(verticalscroll)(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor);

-	#endif

-

-	/* Set driver specific control */

-	#if GDISP_NEED_CONTROL

-	extern void GDISP_LLD_VMT(control)(unsigned what, void *value);

-	#endif

-

-	/* Query driver specific data */

-	extern void *GDISP_LLD_VMT(query)(unsigned what);

-

-	/* Clipping Functions */

-	#if GDISP_NEED_CLIP

-	extern void GDISP_LLD_VMT(setclip)(coord_t x, coord_t y, coord_t cx, coord_t cy);

-	#endif

-

-	/* Messaging API */

-	#if GDISP_NEED_MSGAPI

-	#include "gdisp_lld_msgs.h"

-	extern void GDISP_LLD(msgdispatch)(gdisp_lld_msg_t *msg);

-	#endif

-

-#ifdef __cplusplus

-}

-#endif

-

-#endif	/* GFX_USE_GDISP */

-

-#endif	/* _GDISP_LLD_H */

-/** @} */

-

diff --git a/include/gdisp/lld/gdisp_lld_msgs.h b/include/gdisp/lld/gdisp_lld_msgs.h
deleted file mode 100644
index 6fe78567..00000000
--- a/include/gdisp/lld/gdisp_lld_msgs.h
+++ /dev/null
@@ -1,193 +0,0 @@
-/*

-    ChibiOS/GFX - Copyright (C) 2012

-                 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/gdisp/lld/gdisp_lld_msgs.h

- * @brief   GDISP Graphic Driver subsystem low level driver message structures.

- *

- * @addtogroup GDISP

- * @{

- */

-

-#ifndef _GDISP_LLD_MSGS_H

-#define _GDISP_LLD_MSGS_H

-

-/* This file describes the message API for gdisp_lld */

-#if GFX_USE_GDISP && GDISP_NEED_MSGAPI

-

-typedef enum gdisp_msgaction {

-	GDISP_LLD_MSG_NOP,

-	GDISP_LLD_MSG_INIT,

-	GDISP_LLD_MSG_CLEAR,

-	GDISP_LLD_MSG_DRAWPIXEL,

-	GDISP_LLD_MSG_FILLAREA,

-	GDISP_LLD_MSG_BLITAREA,

-	GDISP_LLD_MSG_DRAWLINE,

-	#if GDISP_NEED_CLIP

-		GDISP_LLD_MSG_SETCLIP,

-	#endif

-	#if GDISP_NEED_CIRCLE

-		GDISP_LLD_MSG_DRAWCIRCLE,

-		GDISP_LLD_MSG_FILLCIRCLE,

-	#endif

-	#if GDISP_NEED_ELLIPSE

-		GDISP_LLD_MSG_DRAWELLIPSE,

-		GDISP_LLD_MSG_FILLELLIPSE,

-	#endif

-	#if GDISP_NEED_ARC

-		GDISP_LLD_MSG_DRAWARC,

-		GDISP_LLD_MSG_FILLARC,

-	#endif

-	#if GDISP_NEED_TEXT

-		GDISP_LLD_MSG_DRAWCHAR,

-		GDISP_LLD_MSG_FILLCHAR,

-	#endif

-	#if GDISP_NEED_PIXELREAD

-		GDISP_LLD_MSG_GETPIXELCOLOR,

-	#endif

-	#if GDISP_NEED_SCROLL

-		GDISP_LLD_MSG_VERTICALSCROLL,

-	#endif

-	#if GDISP_NEED_CONTROL

-		GDISP_LLD_MSG_CONTROL,

-	#endif

-	GDISP_LLD_MSG_QUERY,

-} gdisp_msgaction_t;

-

-typedef union gdisp_lld_msg {

-	gdisp_msgaction_t	action;

-	struct gdisp_lld_msg_init {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_INIT

-	} init;

-	struct gdisp_lld_msg_clear {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_CLEAR

-		color_t				color;

-	} clear;

-	struct gdisp_lld_msg_drawpixel {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWPIXEL

-		coord_t				x, y;

-		color_t				color;

-	} drawpixel;

-	struct gdisp_lld_msg_fillarea {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_FILLAREA

-		coord_t				x, y;

-		coord_t				cx, cy;

-		color_t				color;

-	} fillarea;

-	struct gdisp_lld_msg_blitarea {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_BLITAREA

-		coord_t				x, y;

-		coord_t				cx, cy;

-		coord_t				srcx, srcy;

-		coord_t				srccx;

-		const pixel_t		*buffer;

-	} blitarea;

-	struct gdisp_lld_msg_setclip {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_SETCLIP

-		coord_t				x, y;

-		coord_t				cx, cy;

-	} setclip;

-	struct gdisp_lld_msg_drawline {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWLINE

-		coord_t				x0, y0;

-		coord_t				x1, y1;

-		color_t				color;

-	} drawline;

-	struct gdisp_lld_msg_drawcircle {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWCIRCLE

-		coord_t				x, y;

-		coord_t				radius;

-		color_t				color;

-	} drawcircle;

-	struct gdisp_lld_msg_fillcircle {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_FILLCIRCLE

-		coord_t				x, y;

-		coord_t				radius;

-		color_t				color;

-	} fillcircle;

-	struct gdisp_lld_msg_drawellipse {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWELLIPSE

-		coord_t				x, y;

-		coord_t				a, b;

-		color_t				color;

-	} drawellipse;

-	struct gdisp_lld_msg_fillellipse {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_FILLELLIPSE

-		coord_t				x, y;

-		coord_t				a, b;

-		color_t				color;

-	} fillellipse;

-	struct gdisp_lld_msg_drawarc {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWARC

-		coord_t				x, y;

-		coord_t				radius;

-		coord_t				startangle, endangle;

-		color_t				color;

-	} drawcircle;

-	struct gdisp_lld_msg_fillarc {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_FILLARC

-		coord_t				x, y;

-		coord_t				radius;

-		coord_t				startangle, endangle;

-		color_t				color;

-	} fillcircle;

-	struct gdisp_lld_msg_drawchar {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_DRAWCHAR

-		coord_t				x, y;

-		char				c;

-		font_t				font;

-		color_t				color;

-	} drawchar;

-	struct gdisp_lld_msg_fillchar {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_FILLCHAR

-		coord_t				x, y;

-		char				c;

-		font_t				font;

-		color_t				color;

-		color_t				bgcolor;

-	} fillchar;

-	struct gdisp_lld_msg_getpixelcolor {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_GETPIXELCOLOR

-		coord_t				x, y;

-		color_t				result;

-	} getpixelcolor;

-	struct gdisp_lld_msg_verticalscroll {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_VERTICALSCROLL

-		coord_t				x, y;

-		coord_t				cx, cy;

-		int					lines;

-		color_t				bgcolor;

-	} verticalscroll;

-	struct gdisp_lld_msg_control {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_CONTROL

-		int					what;

-		void *				value;

-	} control;

-	struct gdisp_lld_msg_query {

-		gdisp_msgaction_t	action;			// GDISP_LLD_MSG_QUERY

-		int					what;

-		void *				result;

-	} query;

-} gdisp_lld_msg_t;

-

-#endif	/* GFX_USE_GDISP && GDISP_NEED_MSGAPI */

-#endif	/* _GDISP_LLD_MSGS_H */

-/** @} */

-

diff --git a/include/gdisp/options.h b/include/gdisp/options.h
deleted file mode 100644
index 2fedd34d..00000000
--- a/include/gdisp/options.h
+++ /dev/null
@@ -1,241 +0,0 @@
-/*

-    ChibiOS/GFX - Copyright (C) 2012

-                 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/gdisp/options.h

- * @brief   GDISP sub-system options header file.

- *

- * @addtogroup GDISP

- * @{

- */

-

-#ifndef _GDISP_OPTIONS_H

-#define _GDISP_OPTIONS_H

-

-/**

- * @name    GDISP Functionality to be included

- * @{

- */

-	/**

-	 * @brief   Should all operations be clipped to the screen and colors validated.

-	 * @details	Defaults to TRUE.

-	 * @note    If this is FALSE, any operations that extend beyond the

-	 *          edge of the screen will have undefined results. Any

-	 *			out-of-range colors will produce undefined results.

-	 * @note	If defined then all low level and high level GDISP driver routines

-	 *			must check the validity of inputs and do something sensible

-	 *			if they are out of range. It doesn't have to be efficient,

-	 *			just valid.

-	 */

-	#ifndef GDISP_NEED_VALIDATION

-		#define GDISP_NEED_VALIDATION	TRUE

-	#endif

-	/**

-	 * @brief   Are clipping functions needed.

-	 * @details	Defaults to TRUE

-	 */

-	#ifndef GDISP_NEED_CLIP

-		#define GDISP_NEED_CLIP			TRUE

-	#endif

-	/**

-	 * @brief   Are text functions needed.

-	 * @details	Defaults to TRUE

-	 */

-	#ifndef GDISP_NEED_TEXT

-		#define GDISP_NEED_TEXT			TRUE

-	#endif

-	/**

-	 * @brief   Are circle functions needed.

-	 * @details	Defaults to TRUE

-	 */

-	#ifndef GDISP_NEED_CIRCLE

-		#define GDISP_NEED_CIRCLE		TRUE

-	#endif

-	/**

-	 * @brief   Are ellipse functions needed.

-	 * @details	Defaults to TRUE

-	 */

-	#ifndef GDISP_NEED_ELLIPSE

-		#define GDISP_NEED_ELLIPSE		TRUE

-	#endif

-	/**

-	 * @brief   Are arc functions needed.

-	 * @details	Defaults to FALSE

-	 * @note	Requires the maths library to be included in the link. ie  -lm

-	 */

-	#ifndef GDISP_NEED_ARC

-		#define GDISP_NEED_ARC			FALSE

-	#endif

-	/**

-	 * @brief   Are scrolling functions needed.

-	 * @details	Defaults to FALSE

-	 * @note	This function must be supported by the low level GDISP driver

-	 * 			you have included in your project. If it isn't, defining this

-	 * 			option will cause a compile error.

-	 */

-	#ifndef GDISP_NEED_SCROLL

-		#define GDISP_NEED_SCROLL		FALSE

-	#endif

-	/**

-	 * @brief   Is the capability to read pixels back needed.

-	 * @details	Defaults to FALSE

-	 * @note	This function must be supported by the low level GDISP driver

-	 * 			you have included in your project. If it isn't, defining this

-	 * 			option will cause a compile error.

-	 */

-	#ifndef GDISP_NEED_PIXELREAD

-		#define GDISP_NEED_PIXELREAD	FALSE

-	#endif

-	/**

-	 * @brief   Control some aspect of the hardware operation.

-	 * @details	Defaults to FALSE

-	 * @note	This allows control of hardware specific features such as

-	 * 			screen rotation, backlight levels, contrast etc

-	 */

-	#ifndef GDISP_NEED_CONTROL

-		#define GDISP_NEED_CONTROL		FALSE

-	#endif

-	/**

-	 * @brief   Is the messaging api interface required.

-	 * @details	Defaults to FALSE

-	 */

-	#ifndef GDISP_NEED_MSGAPI

-		#define GDISP_NEED_MSGAPI		FALSE

-	#endif

-/**

- * @}

- *

- * @name    GDISP Multi-Threading Options

- * @{

- */

-	/**

-	 * @brief   Do the drawing functions need to be thread-safe.

-	 * @details	Defaults to FALSE

-	 * @note	Both GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC make

-	 * 			the gdisp API thread-safe.

-	 * @note	This is more efficient than GDISP_NEED_ASYNC as it only

-	 * 			requires a context switch if something else is already

-	 * 			drawing.

-	 */

-	#ifndef GDISP_NEED_MULTITHREAD

-		#define GDISP_NEED_MULTITHREAD	FALSE

-	#endif

-	/**

-	 * @brief   Use asynchronous calls (multi-thread safe).

-	 * @details	Defaults to FALSE

-	 * @note	Both GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC make

-	 * 			the gdisp API thread-safe.

-	 * @note	Turning this on adds two context switches per transaction

-	 *			so it can significantly slow graphics drawing but it allows

-	 *			drawing operations to continue in the background.

-	 */

-	#ifndef GDISP_NEED_ASYNC

-		#define GDISP_NEED_ASYNC		FALSE

-	#endif

-/**

- * @}

- *

- * @name    GDISP Fonts

- * @{

- */

-	/**

-	 * @brief   Include the old global font variable definitions

-	 * @details	Defaults to FALSE

-	 */

-	#ifndef GDISP_OLD_FONT_DEFINITIONS

-		#define GDISP_OLD_FONT_DEFINITIONS		FALSE

-	#endif

-	/**

-	 * @brief   Predefined built in fonts

-	 * @note	Turning off the ones you are not using can save program size.

-	 */

-	#ifndef GDISP_INCLUDE_FONT_SMALL

-		#define GDISP_INCLUDE_FONT_SMALL		TRUE

-	#endif

-	#ifndef GDISP_INCLUDE_FONT_LARGER

-		#define GDISP_INCLUDE_FONT_LARGER		TRUE

-	#endif

-	#ifndef GDISP_INCLUDE_FONT_UI1

-		#define GDISP_INCLUDE_FONT_UI1			TRUE

-	#endif

-	#ifndef GDISP_INCLUDE_FONT_UI2

-		#define GDISP_INCLUDE_FONT_UI2			TRUE

-	#endif

-	#ifndef GDISP_INCLUDE_FONT_LARGENUMBERS

-		#define GDISP_INCLUDE_FONT_LARGENUMBERS	TRUE

-	#endif

-

-/**

- * @}

- *

- * @name    GDISP Optional Sizing Parameters

- * @{

- */

-	/**

-	 * @brief   The maximum height of a font.

-	 * @details	Either 16 or 32. Defaults to 16

-	 * @note	Setting this to 32 causes the font tables to take

-	 *			twice the internal program memory. Don't do it unless

-	 *			you realy must define an unscaled font larger than 16 bits high.

-	 */

-	#ifndef GDISP_MAX_FONT_HEIGHT

-		#define GDISP_MAX_FONT_HEIGHT	16

-	#endif

-/**

- * @}

- *

- * @name    GDISP Optional Low Level Driver Defines

- * @{

- */

-	/**

-	 * @brief   Use a custom board definition even if a board definition exists.

-	 * @details	Defaults to FALSE

-	 * @details	If TRUE, add gdisp_lld_board.h to your project directory and customise it.

-	 * @note	Not all GDISP low level drivers currently use board definition files.

-	 */

-	#ifndef GDISP_USE_CUSTOM_BOARD

-		#define GDISP_USE_CUSTOM_BOARD		FALSE

-	#endif

-	/**

-	 * @brief   Set the screen height and width.

-	 * @note	Ignored by some low level GDISP drivers, optional for others.

-	 * @note	Where these values are allowed, a default is always provided be the low level driver.

-	 * @note	The list of GDISP low level drivers that allow these to be set are...

-	 *				WIN32, SSD1289, SSD1963, TestStub

-	 */

-	/* #define GDISP_SCREEN_WIDTH		nnnn */

-	/* #define GDISP_SCREEN_HEIGHT		nnnn */

-	/**

-	 * @brief   Define which bus interface to use.

-	 * @details	Only required by the SSD1963 driver.

-	 * @note	This will be replaced eventually by board definition files

-	 */

-	/* #define GDISP_USE_FSMC */

-	/* #define GDISP_USE_GPIO */

-	/**

-	 * @brief   Define which two drivers will be used by the VMT layer.

-	 * @details	Only required by the VMT driver.

-	 */

-	/* #define GDISP_VMT_NAME1(x)	x##YourDriver1 */

-	/* #define GDISP_VMT_NAME2(x)	x##YourDriver2 */

-/** @} */

-

-#endif /* _GDISP_OPTIONS_H */

-/** @} */