aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
authorJoel Bodenmann <joel@unormal.org>2013-02-11 09:25:45 +0100
committerJoel Bodenmann <joel@unormal.org>2013-02-11 09:25:45 +0100
commit1bfc5a9f85e7c3296095105ca8e3ee1215b22be8 (patch)
tree08f2662a3ad41936e23e00815ae9ee024bdedbfd /src
parent885b3d53b3a491c62fb0634b78cb9857723ac15d (diff)
downloaduGFX-1bfc5a9f85e7c3296095105ca8e3ee1215b22be8.tar.gz
uGFX-1bfc5a9f85e7c3296095105ca8e3ee1215b22be8.tar.bz2
uGFX-1bfc5a9f85e7c3296095105ca8e3ee1215b22be8.zip
removed GDISP_LLD() macro - fix
Diffstat (limited to 'src')
-rw-r--r--src/gadc/gadc.c38
-rw-r--r--src/gadc/gadc.mk1
-rw-r--r--src/gaudin/gaudin.c38
-rw-r--r--src/gaudin/gaudin.mk1
-rw-r--r--src/gaudout/gaudout.c38
-rw-r--r--src/gaudout/gaudout.mk1
-rw-r--r--src/gdisp/fonts.c780
-rw-r--r--src/gdisp/gdisp.c1268
-rw-r--r--src/gdisp/gdisp.mk2
-rw-r--r--src/gevent/gevent.c197
-rw-r--r--src/gevent/gevent.mk1
-rw-r--r--src/ginput/dial.c36
-rw-r--r--src/ginput/ginput.mk4
-rw-r--r--src/ginput/keyboard.c38
-rw-r--r--src/ginput/mouse.c589
-rw-r--r--src/ginput/toggle.c171
-rw-r--r--src/gmisc/arrayops.c241
-rw-r--r--src/gmisc/gmisc.mk1
-rw-r--r--src/gtimer/gtimer.c240
-rw-r--r--src/gtimer/gtimer.mk1
-rw-r--r--src/gwin/button.c275
-rw-r--r--src/gwin/console.c158
-rw-r--r--src/gwin/graph.c362
-rw-r--r--src/gwin/gwin.c544
-rw-r--r--src/gwin/gwin.mk5
-rw-r--r--src/tdisp/tdisp.c85
-rw-r--r--src/tdisp/tdisp.mk2
27 files changed, 5117 insertions, 0 deletions
diff --git a/src/gadc/gadc.c b/src/gadc/gadc.c
new file mode 100644
index 00000000..5533bb49
--- /dev/null
+++ b/src/gadc/gadc.c
@@ -0,0 +1,38 @@
+/*
+ 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 src/gadc/gadc.c
+ * @brief GADC sub-system code.
+ *
+ * @addtogroup GADC
+ * @{
+ */
+#include "ch.h"
+#include "hal.h"
+#include "gfx.h"
+
+#if GFX_USE_GADC || defined(__DOXYGEN__)
+
+ #error "GADC: Not implemented yet"
+
+#endif /* GFX_USE_GADC */
+/** @} */
+
diff --git a/src/gadc/gadc.mk b/src/gadc/gadc.mk
new file mode 100644
index 00000000..cfe04177
--- /dev/null
+++ b/src/gadc/gadc.mk
@@ -0,0 +1 @@
+GFXSRC += $(GFXLIB)/src/gadc/gadc.c
diff --git a/src/gaudin/gaudin.c b/src/gaudin/gaudin.c
new file mode 100644
index 00000000..120d7d81
--- /dev/null
+++ b/src/gaudin/gaudin.c
@@ -0,0 +1,38 @@
+/*
+ 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 src/gaudin/gaudin.c
+ * @brief GAUDIN sub-system code.
+ *
+ * @addtogroup GAUDIN
+ * @{
+ */
+#include "ch.h"
+#include "hal.h"
+#include "gfx.h"
+
+#if GFX_USE_GAUDIN || defined(__DOXYGEN__)
+
+ #error "GAUDIN: Not implemented yet"
+
+#endif /* GFX_USE_GAUDIN */
+/** @} */
+
diff --git a/src/gaudin/gaudin.mk b/src/gaudin/gaudin.mk
new file mode 100644
index 00000000..f134d264
--- /dev/null
+++ b/src/gaudin/gaudin.mk
@@ -0,0 +1 @@
+GFXSRC += $(GFXLIB)/src/gaudin/gaudin.c
diff --git a/src/gaudout/gaudout.c b/src/gaudout/gaudout.c
new file mode 100644
index 00000000..af8499dc
--- /dev/null
+++ b/src/gaudout/gaudout.c
@@ -0,0 +1,38 @@
+/*
+ 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 src/gaudout/gaudout.c
+ * @brief GAUDOUT sub-system code.
+ *
+ * @addtogroup GAUDOUT
+ * @{
+ */
+#include "ch.h"
+#include "hal.h"
+#include "gfx.h"
+
+#if GFX_USE_GAUDOUT || defined(__DOXYGEN__)
+
+ #error "GAUDOUT: Not implemented yet"
+
+#endif /* GFX_USE_GAUDOUT */
+/** @} */
+
diff --git a/src/gaudout/gaudout.mk b/src/gaudout/gaudout.mk
new file mode 100644
index 00000000..004306bc
--- /dev/null
+++ b/src/gaudout/gaudout.mk
@@ -0,0 +1 @@
+GFXSRC += $(GFXLIB)/src/gaudout/gaudout.c
diff --git a/src/gdisp/fonts.c b/src/gdisp/fonts.c
new file mode 100644
index 00000000..59293359
--- /dev/null
+++ b/src/gdisp/fonts.c
@@ -0,0 +1,780 @@
+/*
+ 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 src/gdisp/fonts.c
+ * @brief GDISP Font Handling.
+ *
+ * @addtogroup GDISP
+ * @{
+ */
+
+#include "ch.h"
+#include "hal.h"
+#include "gfx.h"
+
+#if (GFX_USE_GDISP && GDISP_NEED_TEXT) || defined(__DOXYGEN__)
+
+#include "gdisp/fonts.h"
+
+#if GDISP_OLD_FONT_DEFINITIONS
+ #define FONT_DECL
+#else
+ #define FONT_DECL static
+#endif
+
+/* fontSmall - for side buttons */
+#if GDISP_INCLUDE_FONT_SMALL
+ /* Forward Declarations of internal arrays */
+ static const uint8_t fontSmall_Widths[];
+ static const uint16_t fontSmall_Offsets[];
+ static const fontcolumn_t fontSmall_Data[];
+
+ FONT_DECL const struct font fontSmall = {
+ "Small",
+ 11, 0, 14, 2, 2, 12, ' ', '~', 1, 1,
+ fontSmall_Widths,
+ fontSmall_Offsets,
+ fontSmall_Data};
+ FONT_DECL const struct font fontSmallDouble = {
+ "Small Double",
+ 11, 0, 14, 2, 2, 12, ' ', '~', 2, 2,
+ fontSmall_Widths,
+ fontSmall_Offsets,
+ fontSmall_Data};
+ FONT_DECL const struct font fontSmallNarrow = {
+ "Small Narrow",
+ 11, 0, 14, 2, 2, 12, ' ', '~', 1, 2,
+ fontSmall_Widths,
+ fontSmall_Offsets,
+ fontSmall_Data};
+
+ static const uint8_t fontSmall_Widths[] = {
+ 2, 3, 6, 8, 7, 9, 7, 3, 4, 4, 5, 7, 4, 4, 3, 6,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, 4, 6, 7, 6, 7,
+ 12, 8, 7, 8, 8, 7, 7, 8, 8, 3, 5, 8, 7, 9, 8, 8,
+ 8, 8, 8, 7, 7, 8, 8, 12, 8, 8, 8, 4, 6, 4, 7, 7,
+ 4, 7, 7, 7, 7, 7, 4, 7, 7, 3, 3, 7, 3, 9, 7, 7,
+ 7, 7, 4, 6, 4, 7, 7, 9, 6, 6, 6, 5, 3, 5, 8, 0
+ };
+ static const uint16_t fontSmall_Offsets[] = {
+ 0, 2, 5, 11, 19, 26, 35, 42,
+ 45, 49, 53, 58, 65, 69, 73, 76,
+ 82, 89, 96, 103, 110, 117, 124, 131,
+ 138, 145, 152, 155, 159, 165, 172, 178,
+ 185, 197, 205, 212, 220, 228, 235, 242,
+ 250, 258, 261, 266, 274, 281, 290, 298,
+ 306, 314, 322, 330, 337, 344, 352, 360,
+ 372, 380, 388, 396, 400, 406, 410, 417,
+ 424, 428, 435, 442, 449, 456, 463, 467,
+ 474, 481, 484, 487, 494, 497, 506, 513,
+ 520, 527, 534, 538, 544, 548, 555, 562,
+ 571, 577, 583, 589, 594, 597, 602, 0
+ };
+ static const fontcolumn_t fontSmall_Data[] = {
+ /* */ 0x0000, 0x0000,
+ /* ! */ 0x0000, 0x017F, 0x017F,
+ /* " */ 0x0000, 0x0007, 0x0007, 0x0000, 0x0007, 0x0007,
+ /* # */ 0x0000, 0x0044, 0x01FF, 0x01FF, 0x0044, 0x01FF, 0x01FF, 0x0044,
+ /* $ */ 0x0000, 0x008C, 0x019E, 0x03FF, 0x03FF, 0x01E6, 0x00C4,
+ /* % */ 0x0000, 0x0082, 0x00C7, 0x0065, 0x00B7, 0x01DA, 0x014C, 0x01C6, 0x0082,
+ /* & */ 0x0000, 0x00E6, 0x01FF, 0x013F, 0x01E6, 0x01E0, 0x0120,
+ /* ' */ 0x0000, 0x0007, 0x0007,
+ /* ( */ 0x0000, 0x03FE, 0x07FF, 0x0401,
+ /* ) */ 0x0000, 0x0401, 0x07FF, 0x03FE,
+ /* * */ 0x0000, 0x000A, 0x000E, 0x000E, 0x000A,
+ /* + */ 0x0000, 0x0020, 0x0020, 0x00F8, 0x00F8, 0x0020, 0x0020,
+ /* , */ 0x0000, 0x0200, 0x0300, 0x0100,
+ /* - */ 0x0000, 0x0020, 0x0020, 0x0020,
+ /* . */ 0x0000, 0x0100, 0x0100,
+ /* / */ 0x0000, 0x0180, 0x01E0, 0x0078, 0x001F, 0x0007,
+ /* 0 */ 0x0000, 0x00FE, 0x01FF, 0x0101, 0x0101, 0x01FF, 0x00FE,
+ /* 1 */ 0x0000, 0x0002, 0x0002, 0x01FF, 0x01FF, 0x0000, 0x0000,
+ /* 2 */ 0x0000, 0x0182, 0x01C3, 0x0161, 0x0131, 0x011F, 0x010E,
+ /* 3 */ 0x0000, 0x0082, 0x0183, 0x0111, 0x0111, 0x01FF, 0x00EE,
+ /* 4 */ 0x0000, 0x0060, 0x0078, 0x005E, 0x01FF, 0x01FF, 0x0040,
+ /* 5 */ 0x0000, 0x009F, 0x019F, 0x0109, 0x0109, 0x01F9, 0x00F1,
+ /* 6 */ 0x0000, 0x00FE, 0x01FF, 0x0111, 0x0111, 0x01F3, 0x00E2,
+ /* 7 */ 0x0000, 0x0001, 0x01C1, 0x01F1, 0x003D, 0x000F, 0x0003,
+ /* 8 */ 0x0000, 0x00EE, 0x01FF, 0x0111, 0x0111, 0x01FF, 0x00EE,
+ /* 9 */ 0x0000, 0x008E, 0x019F, 0x0111, 0x0111, 0x01FF, 0x00FE,
+ /* : */ 0x0000, 0x0108, 0x0108,
+ /* ; */ 0x0000, 0x0200, 0x0308, 0x0108,
+ /* < */ 0x0000, 0x0020, 0x0070, 0x00D8, 0x018C, 0x0104,
+ /* = */ 0x0000, 0x0050, 0x0050, 0x0050, 0x0050, 0x0050, 0x0050,
+ /* > */ 0x0000, 0x0104, 0x018C, 0x00D8, 0x0070, 0x0020,
+ /* ? */ 0x0000, 0x0002, 0x0003, 0x0161, 0x0171, 0x001F, 0x000E,
+ /* @ */ 0x0000, 0x0078, 0x01FE, 0x0186, 0x0333, 0x0279, 0x0249, 0x0279, 0x027B, 0x0246, 0x007E, 0x0078,
+ /* A */ 0x0180, 0x01F0, 0x007C, 0x004F, 0x004F, 0x007C, 0x01F0, 0x0180,
+ /* B */ 0x0000, 0x01FF, 0x01FF, 0x0111, 0x0111, 0x01FF, 0x00EE,
+ /* C */ 0x0000, 0x00FE, 0x01FF, 0x0101, 0x0101, 0x0101, 0x0183, 0x0082,
+ /* D */ 0x0000, 0x01FF, 0x01FF, 0x0101, 0x0101, 0x0183, 0x00FE, 0x007C,
+ /* E */ 0x0000, 0x01FF, 0x01FF, 0x0111, 0x0111, 0x0111, 0x0101,
+ /* F */ 0x0000, 0x01FF, 0x01FF, 0x0011, 0x0011, 0x0011, 0x0001,
+ /* G */ 0x0000, 0x00FE, 0x01FF, 0x0101, 0x0111, 0x0191, 0x01F3, 0x01F2,
+ /* H */ 0x0000, 0x01FF, 0x01FF, 0x0010, 0x0010, 0x0010, 0x01FF, 0x01FF,
+ /* I */ 0x0000, 0x01FF, 0x01FF,
+ /* J */ 0x00C0, 0x01C0, 0x0100, 0x01FF, 0x00FF,
+ /* K */ 0x0000, 0x01FF, 0x01FF, 0x003C, 0x0066, 0x00C3, 0x0181, 0x0100,
+ /* L */ 0x0000, 0x01FF, 0x01FF, 0x0100, 0x0100, 0x0100, 0x0100,
+ /* M */ 0x0000, 0x01FF, 0x01FF, 0x003C, 0x00F0, 0x00F0, 0x003C, 0x01FF, 0x01FF,
+ /* N */ 0x0000, 0x01FF, 0x01FF, 0x001E, 0x0038, 0x00E0, 0x01FF, 0x01FF,
+ /* O */ 0x0000, 0x00FE, 0x01FF, 0x0101, 0x0101, 0x0101, 0x01FF, 0x00FE,
+ /* P */ 0x0000, 0x01FF, 0x01FF, 0x0011, 0x0011, 0x0011, 0x001F, 0x000E,
+ /* Q */ 0x0000, 0x00FE, 0x01FF, 0x0101, 0x0141, 0x01C1, 0x03FF, 0x02FE,
+ /* R */ 0x0000, 0x01FF, 0x01FF, 0x0011, 0x0011, 0x0011, 0x01FF, 0x01EE,
+ /* S */ 0x0000, 0x008E, 0x019F, 0x0111, 0x0111, 0x01F3, 0x00E2,
+ /* T */ 0x0000, 0x0001, 0x0001, 0x01FF, 0x01FF, 0x0001, 0x0001,
+ /* U */ 0x0000, 0x00FF, 0x01FF, 0x0100, 0x0100, 0x0100, 0x01FF, 0x00FF,
+ /* V */ 0x0003, 0x001F, 0x007C, 0x01E0, 0x01E0, 0x007C, 0x001F, 0x0003,
+ /* W */ 0x0003, 0x001F, 0x007C, 0x01E0, 0x01E0, 0x007C, 0x007C, 0x01E0, 0x01E0, 0x007C, 0x001F, 0x0003,
+ /* X */ 0x0183, 0x01C7, 0x006C, 0x0038, 0x0038, 0x006C, 0x01C7, 0x0183,
+ /* Y */ 0x0003, 0x0007, 0x000C, 0x01F8, 0x01F8, 0x000C, 0x0007, 0x0003,
+ /* Z */ 0x0181, 0x01C1, 0x0161, 0x0131, 0x0119, 0x010D, 0x0107, 0x0103,
+ /* [ */ 0x0000, 0x07FF, 0x07FF, 0x0401,
+ /* \ */ 0x0000, 0x0007, 0x001F, 0x0078, 0x01E0, 0x0180,
+ /* ] */ 0x0000, 0x0401, 0x07FF, 0x07FF,
+ /* ^ */ 0x0000, 0x0002, 0x0003, 0x0001, 0x0001, 0x0003, 0x0002,
+ /* _ */ 0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400,
+ /* ` */ 0x0000, 0x0001, 0x0003, 0x0002,
+ /* a */ 0x0000, 0x00C0, 0x01E8, 0x0128, 0x0128, 0x01F8, 0x01F0,
+ /* b */ 0x0000, 0x01FF, 0x01FF, 0x0108, 0x0108, 0x01F8, 0x00F0,
+ /* c */ 0x0000, 0x00F0, 0x01F8, 0x0108, 0x0108, 0x0198, 0x0090,
+ /* d */ 0x0000, 0x00F0, 0x01F8, 0x0108, 0x0108, 0x01FF, 0x01FF,
+ /* e */ 0x0000, 0x00F0, 0x01F8, 0x0128, 0x0128, 0x01B8, 0x00B0,
+ /* f */ 0x0000, 0x01FE, 0x01FF, 0x0009,
+ /* g */ 0x0000, 0x04F0, 0x05F8, 0x0508, 0x0508, 0x07F8, 0x03F8,
+ /* h */ 0x0000, 0x01FF, 0x01FF, 0x0018, 0x0008, 0x01F8, 0x01F0,
+ /* i */ 0x0000, 0x01F9, 0x01F9,
+ /* j */ 0x0000, 0x07F9, 0x07F9,
+ /* k */ 0x0000, 0x01FF, 0x01FF, 0x0070, 0x00D8, 0x0188, 0x0100,
+ /* l */ 0x0000, 0x01FF, 0x01FF,
+ /* m */ 0x0000, 0x01F8, 0x01F8, 0x0008, 0x01F8, 0x01F8, 0x0008, 0x01F8, 0x01F0,
+ /* n */ 0x0000, 0x01F8, 0x01F8, 0x0018, 0x0008, 0x01F8, 0x01F0,
+ /* o */ 0x0000, 0x00F0, 0x01F8, 0x0108, 0x0108, 0x01F8, 0x00F0,
+ /* p */ 0x0000, 0x07F8, 0x07F8, 0x0108, 0x0108, 0x01F8, 0x00F0,
+ /* q */ 0x0000, 0x00F0, 0x01F8, 0x0108, 0x0108, 0x07F8, 0x07F8,
+ /* r */ 0x0000, 0x01F8, 0x01F8, 0x0008,
+ /* s */ 0x0000, 0x0090, 0x01B8, 0x0168, 0x01D8, 0x0090,
+ /* t */ 0x0000, 0x00FE, 0x01FE, 0x0108,
+ /* u */ 0x0000, 0x00F8, 0x01F8, 0x0100, 0x0180, 0x01F8, 0x01F8,
+ /* v */ 0x0000, 0x0018, 0x0078, 0x01E0, 0x01E0, 0x0078, 0x0018,
+ /* w */ 0x0000, 0x0078, 0x01F8, 0x01E0, 0x0078, 0x0078, 0x01E0, 0x01F8, 0x0078,
+ /* x */ 0x0000, 0x0198, 0x01F8, 0x0060, 0x01F8, 0x0198,
+ /* y */ 0x0400, 0x0478, 0x07F8, 0x0380, 0x00F8, 0x0078,
+ /* z */ 0x0000, 0x0188, 0x01C8, 0x0168, 0x0138, 0x0118,
+ /* { */ 0x0000, 0x0010, 0x01FF, 0x03EF, 0x0200,
+ /* | */ 0x0000, 0x03FF, 0x03FF,
+ /* } */ 0x0000, 0x0200, 0x03EF, 0x01FF, 0x0010,
+ /* ~ */ 0x0000, 0x0004, 0x0006, 0x0002, 0x0006, 0x0004, 0x0006, 0x0002
+ };
+#endif
+
+/* fontLarger - Tahoma, 11, Bold */
+#if GDISP_INCLUDE_FONT_LARGER
+ /* Forward Declarations of internal arrays */
+ static const uint8_t fontLarger_Widths[];
+ static const uint16_t fontLarger_Offsets[];
+ static const fontcolumn_t fontLarger_Data[];
+
+ FONT_DECL const struct font fontLarger = {
+ "Larger",
+ 12, 1, 13, 2, 2, 13, ' ', '~', 1, 1,
+ fontLarger_Widths,
+ fontLarger_Offsets,
+ fontLarger_Data};
+ FONT_DECL const struct font fontLargerDouble = {
+ "Larger Double",
+ 12, 1, 13, 2, 2, 13, ' ', '~', 2, 2,
+ fontLarger_Widths,
+ fontLarger_Offsets,
+ fontLarger_Data};
+ FONT_DECL const struct font fontLargerNarrow = {
+ "Larger Narrow",
+ 12, 1, 13, 2, 2, 13, ' ', '~', 1, 2,
+ fontLarger_Widths,
+ fontLarger_Offsets,
+ fontLarger_Data};
+ static const uint8_t fontLarger_Widths[] = {
+ 2, 3, 5, 8, 7, 13, 8, 2, 4, 4, 7, 8, 3, 4, 3, 5,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, 3, 9, 8, 9, 6,
+ 9, 8, 7, 7, 8, 6, 5, 7, 8, 4, 5, 7, 6, 10, 7, 8,
+ 7, 8, 8, 7, 6, 7, 7, 11, 7, 6, 6, 4, 5, 4, 9, 8,
+ 5, 6, 7, 5, 7, 6, 5, 7, 7, 2, 3, 6, 2, 10, 7, 7,
+ 7, 7, 4, 5, 5, 7, 6, 10, 6, 6, 5, 6, 4, 6, 9, 0
+ };
+ static const uint16_t fontLarger_Offsets[] = {
+ 0, 2, 5, 10, 18, 25, 38, 46,
+ 48, 52, 56, 63, 71, 74, 78, 81,
+ 86, 93, 100, 107, 114, 121, 128, 135,
+ 142, 149, 156, 159, 162, 171, 179, 188,
+ 194, 203, 211, 218, 225, 233, 239, 244,
+ 251, 259, 263, 268, 275, 281, 291, 298,
+ 306, 313, 321, 329, 336, 342, 349, 356,
+ 367, 374, 380, 386, 390, 395, 399, 408,
+ 416, 421, 427, 434, 439, 446, 452, 457,
+ 464, 471, 473, 476, 482, 484, 494, 501,
+ 508, 515, 522, 526, 531, 536, 543, 549,
+ 559, 565, 571, 576, 582, 586, 592, 0
+ };
+ static const fontcolumn_t fontLarger_Data[] = {
+ /* */ 0x0000, 0x0000,
+ /* ! */ 0x0000, 0x037E, 0x037E,
+ /* " */ 0x0007, 0x0007, 0x0000, 0x0007, 0x0007,
+ /* # */ 0x00C0, 0x03D8, 0x00F8, 0x00DE, 0x03D8, 0x00F8, 0x00DE, 0x0018,
+ /* $ */ 0x0118, 0x023C, 0x0264, 0x0FFF, 0x0264, 0x03C4, 0x0188,
+ /* % */ 0x001C, 0x003E, 0x0022, 0x023E, 0x011C, 0x00C0, 0x0020, 0x0018, 0x01C4, 0x03E2, 0x0220, 0x03E0,
+ 0x01C0,
+ /* & */ 0x01CC, 0x03FE, 0x0232, 0x0272, 0x03DE, 0x018C, 0x03E0, 0x0260,
+ /* ' */ 0x0007, 0x0007,
+ /* ( */ 0x01F8, 0x07FE, 0x0E07, 0x0801,
+ /* ) */ 0x0801, 0x0E07, 0x07FE, 0x01F8,
+ /* * */ 0x0000, 0x000A, 0x0004, 0x001F, 0x001F, 0x0004, 0x000A,
+ /* + */ 0x0000, 0x0020, 0x0020, 0x0020, 0x01FC, 0x0020, 0x0020, 0x0020,
+ /* , */ 0x0000, 0x0F00, 0x0700,
+ /* - */ 0x0020, 0x0020, 0x0020, 0x0020,
+ /* . */ 0x0000, 0x0300, 0x0300,
+ /* / */ 0x0C00, 0x0380, 0x0060, 0x001C, 0x0003,
+ /* 0 */ 0x01FC, 0x03FE, 0x0202, 0x0202, 0x0202, 0x03FE, 0x01FC,
+ /* 1 */ 0x0000, 0x0204, 0x0204, 0x03FE, 0x03FE, 0x0200, 0x0200,
+ /* 2 */ 0x0204, 0x0302, 0x0382, 0x02C2, 0x0262, 0x023E, 0x021C,
+ /* 3 */ 0x0104, 0x0202, 0x0222, 0x0222, 0x0222, 0x03FE, 0x01DC,
+ /* 4 */ 0x0060, 0x0050, 0x0048, 0x0044, 0x03FE, 0x03FE, 0x0040,
+ /* 5 */ 0x0100, 0x021E, 0x021E, 0x0212, 0x0212, 0x03F2, 0x01E2,
+ /* 6 */ 0x01F8, 0x03FC, 0x0216, 0x0212, 0x0212, 0x03F2, 0x01E0,
+ /* 7 */ 0x0002, 0x0002, 0x0382, 0x03E2, 0x007A, 0x001E, 0x0006,
+ /* 8 */ 0x01DC, 0x03FE, 0x0222, 0x0222, 0x0222, 0x03FE, 0x01DC,
+ /* 9 */ 0x003C, 0x027E, 0x0242, 0x0242, 0x0342, 0x01FE, 0x00FC,
+ /* : */ 0x0000, 0x0318, 0x0318,
+ /* ; */ 0x0000, 0x0F18, 0x0718,
+ /* < */ 0x0000, 0x0060, 0x0060, 0x0090, 0x0090, 0x0108, 0x0108, 0x0204, 0x0204,
+ /* = */ 0x0000, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090,
+ /* > */ 0x0000, 0x0204, 0x0204, 0x0108, 0x0108, 0x0090, 0x0090, 0x0060, 0x0060,
+ /* ? */ 0x0004, 0x0002, 0x0362, 0x0372, 0x001E, 0x000C,
+ /* @ */ 0x01F8, 0x0204, 0x04F2, 0x05FA, 0x050A, 0x04FA, 0x05FA, 0x0104, 0x00F8,
+ /* A */ 0x0380, 0x03F0, 0x00FC, 0x008E, 0x008E, 0x00FC, 0x03F0, 0x0380,
+ /* B */ 0x03FE, 0x03FE, 0x0222, 0x0222, 0x0222, 0x03FE, 0x01DC,
+ /* C */ 0x01FC, 0x03FE, 0x0202, 0x0202, 0x0202, 0x0202, 0x018C,
+ /* D */ 0x03FE, 0x03FE, 0x0202, 0x0202, 0x0202, 0x0306, 0x01FC, 0x00F8,
+ /* E */ 0x03FE, 0x03FE, 0x0222, 0x0222, 0x0222, 0x0222,
+ /* F */ 0x03FE, 0x03FE, 0x0022, 0x0022, 0x0022,
+ /* G */ 0x01FC, 0x03FE, 0x0202, 0x0202, 0x0222, 0x03E2, 0x03EC,
+ /* H */ 0x03FE, 0x03FE, 0x0020, 0x0020, 0x0020, 0x0020, 0x03FE, 0x03FE,
+ /* I */ 0x0202, 0x03FE, 0x03FE, 0x0202,
+ /* J */ 0x0200, 0x0202, 0x0202, 0x03FE, 0x01FE,
+ /* K */ 0x03FE, 0x03FE, 0x0070, 0x00D8, 0x018C, 0x0306, 0x0202,
+ /* L */ 0x03FE, 0x03FE, 0x0200, 0x0200, 0x0200, 0x0200,
+ /* M */ 0x03FE, 0x000E, 0x001C, 0x0038, 0x0070, 0x0030, 0x0018, 0x000C, 0x03FE, 0x03FE,
+ /* N */ 0x03FE, 0x000E, 0x001C, 0x0070, 0x01E0, 0x0380, 0x03FE,
+ /* O */ 0x01FC, 0x03FE, 0x0202, 0x0202, 0x0202, 0x0202, 0x03FE, 0x01FC,
+ /* P */ 0x03FE, 0x03FE, 0x0042, 0x0042, 0x0042, 0x007E, 0x003C,
+ /* Q */ 0x01FC, 0x03FE, 0x0202, 0x0202, 0x0602, 0x0E02, 0x0BFE, 0x09FC,
+ /* R */ 0x03FE, 0x03FE, 0x0022, 0x0062, 0x00E2, 0x01BE, 0x031C, 0x0200,
+ /* S */ 0x019C, 0x023E, 0x0222, 0x0222, 0x0222, 0x03E2, 0x01CC,
+ /* T */ 0x0002, 0x0002, 0x03FE, 0x03FE, 0x0002, 0x0002,
+ /* U */ 0x01FE, 0x03FE, 0x0200, 0x0200, 0x0200, 0x03FE, 0x01FE,
+ /* V */ 0x000E, 0x007E, 0x03F0, 0x0380, 0x03F0, 0x007E, 0x000E,
+ /* W */ 0x001E, 0x00FE, 0x03E0, 0x03E0, 0x00FC, 0x000E, 0x00FC, 0x03E0, 0x03E0, 0x00FE, 0x001E,
+ /* X */ 0x0306, 0x038E, 0x00F8, 0x0070, 0x00F8, 0x038E, 0x0306,
+ /* Y */ 0x000E, 0x003E, 0x03F0, 0x03F0, 0x003E, 0x000E,
+ /* Z */ 0x0382, 0x03C2, 0x0262, 0x0232, 0x021E, 0x020E,
+ /* [ */ 0x0FFF, 0x0FFF, 0x0801, 0x0801,
+ /* \ */ 0x0003, 0x001C, 0x0060, 0x0380, 0x0C00,
+ /* ] */ 0x0801, 0x0801, 0x0FFF, 0x0FFF,
+ /* ^ */ 0x0000, 0x0010, 0x0008, 0x0004, 0x0002, 0x0002, 0x0004, 0x0008, 0x0010,
+ /* _ */ 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800,
+ /* ` */ 0x0000, 0x0000, 0x0001, 0x0003, 0x0002,
+ /* a */ 0x0180, 0x03D0, 0x0248, 0x0248, 0x03F8, 0x03F0,
+ /* b */ 0x03FF, 0x03FF, 0x0210, 0x0208, 0x0208, 0x03F8, 0x01F0,
+ /* c */ 0x01F0, 0x03F8, 0x0208, 0x0208, 0x0208,
+ /* d */ 0x01F0, 0x03F8, 0x0208, 0x0208, 0x0108, 0x03FF, 0x03FF,
+ /* e */ 0x01F0, 0x03F8, 0x0248, 0x0248, 0x0278, 0x0170,
+ /* f */ 0x0008, 0x03FE, 0x03FF, 0x0009, 0x0001,
+ /* g */ 0x01F0, 0x0BF8, 0x0A08, 0x0A08, 0x0908, 0x0FF8, 0x07F8,
+ /* h */ 0x03FF, 0x03FF, 0x0010, 0x0008, 0x0008, 0x03F8, 0x03F0,
+ /* i */ 0x03FA, 0x03FA,
+ /* j */ 0x0808, 0x0FFA, 0x07FA,
+ /* k */ 0x03FF, 0x03FF, 0x00E0, 0x01B0, 0x0318, 0x0208,
+ /* l */ 0x03FF, 0x03FF,
+ /* m */ 0x03F8, 0x03F8, 0x0008, 0x0008, 0x03F8, 0x03F0, 0x0008, 0x0008, 0x03F8, 0x03F0,
+ /* n */ 0x03F8, 0x03F8, 0x0010, 0x0008, 0x0008, 0x03F8, 0x03F0,
+ /* o */ 0x01F0, 0x03F8, 0x0208, 0x0208, 0x0208, 0x03F8, 0x01F0,
+ /* p */ 0x0FF8, 0x0FF8, 0x0210, 0x0208, 0x0208, 0x03F8, 0x01F0,
+ /* q */ 0x01F0, 0x03F8, 0x0208, 0x0208, 0x0108, 0x0FF8, 0x0FF8,
+ /* r */ 0x03F8, 0x03F8, 0x0010, 0x0018,
+ /* s */ 0x0130, 0x0278, 0x0248, 0x03C8, 0x0190,
+ /* t */ 0x0008, 0x01FE, 0x03FE, 0x0208, 0x0208,
+ /* u */ 0x01F8, 0x03F8, 0x0200, 0x0200, 0x0100, 0x03F8, 0x03F8,
+ /* v */ 0x0038, 0x00F8, 0x03C0, 0x03C0, 0x00F8, 0x0038,
+ /* w */ 0x0018, 0x00F8, 0x03E0, 0x0380, 0x00F8, 0x00F8, 0x0380, 0x03E0, 0x00F8, 0x0018,
+ /* x */ 0x0318, 0x03B8, 0x00E0, 0x00E0, 0x03B8, 0x0318,
+ /* y */ 0x0038, 0x0CF8, 0x0FC0, 0x03C0, 0x00F8, 0x0038,
+ /* z */ 0x0388, 0x03C8, 0x0268, 0x0238, 0x0218,
+ /* { */ 0x0020, 0x0020, 0x07FE, 0x0FDF, 0x0801, 0x0801,
+ /* | */ 0x0000, 0x0000, 0x0FFF, 0x0FFF,
+ /* } */ 0x0801, 0x0801, 0x0FDF, 0x07FE, 0x0020, 0x0020,
+ /* ~ */ 0x00E0, 0x0030, 0x0030, 0x0030, 0x0060, 0x00C0, 0x00C0, 0x00C0, 0x0070
+ };
+#endif
+
+/* fontUI1 - UI Font 1 Medium Bold */
+#if GDISP_INCLUDE_FONT_UI1
+ /* Forward Declarations of internal arrays */
+ static const uint8_t fontUI1_Widths[];
+ static const uint16_t fontUI1_Offsets[];
+ static const fontcolumn_t fontUI1_Data[];
+
+ FONT_DECL const struct font fontUI1 = {
+ "UI1",
+ 13, 0, 15, 2, 3, 13, ' ', '~', 1, 1,
+ fontUI1_Widths,
+ fontUI1_Offsets,
+ fontUI1_Data};
+ FONT_DECL const struct font fontUI1Double = {
+ "UI1 Double",
+ 13, 0, 15, 2, 3, 13, ' ', '~', 2, 2,
+ fontUI1_Widths,
+ fontUI1_Offsets,
+ fontUI1_Data};
+ FONT_DECL const struct font fontUI1Narrow = {
+ "UI1 Narrow",
+ 13, 0, 15, 2, 3, 13, ' ', '~', 1, 2,
+ fontUI1_Widths,
+ fontUI1_Offsets,
+ fontUI1_Data};
+
+ static const uint8_t fontUI1_Widths[] = {
+ 3, 3, 6, 8, 7, 13, 9, 3, 5, 5, 6, 8, 3, 5, 3, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, 3, 8, 8, 8, 6,
+ 10, 8, 7, 7, 8, 7, 7, 8, 8, 5, 5, 7, 7, 9, 8, 8,
+ 7, 8, 8, 7, 8, 8, 7, 11, 7, 7, 7, 5, 7, 5, 9, 8,
+ 5, 7, 7, 6, 7, 7, 5, 7, 7, 3, 4, 7, 3, 11, 7, 7,
+ 7, 7, 6, 6, 5, 7, 7, 9, 7, 7, 6, 7, 4, 7, 8, 0
+ };
+ static const uint16_t fontUI1_Offsets[] = {
+ 0, 3, 6, 12, 20, 27, 40, 49,
+ 52, 57, 62, 68, 76, 79, 84, 87,
+ 94, 101, 108, 115, 122, 129, 136, 143,
+ 150, 157, 164, 167, 170, 178, 186, 194,
+ 200, 210, 218, 225, 232, 240, 247, 254,
+ 262, 270, 275, 280, 287, 294, 303, 311,
+ 319, 326, 334, 342, 349, 357, 365, 372,
+ 383, 390, 397, 404, 409, 416, 421, 430,
+ 438, 443, 450, 457, 463, 470, 477, 482,
+ 489, 496, 499, 503, 510, 513, 524, 531,
+ 538, 545, 552, 558, 564, 569, 576, 583,
+ 592, 599, 606, 612, 619, 623, 630, 0
+ };
+ static const fontcolumn_t fontUI1_Data[] = {
+ /* */ 0x0000, 0x0000, 0x0000,
+ /* ! */ 0x0000, 0x02FC, 0x02FC,
+ /* " */ 0x0000, 0x000E, 0x000E, 0x0000, 0x000E, 0x000E,
+ /* # */ 0x0000, 0x0080, 0x0390, 0x00F0, 0x039C, 0x00F0, 0x009C, 0x0010,
+ /* $ */ 0x0000, 0x0130, 0x0278, 0x0FC8, 0x027E, 0x03C8, 0x0190,
+ /* % */ 0x0000, 0x0038, 0x007C, 0x0044, 0x007C, 0x0338, 0x00C0, 0x0030, 0x01CC, 0x03E0, 0x0220, 0x03E0,
+ 0x01C0,
+ /* & */ 0x0000, 0x01D8, 0x03FC, 0x0224, 0x027C, 0x02D8, 0x0180, 0x0360, 0x0220,
+ /* ' */ 0x0000, 0x000E, 0x000E,
+ /* ( */ 0x0000, 0x01F0, 0x07FC, 0x0E0E, 0x0802,
+ /* ) */ 0x0000, 0x0802, 0x0E0E, 0x07FC, 0x01F0,
+ /* * */ 0x0000, 0x0014, 0x0008, 0x003E, 0x0008, 0x0014,
+ /* + */ 0x0000, 0x0040, 0x0040, 0x0040, 0x03F8, 0x0040, 0x0040, 0x0040,
+ /* , */ 0x0000, 0x0F00, 0x0700,
+ /* - */ 0x0000, 0x0040, 0x0040, 0x0040, 0x0040,
+ /* . */ 0x0000, 0x0300, 0x0300,
+ /* / */ 0x0000, 0x0C00, 0x0F00, 0x03E0, 0x00F8, 0x001E, 0x0006,
+ /* 0 */ 0x0000, 0x01F8, 0x03FC, 0x0204, 0x0204, 0x03FC, 0x01F8,
+ /* 1 */ 0x0000, 0x0000, 0x0208, 0x03FC, 0x03FC, 0x0200, 0x0000,
+ /* 2 */ 0x0000, 0x0308, 0x038C, 0x02C4, 0x0264, 0x023C, 0x0218,
+ /* 3 */ 0x0000, 0x0108, 0x030C, 0x0224, 0x0224, 0x03FC, 0x01D8,
+ /* 4 */ 0x0000, 0x00C0, 0x00A0, 0x0090, 0x03F8, 0x03FC, 0x0080,
+ /* 5 */ 0x0000, 0x0100, 0x033C, 0x023C, 0x0224, 0x03E4, 0x01C4,
+ /* 6 */ 0x0000, 0x01F0, 0x03F8, 0x022C, 0x0224, 0x03E4, 0x01C0,
+ /* 7 */ 0x0000, 0x0004, 0x0304, 0x03C4, 0x00F4, 0x003C, 0x000C,
+ /* 8 */ 0x0000, 0x01D8, 0x03FC, 0x0224, 0x0224, 0x03FC, 0x01D8,
+ /* 9 */ 0x0000, 0x0038, 0x027C, 0x0244, 0x0344, 0x01FC, 0x00F8,
+ /* : */ 0x0000, 0x0330, 0x0330,
+ /* ; */ 0x0000, 0x0F30, 0x0730,
+ /* < */ 0x0000, 0x0040, 0x00A0, 0x00A0, 0x0110, 0x0110, 0x0208, 0x0208,
+ /* = */ 0x0000, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090,
+ /* > */ 0x0000, 0x0208, 0x0208, 0x0110, 0x0110, 0x00A0, 0x00A0, 0x0040,
+ /* ? */ 0x0000, 0x0008, 0x02C4, 0x02E4, 0x003C, 0x0018,
+ /* @ */ 0x0000, 0x01F0, 0x0208, 0x04E4, 0x05F4, 0x0514, 0x05F4, 0x05F4, 0x0104, 0x00F8,
+ /* A */ 0x0000, 0x0380, 0x03F0, 0x00FC, 0x008C, 0x00FC, 0x03F0, 0x0380,
+ /* B */ 0x0000, 0x03FC, 0x03FC, 0x0224, 0x0224, 0x03FC, 0x01D8,
+ /* C */ 0x0000, 0x01F8, 0x03FC, 0x0204, 0x0204, 0x0204, 0x0108,
+ /* D */ 0x0000, 0x03FC, 0x03FC, 0x0204, 0x0204, 0x030C, 0x01F8, 0x00F0,
+ /* E */ 0x0000, 0x03FC, 0x03FC, 0x0224, 0x0224, 0x0224, 0x0224,
+ /* F */ 0x0000, 0x03FC, 0x03FC, 0x0024, 0x0024, 0x0024, 0x0024,
+ /* G */ 0x0000, 0x01F8, 0x03FC, 0x0204, 0x0204, 0x0244, 0x03C4, 0x03C8,
+ /* H */ 0x0000, 0x03FC, 0x03FC, 0x0020, 0x0020, 0x0020, 0x03FC, 0x03FC,
+ /* I */ 0x0000, 0x0204, 0x03FC, 0x03FC, 0x0204,
+ /* J */ 0x0200, 0x0204, 0x0204, 0x03FC, 0x01FC,
+ /* K */ 0x0000, 0x03FC, 0x03FC, 0x00F0, 0x0198, 0x030C, 0x0204,
+ /* L */ 0x0000, 0x03FC, 0x03FC, 0x0200, 0x0200, 0x0200, 0x0200,
+ /* M */ 0x0000, 0x03FC, 0x001C, 0x0038, 0x0070, 0x0020, 0x0010, 0x03F8, 0x03FC,
+ /* N */ 0x0000, 0x03FC, 0x0018, 0x0030, 0x0060, 0x00C0, 0x0180, 0x03FC,
+ /* O */ 0x0000, 0x01F8, 0x03FC, 0x0204, 0x0204, 0x0204, 0x03FC, 0x01F8,
+ /* P */ 0x0000, 0x03FC, 0x03FC, 0x0044, 0x0044, 0x007C, 0x0038,
+ /* Q */ 0x0000, 0x01F8, 0x03FC, 0x0204, 0x0604, 0x0E04, 0x0BFC, 0x09F8,
+ /* R */ 0x0000, 0x03FC, 0x03FC, 0x0044, 0x00C4, 0x01FC, 0x0338, 0x0200,
+ /* S */ 0x0000, 0x0138, 0x027C, 0x0264, 0x0264, 0x03E4, 0x01C8,
+ /* T */ 0x0004, 0x0004, 0x0004, 0x03FC, 0x03FC, 0x0004, 0x0004, 0x0004,
+ /* U */ 0x0000, 0x01FC, 0x03FC, 0x0200, 0x0200, 0x0200, 0x03FC, 0x01FC,
+ /* V */ 0x0000, 0x001C, 0x00FC, 0x03E0, 0x03E0, 0x00FC, 0x001C,
+ /* W */ 0x0000, 0x001C, 0x00FC, 0x03E0, 0x03C0, 0x007C, 0x007C, 0x03C0, 0x03E0, 0x00FC, 0x001C,
+ /* X */ 0x0000, 0x030C, 0x039C, 0x00F0, 0x00F0, 0x039C, 0x030C,
+ /* Y */ 0x0000, 0x000C, 0x003C, 0x03F0, 0x03F0, 0x003C, 0x000C,
+ /* Z */ 0x0000, 0x0384, 0x03C4, 0x02E4, 0x0274, 0x023C, 0x021C,
+ /* [ */ 0x0000, 0x0FFE, 0x0FFE, 0x0802, 0x0802,
+ /* \ */ 0x0000, 0x0006, 0x001E, 0x00F8, 0x03E0, 0x0F00, 0x0C00,
+ /* ] */ 0x0000, 0x0802, 0x0802, 0x0FFE, 0x0FFE,
+ /* ^ */ 0x0000, 0x0020, 0x0030, 0x0018, 0x000C, 0x000C, 0x0018, 0x0030, 0x0020,
+ /* _ */ 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800,
+ /* ` */ 0x0000, 0x0000, 0x0002, 0x0006, 0x0004,
+ /* a */ 0x0000, 0x0180, 0x03D0, 0x0250, 0x0250, 0x03F0, 0x03E0,
+ /* b */ 0x0000, 0x03FE, 0x03FE, 0x0210, 0x0210, 0x03F0, 0x01E0,
+ /* c */ 0x0000, 0x01E0, 0x03F0, 0x0210, 0x0210, 0x0210,
+ /* d */ 0x0000, 0x01E0, 0x03F0, 0x0210, 0x0210, 0x03FE, 0x03FE,
+ /* e */ 0x0000, 0x01E0, 0x03F0, 0x0250, 0x0250, 0x0270, 0x0160,
+ /* f */ 0x0010, 0x03FC, 0x03FE, 0x0012, 0x0012,
+ /* g */ 0x0000, 0x01E0, 0x0BF0, 0x0A10, 0x0A10, 0x0FF0, 0x07F0,
+ /* h */ 0x0000, 0x03FE, 0x03FE, 0x0010, 0x0010, 0x03F0, 0x03E0,
+ /* i */ 0x0000, 0x03F4, 0x03F4,
+ /* j */ 0x0800, 0x0810, 0x0FF4, 0x07F4,
+ /* k */ 0x0000, 0x03FE, 0x03FE, 0x00C0, 0x01E0, 0x0330, 0x0210,
+ /* l */ 0x0000, 0x03FE, 0x03FE,
+ /* m */ 0x0000, 0x03F0, 0x03F0, 0x0010, 0x0010, 0x03F0, 0x03E0, 0x0010, 0x0010, 0x03F0, 0x03E0,
+ /* n */ 0x0000, 0x03F0, 0x03F0, 0x0010, 0x0010, 0x03F0, 0x03E0,
+ /* o */ 0x0000, 0x01E0, 0x03F0, 0x0210, 0x0210, 0x03F0, 0x01E0,
+ /* p */ 0x0000, 0x0FF0, 0x0FF0, 0x0210, 0x0210, 0x03F0, 0x01E0,
+ /* q */ 0x0000, 0x01E0, 0x03F0, 0x0210, 0x0210, 0x0FF0, 0x0FF0,
+ /* r */ 0x0000, 0x03F0, 0x03F0, 0x0020, 0x0030, 0x0030,
+ /* s */ 0x0000, 0x0260, 0x02F0, 0x02D0, 0x03D0, 0x0190,
+ /* t */ 0x0010, 0x01FC, 0x03FC, 0x0210, 0x0210,
+ /* u */ 0x0000, 0x01F0, 0x03F0, 0x0200, 0x0200, 0x03F0, 0x03F0,
+ /* v */ 0x0000, 0x0070, 0x01F0, 0x0380, 0x0380, 0x01F0, 0x0070,
+ /* w */ 0x0000, 0x00F0, 0x03F0, 0x0300, 0x00F0, 0x00F0, 0x0300, 0x03F0, 0x00F0,
+ /* x */ 0x0000, 0x0330, 0x03F0, 0x00C0, 0x00C0, 0x03F0, 0x0330,
+ /* y */ 0x0000, 0x0030, 0x0CF0, 0x0FC0, 0x03C0, 0x00F0, 0x0030,
+ /* z */ 0x0000, 0x0310, 0x0390, 0x02D0, 0x0270, 0x0230,
+ /* { */ 0x0000, 0x0040, 0x0040, 0x07FC, 0x0FBE, 0x0802, 0x0802,
+ /* | */ 0x0000, 0x0000, 0x0FFE, 0x0FFE,
+ /* } */ 0x0000, 0x0802, 0x0802, 0x0FBE, 0x07FC, 0x0040, 0x0040,
+ /* ~ */ 0x0000, 0x01C0, 0x0020, 0x0020, 0x00C0, 0x0100, 0x0100, 0x00E0
+ };
+#endif
+
+/* fontUI1 - UI Font 2 Medium Bold */
+#if GDISP_INCLUDE_FONT_UI2
+ /* Forward Declarations of internal arrays */
+ static const uint8_t fontUI2_Widths[];
+ static const uint16_t fontUI2_Offsets[];
+ static const fontcolumn_t fontUI2_Data[];
+
+ FONT_DECL const struct font fontUI2 = {
+ "UI2",
+ 11, 1, 13, 2, 2, 12, ' ', '~', 1, 1,
+ fontUI2_Widths,
+ fontUI2_Offsets,
+ fontUI2_Data};
+ FONT_DECL const struct font fontUI2Double = {
+ "UI2 Double",
+ 11, 1, 13, 2, 2, 12, ' ', '~', 2, 2,
+ fontUI2_Widths,
+ fontUI2_Offsets,
+ fontUI2_Data};
+ FONT_DECL const struct font fontUI2Narrow = {
+ "UI2 Narrow",
+ 11, 1, 13, 2, 2, 12, ' ', '~', 1, 2,
+ fontUI2_Widths,
+ fontUI2_Offsets,
+ fontUI2_Data};
+
+ static const uint8_t fontUI2_Widths[] = {
+ 2, 2, 5, 8, 6, 12, 8, 2, 4, 4, 6, 8, 2, 4, 2, 5,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 2, 2, 8, 8, 8, 5,
+ 9, 7, 6, 6, 7, 5, 5, 7, 7, 4, 5, 6, 5, 9, 6, 7,
+ 6, 7, 7, 6, 6, 7, 6, 10, 6, 6, 6, 4, 5, 4, 7, 7,
+ 4, 6, 6, 5, 6, 6, 4, 6, 6, 2, 3, 6, 2, 10, 6, 6,
+ 6, 6, 4, 5, 4, 6, 6, 8, 6, 6, 5, 6, 4, 6, 8, 0
+ };
+ static const uint16_t fontUI2_Offsets[] = {
+ 0, 2, 4, 9, 17, 23, 35, 43,
+ 45, 49, 53, 59, 67, 69, 73, 75,
+ 80, 86, 92, 98, 104, 110, 116, 122,
+ 128, 134, 140, 142, 144, 152, 160, 168,
+ 173, 182, 189, 195, 201, 208, 213, 218,
+ 225, 232, 236, 241, 247, 252, 261, 267,
+ 274, 280, 287, 294, 300, 306, 313, 319,
+ 329, 335, 341, 347, 351, 356, 360, 367,
+ 374, 378, 384, 390, 395, 401, 407, 411,
+ 417, 423, 425, 428, 434, 436, 446, 452,
+ 458, 464, 470, 474, 479, 483, 489, 495,
+ 503, 509, 515, 520, 526, 530, 536, 0
+ };
+ static const fontcolumn_t fontUI2_Data[] = {
+ /* */ 0x0000, 0x0000,
+ /* ! */ 0x017E, 0x017E,
+ /* " */ 0x0007, 0x0007, 0x0000, 0x0007, 0x0007,
+ /* # */ 0x00C0, 0x03D8, 0x00F8, 0x00DE, 0x03D8, 0x00F8, 0x00DE, 0x0018,
+ /* $ */ 0x0098, 0x013C, 0x07E4, 0x013F, 0x01E4, 0x00C8,
+ /* % */ 0x001C, 0x003E, 0x0022, 0x003E, 0x019C, 0x0060, 0x0018, 0x00E6, 0x01F0, 0x0110, 0x01F0, 0x00E0,
+ /* & */ 0x00EC, 0x01FE, 0x0112, 0x013E, 0x016C, 0x00C0, 0x01B0, 0x0110,
+ /* ' */ 0x0007, 0x0007,
+ /* ( */ 0x00F8, 0x03FE, 0x0707, 0x0401,
+ /* ) */ 0x0401, 0x0707, 0x03FE, 0x00F8,
+ /* * */ 0x000A, 0x0004, 0x001F, 0x001F, 0x0004, 0x000A,
+ /* + */ 0x0000, 0x0020, 0x0020, 0x0020, 0x01FC, 0x0020, 0x0020, 0x0020,
+ /* , */ 0x0780, 0x0380,
+ /* - */ 0x0020, 0x0020, 0x0020, 0x0020,
+ /* . */ 0x0180, 0x0180,
+ /* / */ 0x0600, 0x0180, 0x0070, 0x000C, 0x0003,
+ /* 0 */ 0x00FC, 0x01FE, 0x0102, 0x0102, 0x01FE, 0x00FC,
+ /* 1 */ 0x0000, 0x0104, 0x01FE, 0x01FE, 0x0100, 0x0000,
+ /* 2 */ 0x0184, 0x01C6, 0x0162, 0x0132, 0x011E, 0x010C,
+ /* 3 */ 0x0084, 0x0186, 0x0112, 0x0112, 0x01FE, 0x00EC,
+ /* 4 */ 0x0060, 0x0050, 0x0048, 0x01FC, 0x01FE, 0x0040,
+ /* 5 */ 0x0080, 0x019E, 0x011E, 0x0112, 0x01F2, 0x00E2,
+ /* 6 */ 0x00FC, 0x01FE, 0x0112, 0x0112, 0x01F2, 0x00E0,
+ /* 7 */ 0x0002, 0x0002, 0x01C2, 0x01FA, 0x003E, 0x0006,
+ /* 8 */ 0x00EC, 0x01FE, 0x0112, 0x0112, 0x01FE, 0x00EC,
+ /* 9 */ 0x001C, 0x013E, 0x0122, 0x0122, 0x01FE, 0x00FC,
+ /* : */ 0x0198, 0x0198,
+ /* ; */ 0x0798, 0x0398,
+ /* < */ 0x0000, 0x0020, 0x0050, 0x0050, 0x0088, 0x0088, 0x0104, 0x0104,
+ /* = */ 0x0000, 0x0048, 0x0048, 0x0048, 0x0048, 0x0048, 0x0048, 0x0048,
+ /* > */ 0x0000, 0x0104, 0x0104, 0x0088, 0x0088, 0x0050, 0x0050, 0x0020,
+ /* ? */ 0x0004, 0x0162, 0x0172, 0x001E, 0x000C,
+ /* @ */ 0x00F8, 0x0104, 0x0272, 0x02FA, 0x028A, 0x027A, 0x02FA, 0x0084, 0x0078,
+ /* A */ 0x01C0, 0x01F8, 0x007E, 0x0046, 0x007E, 0x01F8, 0x01C0,
+ /* B */ 0x01FE, 0x01FE, 0x0112, 0x0112, 0x01FE, 0x00EC,
+ /* C */ 0x00FC, 0x01FE, 0x0102, 0x0102, 0x0102, 0x0102,
+ /* D */ 0x01FE, 0x01FE, 0x0102, 0x0102, 0x0186, 0x00FC, 0x0078,
+ /* E */ 0x01FE, 0x01FE, 0x0112, 0x0112, 0x0112,
+ /* F */ 0x01FE, 0x01FE, 0x0012, 0x0012, 0x0012,
+ /* G */ 0x00FC, 0x01FE, 0x0102, 0x0102, 0x0122, 0x01E2, 0x01E2,
+ /* H */ 0x01FE, 0x01FE, 0x0010, 0x0010, 0x0010, 0x01FE, 0x01FE,
+ /* I */ 0x0102, 0x01FE, 0x01FE, 0x0102,
+ /* J */ 0x0100, 0x0102, 0x0102, 0x01FE, 0x00FE,
+ /* K */ 0x01FE, 0x01FE, 0x0078, 0x00CC, 0x0186, 0x0102,
+ /* L */ 0x01FE, 0x01FE, 0x0100, 0x0100, 0x0100,
+ /* M */ 0x01FE, 0x000E, 0x001C, 0x0038, 0x0030, 0x0018, 0x000C, 0x01FE, 0x01FE,
+ /* N */ 0x01FE, 0x000E, 0x001C, 0x0038, 0x0070, 0x01FE,
+ /* O */ 0x00FC, 0x01FE, 0x0102, 0x0102, 0x0102, 0x01FE, 0x00FC,
+ /* P */ 0x01FE, 0x01FE, 0x0022, 0x0022, 0x003E, 0x001C,
+ /* Q */ 0x00FC, 0x01FE, 0x0102, 0x0302, 0x0702, 0x05FE, 0x04FC,
+ /* R */ 0x01FE, 0x01FE, 0x0022, 0x0062, 0x00FE, 0x019C, 0x0100,
+ /* S */ 0x011C, 0x013E, 0x0132, 0x0132, 0x01F2, 0x00E2,
+ /* T */ 0x0002, 0x0002, 0x01FE, 0x01FE, 0x0002, 0x0002,
+ /* U */ 0x00FE, 0x01FE, 0x0100, 0x0100, 0x0100, 0x01FE, 0x00FE,
+ /* V */ 0x000E, 0x007E, 0x01F0, 0x01F0, 0x007E, 0x000E,
+ /* W */ 0x000E, 0x007E, 0x01F0, 0x01E0, 0x003E, 0x003E, 0x01E0, 0x01F0, 0x007E, 0x000E,
+ /* X */ 0x0186, 0x01CE, 0x0078, 0x0078, 0x01CE, 0x0186,
+ /* Y */ 0x0006, 0x001E, 0x01F8, 0x01F8, 0x001E, 0x0006,
+ /* Z */ 0x01C2, 0x01E2, 0x0172, 0x013A, 0x011E, 0x010E,
+ /* [ */ 0x07FF, 0x07FF, 0x0401, 0x0401,
+ /* \ */ 0x0003, 0x000C, 0x0070, 0x0180, 0x0600,
+ /* ] */ 0x0401, 0x0401, 0x07FF, 0x07FF,
+ /* ^ */ 0x0010, 0x0008, 0x0004, 0x0002, 0x0004, 0x0008, 0x0010,
+ /* _ */ 0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400,
+ /* ` */ 0x0000, 0x0001, 0x0003, 0x0002,
+ /* a */ 0x00C0, 0x01E8, 0x0128, 0x0128, 0x01F8, 0x01F0,
+ /* b */ 0x01FF, 0x01FF, 0x0108, 0x0108, 0x01F8, 0x00F0,
+ /* c */ 0x00F0, 0x01F8, 0x0108, 0x0108, 0x0108,
+ /* d */ 0x00F0, 0x01F8, 0x0108, 0x0108, 0x01FF, 0x01FF,
+ /* e */ 0x00F0, 0x01F8, 0x0128, 0x0128, 0x0138, 0x0130,
+ /* f */ 0x01FE, 0x01FF, 0x0009, 0x0001,
+ /* g */ 0x00F0, 0x05F8, 0x0508, 0x0508, 0x07F8, 0x03F8,
+ /* h */ 0x01FF, 0x01FF, 0x0008, 0x0008, 0x01F8, 0x01F0,
+ /* i */ 0x01FA, 0x01FA,
+ /* j */ 0x0408, 0x07FA, 0x03FA,
+ /* k */ 0x01FF, 0x01FF, 0x0060, 0x00F0, 0x0198, 0x0108,
+ /* l */ 0x01FF, 0x01FF,
+ /* m */ 0x01F8, 0x01F8, 0x0008, 0x0008, 0x01F8, 0x01F0, 0x0008, 0x0008, 0x01F8, 0x01F0,
+ /* n */ 0x01F8, 0x01F8, 0x0008, 0x0008, 0x01F8, 0x01F0,
+ /* o */ 0x00F0, 0x01F8, 0x0108, 0x0108, 0x01F8, 0x00F0,
+ /* p */ 0x07F8, 0x07F8, 0x0108, 0x0108, 0x01F8, 0x00F0,
+ /* q */ 0x00F0, 0x01F8, 0x0108, 0x0108, 0x07F8, 0x07F8,
+ /* r */ 0x01F8, 0x01F8, 0x0010, 0x0018,
+ /* s */ 0x0130, 0x0178, 0x0168, 0x01E8, 0x00C8,
+ /* t */ 0x00FE, 0x01FE, 0x0108, 0x0108,
+ /* u */ 0x00F8, 0x01F8, 0x0100, 0x0100, 0x01F8, 0x01F8,
+ /* v */ 0x0018, 0x0078, 0x01E0, 0x01E0, 0x0078, 0x0018,
+ /* w */ 0x0078, 0x01F8, 0x01C0, 0x0078, 0x0078, 0x01C0, 0x01F8, 0x0078,
+ /* x */ 0x0198, 0x01F8, 0x0060, 0x0060, 0x01F8, 0x0198,
+ /* y */ 0x0018, 0x0678, 0x07E0, 0x01E0, 0x0078, 0x0018,
+ /* z */ 0x0188, 0x01C8, 0x0168, 0x0138, 0x0118,
+ /* { */ 0x0020, 0x0020, 0x03FE, 0x07DF, 0x0401, 0x0401,
+ /* | */ 0x0000, 0x0000, 0x07FF, 0x07FF,
+ /* } */ 0x0401, 0x0401, 0x07DF, 0x03FE, 0x0020, 0x0020,
+ /* ~ */ 0x0060, 0x0010, 0x0010, 0x0030, 0x0060, 0x0040, 0x0040, 0x0030
+ };
+#endif
+
+/*
+ fontLargeNumbers:
+ Large numbers font, height = 16 (including the decenders)
+ Characters include: 0 - 9, -, +, ., %, :, Space, Comma
+*/
+#if GDISP_INCLUDE_FONT_LARGENUMBERS
+ /* Forward Declarations of internal arrays */
+ static const uint8_t fontLargeNumbers_Widths[];
+ static const uint16_t fontLargeNumbers_Offsets[];
+ static const fontcolumn_t fontLargeNumbers_Data[];
+
+ FONT_DECL const struct font fontLargeNumbers = {
+ "LargeNumbers",
+ 16, 2, 21, 1, 3, 15, '%', ':', 1, 1,
+ fontLargeNumbers_Widths,
+ fontLargeNumbers_Offsets,
+ fontLargeNumbers_Data};
+ FONT_DECL const struct font fontLargeNumbersDouble = {
+ "LargeNumbers Double",
+ 16, 2, 21, 1, 3, 15, '%', ':', 2, 2,
+ fontLargeNumbers_Widths,
+ fontLargeNumbers_Offsets,
+ fontLargeNumbers_Data};
+ FONT_DECL const struct font fontLargeNumbersNarrow = {
+ "LargeNumbers Narrow", 16, 2, 21, 1, 3, 15, '%', ':', 1, 2,
+ fontLargeNumbers_Widths,
+ fontLargeNumbers_Offsets,
+ fontLargeNumbers_Data};
+
+ static const uint8_t fontLargeNumbers_Widths[] = {
+ 15, 0, 0, 0, 0, 0, 11, 3, 6, 3, 0, 10, 10, 10, 10, 10,
+ 10, 10, 10, 10, 10, 4, 0, 0
+ };
+ static const uint16_t fontLargeNumbers_Offsets[] = {
+ 0, 0, 0, 0, 0, 0, 15, 26,
+ 29, 35, 0, 38, 48, 58, 68, 78,
+ 88, 98, 108, 118, 128, 138, 0, 0
+ };
+ static const fontcolumn_t fontLargeNumbers_Data[] = {
+ /* % */ 0x007E, 0x00FF, 0x00C3, 0x80C3, 0xE0FF, 0x7C7E, 0x1F00, 0x07C0, 0x00F0, 0x7E3E, 0xFF0F, 0xC303,
+ 0xC300, 0xFF00, 0x7E00,
+ /* + */ 0x01C0, 0x01C0, 0x01C0, 0x01C0, 0x1FFC, 0x1FFC, 0x1FFC, 0x01C0, 0x01C0, 0x01C0, 0x01C0,
+ /* , */ 0x7000, 0x7000, 0xF000,
+ /* - */ 0x0700, 0x0700, 0x0700, 0x0700, 0x0700, 0x0700,
+ /* . */ 0x7000, 0x7000, 0x7000,
+ /* 0 */ 0x0FF8, 0x3FFE, 0x3FFE, 0x7007, 0x6003, 0x6003, 0x7007, 0x3FFE, 0x3FFE, 0x0FF8,
+ /* 1 */ 0x0000, 0x0070, 0x0038, 0x0038, 0x001C, 0x7FFF, 0x7FFF, 0x7FFF, 0x0000, 0x0000,
+ /* 2 */ 0x600C, 0x700E, 0x7C0F, 0x7E07, 0x6F03, 0x6783, 0x63C7, 0x61FF, 0x60FE, 0x603C,
+ /* 3 */ 0x180C, 0x380E, 0x780F, 0x70C3, 0x60C3, 0x60E3, 0x71FF, 0x3FFE, 0x3F3C, 0x0E00,
+ /* 4 */ 0x0F00, 0x0DC0, 0x0CE0, 0x0C38, 0x0C1E, 0x7FFF, 0x7FFF, 0x7FFF, 0x0C00, 0x0C00,
+ /* 5 */ 0x18C0, 0x38FC, 0x78FF, 0x707F, 0x6063, 0x6063, 0x70E3, 0x3FE3, 0x3FC3, 0x0F80,
+ /* 6 */ 0x0FF8, 0x3FFE, 0x3FFE, 0x70C7, 0x6063, 0x6063, 0x70E7, 0x3FEF, 0x3FC6, 0x0F04,
+ /* 7 */ 0x0003, 0x0003, 0x7803, 0x7F03, 0x7FC3, 0x07F3, 0x00FB, 0x003F, 0x000F, 0x0007,
+ /* 8 */ 0x1E1C, 0x3F3E, 0x7FFF, 0x71E7, 0x60C3, 0x60C3, 0x71E7, 0x7FFF, 0x3F3E, 0x1E1C,
+ /* 9 */ 0x1078, 0x39FE, 0x7BFE, 0x7387, 0x6303, 0x6303, 0x7187, 0x3FFE, 0x3FFE, 0x0FF8,
+ /* : */ 0x0000, 0x0E38, 0x0E38, 0x0E38
+ };
+#endif
+
+static const struct font *BuiltinFontTable[] = {
+ #if GDISP_INCLUDE_FONT_SMALL
+ &fontSmall, &fontSmallDouble, &fontSmallNarrow,
+ #endif
+ #if GDISP_INCLUDE_FONT_LARGER
+ &fontLarger, &fontLargerDouble, &fontLargerNarrow,
+ #endif
+ #if GDISP_INCLUDE_FONT_UI1
+ &fontUI1, &fontUI1Double, &fontUI1Narrow,
+ #endif
+ #if GDISP_INCLUDE_FONT_UI2
+ &fontUI2, &fontUI2Double, &fontUI2Narrow,
+ #endif
+ #if GDISP_INCLUDE_FONT_LARGENUMBERS
+ &fontLargeNumbers, &fontLargeNumbersDouble, &fontLargeNumbersNarrow,
+ #endif
+ };
+
+/**
+ * Match a pattern against the font name.
+ */
+static bool_t matchfont(const char *pattern, const char *name) {
+ while(1) {
+ switch (pattern[0]) {
+ case '*':
+ if (name[0] == 0)
+ return pattern[1] == 0;
+ if (pattern[1] == name[0])
+ pattern++;
+ else
+ name++;
+ break;
+ case 0:
+ return name[0] == 0;
+ default:
+ if (name[0] != pattern[0])
+ return FALSE;
+ pattern++;
+ name++;
+ break;
+ }
+ }
+}
+
+/**
+ * @brief Find a font and return it.
+ * @details The supplied name is matched against the font name. A '*' will replace 0 or more characters.
+ * @return Returns a font or NULL if no matching font could be found.
+ *
+ * @param[in] name The font name to find.
+ *
+ * @note Wildcard matching will match the shortest possible match.
+ *
+ * @api
+ */
+font_t gdispOpenFont(const char *name) {
+ const struct font **p;
+
+ for(p = BuiltinFontTable; p < BuiltinFontTable+sizeof(BuiltinFontTable)/sizeof(BuiltinFontTable[0]); p++) {
+ if (matchfont(name, p[0]->name))
+ return p[0];
+ }
+ return 0;
+}
+
+/**
+ * @brief Release a font after use.
+ *
+ * @param[in] font The font to release.
+ *
+ * @api
+ */
+void gdispCloseFont(font_t font) {
+ (void) font;
+}
+
+/**
+ * @brief Get the name of the specified font.
+ * @returns The name of the font.
+ *
+ * @param[in] font The font to get the name for.
+ *
+ * @api
+ */
+const char *gdispGetFontName(font_t font) {
+ return font->name;
+}
+
+#endif /* GFX_USE_GDISP && GDISP_NEED_TEXT */
+/** @} */
diff --git a/src/gdisp/gdisp.c b/src/gdisp/gdisp.c
new file mode 100644
index 00000000..2d757fcb
--- /dev/null
+++ b/src/gdisp/gdisp.c
@@ -0,0 +1,1268 @@
+/*
+ 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 src/gdisp/gdisp.c
+ * @brief GDISP Driver code.
+ *
+ * @addtogroup GDISP
+ * @{
+ */
+#include "ch.h"
+#include "hal.h"
+#include "gfx.h"
+
+#if GFX_USE_GDISP || defined(__DOXYGEN__)
+
+#ifdef GDISP_NEED_TEXT
+ #include "gdisp/fonts.h"
+#endif
+
+/*===========================================================================*/
+/* Driver local definitions. */
+/*===========================================================================*/
+
+#if GDISP_NEED_MULTITHREAD
+ #if !CH_USE_MUTEXES
+ #error "GDISP: CH_USE_MUTEXES must be defined in chconf.h because GDISP_NEED_MULTITHREAD is defined"
+ #endif
+#endif
+
+#if GDISP_NEED_ASYNC
+ #if !CH_USE_MAILBOXES || !CH_USE_MUTEXES || !CH_USE_SEMAPHORES
+ #error "GDISP: CH_USE_MAILBOXES, CH_USE_SEMAPHORES and CH_USE_MUTEXES must be defined in chconf.h because GDISP_NEED_ASYNC is defined"
+ #endif
+#endif
+
+/*===========================================================================*/
+/* Driver exported variables. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver local variables. */
+/*===========================================================================*/
+
+#if GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC
+ static Mutex gdispMutex;
+#endif
+
+#if GDISP_NEED_ASYNC
+ #define GDISP_THREAD_STACK_SIZE 512 /* Just a number - not yet a reflection of actual use */
+ #define GDISP_QUEUE_SIZE 8 /* We only allow a short queue */
+
+ static Thread * lldThread;
+ static Mailbox gdispMailbox;
+ static msg_t gdispMailboxQueue[GDISP_QUEUE_SIZE];
+ static Semaphore gdispMsgsSem;
+ static Mutex gdispMsgsMutex;
+ static gdisp_lld_msg_t gdispMsgs[GDISP_QUEUE_SIZE];
+ static WORKING_AREA(waGDISPThread, GDISP_THREAD_STACK_SIZE);
+#endif
+
+/*===========================================================================*/
+/* Driver local functions. */
+/*===========================================================================*/
+
+#if GDISP_NEED_ASYNC
+ static msg_t GDISPThreadHandler(void *arg) {
+ (void)arg;
+ gdisp_lld_msg_t *pmsg;
+
+ #if CH_USE_REGISTRY
+ chRegSetThreadName("GDISPAsyncAPI");
+ #endif
+
+ while(1) {
+ /* Wait for msg with work to do. */
+ chMBFetch(&gdispMailbox, (msg_t *)&pmsg, TIME_INFINITE);
+
+ /* OK - we need to obtain the mutex in case a synchronous operation is occurring */
+ chMtxLock(&gdispMutex);
+ GDISP_LLD(msgdispatch)(pmsg);
+ chMtxUnlock();
+
+ /* Mark the message as free */
+ pmsg->action = GDISP_LLD_MSG_NOP;
+ chSemSignal(&gdispMsgsSem);
+ }
+ return 0;
+ }
+
+ static gdisp_lld_msg_t *gdispAllocMsg(gdisp_msgaction_t action) {
+ gdisp_lld_msg_t *p;
+
+ while(1) { /* To be sure, to be sure */
+
+ /* Wait for a slot */
+ chSemWait(&gdispMsgsSem);
+
+ /* Find the slot */
+ chMtxLock(&gdispMsgsMutex);
+ for(p=gdispMsgs; p < &gdispMsgs[GDISP_QUEUE_SIZE]; p++) {
+ if (p->action == GDISP_LLD_MSG_NOP) {
+ /* Allocate it */
+ p->action = action;
+ chMtxUnlock();
+ return p;
+ }
+ }
+ chMtxUnlock();
+
+ /* Oops - none found, try again */
+ chSemSignal(&gdispMsgsSem);
+ }
+ }
+#endif
+
+/*===========================================================================*/
+/* Driver exported functions. */
+/*===========================================================================*/
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+ /**
+ * @brief GDISP Driver initialization.
+ * @note This function is NOT currently implicitly invoked by @p halInit().
+ * It must be called manually.
+ *
+ * @return True if succeeded, False otherwise
+ *
+ * @init
+ */
+ bool_t gdispInit(void) {
+ bool_t res;
+
+ /* Initialise Mutex */
+ chMtxInit(&gdispMutex);
+
+ /* Initialise driver */
+ chMtxLock(&gdispMutex);
+ res = lld_gdisp_init();
+ chMtxUnlock();
+
+ return res;
+ }
+#elif GDISP_NEED_ASYNC
+ bool_t gdispInit(void) {
+ bool_t res;
+ unsigned i;
+
+ /* Mark all the Messages as free */
+ for(i=0; i < GDISP_QUEUE_SIZE; i++)
+ gdispMsgs[i].action = GDISP_LLD_MSG_NOP;
+
+ /* Initialise our Mailbox, Mutex's and Counting Semaphore.
+ * A Mutex is required as well as the Mailbox and Thread because some calls have to be synchronous.
+ * Synchronous calls get handled by the calling thread, asynchronous by our worker thread.
+ */
+ chMBInit(&gdispMailbox, gdispMailboxQueue, sizeof(gdispMailboxQueue)/sizeof(gdispMailboxQueue[0]));
+ chMtxInit(&gdispMutex);
+ chMtxInit(&gdispMsgsMutex);
+ chSemInit(&gdispMsgsSem, GDISP_QUEUE_SIZE);
+
+ lldThread = chThdCreateStatic(waGDISPThread, sizeof(waGDISPThread), NORMALPRIO, GDISPThreadHandler, NULL);
+
+ /* Initialise driver - synchronous */
+ chMtxLock(&gdispMutex);
+ res = lld_gdisp_init();
+ chMtxUnlock();
+
+ return res;
+ }
+#endif
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+ /**
+ * @brief Test if the GDISP engine is currently drawing.
+ * @note This function will always return FALSE if
+ * GDISP_NEED_ASYNC is not defined.
+ *
+ * @return TRUE if gdisp is busy, FALSE otherwise
+ *
+ * @init
+ */
+ bool_t gdispIsBusy(void) {
+ return FALSE;
+ }
+#elif GDISP_NEED_ASYNC
+ bool_t gdispIsBusy(void) {
+ return chMBGetUsedCountI(&gdispMailbox) != FALSE;
+ }
+#endif
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+ /**
+ * @brief Clear the display to the specified color.
+ *
+ * @param[in] color The color to use when clearing the screen
+ *
+ * @api
+ */
+ void gdispClear(color_t color) {
+ chMtxLock(&gdispMutex);
+ lld_gdisp_clear(color);
+ chMtxUnlock();
+ }
+#elif GDISP_NEED_ASYNC
+ void gdispClear(color_t color) {
+ gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_CLEAR);
+ p->clear.color = color;
+ chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);
+ }
+#endif
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+ /**
+ * @brief Set a pixel in the specified color.
+ *
+ * @param[in] x,y The position to set the pixel.
+ * @param[in] color The color to use
+ *
+ * @api
+ */
+ void gdispDrawPixel(coord_t x, coord_t y, color_t color) {
+ chMtxLock(&gdispMutex);
+ lld_gdisp_draw_pixel(x, y, color);
+ chMtxUnlock();
+ }
+#elif GDISP_NEED_ASYNC
+ void gdispDrawPixel(coord_t x, coord_t y, color_t color) {
+ gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_DRAWPIXEL);
+ p->drawpixel.x = x;
+ p->drawpixel.y = y;
+ p->drawpixel.color = color;
+ chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);
+ }
+#endif
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a line.
+ *
+ * @param[in] x0,y0 The start position
+ * @param[in] x1,y1 The end position
+ * @param[in] color The color to use
+ *
+ * @api
+ */
+ void gdispDrawLine(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {
+ chMtxLock(&gdispMutex);
+ lld_gdisp_draw_line(x0, y0, x1, y1, color);
+ chMtxUnlock();
+ }
+#elif GDISP_NEED_ASYNC
+ void gdispDrawLine(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {
+ gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_DRAWLINE);
+ p->drawline.x0 = x0;
+ p->drawline.y0 = y0;
+ p->drawline.x1 = x1;
+ p->drawline.y1 = y1;
+ p->drawline.color = color;
+ chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);
+ }
+#endif
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+ /**
+ * @brief Fill an area with a color.
+ *
+ * @param[in] x,y The start position
+ * @param[in] cx,cy The size of the box (outside dimensions)
+ * @param[in] color The color to use
+ *
+ * @api
+ */
+ void gdispFillArea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+ chMtxLock(&gdispMutex);
+ lld_gdisp_fill_area(x, y, cx, cy, color);
+ chMtxUnlock();
+ }
+#elif GDISP_NEED_ASYNC
+ void gdispFillArea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+ gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_FILLAREA);
+ p->fillarea.x = x;
+ p->fillarea.y = y;
+ p->fillarea.cx = cx;
+ p->fillarea.cy = cy;
+ p->fillarea.color = color;
+ chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);
+ }
+#endif
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+ /**
+ * @brief Fill an area using the supplied bitmap.
+ * @details The bitmap is in the pixel format specified by the low level driver
+ * @note If a packed pixel format is used and the width doesn't
+ * match a whole number of bytes, the next line will start on a
+ * non-byte boundary (no end-of-line padding).
+ * @note If GDISP_NEED_ASYNC is defined then the buffer must be static
+ * or at least retained until this call has finished the blit. You can
+ * tell when all graphics drawing is finished by @p gdispIsBusy() going FALSE.
+ *
+ * @param[in] x,y The start position
+ * @param[in] cx,cy The size of the filled area
+ * @param[in] srcx,srcy The bitmap position to start the fill form
+ * @param[in] srccx The width of a line in the bitmap
+ * @param[in] buffer The bitmap in the driver's pixel format
+ *
+ * @api
+ */
+ 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) {
+ chMtxLock(&gdispMutex);
+ lld_gdisp_blit_area_ex(x, y, cx, cy, srcx, srcy, srccx, buffer);
+ chMtxUnlock();
+ }
+#elif GDISP_NEED_ASYNC
+ 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) {
+ gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_BLITAREA);
+ p->blitarea.x = x;
+ p->blitarea.y = y;
+ p->blitarea.cx = cx;
+ p->blitarea.cy = cy;
+ p->blitarea.srcx = srcx;
+ p->blitarea.srcy = srcy;
+ p->blitarea.srccx = srccx;
+ p->blitarea.buffer = buffer;
+ chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);
+ }
+#endif
+
+#if (GDISP_NEED_CLIP && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+ /**
+ * @brief Clip all drawing to the defined area.
+ *
+ * @param[in] x,y The start position
+ * @param[in] cx,cy The size of the clip area
+ *
+ * @api
+ */
+ void gdispSetClip(coord_t x, coord_t y, coord_t cx, coord_t cy) {
+ chMtxLock(&gdispMutex);
+ lld_gdisp_set_clip(x, y, cx, cy);
+ chMtxUnlock();
+ }
+#elif GDISP_NEED_CLIP && GDISP_NEED_ASYNC
+ void gdispSetClip(coord_t x, coord_t y, coord_t cx, coord_t cy) {
+ gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_SETCLIP);
+ p->setclip.x = x;
+ p->setclip.y = y;
+ p->setclip.cx = cx;
+ p->setclip.cy = cy;
+ chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);
+ }
+#endif
+
+#if (GDISP_NEED_CIRCLE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a circle.
+ *
+ * @param[in] x,y The center of the circle
+ * @param[in] radius The radius of the circle
+ * @param[in] color The color to use
+ *
+ * @api
+ */
+ void gdispDrawCircle(coord_t x, coord_t y, coord_t radius, color_t color) {
+ chMtxLock(&gdispMutex);
+ lld_gdisp_draw_circle(x, y, radius, color);
+ chMtxUnlock();
+ }
+#elif GDISP_NEED_CIRCLE && GDISP_NEED_ASYNC
+ void gdispDrawCircle(coord_t x, coord_t y, coord_t radius, color_t color) {
+ gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_DRAWCIRCLE);
+ p->drawcircle.x = x;
+ p->drawcircle.y = y;
+ p->drawcircle.radius = radius;
+ p->drawcircle.color = color;
+ chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);
+ }
+#endif
+
+#if (GDISP_NEED_CIRCLE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a filled circle.
+ *
+ * @param[in] x,y The center of the circle
+ * @param[in] radius The radius of the circle
+ * @param[in] color The color to use
+ *
+ * @api
+ */
+ void gdispFillCircle(coord_t x, coord_t y, coord_t radius, color_t color) {
+ chMtxLock(&gdispMutex);
+ lld_gdisp_fill_circle(x, y, radius, color);
+ chMtxUnlock();
+ }
+#elif GDISP_NEED_CIRCLE && GDISP_NEED_ASYNC
+ void gdispFillCircle(coord_t x, coord_t y, coord_t radius, color_t color) {
+ gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_FILLCIRCLE);
+ p->fillcircle.x = x;
+ p->fillcircle.y = y;
+ p->fillcircle.radius = radius;
+ p->fillcircle.color = color;
+ chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);
+ }
+#endif
+
+#if (GDISP_NEED_ELLIPSE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+ /**
+ * @brief Draw an ellipse.
+ *
+ * @param[in] x,y The center of the ellipse
+ * @param[in] a,b The dimensions of the ellipse
+ * @param[in] color The color to use
+ *
+ * @api
+ */
+ void gdispDrawEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
+ chMtxLock(&gdispMutex);
+ lld_gdisp_draw_ellipse(x, y, a, b, color);
+ chMtxUnlock();
+ }
+#elif GDISP_NEED_ELLIPSE && GDISP_NEED_ASYNC
+ void gdispDrawEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
+ gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_DRAWELLIPSE);
+ p->drawellipse.x = x;
+ p->drawellipse.y = y;
+ p->drawellipse.a = a;
+ p->drawellipse.b = b;
+ p->drawellipse.color = color;
+ chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);
+ }
+#endif
+
+#if (GDISP_NEED_ELLIPSE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a filled ellipse.
+ *
+ * @param[in] x,y The center of the ellipse
+ * @param[in] a,b The dimensions of the ellipse
+ * @param[in] color The color to use
+ *
+ * @api
+ */
+ void gdispFillEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
+ chMtxLock(&gdispMutex);
+ lld_gdisp_fill_ellipse(x, y, a, b, color);
+ chMtxUnlock();
+ }
+#elif GDISP_NEED_ELLIPSE && GDISP_NEED_ASYNC
+ void gdispFillEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
+ gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_FILLELLIPSE);
+ p->fillellipse.x = x;
+ p->fillellipse.y = y;
+ p->fillellipse.a = a;
+ p->fillellipse.b = b;
+ p->fillellipse.color = color;
+ chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);
+ }
+#endif
+
+#if (GDISP_NEED_ARC && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+ /*
+ * @brief Draw an arc.
+ *
+ * @param[in] x0,y0 The center point
+ * @param[in] radius The radius of the arc
+ * @param[in] start The start angle (0 to 360)
+ * @param[in] end The end angle (0 to 360)
+ * @param[in] color The color of the arc
+ *
+ * @api
+ */
+ void gdispDrawArc(coord_t x, coord_t y, coord_t radius, coord_t start, coord_t end, color_t color) {
+ chMtxLock(&gdispMutex);
+ lld_gdisp_draw_arc(x, y, radius, start, end, color);
+ chMtxUnlock();
+ }
+#elif GDISP_NEED_ARC && GDISP_NEED_ASYNC
+ void gdispDrawArc(coord_t x, coord_t y, coord_t radius, coord_t start, coord_t end, color_t color) {
+ gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_DRAWARC);
+ p->drawarc.x = x;
+ p->drawarc.y = y;
+ p->drawarc.radius = radius;
+ p->drawarc.start = start;
+ p->drawarc.end = end;
+ p->drawarc.color = color;
+ chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);
+ }
+#endif
+
+#if (GDISP_NEED_ARC && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+ /*
+ * @brief Draw a filled arc.
+ * @note Not very efficient currently - does lots of overdrawing
+ *
+ * @param[in] x0,y0 The center point
+ * @param[in] radius The radius of the arc
+ * @param[in] start The start angle (0 to 360)
+ * @param[in] end The end angle (0 to 360)
+ * @param[in] color The color of the arc
+ *
+ * @api
+ */
+ void gdispFillArc(coord_t x, coord_t y, coord_t radius, coord_t start, coord_t end, color_t color) {
+ chMtxLock(&gdispMutex);
+ lld_gdisp_fill_arc(x, y, radius, start, end, color);
+ chMtxUnlock();
+ }
+#elif GDISP_NEED_ARC && GDISP_NEED_ASYNC
+ void gdispFillArc(coord_t x, coord_t y, coord_t radius, coord_t start, coord_t end, color_t color) {
+ gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_FILLARC);
+ p->fillarc.x = x;
+ p->fillarc.y = y;
+ p->fillarc.radius = radius;
+ p->fillarc.start = start;
+ p->fillarc.end = end;
+ p->fillarc.color = color;
+ chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);
+ }
+#endif
+
+#if GDISP_NEED_ARC || defined(__DOXYGEN__)
+/**
+ * @brief Draw a rectangular box with rounded corners
+ *
+ * @param[in] x,y The start position
+ * @param[in] cx,cy The size of the box (outside dimensions)
+ * @param[in] radius The radius of the rounded corners
+ * @param[in] color The color to use
+ *
+ * @api
+ */
+void gdispDrawRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t radius, color_t color) {
+ if (2*radius > cx || 2*radius > cy) {
+ gdispDrawBox(x, y, cx, cy, color);
+ return;
+ }
+ gdispDrawArc(x+radius, y+radius, radius, 90, 180, color);
+ gdispDrawLine(x+radius+1, y, x+cx-2-radius, y, color);
+ gdispDrawArc(x+cx-1-radius, y+radius, radius, 0, 90, color);
+ gdispDrawLine(x+cx-1, y+radius+1, x+cx-1, y+cy-2-radius, color);
+ gdispDrawArc(x+cx-1-radius, y+cy-1-radius, radius, 270, 360, color);
+ gdispDrawLine(x+radius+1, y+cy-1, x+cx-2-radius, y+cy-1, color);
+ gdispDrawArc(x+radius, y+cy-1-radius, radius, 180, 270, color);
+ gdispDrawLine(x, y+radius+1, x, y+cy-2-radius, color);
+}
+#endif
+
+#if GDISP_NEED_ARC || defined(__DOXYGEN__)
+/**
+ * @brief Draw a filled rectangular box with rounded corners
+ *
+ * @param[in] x,y The start position
+ * @param[in] cx,cy The size of the box (outside dimensions)
+ * @param[in] radius The radius of the rounded corners
+ * @param[in] color The color to use
+ *
+ * @api
+ */
+void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t radius, color_t color) {
+ coord_t radius2;
+
+ radius2 = radius*2;
+ if (radius2 > cx || radius2 > cy) {
+ gdispFillArea(x, y, cx, cy, color);
+ return;
+ }
+ gdispFillArc(x+radius, y+radius, radius, 90, 180, color);
+ gdispFillArea(x+radius+1, y, cx-radius2, radius, color);
+ gdispFillArc(x+cx-1-radius, y+radius, radius, 0, 90, color);
+ gdispFillArc(x+cx-1-radius, y+cy-1-radius, radius, 270, 360, color);
+ gdispFillArea(x+radius+1, y+cy-radius, cx-radius2, radius, color);
+ gdispFillArc(x+radius, y+cy-1-radius, radius, 180, 270, color);
+ gdispFillArea(x, y+radius, cx, cy-radius2, color);
+}
+#endif
+
+#if (GDISP_NEED_TEXT && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a text character.
+ *
+ * @param[in] x,y The position for the text
+ * @param[in] c The character to draw
+ * @param[in] font The font to use
+ * @param[in] color The color to use
+ *
+ * @api
+ */
+ void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color) {
+ chMtxLock(&gdispMutex);
+ lld_gdisp_draw_char(x, y, c, font, color);
+ chMtxUnlock();
+ }
+#elif GDISP_NEED_TEXT && GDISP_NEED_ASYNC
+ void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color) {
+ gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_DRAWCHAR);
+ p->drawchar.x = x;
+ p->drawchar.y = y;
+ p->drawchar.c = c;
+ p->drawchar.font = font;
+ p->drawchar.color = color;
+ chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);
+ }
+#endif
+
+#if (GDISP_NEED_TEXT && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a text character with a filled background.
+ *
+ * @param[in] x,y The position for the text
+ * @param[in] c The character to draw
+ * @param[in] font The font to use
+ * @param[in] color The color to use
+ * @param[in] bgcolor The background color to use
+ *
+ * @api
+ */
+ void gdispFillChar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor) {
+ chMtxLock(&gdispMutex);
+ lld_gdisp_fill_char(x, y, c, font, color, bgcolor);
+ chMtxUnlock();
+ }
+#elif GDISP_NEED_TEXT && GDISP_NEED_ASYNC
+ void gdispFillChar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor) {
+ gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_FILLCHAR);
+ p->fillchar.x = x;
+ p->fillchar.y = y;
+ p->fillchar.c = c;
+ p->fillchar.font = font;
+ p->fillchar.color = color;
+ p->fillchar.bgcolor = bgcolor;
+ chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);
+ }
+#endif
+
+#if (GDISP_NEED_PIXELREAD && (GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC)) || defined(__DOXYGEN__)
+ /**
+ * @brief Get the color of a pixel.
+ * @return The color of the pixel.
+ *
+ * @param[in] x,y The position of the pixel
+ *
+ * @api
+ */
+ color_t gdispGetPixelColor(coord_t x, coord_t y) {
+ color_t c;
+
+ /* Always synchronous as it must return a value */
+ chMtxLock(&gdispMutex);
+ c = lld_gdisp_get_pixel_color(x, y);
+ chMtxUnlock();
+
+ return c;
+ }
+#endif
+
+#if (GDISP_NEED_SCROLL && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+ /**
+ * @brief Scroll vertically a section of the screen.
+ * @pre GDISP_NEED_SCROLL must be set to TRUE in halconf.h
+ * @note Optional.
+ * @note If lines is >= cy, it is equivelent to a area fill with bgcolor.
+ *
+ * @param[in] x, y The start of the area to be scrolled
+ * @param[in] cx, cy The size of the area to be scrolled
+ * @param[in] lines The number of lines to scroll (Can be positive or negative)
+ * @param[in] bgcolor The color to fill the newly exposed area.
+ *
+ * @api
+ */
+ void gdispVerticalScroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
+ chMtxLock(&gdispMutex);
+ lld_gdisp_vertical_scroll(x, y, cx, cy, lines, bgcolor);
+ chMtxUnlock();
+ }
+#elif GDISP_NEED_SCROLL && GDISP_NEED_ASYNC
+ void gdispVerticalScroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
+ gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_VERTICALSCROLL);
+ p->verticalscroll.x = x;
+ p->verticalscroll.y = y;
+ p->verticalscroll.cx = cx;
+ p->verticalscroll.cy = cy;
+ p->verticalscroll.lines = lines;
+ p->verticalscroll.bgcolor = bgcolor;
+ chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);
+ }
+#endif
+
+#if (GDISP_NEED_CONTROL && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+ /**
+ * @brief Set the power mode for the display.
+ * @pre The GDISP unit must have been initialised using @p gdispInit().
+ * @note Depending on the hardware implementation this function may not
+ * support some codes. They will be ignored.
+ *
+ * @param[in] what what you want to control
+ * @param[in] value The value to be assigned
+ *
+ * @api
+ */
+ void gdispControl(unsigned what, void *value) {
+ chMtxLock(&gdispMutex);
+ lld_gdisp_control(what, value);
+ chMtxUnlock();
+ chThdSleepMilliseconds(100);
+ }
+#elif GDISP_NEED_CONTROL && GDISP_NEED_ASYNC
+ void gdispControl(unsigned what, void *value) {
+ gdisp_lld_msg_t *p = gdispAllocMsg(GDISP_LLD_MSG_CONTROL);
+ p->control.what = what;
+ p->control.value = value;
+ chMBPost(&gdispMailbox, (msg_t)p, TIME_INFINITE);
+ chThdSleepMilliseconds(100);
+ }
+#endif
+
+#if (GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC) || defined(__DOXYGEN__)
+ /**
+ * @brief Query a property of the display.
+ * @pre The GDISP unit must have been initialised using @p gdispInit().
+ * @note The result must be typecast to the correct type.
+ * @note An uunsupported query will return (void *)-1.
+ *
+ * @param[in] what What to query
+ *
+ * @api
+ */
+ void *gdispQuery(unsigned what) {
+ void *res;
+
+ chMtxLock(&gdispMutex);
+ res = lld_gdisp_query(what);
+ chMtxUnlock();
+ return res;
+ }
+#endif
+
+/*===========================================================================*/
+/* High Level Driver Routines. */
+/*===========================================================================*/
+
+/**
+ * @brief Draw a rectangular box.
+ *
+ * @param[in] x,y The start position
+ * @param[in] cx,cy The size of the box (outside dimensions)
+ * @param[in] color The color to use
+ *
+ * @api
+ */
+void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+ /* No mutex required as we only call high level functions which have their own mutex */
+ coord_t x1, y1;
+
+ x1 = x+cx-1;
+ y1 = y+cy-1;
+
+ if (cx > 2) {
+ if (cy >= 1) {
+ gdispDrawLine(x, y, x1, y, color);
+ if (cy >= 2) {
+ gdispDrawLine(x, y1, x1, y1, color);
+ if (cy > 2) {
+ gdispDrawLine(x, y+1, x, y1-1, color);
+ gdispDrawLine(x1, y+1, x1, y1-1, color);
+ }
+ }
+ }
+ } else if (cx == 2) {
+ gdispDrawLine(x, y, x, y1, color);
+ gdispDrawLine(x1, y, x1, y1, color);
+ } else if (cx == 1) {
+ gdispDrawLine(x, y, x, y1, color);
+ }
+}
+
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a text string.
+ *
+ * @param[in] x,y The position for the text
+ * @param[in] font The font to use
+ * @param[in] str The string to draw
+ * @param[in] color The color to use
+ *
+ * @api
+ */
+ void gdispDrawString(coord_t x, coord_t y, const char *str, font_t font, color_t color) {
+ /* No mutex required as we only call high level functions which have their own mutex */
+ coord_t w, p;
+ char c;
+ int first;
+
+ if (!str) return;
+
+ first = 1;
+ p = font->charPadding * font->xscale;
+ while(*str) {
+ /* Get the next printable character */
+ c = *str++;
+ w = _getCharWidth(font, c) * font->xscale;
+ if (!w) continue;
+
+ /* Handle inter-character padding */
+ if (p) {
+ if (!first)
+ x += p;
+ else
+ first = 0;
+ }
+
+ /* Print the character */
+ gdispDrawChar(x, y, c, font, color);
+ x += w;
+ }
+ }
+#endif
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a text string.
+ *
+ * @param[in] x,y The position for the text
+ * @param[in] str The string to draw
+ * @param[in] font The font to use
+ * @param[in] color The color to use
+ * @param[in] bgcolor The background color to use
+ *
+ * @api
+ */
+ void gdispFillString(coord_t x, coord_t y, const char *str, font_t font, color_t color, color_t bgcolor) {
+ /* No mutex required as we only call high level functions which have their own mutex */
+ coord_t w, h, p;
+ char c;
+ int first;
+
+ if (!str) return;
+
+ first = 1;
+ h = font->height * font->yscale;
+ p = font->charPadding * font->xscale;
+ while(*str) {
+ /* Get the next printable character */
+ c = *str++;
+ w = _getCharWidth(font, c) * font->xscale;
+ if (!w) continue;
+
+ /* Handle inter-character padding */
+ if (p) {
+ if (!first) {
+ gdispFillArea(x, y, p, h, bgcolor);
+ x += p;
+ } else
+ first = 0;
+ }
+
+ /* Print the character */
+ gdispFillChar(x, y, c, font, color, bgcolor);
+ x += w;
+ }
+ }
+#endif
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a text string verticly centered within the specified box.
+ *
+ * @param[in] x,y The position for the text (need to define top-right or base-line - check code)
+ * @param[in] cx,cy The width and height of the box
+ * @param[in] str The string to draw
+ * @param[in] font The font to use
+ * @param[in] color The color to use
+ * @param[in] justify Justify the text left, center or right within the box
+ *
+ * @api
+ */
+ 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) {
+ /* No mutex required as we only call high level functions which have their own mutex */
+ coord_t w, h, p, ypos, xpos;
+ char c;
+ int first;
+ const char *rstr;
+
+ if (!str) str = "";
+
+ h = font->height * font->yscale;
+ p = font->charPadding * font->xscale;
+
+ /* Oops - font too large for the area */
+ if (h > cy) return;
+
+ /* See if we need to fill above the font */
+ ypos = (cy - h + 1)/2;
+ if (ypos > 0) {
+ y += ypos;
+ cy -= ypos;
+ }
+
+ /* See if we need to fill below the font */
+ ypos = cy - h;
+ if (ypos > 0)
+ cy -= ypos;
+
+ /* get the start of the printable string and the xpos */
+ switch(justify) {
+ case justifyCenter:
+ /* Get the length of the entire string */
+ w = gdispGetStringWidth(str, font);
+ if (w <= cx)
+ xpos = x + (cx - w)/2;
+ else {
+ /* Calculate how much of the string we need to get rid of */
+ ypos = (w - cx)/2;
+ xpos = 0;
+ first = 1;
+ while(*str) {
+ /* Get the next printable character */
+ c = *str++;
+ w = _getCharWidth(font, c) * font->xscale;
+ if (!w) continue;
+
+ /* Handle inter-character padding */
+ if (p) {
+ if (!first) {
+ xpos += p;
+ if (xpos > ypos) break;
+ } else
+ first = 0;
+ }
+
+ /* Print the character */
+ xpos += w;
+ if (xpos > ypos) break;
+ }
+ xpos = ypos - xpos + x;
+ }
+ break;
+ case justifyRight:
+ /* Find the end of the string */
+ for(rstr = str; *str; str++);
+ xpos = x+cx - 2;
+ first = 1;
+ for(str--; str >= rstr; str--) {
+ /* Get the next printable character */
+ c = *str;
+ w = _getCharWidth(font, c) * font->xscale;
+ if (!w) continue;
+
+ /* Handle inter-character padding */
+ if (p) {
+ if (!first) {
+ if (xpos - p < x) break;
+ xpos -= p;
+ } else
+ first = 0;
+ }
+
+ /* Print the character */
+ if (xpos - w < x) break;
+ xpos -= w;
+ }
+ str++;
+ break;
+ case justifyLeft:
+ /* Fall through */
+ default:
+ xpos = x+1;
+ break;
+ }
+
+ /* Print characters until we run out of room */
+ first = 1;
+ while(*str) {
+ /* Get the next printable character */
+ c = *str++;
+ w = _getCharWidth(font, c) * font->xscale;
+ if (!w) continue;
+
+ /* Handle inter-character padding */
+ if (p) {
+ if (!first) {
+ if (xpos + p > x+cx) break;
+ xpos += p;
+ } else
+ first = 0;
+ }
+
+ /* Print the character */
+ if (xpos + w > x+cx) break;
+ gdispDrawChar(xpos, y, c, font, color);
+ xpos += w;
+ }
+ }
+#endif
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a text string verticly centered within the specified box. The box background is filled with the specified background color.
+ * @note The entire box is filled
+ *
+ * @param[in] x,y The position for the text (need to define top-right or base-line - check code)
+ * @param[in] cx,cy The width and height of the box
+ * @param[in] str The string to draw
+ * @param[in] font The font to use
+ * @param[in] color The color to use
+ * @param[in] bgcolor The background color to use
+ * @param[in] justify Justify the text left, center or right within the box
+ *
+ * @api
+ */
+ 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) {
+ /* No mutex required as we only call high level functions which have their own mutex */
+ coord_t w, h, p, ypos, xpos;
+ char c;
+ int first;
+ const char *rstr;
+
+ if (!str) str = "";
+
+ h = font->height * font->yscale;
+ p = font->charPadding * font->xscale;
+
+ /* Oops - font too large for the area */
+ if (h > cy) return;
+
+ /* See if we need to fill above the font */
+ ypos = (cy - h + 1)/2;
+ if (ypos > 0) {
+ gdispFillArea(x, y, cx, ypos, bgcolor);
+ y += ypos;
+ cy -= ypos;
+ }
+
+ /* See if we need to fill below the font */
+ ypos = cy - h;
+ if (ypos > 0) {
+ gdispFillArea(x, y+cy-ypos, cx, ypos, bgcolor);
+ cy -= ypos;
+ }
+
+ /* get the start of the printable string and the xpos */
+ switch(justify) {
+ case justifyCenter:
+ /* Get the length of the entire string */
+ w = gdispGetStringWidth(str, font);
+ if (w <= cx)
+ xpos = x + (cx - w)/2;
+ else {
+ /* Calculate how much of the string we need to get rid of */
+ ypos = (w - cx)/2;
+ xpos = 0;
+ first = 1;
+ while(*str) {
+ /* Get the next printable character */
+ c = *str++;
+ w = _getCharWidth(font, c) * font->xscale;
+ if (!w) continue;
+
+ /* Handle inter-character padding */
+ if (p) {
+ if (!first) {
+ xpos += p;
+ if (xpos > ypos) break;
+ } else
+ first = 0;
+ }
+
+ /* Print the character */
+ xpos += w;
+ if (xpos > ypos) break;
+ }
+ xpos = ypos - xpos + x;
+ }
+ break;
+ case justifyRight:
+ /* Find the end of the string */
+ for(rstr = str; *str; str++);
+ xpos = x+cx - 2;
+ first = 1;
+ for(str--; str >= rstr; str--) {
+ /* Get the next printable character */
+ c = *str;
+ w = _getCharWidth(font, c) * font->xscale;
+ if (!w) continue;
+
+ /* Handle inter-character padding */
+ if (p) {
+ if (!first) {
+ if (xpos - p < x) break;
+ xpos -= p;
+ } else
+ first = 0;
+ }
+
+ /* Print the character */
+ if (xpos - w < x) break;
+ xpos -= w;
+ }
+ str++;
+ break;
+ case justifyLeft:
+ /* Fall through */
+ default:
+ xpos = x+1;
+ break;
+ }
+
+ /* Fill any space to the left */
+ if (x < xpos)
+ gdispFillArea(x, y, xpos-x, cy, bgcolor);
+
+ /* Print characters until we run out of room */
+ first = 1;
+ while(*str) {
+ /* Get the next printable character */
+ c = *str++;
+ w = _getCharWidth(font, c) * font->xscale;
+ if (!w) continue;
+
+ /* Handle inter-character padding */
+ if (p) {
+ if (!first) {
+ if (xpos + p > x+cx) break;
+ gdispFillArea(xpos, y, p, cy, bgcolor);
+ xpos += p;
+ } else
+ first = 0;
+ }
+
+ /* Print the character */
+ if (xpos + w > x+cx) break;
+ gdispFillChar(xpos, y, c, font, color, bgcolor);
+ xpos += w;
+ }
+
+ /* Fill any space to the right */
+ if (xpos < x+cx)
+ gdispFillArea(xpos, y, x+cx-xpos, cy, bgcolor);
+ }
+#endif
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+ /**
+ * @brief Get a metric of a font.
+ * @return The metric requested in pixels.
+ *
+ * @param[in] font The font to test
+ * @param[in] metric The metric to measure
+ *
+ * @api
+ */
+ coord_t gdispGetFontMetric(font_t font, fontmetric_t metric) {
+ /* No mutex required as we only read static data */
+ switch(metric) {
+ case fontHeight: return font->height * font->yscale;
+ case fontDescendersHeight: return font->descenderHeight * font->yscale;
+ case fontLineSpacing: return font->lineSpacing * font->yscale;
+ case fontCharPadding: return font->charPadding * font->xscale;
+ case fontMinWidth: return font->minWidth * font->xscale;
+ case fontMaxWidth: return font->maxWidth * font->xscale;
+ }
+ return 0;
+ }
+#endif
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+ /**
+ * @brief Get the pixel width of a character.
+ * @return The width of the character in pixels. Does not include any between character padding.
+ *
+ * @param[in] c The character to draw
+ * @param[in] font The font to use
+ *
+ * @api
+ */
+ coord_t gdispGetCharWidth(char c, font_t font) {
+ /* No mutex required as we only read static data */
+ return _getCharWidth(font, c) * font->xscale;
+ }
+#endif
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+ /**
+ * @brief Get the pixel width of a string.
+ * @return The width of the string in pixels.
+ *
+ * @param[in] str The string to measure
+ * @param[in] font The font to use
+ *
+ * @api
+ */
+ coord_t gdispGetStringWidth(const char* str, font_t font) {
+ /* No mutex required as we only read static data */
+ coord_t w, p, x;
+ char c;
+ int first;
+
+ first = 1;
+ x = 0;
+ p = font->charPadding * font->xscale;
+ while(*str) {
+ /* Get the next printable character */
+ c = *str++;
+ w = _getCharWidth(font, c) * font->xscale;
+ if (!w) continue;
+
+ /* Handle inter-character padding */
+ if (p) {
+ if (!first)
+ x += p;
+ else
+ first = 0;
+ }
+
+ /* Add the character width */
+ x += w;
+ }
+ return x;
+ }
+#endif
+
+#if (!defined(gdispPackPixels) && !defined(GDISP_PIXELFORMAT_CUSTOM)) || defined(__DOXYGEN__)
+ /**
+ * @brief Pack a pixel into a pixel buffer.
+ * @note This function performs no buffer boundary checking
+ * regardless of whether GDISP_NEED_CLIP has been specified.
+ *
+ * @param[in] buf The buffer to put the pixel in
+ * @param[in] cx The width of a pixel line
+ * @param[in] x, y The location of the pixel to place
+ * @param[in] color The color to put into the buffer
+ *
+ * @api
+ */
+ void gdispPackPixels(pixel_t *buf, coord_t cx, coord_t x, coord_t y, color_t color) {
+ /* No mutex required as we only read static data */
+ #if defined(GDISP_PIXELFORMAT_RGB888)
+ #error "GDISP: Packed pixels not supported yet"
+ #elif defined(GDISP_PIXELFORMAT_RGB444)
+ #error "GDISP: Packed pixels not supported yet"
+ #elif defined(GDISP_PIXELFORMAT_RGB666)
+ #error "GDISP: Packed pixels not supported yet"
+ #elif
+ #error "GDISP: Unsupported packed pixel format"
+ #endif
+ }
+#endif
+
+#endif /* GFX_USE_GDISP */
+/** @} */
diff --git a/src/gdisp/gdisp.mk b/src/gdisp/gdisp.mk
new file mode 100644
index 00000000..426e9e2c
--- /dev/null
+++ b/src/gdisp/gdisp.mk
@@ -0,0 +1,2 @@
+GFXSRC += $(GFXLIB)/src/gdisp/gdisp.c \
+ $(GFXLIB)/src/gdisp/fonts.c
diff --git a/src/gevent/gevent.c b/src/gevent/gevent.c
new file mode 100644
index 00000000..f3d909f0
--- /dev/null
+++ b/src/gevent/gevent.c
@@ -0,0 +1,197 @@
+/*
+ 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 src/gevent/gevent.c
+ * @brief GEVENT Driver code.
+ *
+ * @addtogroup GEVENT
+ * @{
+ */
+#include "ch.h"
+#include "hal.h"
+#include "gfx.h"
+
+#if GFX_USE_GEVENT || defined(__DOXYGEN__)
+
+#if GEVENT_ASSERT_NO_RESOURCE
+ #define GEVENT_ASSERT(x) assert(x)
+#else
+ #define GEVENT_ASSERT(x)
+#endif
+
+/* This mutex protects access to our tables */
+static MUTEX_DECL(geventMutex);
+
+/* Our table of listener/source pairs */
+static GSourceListener Assignments[GEVENT_MAX_SOURCE_LISTENERS];
+
+/* Loop through the assignment table deleting this listener/source pair. */
+/* Null is treated as a wildcard. */
+static void deleteAssignments(GListener *pl, GSourceHandle gsh) {
+ GSourceListener *psl;
+
+ for(psl = Assignments; psl < Assignments+GEVENT_MAX_SOURCE_LISTENERS; psl++) {
+ if ((!pl || psl->pListener == pl) && (!gsh || psl->pSource == gsh)) {
+ if (chSemGetCounterI(&psl->pListener->waitqueue) < 0) {
+ chBSemWait(&psl->pListener->eventlock); // Obtain the buffer lock
+ psl->pListener->event.type = GEVENT_EXIT; // Set up the EXIT event
+ chSemSignal(&psl->pListener->waitqueue); // Wake up the listener
+ chBSemSignal(&psl->pListener->eventlock); // Release the buffer lock
+ }
+ psl->pListener = 0;
+ }
+ }
+}
+
+void geventListenerInit(GListener *pl) {
+ chSemInit(&pl->waitqueue, 0); // Next wait'er will block
+ chBSemInit(&pl->eventlock, FALSE); // Only one thread at a time looking at the event buffer
+ pl->callback = 0; // No callback active
+ pl->event.type = GEVENT_NULL; // Always safety
+}
+
+bool_t geventAttachSource(GListener *pl, GSourceHandle gsh, unsigned flags) {
+ GSourceListener *psl, *pslfree;
+
+ // Safety first
+ if (!pl || !gsh) {
+ GEVENT_ASSERT(FALSE);
+ return FALSE;
+ }
+
+ chMtxLock(&geventMutex);
+
+ // Check if this pair is already in the table (scan for a free slot at the same time)
+ pslfree = 0;
+ for(psl = Assignments; psl < Assignments+GEVENT_MAX_SOURCE_LISTENERS; psl++) {
+
+ if (pl == psl->pListener && gsh == psl->pSource) {
+ // Just update the flags
+ chBSemWait(&pl->eventlock); // Safety first - just in case a source is using it
+ psl->listenflags = flags;
+ chBSemSignal(&pl->eventlock); // Release this lock
+ chMtxUnlock();
+ return TRUE;
+ }
+ if (!pslfree && !psl->pListener)
+ pslfree = psl;
+ }
+
+ // A free slot was found - allocate it
+ if (pslfree) {
+ pslfree->pListener = pl;
+ pslfree->pSource = gsh;
+ pslfree->listenflags = flags;
+ pslfree->srcflags = 0;
+ }
+ chMtxUnlock();
+ GEVENT_ASSERT(pslfree != 0);
+ return pslfree != 0;
+}
+
+void geventDetachSource(GListener *pl, GSourceHandle gsh) {
+ if (pl && gsh) {
+ chMtxLock(&geventMutex);
+ deleteAssignments(pl, gsh);
+ if (!gsh && chSemGetCounterI(&pl->waitqueue) < 0) {
+ chBSemWait(&pl->eventlock); // Obtain the buffer lock
+ pl->event.type = GEVENT_EXIT; // Set up the EXIT event
+ chSemSignal(&pl->waitqueue); // Wake up the listener
+ chBSemSignal(&pl->eventlock); // Release the buffer lock
+ }
+ chMtxUnlock();
+ }
+}
+
+GEvent *geventEventWait(GListener *pl, systime_t timeout) {
+ if (pl->callback || chSemGetCounterI(&pl->waitqueue) < 0)
+ return 0;
+ return chSemWaitTimeout(&pl->waitqueue, timeout) == RDY_OK ? &pl->event : 0;
+}
+
+void geventRegisterCallback(GListener *pl, GEventCallbackFn fn, void *param) {
+ if (pl) {
+ chMtxLock(&geventMutex);
+ chBSemWait(&pl->eventlock); // Obtain the buffer lock
+ pl->param = param; // Set the param
+ pl->callback = fn; // Set the callback function
+ if (chSemGetCounterI(&pl->waitqueue) < 0) {
+ pl->event.type = GEVENT_EXIT; // Set up the EXIT event
+ chSemSignal(&pl->waitqueue); // Wake up the listener
+ }
+ chBSemSignal(&pl->eventlock); // Release the buffer lock
+ chMtxUnlock();
+ }
+}
+
+GSourceListener *geventGetSourceListener(GSourceHandle gsh, GSourceListener *lastlr) {
+ GSourceListener *psl;
+
+ // Safety first
+ if (!gsh)
+ return 0;
+
+ chMtxLock(&geventMutex);
+
+ // Unlock the last listener event buffer
+ if (lastlr)
+ chBSemSignal(&lastlr->pListener->eventlock);
+
+ // Loop through the table looking for attachments to this source
+ for(psl = lastlr ? (lastlr+1) : Assignments; psl < Assignments+GEVENT_MAX_SOURCE_LISTENERS; psl++) {
+ if (gsh == psl->pSource) {
+ chBSemWait(&psl->pListener->eventlock); // Obtain a lock on the listener event buffer
+ chMtxUnlock();
+ return psl;
+ }
+ }
+ chMtxUnlock();
+ return 0;
+}
+
+GEvent *geventGetEventBuffer(GSourceListener *psl) {
+ // We already know we have the event lock
+ return &psl->pListener->callback || chSemGetCounterI(&psl->pListener->waitqueue) < 0 ? &psl->pListener->event : 0;
+}
+
+void geventSendEvent(GSourceListener *psl) {
+ chMtxLock(&geventMutex);
+ if (psl->pListener->callback) { // This test needs to be taken inside the mutex
+ chMtxUnlock();
+ // We already know we have the event lock
+ psl->pListener->callback(psl->pListener->param, &psl->pListener->event);
+
+ } else {
+ // Wake up the listener
+ if (chSemGetCounterI(&psl->pListener->waitqueue) < 0)
+ chSemSignal(&psl->pListener->waitqueue);
+ chMtxUnlock();
+ }
+}
+
+void geventDetachSourceListeners(GSourceHandle gsh) {
+ chMtxLock(&geventMutex);
+ deleteAssignments(0, gsh);
+ chMtxUnlock();
+}
+
+#endif /* GFX_USE_GEVENT */
+/** @} */
diff --git a/src/gevent/gevent.mk b/src/gevent/gevent.mk
new file mode 100644
index 00000000..59226318
--- /dev/null
+++ b/src/gevent/gevent.mk
@@ -0,0 +1 @@
+GFXSRC += $(GFXLIB)/src/gevent/gevent.c
diff --git a/src/ginput/dial.c b/src/ginput/dial.c
new file mode 100644
index 00000000..a447d8bc
--- /dev/null
+++ b/src/ginput/dial.c
@@ -0,0 +1,36 @@
+/*
+ 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 src/ginput/dial.c
+ * @brief GINPUT dial code.
+ *
+ * @defgroup Dial Dial
+ * @ingroup GINPUT
+ * @{
+ */
+#include "ch.h"
+#include "hal.h"
+#include "gfx.h"
+
+#if (GFX_USE_GINPUT && GINPUT_NEED_DIAL) || defined(__DOXYGEN__)
+ #error "GINPUT: GINPUT_NEED_DIAL - Not Implemented Yet"
+#endif /* GFX_USE_GINPUT && GINPUT_NEED_DIAL */
+/** @} */
diff --git a/src/ginput/ginput.mk b/src/ginput/ginput.mk
new file mode 100644
index 00000000..06bcfc07
--- /dev/null
+++ b/src/ginput/ginput.mk
@@ -0,0 +1,4 @@
+GFXSRC += $(GFXLIB)/src/ginput/mouse.c \
+ $(GFXLIB)/src/ginput/keyboard.c \
+ $(GFXLIB)/src/ginput/toggle.c \
+ $(GFXLIB)/src/ginput/dial.c
diff --git a/src/ginput/keyboard.c b/src/ginput/keyboard.c
new file mode 100644
index 00000000..56ff5e8a
--- /dev/null
+++ b/src/ginput/keyboard.c
@@ -0,0 +1,38 @@
+/*
+ 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 src/ginput/keyboard.c
+ * @brief GINPUT keyboard code.
+ *
+ * @defgroup Keyboard Keyboard
+ * @ingroup GINPUT
+ *
+ * @{
+ */
+
+#include "ch.h"
+#include "hal.h"
+#include "gfx.h"
+
+#if (GFX_USE_GINPUT && GINPUT_NEED_KEYBOARD) || defined(__DOXYGEN__)
+ #error "GINPUT: GINPUT_NEED_KEYBOARD - Not Implemented Yet"
+#endif /* GFX_USE_GINPUT && GINPUT_NEED_KEYBOARD */
+/** @} */
diff --git a/src/ginput/mouse.c b/src/ginput/mouse.c
new file mode 100644
index 00000000..94734888
--- /dev/null
+++ b/src/ginput/mouse.c
@@ -0,0 +1,589 @@
+/*
+ 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 src/ginput/mouse.c
+ * @brief GINPUT mouse/touch code.
+ *
+ * @defgroup Mouse Mouse
+ * @ingroup GINPUT
+ * @{
+ */
+#include "ch.h"
+#include "hal.h"
+#include "gfx.h"
+
+#if (GFX_USE_GINPUT && GINPUT_NEED_MOUSE) || defined(__DOXYGEN__)
+
+#include "ginput/lld/mouse.h"
+
+#if GINPUT_MOUSE_NEED_CALIBRATION
+ #if !defined(GFX_USE_GDISP) || !GFX_USE_GDISP
+ #error "GINPUT: GFX_USE_GDISP must be defined when mouse or touch calibration is required"
+ #endif
+
+ #define GINPUT_MOUSE_CALIBRATION_FONT "* Double"
+ #define GINPUT_MOUSE_CALIBRATION_FONT2 "* Narrow"
+ #define GINPUT_MOUSE_CALIBRATION_TEXT "Calibration"
+ #define GINPUT_MOUSE_CALIBRATION_ERROR_TEXT "Failed - Please try again!"
+ #define GINPUT_MOUSE_CALIBRATION_SAME_TEXT "Error: Same Reading - Check Driver!"
+
+ #if GINPUT_MOUSE_MAX_CALIBRATION_ERROR < 0
+ #define GINPUT_MOUSE_CALIBRATION_POINTS 3
+ #else
+ #define GINPUT_MOUSE_CALIBRATION_POINTS 4
+ #endif
+
+ typedef struct Calibration_t {
+ float ax;
+ float bx;
+ float cx;
+ float ay;
+ float by;
+ float cy;
+ } Calibration;
+#endif
+
+typedef struct MousePoint_t {
+ coord_t x, y;
+ } MousePoint;
+
+static GTIMER_DECL(MouseTimer);
+
+static struct MouseConfig_t {
+ MouseReading t;
+ MousePoint movepos;
+ MousePoint clickpos;
+ systime_t clicktime;
+ uint16_t last_buttons;
+ uint16_t flags;
+ #define FLG_INIT_DONE 0x8000
+ #define FLG_CLICK_TIMER 0x0001
+ #define FLG_IN_CAL 0x0010
+ #define FLG_CAL_OK 0x0020
+ #define FLG_CAL_SAVED 0x0040
+ #define FLG_CAL_FREE 0x0080
+ #if GINPUT_MOUSE_NEED_CALIBRATION
+ GMouseCalibrationSaveRoutine fnsavecal;
+ GMouseCalibrationLoadRoutine fnloadcal;
+ Calibration caldata;
+ #endif
+ } MouseConfig;
+
+#if GINPUT_MOUSE_NEED_CALIBRATION
+ static __inline void _tsDrawCross(const MousePoint *pp) {
+ gdispDrawLine(pp->x-15, pp->y, pp->x-2, pp->y, White);
+ gdispDrawLine(pp->x+2, pp->y, pp->x+15, pp->y, White);
+ gdispDrawLine(pp->x, pp->y-15, pp->x, pp->y-2, White);
+ gdispDrawLine(pp->x, pp->y+2, pp->x, pp->y+15, White);
+
+ gdispDrawLine(pp->x-15, pp->y+15, pp->x-7, pp->y+15, RGB2COLOR(184,158,131));
+ gdispDrawLine(pp->x-15, pp->y+7, pp->x-15, pp->y+15, RGB2COLOR(184,158,131));
+
+ gdispDrawLine(pp->x-15, pp->y-15, pp->x-7, pp->y-15, RGB2COLOR(184,158,131));
+ gdispDrawLine(pp->x-15, pp->y-7, pp->x-15, pp->y-15, RGB2COLOR(184,158,131));
+
+ gdispDrawLine(pp->x+7, pp->y+15, pp->x+15, pp->y+15, RGB2COLOR(184,158,131));
+ gdispDrawLine(pp->x+15, pp->y+7, pp->x+15, pp->y+15, RGB2COLOR(184,158,131));
+
+ gdispDrawLine(pp->x+7, pp->y-15, pp->x+15, pp->y-15, RGB2COLOR(184,158,131));
+ gdispDrawLine(pp->x+15, pp->y-15, pp->x+15, pp->y-7, RGB2COLOR(184,158,131));
+ }
+
+ static __inline void _tsClearCross(const MousePoint *pp) {
+ gdispFillArea(pp->x - 15, pp->y - 15, 42, 42, Blue);
+ }
+
+ static __inline void _tsTransform(MouseReading *pt, const Calibration *c) {
+ pt->x = (coord_t) (c->ax * pt->x + c->bx * pt->y + c->cx);
+ pt->y = (coord_t) (c->ay * pt->x + c->by * pt->y + c->cy);
+ }
+
+ static __inline void _tsDo3PointCalibration(const MousePoint *cross, const MousePoint *points, Calibration *c) {
+ float dx, dx0, dx1, dx2, dy0, dy1, dy2;
+
+ /* Compute all the required determinants */
+ dx = ((float)(points[0].x - points[2].x)) * ((float)(points[1].y - points[2].y))
+ - ((float)(points[1].x - points[2].x)) * ((float)(points[0].y - points[2].y));
+
+ dx0 = ((float)(cross[0].x - cross[2].x)) * ((float)(points[1].y - points[2].y))
+ - ((float)(cross[1].x - cross[2].x)) * ((float)(points[0].y - points[2].y));
+
+ dx1 = ((float)(cross[1].x - cross[2].x)) * ((float)(points[0].x - points[2].x))
+ - ((float)(cross[0].x - cross[2].x)) * ((float)(points[1].x - points[2].x));
+
+ dx2 = cross[0].x * ((float)points[1].x * (float)points[2].y - (float)points[2].x * (float)points[1].y) -
+ cross[1].x * ((float)points[0].x * (float)points[2].y - (float)points[2].x * (float)points[0].y) +
+ cross[2].x * ((float)points[0].x * (float)points[1].y - (float)points[1].x * (float)points[0].y);
+
+ dy0 = ((float)(cross[0].y - cross[2].y)) * ((float)(points[1].y - points[2].y))
+ - ((float)(cross[1].y - cross[2].y)) * ((float)(points[0].y - points[2].y));
+
+ dy1 = ((float)(cross[1].y - cross[2].y)) * ((float)(points[0].x - points[2].x))
+ - ((float)(cross[0].y - cross[2].y)) * ((float)(points[1].x - points[2].x));
+
+ dy2 = cross[0].y * ((float)points[1].x * (float)points[2].y - (float)points[2].x * (float)points[1].y) -
+ cross[1].y * ((float)points[0].x * (float)points[2].y - (float)points[2].x * (float)points[0].y) +
+ cross[2].y * ((float)points[0].x * (float)points[1].y - (float)points[1].x * (float)points[0].y);
+
+ /* Now, calculate all the required coefficients */
+ c->ax = dx0 / dx;
+ c->bx = dx1 / dx;
+ c->cx = dx2 / dx;
+
+ c->ay = dy0 / dx;
+ c->by = dy1 / dx;
+ c->cy = dy2 / dx;
+ }
+#endif
+
+#if GINPUT_MOUSE_READ_CYCLES > 1
+ static void get_raw_reading(MouseReading *pt) {
+ int32_t x, y, z;
+ unsigned i;
+
+ x = y = z = 0;
+ for(i = 0; i < GINPUT_MOUSE_READ_CYCLES; i++) {
+ ginput_lld_mouse_get_reading(pt);
+ x += pt->x;
+ y += pt->y;
+ z += pt->z;
+ }
+
+ /* Take the average of the readings */
+ pt->x = x / GINPUT_MOUSE_READ_CYCLES;
+ pt->y = y / GINPUT_MOUSE_READ_CYCLES;
+ pt->z = z / GINPUT_MOUSE_READ_CYCLES;
+ }
+#else
+ #define get_raw_reading(pt) ginput_lld_mouse_get_reading(pt)
+#endif
+
+static void get_calibrated_reading(MouseReading *pt) {
+ #if GINPUT_MOUSE_NEED_CALIBRATION || GDISP_NEED_CONTROL
+ coord_t w, h;
+ #endif
+
+ get_raw_reading(pt);
+
+ #if GINPUT_MOUSE_NEED_CALIBRATION || GDISP_NEED_CONTROL
+ w = gdispGetWidth();
+ h = gdispGetHeight();
+ #endif
+
+ #if GINPUT_MOUSE_NEED_CALIBRATION
+ _tsTransform(pt, &MouseConfig.caldata);
+ #endif
+
+ #if GDISP_NEED_CONTROL
+ switch(gdispGetOrientation()) {
+ case GDISP_ROTATE_0:
+ break;
+ case GDISP_ROTATE_90:
+ {
+ coord_t t = pt->y;
+ pt->y = h - 1 - pt->x;
+ pt->x = t;
+ }
+ break;
+ case GDISP_ROTATE_180:
+ pt->x = w - 1 - pt->x;
+ pt->y = h - 1 - pt->y;
+ break;
+ case GDISP_ROTATE_270:
+ {
+ coord_t t = pt->x;
+ pt->x = w - 1 - pt->y;
+ pt->y = t;
+ }
+ break;
+ }
+ #endif
+
+ #if GINPUT_MOUSE_NEED_CALIBRATION
+ if (pt->x < 0) pt->x = 0;
+ else if (pt->x >= w) pt->x = w-1;
+ if (pt->y < 0) pt->y = 0;
+ else if (pt->y >= h) pt->y = h-1;
+ #endif
+}
+
+static void MousePoll(void *param) {
+ (void) param;
+ GSourceListener *psl;
+ GEventMouse *pe;
+ unsigned meta;
+ uint16_t tbtns;
+ uint32_t cdiff;
+ uint32_t mdiff;
+
+ // Save the last mouse state
+ MouseConfig.last_buttons = MouseConfig.t.buttons;
+
+ // Get the new mouse reading
+ get_calibrated_reading(&MouseConfig.t);
+
+ // Calculate out new event meta value and handle CLICK and CXTCLICK
+ meta = GMETA_NONE;
+
+ // Calculate the position difference from our movement reference (update the reference if out of range)
+ mdiff = (MouseConfig.t.x - MouseConfig.movepos.x) * (MouseConfig.t.x - MouseConfig.movepos.x) +
+ (MouseConfig.t.y - MouseConfig.movepos.y) * (MouseConfig.t.y - MouseConfig.movepos.y);
+ if (mdiff > GINPUT_MOUSE_MAX_MOVE_JITTER * GINPUT_MOUSE_MAX_MOVE_JITTER) {
+ MouseConfig.movepos.x = MouseConfig.t.x;
+ MouseConfig.movepos.y = MouseConfig.t.y;
+ }
+
+ // Check if the click has moved outside the click area and if so cancel the click
+ if ((MouseConfig.flags & FLG_CLICK_TIMER)) {
+ cdiff = (MouseConfig.t.x - MouseConfig.clickpos.x) * (MouseConfig.t.x - MouseConfig.clickpos.x) +
+ (MouseConfig.t.y - MouseConfig.clickpos.y) * (MouseConfig.t.y - MouseConfig.clickpos.y);
+ if (cdiff > GINPUT_MOUSE_MAX_CLICK_JITTER * GINPUT_MOUSE_MAX_CLICK_JITTER)
+ MouseConfig.flags &= ~FLG_CLICK_TIMER;
+ }
+
+ // Mouse down
+ tbtns = MouseConfig.t.buttons & ~MouseConfig.last_buttons;
+ if ((tbtns & GINPUT_MOUSE_BTN_LEFT))
+ meta |= GMETA_MOUSE_DOWN;
+ if ((tbtns & (GINPUT_MOUSE_BTN_LEFT|GINPUT_MOUSE_BTN_RIGHT))) {
+ MouseConfig.clickpos.x = MouseConfig.t.x;
+ MouseConfig.clickpos.y = MouseConfig.t.y;
+ MouseConfig.clicktime = chTimeNow();
+ MouseConfig.flags |= FLG_CLICK_TIMER;
+ }
+
+ // Mouse up
+ tbtns = ~MouseConfig.t.buttons & MouseConfig.last_buttons;
+ if ((tbtns & GINPUT_MOUSE_BTN_LEFT))
+ meta |= GMETA_MOUSE_UP;
+ if ((tbtns & (GINPUT_MOUSE_BTN_LEFT|GINPUT_MOUSE_BTN_RIGHT))) {
+ if ((MouseConfig.flags & FLG_CLICK_TIMER)) {
+ if ((tbtns & GINPUT_MOUSE_BTN_LEFT)
+ #if GINPUT_MOUSE_CLICK_TIME != TIME_INFINITE
+ && chTimeNow() - MouseConfig.clicktime < MS2ST(GINPUT_MOUSE_CLICK_TIME)
+ #endif
+ )
+ meta |= GMETA_MOUSE_CLICK;
+ else
+ meta |= GMETA_MOUSE_CXTCLICK;
+ MouseConfig.flags &= ~FLG_CLICK_TIMER;
+ }
+ }
+
+ // Send the event to the listeners that are interested.
+ psl = 0;
+ while ((psl = geventGetSourceListener((GSourceHandle)(&MouseConfig), psl))) {
+ if (!(pe = (GEventMouse *)geventGetEventBuffer(psl))) {
+ // This listener is missing - save the meta events that have happened
+ psl->srcflags |= meta;
+ continue;
+ }
+
+ // If we haven't really moved (and there are no meta events) don't bother sending the event
+ if (mdiff <= GINPUT_MOUSE_MAX_MOVE_JITTER * GINPUT_MOUSE_MAX_MOVE_JITTER && !psl->srcflags && !meta && !(psl->listenflags & GLISTEN_MOUSENOFILTER))
+ continue;
+
+ // Send the event if we are listening for it
+ if (((MouseConfig.t.buttons & GINPUT_MOUSE_BTN_LEFT) && (psl->listenflags & GLISTEN_MOUSEDOWNMOVES))
+ || (!(MouseConfig.t.buttons & GINPUT_MOUSE_BTN_LEFT) && (psl->listenflags & GLISTEN_MOUSEUPMOVES))
+ || (meta && (psl->listenflags & GLISTEN_MOUSEMETA))) {
+ pe->type = GINPUT_MOUSE_EVENT_TYPE;
+ pe->instance = 0;
+ pe->x = MouseConfig.t.x;
+ pe->y = MouseConfig.t.y;
+ pe->z = MouseConfig.t.z;
+ pe->current_buttons = MouseConfig.t.buttons;
+ pe->last_buttons = MouseConfig.last_buttons;
+ pe->meta = meta;
+ if (psl->srcflags) {
+ pe->current_buttons |= GINPUT_MISSED_MOUSE_EVENT;
+ pe->meta |= psl->srcflags;
+ psl->srcflags = 0;
+ }
+ geventSendEvent(psl);
+ }
+ }
+}
+
+GSourceHandle ginputGetMouse(uint16_t instance) {
+ #if GINPUT_MOUSE_NEED_CALIBRATION
+ Calibration *pc;
+ #endif
+
+ // We only support a single mouse instance currently
+ // Instance 9999 is the same as instance 0 except that it installs
+ // a special "raw" calibration if there isn't one we can load.
+ if (instance && instance != 9999)
+ return 0;
+
+ // Do we need to initialise the mouse subsystem?
+ if (!(MouseConfig.flags & FLG_INIT_DONE)) {
+ ginput_lld_mouse_init();
+
+ #if GINPUT_MOUSE_NEED_CALIBRATION
+ #if GINPUT_MOUSE_LLD_CALIBRATION_LOADSAVE
+ if (!MouseConfig.fnloadcal) {
+ MouseConfig.fnloadcal = ginput_lld_mouse_calibration_load;
+ MouseConfig.flags &= ~FLG_CAL_FREE;
+ }
+ if (!MouseConfig.fnsavecal)
+ MouseConfig.fnsavecal = ginput_lld_mouse_calibration_save;
+ #endif
+ if (MouseConfig.fnloadcal && (pc = (Calibration *)MouseConfig.fnloadcal(instance))) {
+ MouseConfig.caldata = pc[0];
+ MouseConfig.flags |= (FLG_CAL_OK|FLG_CAL_SAVED);
+ if ((MouseConfig.flags & FLG_CAL_FREE))
+ chHeapFree((void *)pc);
+ } else if (instance == 9999) {
+ MouseConfig.caldata.ax = 1;
+ MouseConfig.caldata.bx = 0;
+ MouseConfig.caldata.cx = 0;
+ MouseConfig.caldata.ay = 0;
+ MouseConfig.caldata.by = 1;
+ MouseConfig.caldata.cy = 0;
+ MouseConfig.flags |= (FLG_CAL_OK|FLG_CAL_SAVED);
+ } else
+ ginputCalibrateMouse(instance);
+ #endif
+
+ // Get the first reading
+ MouseConfig.last_buttons = 0;
+ get_calibrated_reading(&MouseConfig.t);
+
+ // Mark init as done and start the Poll timer
+ MouseConfig.flags |= FLG_INIT_DONE;
+ gtimerStart(&MouseTimer, MousePoll, 0, TRUE, GINPUT_MOUSE_POLL_PERIOD);
+ }
+
+ // Return our structure as the handle
+ return (GSourceHandle)&MouseConfig;
+}
+
+bool_t ginputGetMouseStatus(uint16_t instance, GEventMouse *pe) {
+ // Win32 threads don't seem to recognise priority and/or pre-emption
+ // so we add a sleep here to prevent 100% polled applications from locking up.
+ chThdSleepMilliseconds(1);
+
+ if (instance || (MouseConfig.flags & (FLG_INIT_DONE|FLG_IN_CAL)) != FLG_INIT_DONE)
+ return FALSE;
+
+ pe->type = GINPUT_MOUSE_EVENT_TYPE;
+ pe->instance = instance;
+ pe->x = MouseConfig.t.x;
+ pe->y = MouseConfig.t.y;
+ pe->z = MouseConfig.t.z;
+ pe->current_buttons = MouseConfig.t.buttons;
+ pe->last_buttons = MouseConfig.last_buttons;
+ if (pe->current_buttons & ~pe->last_buttons & GINPUT_MOUSE_BTN_LEFT)
+ pe->meta = GMETA_MOUSE_DOWN;
+ else if (~pe->current_buttons & pe->last_buttons & GINPUT_MOUSE_BTN_LEFT)
+ pe->meta = GMETA_MOUSE_UP;
+ else
+ pe->meta = GMETA_NONE;
+ return TRUE;
+}
+
+bool_t ginputCalibrateMouse(uint16_t instance) {
+ #if !GINPUT_MOUSE_NEED_CALIBRATION
+ (void) instance;
+
+ return FALSE;
+ #else
+
+ const coord_t height = gdispGetHeight();
+ const coord_t width = gdispGetWidth();
+ const MousePoint cross[] = {{(width / 4), (height / 4)},
+ {(width - (width / 4)) , (height / 4)},
+ {(width - (width / 4)) , (height - (height / 4))},
+ {(width / 2), (height / 2)}}; /* Check point */
+ MousePoint points[GINPUT_MOUSE_CALIBRATION_POINTS];
+ const MousePoint *pc;
+ MousePoint *pt;
+ int32_t px, py;
+ unsigned i, j;
+ font_t font1, font2;
+ #if GINPUT_MOUSE_MAX_CALIBRATION_ERROR >= 0
+ unsigned err;
+ #endif
+
+ if (instance || (MouseConfig.flags & FLG_IN_CAL))
+ return FALSE;
+
+ font1 = gdispOpenFont(GINPUT_MOUSE_CALIBRATION_FONT);
+ font2 = gdispOpenFont(GINPUT_MOUSE_CALIBRATION_FONT2);
+
+ MouseConfig.flags |= FLG_IN_CAL;
+ gtimerStop(&MouseTimer);
+ MouseConfig.flags &= ~(FLG_CAL_OK|FLG_CAL_SAVED);
+
+ #if GDISP_NEED_CONTROL
+ gdispSetOrientation(GDISP_ROTATE_0);
+ #endif
+
+ #if GDISP_NEED_CLIP
+ gdispSetClip(0, 0, width, height);
+ #endif
+
+ #if GINPUT_MOUSE_MAX_CALIBRATION_ERROR >= 0
+ while(1) {
+ #endif
+ gdispClear(Blue);
+
+ gdispFillStringBox(0, 5, width, 30, GINPUT_MOUSE_CALIBRATION_TEXT, font1, White, Blue, justifyCenter);
+
+ for(i = 0, pt = points, pc = cross; i < GINPUT_MOUSE_CALIBRATION_POINTS; i++, pt++, pc++) {
+ _tsDrawCross(pc);
+
+ do {
+
+ /* Wait for the mouse to be pressed */
+ while(get_raw_reading(&MouseConfig.t), !(MouseConfig.t.buttons & GINPUT_MOUSE_BTN_LEFT))
+ chThdSleepMilliseconds(20);
+
+ /* Average all the samples while the mouse is down */
+ for(px = py = 0, j = 0;
+ chThdSleepMilliseconds(20), /* Settling time between readings */
+ get_raw_reading(&MouseConfig.t),
+ (MouseConfig.t.buttons & GINPUT_MOUSE_BTN_LEFT);
+ j++) {
+ px += MouseConfig.t.x;
+ py += MouseConfig.t.y;
+ }
+
+ } while(!j);
+
+ pt->x = px / j;
+ pt->y = py / j;
+
+ _tsClearCross(pc);
+
+ if (i >= 1 && pt->x == (pt-1)->x && pt->y == (pt-1)->y) {
+ gdispFillStringBox(0, 35, width, 40, GINPUT_MOUSE_CALIBRATION_SAME_TEXT, font2, Red, Yellow, justifyCenter);
+ chThdSleepMilliseconds(5000);
+ gdispFillArea(0, 35, width, 40, Blue);
+ }
+
+ }
+
+ /* Apply 3 point calibration algorithm */
+ _tsDo3PointCalibration(cross, points, &MouseConfig.caldata);
+
+ /* Verification of correctness of calibration (optional) :
+ * See if the 4th point (Middle of the screen) coincides with the calibrated
+ * result. If point is within +/- Squareroot(ERROR) pixel margin, then successful calibration
+ * Else, start from the beginning.
+ */
+ #if GINPUT_MOUSE_MAX_CALIBRATION_ERROR >= 0
+ /* Transform the co-ordinates */
+ MouseConfig.t.x = points[3].x;
+ MouseConfig.t.y = points[3].y;
+ _tsTransform(&MouseConfig.t, &MouseConfig.caldata);
+
+ /* Calculate the delta */
+ err = (MouseConfig.t.x - cross[3].x) * (MouseConfig.t.x - cross[3].x) +
+ (MouseConfig.t.y - cross[3].y) * (MouseConfig.t.y - cross[3].y);
+
+ if (err <= GINPUT_MOUSE_MAX_CALIBRATION_ERROR * GINPUT_MOUSE_MAX_CALIBRATION_ERROR)
+ break;
+
+ gdispFillStringBox(0, 35, width, 40, GINPUT_MOUSE_CALIBRATION_ERROR_TEXT, font2, Red, Yellow, justifyCenter);
+ chThdSleepMilliseconds(5000);
+ }
+ #endif
+
+ // Restart everything
+ gdispCloseFont(font1);
+ gdispCloseFont(font2);
+ MouseConfig.flags |= FLG_CAL_OK;
+ MouseConfig.last_buttons = 0;
+ get_calibrated_reading(&MouseConfig.t);
+ MouseConfig.flags &= ~FLG_IN_CAL;
+ if ((MouseConfig.flags & FLG_INIT_DONE))
+ gtimerStart(&MouseTimer, MousePoll, 0, TRUE, GINPUT_MOUSE_POLL_PERIOD);
+
+ // Save the calibration data (if possible)
+ if (MouseConfig.fnsavecal) {
+ MouseConfig.fnsavecal(instance, (const uint8_t *)&MouseConfig.caldata, sizeof(MouseConfig.caldata));
+ MouseConfig.flags |= FLG_CAL_SAVED;
+ }
+
+ return TRUE;
+ #endif
+}
+
+/* Set the routines to save and fetch calibration data.
+ * This function should be called before first calling ginputGetMouse() for a particular instance
+ * as the gdispGetMouse() routine may attempt to fetch calibration data and perform a startup calibration if there is no way to get it.
+ * If this is called after gdispGetMouse() has been called and the driver requires calibration storage, it will immediately save the data is has already obtained.
+ * The 'requireFree' parameter indicates if the fetch buffer must be free()'d to deallocate the buffer provided by the Fetch routine.
+ */
+void ginputSetMouseCalibrationRoutines(uint16_t instance, GMouseCalibrationSaveRoutine fnsave, GMouseCalibrationLoadRoutine fnload, bool_t requireFree) {
+ #if GINPUT_MOUSE_NEED_CALIBRATION
+ if (instance)
+ return;
+
+ MouseConfig.fnloadcal = fnload;
+ MouseConfig.fnsavecal = fnsave;
+ if (requireFree)
+ MouseConfig.flags |= FLG_CAL_FREE;
+ else
+ MouseConfig.flags &= ~FLG_CAL_FREE;
+ #if GINPUT_MOUSE_LLD_CALIBRATION_LOADSAVE
+ if (!MouseConfig.fnloadcal) {
+ MouseConfig.fnloadcal = ginput_lld_mouse_calibration_load;
+ MouseConfig.flags &= ~FLG_CAL_FREE;
+ }
+ if (!MouseConfig.fnsavecal)
+ MouseConfig.fnsavecal = ginput_lld_mouse_calibration_save;
+ #endif
+ if (MouseConfig.fnsavecal && (MouseConfig.flags & (FLG_CAL_OK|FLG_CAL_SAVED)) == FLG_CAL_OK) {
+ MouseConfig.fnsavecal(instance, (const uint8_t *)&MouseConfig.caldata, sizeof(MouseConfig.caldata));
+ MouseConfig.flags |= FLG_CAL_SAVED;
+ }
+ #else
+ (void)instance, (void)fnsave, (void)fnload, (void)requireFree;
+ #endif
+}
+
+/* Test if a particular mouse instance requires routines to save its calibration data. */
+bool_t ginputRequireMouseCalibrationStorage(uint16_t instance) {
+ if (instance)
+ return FALSE;
+
+ #if GINPUT_MOUSE_NEED_CALIBRATION && !GINPUT_MOUSE_LLD_CALIBRATION_LOADSAVE
+ return TRUE;
+ #else
+ return FALSE;
+ #endif
+}
+
+/* Wake up the mouse driver from an interrupt service routine (there may be new readings available) */
+void ginputMouseWakeup(void) {
+ gtimerJab(&MouseTimer);
+}
+
+/* Wake up the mouse driver from an interrupt service routine (there may be new readings available) */
+void ginputMouseWakeupI(void) {
+ gtimerJabI(&MouseTimer);
+}
+
+#endif /* GFX_USE_GINPUT && GINPUT_NEED_MOUSE */
+/** @} */
diff --git a/src/ginput/toggle.c b/src/ginput/toggle.c
new file mode 100644
index 00000000..4401e295
--- /dev/null
+++ b/src/ginput/toggle.c
@@ -0,0 +1,171 @@
+/*
+ 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 src/ginput/toggle.c
+ * @brief GINPUT toggle code.
+ *
+ * @defgroup Toggle Toggle
+ * @ingroup GINPUT
+ * @{
+ */
+#include "ch.h"
+#include "hal.h"
+#include "gfx.h"
+
+#if (GFX_USE_GINPUT && GINPUT_NEED_TOGGLE) || defined(__DOXYGEN__)
+
+#include "ginput/lld/toggle.h"
+
+#define GINPUT_TOGGLE_ISON 0x01
+#define GINPUT_TOGGLE_INVERT 0x02
+
+static GTIMER_DECL(ToggleTimer);
+static struct GEventToggleStatus_t {
+ uint8_t status;
+} ToggleStatus[GINPUT_TOGGLE_NUM_PORTS];
+
+// Our polling function
+static void TogglePoll(void *param) {
+ (void) param;
+
+ const GToggleConfig *ptc;
+ GSourceListener *psl;
+ GEventToggle *pe;
+ unsigned i, bits, mask;
+ uint8_t state;
+
+ // Loop while there are bits to get
+ for(ptc = GInputToggleConfigTable, i=0; i < GINPUT_TOGGLE_NUM_PORTS; ptc++) {
+
+ // Get the next block of bits
+ bits = ginput_lld_toggle_getbits(ptc) ^ ptc->invert;
+
+ // Extract the bits of use
+ for(mask = ptc->mask; i < GINPUT_TOGGLE_NUM_PORTS && mask; mask >>= 1, bits >>= 1) {
+ // Ignore bits not in our mask
+ if (!(mask & 1))
+ continue;
+
+ // Calculate our new state
+ state = ToggleStatus[i].status & ~GINPUT_TOGGLE_ISON;
+ if (state & GINPUT_TOGGLE_INVERT)
+ bits ^= 1;
+ if (bits & 1)
+ state |= GINPUT_TOGGLE_ISON;
+
+ // Has it changed?
+ if ((state ^ ToggleStatus[i].status) & GINPUT_TOGGLE_ISON) {
+
+ // Save the new state
+ ToggleStatus[i].status = state;
+
+ // Send the event to the listeners that are interested.
+ psl = 0;
+ while ((psl = geventGetSourceListener((GSourceHandle)(ToggleStatus+i), psl))) {
+ if (!(pe = (GEventToggle *)geventGetEventBuffer(psl)))
+ continue;
+ if ((state & GINPUT_TOGGLE_ISON)) {
+ if ((psl->listenflags & GLISTEN_TOGGLE_ON)) {
+ pe->type = GEVENT_TOGGLE;
+ pe->instance = i;
+ pe->on = TRUE;
+ geventSendEvent(psl);
+ }
+ } else {
+ if ((psl->listenflags & GLISTEN_TOGGLE_OFF)) {
+ pe->type = GEVENT_TOGGLE;
+ pe->instance = i;
+ pe->on = FALSE;
+ geventSendEvent(psl);
+ }
+ }
+ }
+ }
+
+ // Next toggle switch
+ i++;
+ }
+ }
+}
+
+/* Hardware Toggle/Switch/Button Functions */
+GSourceHandle ginputGetToggle(uint16_t instance) {
+ const GToggleConfig *ptc;
+
+ if (instance >= GINPUT_TOGGLE_NUM_PORTS)
+ return 0;
+
+ // Do we need to initialise the toggle subsystem?
+ if (!gtimerIsActive(&ToggleTimer)) {
+ for(ptc = GInputToggleConfigTable; ptc < GInputToggleConfigTable+sizeof(GInputToggleConfigTable)/sizeof(GInputToggleConfigTable[0]); ptc++)
+ ginput_lld_toggle_init(ptc);
+ gtimerStart(&ToggleTimer, TogglePoll, 0, TRUE, GINPUT_TOGGLE_POLL_PERIOD);
+ }
+
+ // OK - return this input
+ return (GSourceHandle)(ToggleStatus+instance);
+}
+
+// If invert is true, invert the on/off sense for the toggle
+void ginputInvertToggle(uint16_t instance, bool_t invert) {
+ if (instance >= GINPUT_TOGGLE_NUM_PORTS)
+ return;
+ if (invert) {
+ if (!(ToggleStatus[instance].status & GINPUT_TOGGLE_INVERT)) {
+ ToggleStatus[instance].status |= GINPUT_TOGGLE_INVERT;
+ ToggleStatus[instance].status ^= GINPUT_TOGGLE_ISON;
+ }
+ } else {
+ if ((ToggleStatus[instance].status & GINPUT_TOGGLE_INVERT)) {
+ ToggleStatus[instance].status &= ~GINPUT_TOGGLE_INVERT;
+ ToggleStatus[instance].status ^= GINPUT_TOGGLE_ISON;
+ }
+ }
+}
+
+/* Get the current toggle status.
+ * Returns FALSE on error (eg invalid instance)
+ */
+bool_t ginputGetToggleStatus(uint16_t instance, GEventToggle *ptoggle) {
+ // Win32 threads don't seem to recognise priority and/or pre-emption
+ // so we add a sleep here to prevent 100% polled applications from locking up.
+ chThdSleepMilliseconds(1);
+
+ if (instance >= GINPUT_TOGGLE_NUM_PORTS)
+ return FALSE;
+ ptoggle->type = GEVENT_TOGGLE;
+ ptoggle->instance = instance;
+ ptoggle->on = (ToggleStatus[instance].status & GINPUT_TOGGLE_ISON) ? TRUE : FALSE;
+ return TRUE;
+}
+
+/* Wake up the mouse driver from an interrupt service routine (there may be new readings available) */
+void ginputToggleWakeup(void) {
+ gtimerJab(&ToggleTimer);
+}
+
+/* Wake up the mouse driver from an interrupt service routine (there may be new readings available) */
+void ginputToggleWakeupI(void) {
+ gtimerJabI(&ToggleTimer);
+}
+
+#endif /* GFX_USE_GINPUT && GINPUT_NEED_TOGGLE */
+/** @} */
diff --git a/src/gmisc/arrayops.c b/src/gmisc/arrayops.c
new file mode 100644
index 00000000..6eeb0e75
--- /dev/null
+++ b/src/gmisc/arrayops.c
@@ -0,0 +1,241 @@
+/*
+ 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 src/gmisc/arrayops.c
+ * @brief GMISC Array Operations code.
+ *
+ * @addtogroup GMISC
+ * @{
+ */
+#include "ch.h"
+#include "hal.h"
+#include "gfx.h"
+
+#if (GFX_USE_GMISC && GMISC_NEED_ARRAYOPS) || defined(__DOXYGEN__)
+
+void gmiscArrayConvert(ArrayDataFormat srcfmt, void *src, ArrayDataFormat dstfmt, void *dst, size_t cnt) {
+ uint8_t *src8, *dst8;
+ uint16_t *src16, *dst16;
+
+ dst8 = dst;
+ dst16 = dst;
+ src8 = src;
+ src16 = src;
+
+ /* We do this as a big switch in order to optimise efficiency for each transfer type */
+ switch(dstfmt) {
+ case ARRAY_DATA_4BITUNSIGNED:
+ switch(srcfmt) {
+ case ARRAY_DATA_4BITUNSIGNED: if (dst != src) while(cnt--) { *dst8++ = *src8++; } break;
+ case ARRAY_DATA_4BITSIGNED: while(cnt--) { *dst8++ = (*src8++ ^ 8); } break;
+ case ARRAY_DATA_8BITUNSIGNED: while(cnt--) { *dst8++ = *src8++ >> 4; } break;
+ case ARRAY_DATA_8BITSIGNED: while(cnt--) { *dst8++ = (*src8++ ^ 128) >> 4; } break;
+ case ARRAY_DATA_10BITUNSIGNED: while(cnt--) { *dst8++ = *src16++ >> 6; } break;
+ case ARRAY_DATA_10BITSIGNED: while(cnt--) { *dst8++ = (*src16++ ^ 512) >> 6; } break;
+ case ARRAY_DATA_12BITUNSIGNED: while(cnt--) { *dst8++ = *src16++ >> 8; } break;
+ case ARRAY_DATA_12BITSIGNED: while(cnt--) { *dst8++ = (*src16++ ^ 2048) >> 8; } break;
+ case ARRAY_DATA_14BITUNSIGNED: while(cnt--) { *dst8++ = *src16++ >> 10; } break;
+ case ARRAY_DATA_14BITSIGNED: while(cnt--) { *dst8++ = (*src16++ ^ 8192) >> 10; } break;
+ case ARRAY_DATA_16BITUNSIGNED: while(cnt--) { *dst8++ = *src16++ >> 12; } break;
+ case ARRAY_DATA_16BITSIGNED: while(cnt--) { *dst8++ = (*src16++ ^ 32768) >> 12; } break;
+ }
+ break;
+ case ARRAY_DATA_4BITSIGNED:
+ switch(srcfmt) {
+ case ARRAY_DATA_4BITUNSIGNED: while(cnt--) { *dst8++ = (*src8++ ^ 8); } break;
+ case ARRAY_DATA_4BITSIGNED: if (dst != src) while(cnt--) { *dst8++ = *src8++; } break;
+ case ARRAY_DATA_8BITUNSIGNED: while(cnt--) { *dst8++ = (*src8++ ^ 128) >> 4; } break;
+ case ARRAY_DATA_8BITSIGNED: while(cnt--) { *dst8++ = *src8++ >> 4; } break;
+ case ARRAY_DATA_10BITUNSIGNED: while(cnt--) { *dst8++ = (*src16++ ^ 512) >> 6; } break;
+ case ARRAY_DATA_10BITSIGNED: while(cnt--) { *dst8++ = *src16++ >> 6; } break;
+ case ARRAY_DATA_12BITUNSIGNED: while(cnt--) { *dst8++ = (*src16++ ^ 2048) >> 8; } break;
+ case ARRAY_DATA_12BITSIGNED: while(cnt--) { *dst8++ = *src16++ >> 8; } break;
+ case ARRAY_DATA_14BITUNSIGNED: while(cnt--) { *dst8++ = (*src16++ ^ 8192) >> 10; } break;
+ case ARRAY_DATA_14BITSIGNED: while(cnt--) { *dst8++ = *src16++ >> 10; } break;
+ case ARRAY_DATA_16BITUNSIGNED: while(cnt--) { *dst8++ = (*src16++ ^ 32768) >> 12; } break;
+ case ARRAY_DATA_16BITSIGNED: while(cnt--) { *dst8++ = *src16++ >> 12; } break;
+ }
+ break;
+ case ARRAY_DATA_8BITUNSIGNED:
+ switch(srcfmt) {
+ case ARRAY_DATA_4BITUNSIGNED: while(cnt--) { *dst8++ = *src8++ << 4; } break;
+ case ARRAY_DATA_4BITSIGNED: while(cnt--) { *dst8++ = (*src8++ ^ 8) << 4; } break;
+ case ARRAY_DATA_8BITUNSIGNED: if (dst != src) while(cnt--) { *dst8++ = *src8++; } break;
+ case ARRAY_DATA_8BITSIGNED: while(cnt--) { *dst8++ = (*src8++ ^ 128); } break;
+ case ARRAY_DATA_10BITUNSIGNED: while(cnt--) { *dst8++ = *src16++ >> 2; } break;
+ case ARRAY_DATA_10BITSIGNED: while(cnt--) { *dst8++ = (*src16++ ^ 512) >> 2; } break;
+ case ARRAY_DATA_12BITUNSIGNED: while(cnt--) { *dst8++ = *src16++ >> 4; } break;
+ case ARRAY_DATA_12BITSIGNED: while(cnt--) { *dst8++ = (*src16++ ^ 2048) >> 4; } break;
+ case ARRAY_DATA_14BITUNSIGNED: while(cnt--) { *dst8++ = *src16++ >> 6; } break;
+ case ARRAY_DATA_14BITSIGNED: while(cnt--) { *dst8++ = (*src16++ ^ 8192) >> 6; } break;
+ case ARRAY_DATA_16BITUNSIGNED: while(cnt--) { *dst8++ = *src16++ >> 8; } break;
+ case ARRAY_DATA_16BITSIGNED: while(cnt--) { *dst8++ = (*src16++ ^ 32768) >> 8; } break;
+ }
+ break;
+ case ARRAY_DATA_8BITSIGNED:
+ switch(srcfmt) {
+ case ARRAY_DATA_4BITUNSIGNED: while(cnt--) { *dst8++ = (*src8++ ^ 8) << 4; } break;
+ case ARRAY_DATA_4BITSIGNED: while(cnt--) { *dst8++ = *src8++ << 4; } break;
+ case ARRAY_DATA_8BITUNSIGNED: while(cnt--) { *dst8++ = (*src8++ ^ 128); } break;
+ case ARRAY_DATA_8BITSIGNED: if (dst != src) while(cnt--) { *dst8++ = *src8++; } break;
+ case ARRAY_DATA_10BITUNSIGNED: while(cnt--) { *dst8++ = (*src16++ ^ 512) >> 2; } break;
+ case ARRAY_DATA_10BITSIGNED: while(cnt--) { *dst8++ = *src16++ >> 2; } break;
+ case ARRAY_DATA_12BITUNSIGNED: while(cnt--) { *dst8++ = (*src16++ ^ 2048) >> 4; } break;
+ case ARRAY_DATA_12BITSIGNED: while(cnt--) { *dst8++ = *src16++ >> 4; } break;
+ case ARRAY_DATA_14BITUNSIGNED: while(cnt--) { *dst8++ = (*src16++ ^ 8192) >> 6; } break;
+ case ARRAY_DATA_14BITSIGNED: while(cnt--) { *dst8++ = *src16++ >> 6; } break;
+ case ARRAY_DATA_16BITUNSIGNED: while(cnt--) { *dst8++ = (*src16++ ^ 32768) >> 8; } break;
+ case ARRAY_DATA_16BITSIGNED: while(cnt--) { *dst8++ = *src16++ >> 8; } break;
+ }
+ break;
+ case ARRAY_DATA_10BITUNSIGNED:
+ switch(srcfmt) {
+ case ARRAY_DATA_4BITUNSIGNED: while(cnt--) { *dst16++ = *src8++ << 6; } break;
+ case ARRAY_DATA_4BITSIGNED: while(cnt--) { *dst16++ = (*src8++ ^ 8) << 6; } break;
+ case ARRAY_DATA_8BITUNSIGNED: while(cnt--) { *dst16++ = *src8++ << 2; } break;
+ case ARRAY_DATA_8BITSIGNED: while(cnt--) { *dst16++ = (*src8++ ^ 128) << 2; } break;
+ case ARRAY_DATA_10BITUNSIGNED: if (dst != src) while(cnt--) { *dst16++ = *src16++; } break;
+ case ARRAY_DATA_10BITSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 512); } break;
+ case ARRAY_DATA_12BITUNSIGNED: while(cnt--) { *dst16++ = *src16++ >> 2; } break;
+ case ARRAY_DATA_12BITSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 2048) >> 2; } break;
+ case ARRAY_DATA_14BITUNSIGNED: while(cnt--) { *dst16++ = *src16++ >> 4; } break;
+ case ARRAY_DATA_14BITSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 8192) >> 4; } break;
+ case ARRAY_DATA_16BITUNSIGNED: while(cnt--) { *dst16++ = *src16++ >> 6; } break;
+ case ARRAY_DATA_16BITSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 32768) >> 6; } break;
+ }
+ break;
+ case ARRAY_DATA_10BITSIGNED:
+ switch(srcfmt) {
+ case ARRAY_DATA_4BITUNSIGNED: while(cnt--) { *dst16++ = (*src8++ ^ 8) << 6; } break;
+ case ARRAY_DATA_4BITSIGNED: while(cnt--) { *dst16++ = *src8++ << 6; } break;
+ case ARRAY_DATA_8BITUNSIGNED: while(cnt--) { *dst16++ = (*src8++ ^ 128) << 2; } break;
+ case ARRAY_DATA_8BITSIGNED: while(cnt--) { *dst16++ = *src8++ << 2; } break;
+ case ARRAY_DATA_10BITUNSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 512); } break;
+ case ARRAY_DATA_10BITSIGNED: if (dst != src) while(cnt--) { *dst16++ = *src16++; } break;
+ case ARRAY_DATA_12BITUNSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 2048) >> 2; } break;
+ case ARRAY_DATA_12BITSIGNED: while(cnt--) { *dst16++ = *src16++ >> 2; } break;
+ case ARRAY_DATA_14BITUNSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 8192) >> 4; } break;
+ case ARRAY_DATA_14BITSIGNED: while(cnt--) { *dst16++ = *src16++ >> 4; } break;
+ case ARRAY_DATA_16BITUNSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 32768) >> 6; } break;
+ case ARRAY_DATA_16BITSIGNED: while(cnt--) { *dst16++ = *src16++ >> 6; } break;
+ }
+ break;
+ case ARRAY_DATA_12BITUNSIGNED:
+ switch(srcfmt) {
+ case ARRAY_DATA_4BITUNSIGNED: while(cnt--) { *dst16++ = *src8++ << 8; } break;
+ case ARRAY_DATA_4BITSIGNED: while(cnt--) { *dst16++ = (*src8++ ^ 8) << 8; } break;
+ case ARRAY_DATA_8BITUNSIGNED: while(cnt--) { *dst16++ = *src8++ << 4; } break;
+ case ARRAY_DATA_8BITSIGNED: while(cnt--) { *dst16++ = (*src8++ ^ 128) << 4; } break;
+ case ARRAY_DATA_10BITUNSIGNED: while(cnt--) { *dst16++ = *src16++ << 2; } break;
+ case ARRAY_DATA_10BITSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 512) << 2; } break;
+ case ARRAY_DATA_12BITUNSIGNED: if (dst != src) while(cnt--) { *dst16++ = *src16++; } break;
+ case ARRAY_DATA_12BITSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 2048); } break;
+ case ARRAY_DATA_14BITUNSIGNED: while(cnt--) { *dst16++ = *src16++ >> 2; } break;
+ case ARRAY_DATA_14BITSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 8192) >> 2; } break;
+ case ARRAY_DATA_16BITUNSIGNED: while(cnt--) { *dst16++ = *src16++ >> 4; } break;
+ case ARRAY_DATA_16BITSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 32768) >> 4; } break;
+ }
+ break;
+ case ARRAY_DATA_12BITSIGNED:
+ switch(srcfmt) {
+ case ARRAY_DATA_4BITUNSIGNED: while(cnt--) { *dst16++ = (*src8++ ^ 8) << 8; } break;
+ case ARRAY_DATA_4BITSIGNED: while(cnt--) { *dst16++ = *src8++ << 8; } break;
+ case ARRAY_DATA_8BITUNSIGNED: while(cnt--) { *dst16++ = (*src8++ ^ 128) << 4; } break;
+ case ARRAY_DATA_8BITSIGNED: while(cnt--) { *dst16++ = *src8++ << 4; } break;
+ case ARRAY_DATA_10BITUNSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 512) << 2; } break;
+ case ARRAY_DATA_10BITSIGNED: while(cnt--) { *dst16++ = *src16++ << 2; } break;
+ case ARRAY_DATA_12BITUNSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 2048); } break;
+ case ARRAY_DATA_12BITSIGNED: if (dst != src) while(cnt--) { *dst16++ = *src16++; } break;
+ case ARRAY_DATA_14BITUNSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 8192) >> 2; } break;
+ case ARRAY_DATA_14BITSIGNED: while(cnt--) { *dst16++ = *src16++ >> 2; } break;
+ case ARRAY_DATA_16BITUNSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 32768) >> 4; } break;
+ case ARRAY_DATA_16BITSIGNED: while(cnt--) { *dst16++ = *src16++ >> 4; } break;
+ }
+ break;
+ case ARRAY_DATA_14BITUNSIGNED:
+ switch(srcfmt) {
+ case ARRAY_DATA_4BITUNSIGNED: while(cnt--) { *dst16++ = *src8++ << 10; } break;
+ case ARRAY_DATA_4BITSIGNED: while(cnt--) { *dst16++ = (*src8++ ^ 8) << 10; } break;
+ case ARRAY_DATA_8BITUNSIGNED: while(cnt--) { *dst16++ = *src8++ << 6; } break;
+ case ARRAY_DATA_8BITSIGNED: while(cnt--) { *dst16++ = (*src8++ ^ 128) << 6; } break;
+ case ARRAY_DATA_10BITUNSIGNED: while(cnt--) { *dst16++ = *src16++ << 4; } break;
+ case ARRAY_DATA_10BITSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 512) << 4; } break;
+ case ARRAY_DATA_12BITUNSIGNED: while(cnt--) { *dst16++ = *src16++ << 2; } break;
+ case ARRAY_DATA_12BITSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 2048) >> 2; } break;
+ case ARRAY_DATA_14BITUNSIGNED: if (dst != src) while(cnt--) { *dst16++ = *src16++; } break;
+ case ARRAY_DATA_14BITSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 8192); } break;
+ case ARRAY_DATA_16BITUNSIGNED: while(cnt--) { *dst16++ = *src16++ >> 2; } break;
+ case ARRAY_DATA_16BITSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 32768) >> 2; } break;
+ }
+ break;
+ case ARRAY_DATA_14BITSIGNED:
+ switch(srcfmt) {
+ case ARRAY_DATA_4BITUNSIGNED: while(cnt--) { *dst16++ = (*src8++ ^ 8) << 10; } break;
+ case ARRAY_DATA_4BITSIGNED: while(cnt--) { *dst16++ = *src8++ << 10; } break;
+ case ARRAY_DATA_8BITUNSIGNED: while(cnt--) { *dst16++ = (*src8++ ^ 128) << 6; } break;
+ case ARRAY_DATA_8BITSIGNED: while(cnt--) { *dst16++ = *src8++ << 6; } break;
+ case ARRAY_DATA_10BITUNSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 512) << 4; } break;
+ case ARRAY_DATA_10BITSIGNED: while(cnt--) { *dst16++ = *src16++ << 4; } break;
+ case ARRAY_DATA_12BITUNSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 2048) << 2; } break;
+ case ARRAY_DATA_12BITSIGNED: while(cnt--) { *dst16++ = *src16++ << 2; } break;
+ case ARRAY_DATA_14BITUNSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 8192); } break;
+ case ARRAY_DATA_14BITSIGNED: if (dst != src) while(cnt--) { *dst16++ = *src16++; } break;
+ case ARRAY_DATA_16BITUNSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 32768) >> 2; } break;
+ case ARRAY_DATA_16BITSIGNED: while(cnt--) { *dst16++ = *src16++ >> 2; } break;
+ }
+ break;
+ case ARRAY_DATA_16BITUNSIGNED:
+ switch(srcfmt) {
+ case ARRAY_DATA_4BITUNSIGNED: while(cnt--) { *dst16++ = *src8++ << 12; } break;
+ case ARRAY_DATA_4BITSIGNED: while(cnt--) { *dst16++ = (*src8++ ^ 8) << 12; } break;
+ case ARRAY_DATA_8BITUNSIGNED: while(cnt--) { *dst16++ = *src8++ << 8; } break;
+ case ARRAY_DATA_8BITSIGNED: while(cnt--) { *dst16++ = (*src8++ ^ 128) << 8; } break;
+ case ARRAY_DATA_10BITUNSIGNED: while(cnt--) { *dst16++ = *src16++ << 6; } break;
+ case ARRAY_DATA_10BITSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 512) << 6; } break;
+ case ARRAY_DATA_12BITUNSIGNED: while(cnt--) { *dst16++ = *src16++ << 4; } break;
+ case ARRAY_DATA_12BITSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 2048) >> 4; } break;
+ case ARRAY_DATA_14BITUNSIGNED: while(cnt--) { *dst16++ = *src16++ >> 2; } break;
+ case ARRAY_DATA_14BITSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 8192) >> 2; } break;
+ case ARRAY_DATA_16BITUNSIGNED: if (dst != src) while(cnt--) { *dst16++ = *src16++; } break;
+ case ARRAY_DATA_16BITSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 32768); } break;
+ }
+ break;
+ case ARRAY_DATA_16BITSIGNED:
+ switch(srcfmt) {
+ case ARRAY_DATA_4BITUNSIGNED: while(cnt--) { *dst16++ = (*src8++ ^ 8) << 12; } break;
+ case ARRAY_DATA_4BITSIGNED: while(cnt--) { *dst16++ = *src8++ << 12; } break;
+ case ARRAY_DATA_8BITUNSIGNED: while(cnt--) { *dst16++ = (*src8++ ^ 128) << 8; } break;
+ case ARRAY_DATA_8BITSIGNED: while(cnt--) { *dst16++ = *src8++ << 8; } break;
+ case ARRAY_DATA_10BITUNSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 512) << 6; } break;
+ case ARRAY_DATA_10BITSIGNED: while(cnt--) { *dst16++ = *src16++ << 6; } break;
+ case ARRAY_DATA_12BITUNSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 2048) << 4; } break;
+ case ARRAY_DATA_12BITSIGNED: while(cnt--) { *dst16++ = *src16++ << 4; } break;
+ case ARRAY_DATA_14BITUNSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 8192) << 2; } break;
+ case ARRAY_DATA_14BITSIGNED: while(cnt--) { *dst16++ = *src16++ >> 2; } break;
+ case ARRAY_DATA_16BITUNSIGNED: while(cnt--) { *dst16++ = (*src16++ ^ 32768); } break;
+ case ARRAY_DATA_16BITSIGNED: if (dst != src) while(cnt--) { *dst16++ = *src16++; } break;
+ }
+ break;
+ }
+}
+
+#endif /* GFX_USE_GMISC && GMISC_NEED_ARRAYOPS */
+/** @} */
diff --git a/src/gmisc/gmisc.mk b/src/gmisc/gmisc.mk
new file mode 100644
index 00000000..7e4caea8
--- /dev/null
+++ b/src/gmisc/gmisc.mk
@@ -0,0 +1 @@
+GFXSRC += $(GFXLIB)/src/gmisc/arrayops.c
diff --git a/src/gtimer/gtimer.c b/src/gtimer/gtimer.c
new file mode 100644
index 00000000..76dd57e2
--- /dev/null
+++ b/src/gtimer/gtimer.c
@@ -0,0 +1,240 @@
+/*
+ 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 src/gtimer/gtimer.c
+ * @brief GTIMER sub-system code.
+ *
+ * @addtogroup GTIMER
+ * @{
+ */
+#include "ch.h"
+#include "hal.h"
+#include "gfx.h"
+
+#if GFX_USE_GTIMER || defined(__DOXYGEN__)
+
+#if !CH_USE_MUTEXES || !CH_USE_SEMAPHORES
+ #error "GTIMER: CH_USE_MUTEXES and CH_USE_SEMAPHORES must be defined in chconf.h"
+#endif
+
+#define GTIMER_FLG_PERIODIC 0x0001
+#define GTIMER_FLG_INFINITE 0x0002
+#define GTIMER_FLG_JABBED 0x0004
+#define GTIMER_FLG_SCHEDULED 0x0008
+
+/* Don't rework this macro to use a ternary operator - the gcc compiler stuffs it up */
+#define TimeIsWithin(x, start, end) ((end >= start && x >= start && x <= end) || (end < start && (x >= start || x <= end)))
+
+/* This mutex protects access to our tables */
+static MUTEX_DECL(mutex);
+static Thread *pThread = 0;
+static GTimer *pTimerHead = 0;
+static BSEMAPHORE_DECL(waitsem, TRUE);
+static WORKING_AREA(waTimerThread, GTIMER_THREAD_WORKAREA_SIZE);
+
+/*===========================================================================*/
+/* Driver local functions. */
+/*===========================================================================*/
+
+static msg_t GTimerThreadHandler(void *arg) {
+ (void)arg;
+ GTimer *pt;
+ systime_t tm;
+ systime_t nxtTimeout;
+ systime_t lastTime;
+ GTimerFunction fn;
+ void *param;
+
+ #if CH_USE_REGISTRY
+ chRegSetThreadName("GTimer");
+ #endif
+
+ nxtTimeout = TIME_INFINITE;
+ lastTime = 0;
+ while(1) {
+ /* Wait for work to do. */
+ chThdYield(); // Give someone else a go no matter how busy we are
+ chBSemWaitTimeout(&waitsem, nxtTimeout);
+
+ restartTimerChecks:
+
+ // Our reference time
+ tm = chTimeNow();
+ nxtTimeout = TIME_INFINITE;
+
+ /* We need to obtain the mutex */
+ chMtxLock(&mutex);
+
+ if (pTimerHead) {
+ pt = pTimerHead;
+ do {
+ // Do we have something to do for this timer?
+ if ((pt->flags & GTIMER_FLG_JABBED) || (!(pt->flags & GTIMER_FLG_INFINITE) && TimeIsWithin(pt->when, lastTime, tm))) {
+
+ // Is this timer periodic?
+ if ((pt->flags & GTIMER_FLG_PERIODIC) && pt->period != TIME_IMMEDIATE) {
+ // Yes - Update ready for the next period
+ if (!(pt->flags & GTIMER_FLG_INFINITE)) {
+ // We may have skipped a period.
+ // We use this complicated formulae rather than a loop
+ // because the gcc compiler stuffs up the loop so that it
+ // either loops forever or doesn't get executed at all.
+ pt->when += ((tm + pt->period - pt->when) / pt->period) * pt->period;
+ }
+
+ // We are definitely no longer jabbed
+ pt->flags &= ~GTIMER_FLG_JABBED;
+
+ } else {
+ // No - get us off the timers list
+ if (pt->next == pt->prev)
+ pTimerHead = 0;
+ else {
+ pt->next->prev = pt->prev;
+ pt->prev->next = pt->next;
+ if (pTimerHead == pt)
+ pTimerHead = pt->next;
+ }
+ pt->flags = 0;
+ }
+
+ // Call the callback function
+ fn = pt->fn;
+ param = pt->param;
+ chMtxUnlock();
+ fn(param);
+
+ // We no longer hold the mutex, the callback function may have taken a while
+ // and our list may have been altered so start again!
+ goto restartTimerChecks;
+ }
+
+ // Find when we next need to wake up
+ if (!(pt->flags & GTIMER_FLG_INFINITE) && pt->when - tm < nxtTimeout)
+ nxtTimeout = pt->when - tm;
+ pt = pt->next;
+ } while(pt != pTimerHead);
+ }
+
+ // Ready for the next loop
+ lastTime = tm;
+ chMtxUnlock();
+ }
+ return 0;
+}
+
+void gtimerInit(GTimer *pt) {
+ pt->flags = 0;
+}
+
+void gtimerStart(GTimer *pt, GTimerFunction fn, void *param, bool_t periodic, systime_t millisec) {
+ chMtxLock(&mutex);
+
+ // Start our thread if not already going
+ if (!pThread)
+ pThread = chThdCreateStatic(waTimerThread, sizeof(waTimerThread), HIGHPRIO, GTimerThreadHandler, NULL);
+
+ // Is this already scheduled?
+ if (pt->flags & GTIMER_FLG_SCHEDULED) {
+ // Cancel it!
+ if (pt->next == pt->prev)
+ pTimerHead = 0;
+ else {
+ pt->next->prev = pt->prev;
+ pt->prev->next = pt->next;
+ if (pTimerHead == pt)
+ pTimerHead = pt->next;
+ }
+ }
+
+ // Set up the timer structure
+ pt->fn = fn;
+ pt->param = param;
+ pt->flags = GTIMER_FLG_SCHEDULED;
+ if (periodic)
+ pt->flags |= GTIMER_FLG_PERIODIC;
+ if (millisec == TIME_INFINITE) {
+ pt->flags |= GTIMER_FLG_INFINITE;
+ pt->period = TIME_INFINITE;
+ } else {
+ pt->period = MS2ST(millisec);
+ pt->when = chTimeNow() + pt->period;
+ }
+
+ // Just pop it on the end of the queue
+ if (pTimerHead) {
+ pt->next = pTimerHead;
+ pt->prev = pTimerHead->prev;
+ pt->prev->next = pt;
+ pt->next->prev = pt;
+ } else
+ pt->next = pt->prev = pTimerHead = pt;
+
+ // Bump the thread
+ if (!(pt->flags & GTIMER_FLG_INFINITE))
+ chBSemSignal(&waitsem);
+ chMtxUnlock();
+}
+
+void gtimerStop(GTimer *pt) {
+ chMtxLock(&mutex);
+ if (pt->flags & GTIMER_FLG_SCHEDULED) {
+ // Cancel it!
+ if (pt->next == pt->prev)
+ pTimerHead = 0;
+ else {
+ pt->next->prev = pt->prev;
+ pt->prev->next = pt->next;
+ if (pTimerHead == pt)
+ pTimerHead = pt->next;
+ }
+ // Make sure we know the structure is dead!
+ pt->flags = 0;
+ }
+ chMtxUnlock();
+}
+
+bool_t gtimerIsActive(GTimer *pt) {
+ return (pt->flags & GTIMER_FLG_SCHEDULED) ? TRUE : FALSE;
+}
+
+void gtimerJab(GTimer *pt) {
+ chMtxLock(&mutex);
+
+ // Jab it!
+ pt->flags |= GTIMER_FLG_JABBED;
+
+ // Bump the thread
+ chBSemSignal(&waitsem);
+ chMtxUnlock();
+}
+
+void gtimerJabI(GTimer *pt) {
+ // Jab it!
+ pt->flags |= GTIMER_FLG_JABBED;
+
+ // Bump the thread
+ chBSemSignalI(&waitsem);
+}
+
+#endif /* GFX_USE_GTIMER */
+/** @} */
+
diff --git a/src/gtimer/gtimer.mk b/src/gtimer/gtimer.mk
new file mode 100644
index 00000000..e6c2b588
--- /dev/null
+++ b/src/gtimer/gtimer.mk
@@ -0,0 +1 @@
+GFXSRC += $(GFXLIB)/src/gtimer/gtimer.c
diff --git a/src/gwin/button.c b/src/gwin/button.c
new file mode 100644
index 00000000..8a904d95
--- /dev/null
+++ b/src/gwin/button.c
@@ -0,0 +1,275 @@
+/*
+ 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 src/gwin/button.c
+ * @brief GWIN sub-system button code.
+ *
+ * @defgroup Button Button
+ * @ingroup GWIN
+ *
+ * @{
+ */
+
+#include "ch.h"
+#include "hal.h"
+#include "gfx.h"
+
+#if (GFX_USE_GWIN && GWIN_NEED_BUTTON) || defined(__DOXYGEN__)
+
+#include <string.h>
+
+#include "gwin/internal.h"
+
+static const GButtonStyle GButtonDefaultStyle = {
+ GBTN_3D,
+ HTML2COLOR(0x404040), // color_up_edge;
+ HTML2COLOR(0xE0E0E0), // color_up_fill;
+ HTML2COLOR(0x000000), // color_up_txt;
+ HTML2COLOR(0x404040), // color_dn_edge;
+ HTML2COLOR(0x808080), // color_dn_fill;
+ HTML2COLOR(0x404040), // color_dn_txt;
+ };
+
+// Process an event callback
+static void gwinButtonCallback(void *param, GEvent *pe) {
+ GSourceListener *psl;
+ #define gh ((GHandle)param)
+ #define gbw ((GButtonObject *)param)
+ #define gsh ((GSourceHandle)param)
+ #define pme ((GEventMouse *)pe)
+ #define pte ((GEventTouch *)pe)
+ #define pxe ((GEventToggle *)pe)
+ #define pbe ((GEventGWinButton *)pe)
+
+ switch (pe->type) {
+ #if defined(GINPUT_NEED_MOUSE) && GINPUT_NEED_MOUSE
+ case GEVENT_MOUSE:
+ case GEVENT_TOUCH:
+ // Ignore anything other than the primary mouse button going up or down
+ if (!((pme->current_buttons ^ pme->last_buttons) & GINPUT_MOUSE_BTN_LEFT))
+ return;
+
+ if (gbw->state == GBTN_UP) {
+ // Our button is UP: Test for button down over the button
+ if ((pme->current_buttons & GINPUT_MOUSE_BTN_LEFT)
+ && pme->x >= gbw->gwin.x && pme->x < gbw->gwin.x + gbw->gwin.width
+ && pme->y >= gbw->gwin.y && pme->y < gbw->gwin.y + gbw->gwin.height) {
+ gbw->state = GBTN_DOWN;
+ gwinButtonDraw((GHandle)param);
+ }
+ return;
+ }
+
+ // Our button is DOWN
+
+ // Skip more mouse downs
+ if ((pme->current_buttons & GINPUT_MOUSE_BTN_LEFT))
+ return;
+
+ // This must be a mouse up - set the button as UP
+ gbw->state = GBTN_UP;
+ gwinButtonDraw((GHandle)param);
+
+ // If the mouse up was over the button then create the event
+ if (pme->x >= gbw->gwin.x && pme->x < gbw->gwin.x + gbw->gwin.width
+ && pme->y >= gbw->gwin.y && pme->y < gbw->gwin.y + gbw->gwin.height)
+ break;
+
+ return;
+ #endif
+
+ #if defined(GINPUT_NEED_TOGGLE) && GINPUT_NEED_TOGGLE
+ case GEVENT_TOGGLE:
+ // State has changed - update the button
+ gbw->state = pxe->on ? GBTN_DOWN : GBTN_UP;
+ gwinButtonDraw((GHandle)param);
+
+ // Trigger the event on button down (different than for mouse/touch)
+ if (gbw->state == GBTN_DOWN)
+ break;
+
+ return;
+ #endif
+
+ default:
+ return;
+ }
+
+ // Trigger a GWIN Button Event
+ psl = 0;
+ while ((psl = geventGetSourceListener(gsh, psl))) {
+ if (!(pe = geventGetEventBuffer(psl)))
+ continue;
+ pbe->type = GEVENT_GWIN_BUTTON;
+ pbe->button = gh;
+ geventSendEvent(psl);
+ }
+
+ #undef pbe
+ #undef pme
+ #undef pte
+ #undef pxe
+ #undef gsh
+ #undef gbw
+ #undef gh
+}
+
+GHandle gwinCreateButton(GButtonObject *gb, coord_t x, coord_t y, coord_t width, coord_t height, font_t font, GButtonType type) {
+ if (!(gb = (GButtonObject *)_gwinInit((GWindowObject *)gb, x, y, width, height, sizeof(GButtonObject))))
+ return 0;
+ gb->gwin.type = GW_BUTTON;
+ gwinSetFont(&gb->gwin, font);
+ gwinSetButtonStyle(&gb->gwin, &GButtonDefaultStyle);
+ gb->type = type;
+ gb->state = GBTN_UP;
+ gb->txt = "";
+ geventListenerInit(&gb->listener);
+ geventRegisterCallback(&gb->listener, gwinButtonCallback, gb);
+ return (GHandle)gb;
+}
+
+void gwinSetButtonStyle(GHandle gh, const GButtonStyle *style) {
+ #define gbw ((GButtonObject *)gh)
+ if (gh->type != GW_BUTTON)
+ return;
+
+ gbw->style.shape = style->shape;
+ gbw->style.color_up_edge = style->color_up_edge;
+ gbw->style.color_up_fill = style->color_up_fill;
+ gbw->style.color_dn_edge = style->color_dn_edge;
+ gbw->style.color_dn_fill = style->color_dn_fill;
+ gbw->style.color_up_txt = style->color_up_txt;
+ gbw->style.color_dn_txt = style->color_dn_txt;
+ #undef gbw
+}
+
+void gwinSetButtonText(GHandle gh, const char *txt, bool_t useAlloc) {
+ #define gbw ((GButtonObject *)gh)
+ if (gh->type != GW_BUTTON)
+ return;
+
+ // Dispose of the old string
+ if ((gh->flags & GBTN_FLG_ALLOCTXT)) {
+ gh->flags &= ~GBTN_FLG_ALLOCTXT;
+ if (gbw->txt) {
+ chHeapFree((void *)gbw->txt);
+ gbw->txt = "";
+ }
+ }
+ // Alloc the new text if required
+ if (txt && useAlloc) {
+ char *str;
+
+ if ((str = (char *)chHeapAlloc(NULL, strlen(txt)+1))) {
+ gh->flags |= GBTN_FLG_ALLOCTXT;
+ strcpy(str, txt);
+ }
+ txt = (const char *)str;
+ }
+
+ gbw->txt = txt ? txt : "";
+ #undef gbw
+}
+
+void gwinButtonDraw(GHandle gh) {
+ color_t cedge;
+ color_t cfill;
+ color_t ctxt;
+ const char * txt;
+ #define gbw ((GButtonObject *)gh)
+ #define RND_CNR_SIZE 5
+
+ if (gh->type != GW_BUTTON)
+ return;
+
+ #if GDISP_NEED_CLIP
+ gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+ #endif
+
+ // Get the text (safely)
+ txt = gh->font && gbw->txt ? gbw->txt : "";
+
+ // Determine the colors to use
+ switch(gbw->state) {
+ case GBTN_DOWN:
+ cedge = gbw->style.color_dn_edge;
+ cfill = gbw->style.color_dn_fill;
+ ctxt = gbw->style.color_dn_txt;
+ break;
+ case GBTN_UP: default:
+ cedge = gbw->style.color_up_edge;
+ cfill = gbw->style.color_up_fill;
+ ctxt = gbw->style.color_up_txt;
+ break;
+ }
+
+ // Draw according to the shape specified.
+ switch(gbw->style.shape) {
+#if GDISP_NEED_ARC
+ case GBTN_ROUNDED:
+ if (gh->width >= 2*RND_CNR_SIZE+10) {
+ gdispFillRoundedBox(gh->x+1, gh->y+1, gh->width-2, gh->height-2, RND_CNR_SIZE-1, cfill);
+ gdispDrawStringBox(gh->x+1, gh->y+RND_CNR_SIZE, gh->width-2, gh->height-(2*RND_CNR_SIZE), txt, gh->font, ctxt, justifyCenter);
+ gdispDrawRoundedBox(gh->x, gh->y, gh->width, gh->height, RND_CNR_SIZE, cedge);
+ break;
+ }
+ /* Fall Through */
+#endif
+ case GBTN_SQUARE:
+ gdispFillStringBox(gh->x+1, gh->y+1, gh->width-2, gh->height-2, txt, gh->font, ctxt, cfill, justifyCenter);
+ gdispDrawBox(gh->x, gh->y, gh->width, gh->height, cedge);
+ break;
+#if GDISP_NEED_ELLIPSE
+ case GBTN_ELLIPSE:
+ gdispFillEllipse(gh->x+1, gh->y+1, gh->width/2-1, gh->height/2-1, cfill);
+ gdispDrawStringBox(gh->x+1, gh->y+1, gh->width-2, gh->height-2, txt, gh->font, ctxt, justifyCenter);
+ gdispDrawEllipse(gh->x, gh->y, gh->width/2, gh->height/2, cedge);
+ break;
+#endif
+ case GBTN_3D: default:
+ gdispFillStringBox(gh->x, gh->y, gh->width-1, gh->height-1, txt, gh->font, ctxt, cfill, justifyCenter);
+ gdispDrawLine(gh->x+gh->width-1, gh->y, gh->x+gh->width-1, gh->y+gh->height-1, cedge);
+ gdispDrawLine(gh->x, gh->y+gh->height-1, gh->x+gh->width-2, gh->y+gh->height-1, cedge);
+ break;
+ }
+ #undef gbw
+}
+
+#if defined(GINPUT_NEED_MOUSE) && GINPUT_NEED_MOUSE
+ bool_t gwinAttachButtonMouseSource(GHandle gh, GSourceHandle gsh) {
+ if (gh->type != GW_BUTTON)
+ return FALSE;
+
+ return geventAttachSource(&((GButtonObject *)gh)->listener, gsh, GLISTEN_MOUSEMETA);
+ }
+#endif
+
+#if defined(GINPUT_NEED_TOGGLE) && GINPUT_NEED_TOGGLE
+ bool_t gwinAttachButtonToggleSource(GHandle gh, GSourceHandle gsh) {
+ if (gh->type != GW_BUTTON)
+ return FALSE;
+
+ return geventAttachSource(&((GButtonObject *)gh)->listener, gsh, GLISTEN_TOGGLE_OFF|GLISTEN_TOGGLE_ON);
+ }
+#endif
+
+#endif /* GFX_USE_GWIN && GWIN_NEED_BUTTON */
+/** @} */
+
diff --git a/src/gwin/console.c b/src/gwin/console.c
new file mode 100644
index 00000000..9be7ee34
--- /dev/null
+++ b/src/gwin/console.c
@@ -0,0 +1,158 @@
+/*
+ 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 src/gwin/console.c
+ * @brief GWIN sub-system console code.
+ *
+ * @defgroup Console Console
+ * @ingroup GWIN
+ *
+ * @{
+ */
+
+#include "ch.h"
+#include "hal.h"
+#include "gfx.h"
+
+#if (GFX_USE_GWIN && GWIN_NEED_CONSOLE) || defined(__DOXYGEN__)
+
+#include <string.h>
+
+#include "gwin/internal.h"
+
+#define GWIN_CONSOLE_USE_CLEAR_LINES TRUE
+#define GWIN_CONSOLE_USE_FILLED_CHARS FALSE
+
+/*
+ * Stream interface implementation. The interface is write only
+ */
+
+#define Stream2GWindow(ip) ((GHandle)(((char *)(ip)) - (size_t)(&(((GConsoleObject *)0)->stream))))
+
+static size_t GWinStreamWrite(void *ip, const uint8_t *bp, size_t n) { gwinPutCharArray(Stream2GWindow(ip), (const char *)bp, n); return RDY_OK; }
+static size_t GWinStreamRead(void *ip, uint8_t *bp, size_t n) { (void)ip; (void)bp; (void)n; return 0; }
+static msg_t GWinStreamPut(void *ip, uint8_t b) { gwinPutChar(Stream2GWindow(ip), (char)b); return RDY_OK; }
+static msg_t GWinStreamGet(void *ip) {(void)ip; return RDY_OK; }
+static msg_t GWinStreamPutTimed(void *ip, uint8_t b, systime_t time) { (void)time; gwinPutChar(Stream2GWindow(ip), (char)b); return RDY_OK; }
+static msg_t GWinStreamGetTimed(void *ip, systime_t timeout) { (void)ip; (void)timeout; return RDY_OK; }
+static size_t GWinStreamWriteTimed(void *ip, const uint8_t *bp, size_t n, systime_t time) { (void)time; gwinPutCharArray(Stream2GWindow(ip), (const char *)bp, n); return RDY_OK; }
+static size_t GWinStreamReadTimed(void *ip, uint8_t *bp, size_t n, systime_t time) { (void)ip; (void)bp; (void)n; (void)time; return 0; }
+
+struct GConsoleWindowVMT_t {
+ _base_asynchronous_channel_methods
+};
+
+static const struct GConsoleWindowVMT_t GWindowConsoleVMT = {
+ GWinStreamWrite,
+ GWinStreamRead,
+ GWinStreamPut,
+ GWinStreamGet,
+ GWinStreamPutTimed,
+ GWinStreamGetTimed,
+ GWinStreamWriteTimed,
+ GWinStreamReadTimed
+};
+
+GHandle gwinCreateConsole(GConsoleObject *gc, coord_t x, coord_t y, coord_t width, coord_t height, font_t font) {
+ if (!(gc = (GConsoleObject *)_gwinInit((GWindowObject *)gc, x, y, width, height, sizeof(GConsoleObject))))
+ return 0;
+ gc->gwin.type = GW_CONSOLE;
+ gwinSetFont(&gc->gwin, font);
+ gc->stream.vmt = &GWindowConsoleVMT;
+ gc->cx = 0;
+ gc->cy = 0;
+ return (GHandle)gc;
+}
+
+BaseSequentialStream *gwinGetConsoleStream(GHandle gh) {
+ if (gh->type != GW_CONSOLE)
+ return 0;
+ return (BaseSequentialStream *)&(((GConsoleObject *)(gh))->stream);
+}
+
+void gwinPutChar(GHandle gh, char c) {
+ uint8_t width;
+ #define gcw ((GConsoleObject *)gh)
+
+ if (gh->type != GW_CONSOLE || !gh->font) return;
+
+ #if GDISP_NEED_CLIP
+ gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+ #endif
+
+ if (c == '\n') {
+ gcw->cx = 0;
+ gcw->cy += gcw->fy;
+ // We use lazy scrolling here and only scroll when the next char arrives
+ } else if (c == '\r') {
+ // gcw->cx = 0;
+ } else {
+ width = gdispGetCharWidth(c, gh->font) + gcw->fp;
+ if (gcw->cx + width >= gh->width) {
+ gcw->cx = 0;
+ gcw->cy += gcw->fy;
+ }
+
+ if (gcw->cy + gcw->fy > gh->height) {
+#if GDISP_NEED_SCROLL
+ /* scroll the console */
+ gdispVerticalScroll(gh->x, gh->y, gh->width, gh->height, gcw->fy, gh->bgcolor);
+ /* reset the cursor to the start of the last line */
+ gcw->cx = 0;
+ gcw->cy = (((coord_t)(gh->height/gcw->fy))-1)*gcw->fy;
+#else
+ /* clear the console */
+ gdispFillArea(gh->x, gh->y, gh->width, gh->height, gh->bgcolor);
+ /* reset the cursor to the top of the window */
+ gcw->cx = 0;
+ gcw->cy = 0;
+#endif
+ }
+
+#if GWIN_CONSOLE_USE_CLEAR_LINES
+ /* clear to the end of the line */
+ if (gcw->cx == 0)
+ gdispFillArea(gh->x, gh->y + gcw->cy, gh->width, gcw->fy, gh->bgcolor);
+#endif
+#if GWIN_CONSOLE_USE_FILLED_CHARS
+ gdispFillChar(gh->x + gcw->cx, gh->y + gcw->cy, c, gh->font, gh->color, gh->bgcolor);
+#else
+ gdispDrawChar(gh->x + gcw->cx, gh->y + gcw->cy, c, gh->font, gh->color);
+#endif
+
+ /* update cursor */
+ gcw->cx += width;
+ }
+ #undef gcw
+}
+
+void gwinPutString(GHandle gh, const char *str) {
+ while(*str)
+ gwinPutChar(gh, *str++);
+}
+
+void gwinPutCharArray(GHandle gh, const char *str, size_t n) {
+ while(n--)
+ gwinPutChar(gh, *str++);
+}
+
+#endif /* GFX_USE_GWIN && GWIN_NEED_CONSOLE */
+/** @} */
+
diff --git a/src/gwin/graph.c b/src/gwin/graph.c
new file mode 100644
index 00000000..a9d20c4b
--- /dev/null
+++ b/src/gwin/graph.c
@@ -0,0 +1,362 @@
+/*
+ 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 src/gwin/graph.c
+ * @brief GWIN sub-system button code.
+ *
+ * @defgroup Graph Graph
+ * @ingroup GWIN
+ *
+ * @{
+ */
+
+#include "ch.h"
+#include "hal.h"
+#include "gfx.h"
+
+#if (GFX_USE_GWIN && GWIN_NEED_GRAPH) || defined(__DOXYGEN__)
+
+#include "gwin/internal.h"
+
+#define GGRAPH_FLG_CONNECTPOINTS (GWIN_FIRST_CONTROL_FLAG<<0)
+#define GGRAPH_ARROW_SIZE 5
+
+static const GGraphStyle GGraphDefaultStyle = {
+ { GGRAPH_POINT_DOT, 0, White }, // point
+ { GGRAPH_LINE_DOT, 2, Gray }, // line
+ { GGRAPH_LINE_SOLID, 0, White }, // x axis
+ { GGRAPH_LINE_SOLID, 0, White }, // y axis
+ { GGRAPH_LINE_NONE, 0, White, 0 }, // x grid
+ { GGRAPH_LINE_NONE, 0, White, 0 }, // y grid
+ GWIN_GRAPH_STYLE_XAXIS_ARROWS|GWIN_GRAPH_STYLE_YAXIS_ARROWS // flags
+};
+
+static void pointto(GGraphObject *gg, coord_t x, coord_t y, const GGraphPointStyle *style) {
+ if (style->type == GGRAPH_POINT_NONE)
+ return;
+
+ // Convert to device space. Note the y-axis is inverted.
+ x += gg->gwin.x + gg->xorigin;
+ y = gg->gwin.y + gg->gwin.height - 1 - gg->yorigin - y;
+
+ if (style->size <= 1) {
+ gdispDrawPixel(x, y, style->color);
+ return;
+ }
+
+ switch(style->type) {
+ case GGRAPH_POINT_SQUARE:
+ gdispDrawBox(x-style->size, y-style->size, 2*style->size, 2*style->size, style->color);
+ break;
+#if GDISP_NEED_CIRCLE
+ case GGRAPH_POINT_CIRCLE:
+ gdispDrawCircle(x, y, style->size, style->color);
+ break;
+#endif
+ case GGRAPH_POINT_DOT:
+ default:
+ gdispDrawPixel(x, y, style->color);
+ break;
+ }
+}
+
+static void lineto(GGraphObject *gg, coord_t x0, coord_t y0, coord_t x1, coord_t y1, const GGraphLineStyle *style) {
+ coord_t dy, dx;
+ coord_t addx, addy;
+ coord_t P, diff, i;
+ coord_t run_on, run_off, run;
+
+ if (style->type == GGRAPH_LINE_NONE)
+ return;
+
+ // Convert to device space. Note the y-axis is inverted.
+ x0 += gg->gwin.x + gg->xorigin;
+ y0 = gg->gwin.y + gg->gwin.height - 1 - gg->yorigin - y0;
+ x1 += gg->gwin.x + gg->xorigin;
+ y1 = gg->gwin.y + gg->gwin.height - 1 - gg->yorigin - y1;
+
+ if (style->size <= 0) {
+ // Use the driver to draw a solid line
+ gdispDrawLine(x0, y0, x1, y1, style->color);
+ return;
+ }
+
+ switch (style->type) {
+ case GGRAPH_LINE_DOT:
+ run_on = 1;
+ run_off = -style->size;
+ break;
+
+ case GGRAPH_LINE_DASH:
+ run_on = style->size;
+ run_off = -style->size;
+ break;
+
+ case GGRAPH_LINE_SOLID:
+ default:
+ // Use the driver to draw a solid line
+ gdispDrawLine(x0, y0, x1, y1, style->color);
+ return;
+ }
+
+ // Use Bresenham's algorithm modified to draw a stylized line
+ run = 0;
+ 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) {
+ if (run++ >= 0) {
+ if (run >= run_on)
+ run = run_off;
+ gdispDrawPixel(x0, y0, style->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) {
+ if (run++ >= 0) {
+ if (run >= run_on)
+ run = run_off;
+ gdispDrawPixel(x0, y0, style->color);
+ }
+ if (P < 0) {
+ P += dx;
+ y0 += addy;
+ } else {
+ P += diff;
+ x0 += addx;
+ y0 += addy;
+ }
+ }
+ }
+}
+
+GHandle gwinCreateGraph(GGraphObject *gg, coord_t x, coord_t y, coord_t width, coord_t height) {
+ if (!(gg = (GGraphObject *)_gwinInit((GWindowObject *)gg, x, y, width, height, sizeof(GGraphObject))))
+ return 0;
+ gg->gwin.type = GW_GRAPH;
+ gg->xorigin = gg->yorigin = 0;
+ gg->lastx = gg->lasty = 0;
+ gwinGraphSetStyle(&gg->gwin, &GGraphDefaultStyle);
+ return (GHandle)gg;
+}
+
+void gwinGraphSetStyle(GHandle gh, const GGraphStyle *pstyle) {
+ #define gg ((GGraphObject *)gh)
+
+ if (gh->type != GW_GRAPH)
+ return;
+
+ gg->style.point.type = pstyle->point.type;
+ gg->style.point.size = pstyle->point.size;
+ gg->style.point.color = pstyle->point.color;
+ gg->style.line.type = pstyle->line.type;
+ gg->style.line.size = pstyle->line.size;
+ gg->style.line.color = pstyle->line.color;
+ gg->style.xaxis.type = pstyle->xaxis.type;
+ gg->style.xaxis.size = pstyle->xaxis.size;
+ gg->style.xaxis.color = pstyle->xaxis.color;
+ gg->style.yaxis.type = pstyle->yaxis.type;
+ gg->style.yaxis.size = pstyle->yaxis.size;
+ gg->style.yaxis.color = pstyle->yaxis.color;
+ gg->style.xgrid.type = pstyle->xgrid.type;
+ gg->style.xgrid.size = pstyle->xgrid.size;
+ gg->style.xgrid.color = pstyle->xgrid.color;
+ gg->style.xgrid.spacing = pstyle->xgrid.spacing;
+ gg->style.ygrid.type = pstyle->ygrid.type;
+ gg->style.ygrid.size = pstyle->ygrid.size;
+ gg->style.ygrid.color = pstyle->ygrid.color;
+ gg->style.ygrid.spacing = pstyle->ygrid.spacing;
+ gg->style.flags = pstyle->flags;
+
+ #undef gg
+}
+
+void gwinGraphSetOrigin(GHandle gh, coord_t x, coord_t y) {
+ #define gg ((GGraphObject *)gh)
+
+ if (gh->type != GW_GRAPH)
+ return;
+
+ gg->xorigin = x;
+ gg->yorigin = y;
+
+ #undef gg
+}
+
+void gwinGraphDrawAxis(GHandle gh) {
+ #define gg ((GGraphObject *)gh)
+ coord_t i, xmin, ymin, xmax, ymax;
+
+ if (gh->type != GW_GRAPH)
+ return;
+
+ xmin = -gg->xorigin;
+ xmax = gh->width-gg->xorigin-1;
+ ymin = -gg->yorigin;
+ ymax = gh->height-gg->yorigin-1;
+
+ // x grid - this code assumes that the GGraphGridStyle is a superset of GGraphListStyle
+ if (gg->style.xgrid.type != GGRAPH_LINE_NONE && gg->style.xgrid.spacing >= 2) {
+ for(i = gg->style.xgrid.spacing; i <= xmax; i += gg->style.xgrid.spacing)
+ lineto(gg, i, ymin, i, ymax, (GGraphLineStyle *)&gg->style.xgrid);
+ for(i = -gg->style.xgrid.spacing; i >= xmin; i -= gg->style.xgrid.spacing)
+ lineto(gg, i, ymin, i, ymax, (GGraphLineStyle *)&gg->style.xgrid);
+ }
+
+ // y grid - this code assumes that the GGraphGridStyle is a superset of GGraphListStyle
+ if (gg->style.ygrid.type != GGRAPH_LINE_NONE && gg->style.ygrid.spacing >= 2) {
+ for(i = gg->style.ygrid.spacing; i <= ymax; i += gg->style.ygrid.spacing)
+ lineto(gg, xmin, i, xmax, i, (GGraphLineStyle *)&gg->style.ygrid);
+ for(i = -gg->style.ygrid.spacing; i >= ymin; i -= gg->style.ygrid.spacing)
+ lineto(gg, xmin, i, xmax, i, (GGraphLineStyle *)&gg->style.ygrid);
+ }
+
+ // x axis
+ lineto(gg, xmin, 0, xmax, 0, &gg->style.xaxis);
+ if ((gg->style.flags & GWIN_GRAPH_STYLE_XAXIS_NEGATIVE_ARROWS)) {
+ if (xmin > 0 || xmin < -(GGRAPH_ARROW_SIZE+1)) {
+ lineto(gg, xmin, 0, xmin+GGRAPH_ARROW_SIZE, GGRAPH_ARROW_SIZE, &gg->style.xaxis);
+ lineto(gg, xmin, 0, xmin+GGRAPH_ARROW_SIZE, -GGRAPH_ARROW_SIZE, &gg->style.xaxis);
+ }
+ }
+ if ((gg->style.flags & GWIN_GRAPH_STYLE_XAXIS_POSITIVE_ARROWS)) {
+ if (xmax < 0 || xmax > (GGRAPH_ARROW_SIZE+1)) {
+ lineto(gg, xmax, 0, xmax-GGRAPH_ARROW_SIZE, GGRAPH_ARROW_SIZE, &gg->style.xaxis);
+ lineto(gg, xmax, 0, xmax-GGRAPH_ARROW_SIZE, -GGRAPH_ARROW_SIZE, &gg->style.xaxis);
+ }
+ }
+
+ // y axis
+ lineto(gg, 0, ymin, 0, ymax, &gg->style.yaxis);
+ if ((gg->style.flags & GWIN_GRAPH_STYLE_YAXIS_NEGATIVE_ARROWS)) {
+ if (ymin > 0 || ymin < -(GGRAPH_ARROW_SIZE+1)) {
+ lineto(gg, 0, ymin, GGRAPH_ARROW_SIZE, ymin+GGRAPH_ARROW_SIZE, &gg->style.yaxis);
+ lineto(gg, 0, ymin, -GGRAPH_ARROW_SIZE, ymin+GGRAPH_ARROW_SIZE, &gg->style.yaxis);
+ }
+ }
+ if ((gg->style.flags & GWIN_GRAPH_STYLE_YAXIS_POSITIVE_ARROWS)) {
+ if (ymax < 0 || ymax > (GGRAPH_ARROW_SIZE+1)) {
+ lineto(gg, 0, ymax, GGRAPH_ARROW_SIZE, ymax-GGRAPH_ARROW_SIZE, &gg->style.yaxis);
+ lineto(gg, 0, ymax, -GGRAPH_ARROW_SIZE, ymax-GGRAPH_ARROW_SIZE, &gg->style.yaxis);
+ }
+ }
+
+ #undef gg
+}
+
+void gwinGraphStartSet(GHandle gh) {
+ if (gh->type != GW_GRAPH)
+ return;
+
+ gh->flags &= ~GGRAPH_FLG_CONNECTPOINTS;
+}
+
+void gwinGraphDrawPoint(GHandle gh, coord_t x, coord_t y) {
+ #define gg ((GGraphObject *)gh)
+
+ if (gh->type != GW_GRAPH)
+ return;
+
+ if ((gh->flags & GGRAPH_FLG_CONNECTPOINTS)) {
+ // Draw the line
+ lineto(gg, gg->lastx, gg->lasty, x, y, &gg->style.line);
+
+ // Redraw the previous point because the line may have overwritten it
+ pointto(gg, gg->lastx, gg->lasty, &gg->style.point);
+
+ } else
+ gh->flags |= GGRAPH_FLG_CONNECTPOINTS;
+
+ // Save this point for next time.
+ gg->lastx = x;
+ gg->lasty = y;
+
+ // Draw this point.
+ pointto(gg, x, y, &gg->style.point);
+
+ #undef gg
+}
+
+void gwinGraphDrawPoints(GHandle gh, const GGraphPoint *points, unsigned count) {
+ #define gg ((GGraphObject *)gh)
+ unsigned i;
+ const GGraphPoint *p;
+
+ if (gh->type != GW_GRAPH)
+ return;
+
+ // Draw the connecting lines
+ for(p = points, i = 0; i < count; p++, i++) {
+ if ((gh->flags & GGRAPH_FLG_CONNECTPOINTS)) {
+ // Draw the line
+ lineto(gg, gg->lastx, gg->lasty, p->x, p->y, &gg->style.line);
+
+ // Redraw the previous point because the line may have overwritten it
+ if (i == 0)
+ pointto(gg, gg->lastx, gg->lasty, &gg->style.point);
+
+ } else
+ gh->flags |= GGRAPH_FLG_CONNECTPOINTS;
+
+ // Save this point for next time.
+ gg->lastx = p->x;
+ gg->lasty = p->y;
+ }
+
+
+ // Draw the points.
+ for(p = points, i = 0; i < count; p++, i++)
+ pointto(gg, p->x, p->y, &gg->style.point);
+
+ #undef gg
+}
+
+#endif /* GFX_USE_GWIN && GWIN_NEED_GRAPH */
+/** @} */
+
diff --git a/src/gwin/gwin.c b/src/gwin/gwin.c
new file mode 100644
index 00000000..4eef79ad
--- /dev/null
+++ b/src/gwin/gwin.c
@@ -0,0 +1,544 @@
+/*
+ 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 src/gwin/gwin.c
+ * @brief GWIN sub-system code.
+ *
+ * @defgroup Window Window
+ * @ingroup GWIN
+ *
+ * @{
+ */
+
+#include "ch.h"
+#include "hal.h"
+#include "gfx.h"
+
+#if GFX_USE_GWIN || defined(__DOXYGEN__)
+
+#include "gwin/internal.h"
+
+// Internal routine for use by GWIN components only
+// Initialise a window creating it dynamicly if required.
+GHandle _gwinInit(GWindowObject *gw, coord_t x, coord_t y, coord_t width, coord_t height, size_t size) {
+ coord_t w, h;
+
+ // Check the window size against the screen size
+ w = gdispGetWidth();
+ h = gdispGetHeight();
+ if (x < 0) { width += x; x = 0; }
+ if (y < 0) { height += y; y = 0; }
+ if (x >= w || y >= h) return 0;
+ if (x+width > w) width = w - x;
+ if (y+height > h) height = h - y;
+
+ // Allocate the structure if necessary
+ if (!gw) {
+ if (!(gw = (GWindowObject *)chHeapAlloc(NULL, size)))
+ return 0;
+ gw->flags = GWIN_FLG_DYNAMIC;
+ } else
+ gw->flags = 0;
+
+ // Initialise all basic fields (except the type)
+ gw->x = x;
+ gw->y = y;
+ gw->width = width;
+ gw->height = height;
+ gw->color = White;
+ gw->bgcolor = Black;
+#if GDISP_NEED_TEXT
+ gw->font = 0;
+#endif
+ return (GHandle)gw;
+}
+
+/**
+ * @brief Create a basic window.
+ * @return NULL if there is no resultant drawing area, otherwise a window handle.
+ *
+ * @param[in] gw The window structure to initialise. If this is NULL the structure is dynamically allocated.
+ * @param[in] x,y The screen co-ordinates for the bottom left corner of the window
+ * @param[in] width The width of the window
+ * @param[in] height The height of the window
+ * @note The default drawing color gets set to White and the background drawing color to Black.
+ * @note No default font is set so make sure to set one before drawing any text.
+ * @note The dimensions and position may be changed to fit on the real screen.
+ * @note The window is not automatically cleared on creation. You must do that by calling gwinClear() (possibly after changing your background color)
+ *
+ * @api
+ */
+GHandle gwinCreateWindow(GWindowObject *gw, coord_t x, coord_t y, coord_t width, coord_t height) {
+ if (!(gw = (GWindowObject *)_gwinInit((GWindowObject *)gw, x, y, width, height, sizeof(GWindowObject))))
+ return 0;
+ gw->type = GW_WINDOW;
+ return (GHandle)gw;
+}
+
+/**
+ * @brief Destroy a window (of any type). Releases any dynamicly allocated memory.
+ *
+ * @param[in] gh The window handle
+ *
+ * @api
+ */
+void gwinDestroyWindow(GHandle gh) {
+ // Clean up any type specific dynamic memory allocations
+ switch(gh->type) {
+#if GWIN_NEED_BUTTON
+ case GW_BUTTON:
+ if ((gh->flags & GBTN_FLG_ALLOCTXT)) {
+ gh->flags &= ~GBTN_FLG_ALLOCTXT; // To be sure, to be sure
+ chHeapFree((void *)((GButtonObject *)gh)->txt);
+ }
+ break;
+#endif
+ default:
+ break;
+ }
+
+ // Clean up the structure
+ if (gh->flags & GWIN_FLG_DYNAMIC) {
+ gh->flags = 0; // To be sure, to be sure
+ chHeapFree((void *)gh);
+ }
+}
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+/**
+ * @brief Set the current font for this window.
+ *
+ * @param[in] gh The window handle
+ * @param[in] font The font to use for text functions
+ *
+ * @api
+ */
+void gwinSetFont(GHandle gh, font_t font) {
+ gh->font = font;
+#if GWIN_NEED_CONSOLE
+ if (font && gh->type == GW_CONSOLE) {
+ ((GConsoleObject *)gh)->fy = gdispGetFontMetric(font, fontHeight);
+ ((GConsoleObject *)gh)->fp = gdispGetFontMetric(font, fontCharPadding);
+ }
+#endif
+}
+#endif
+
+/**
+ * @brief Clear the window
+ * @note Uses the current background color to clear the window
+ *
+ * @param[in] gh The window handle
+ *
+ * @api
+ */
+void gwinClear(GHandle gh) {
+ #if GDISP_NEED_CLIP
+ gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+ #endif
+ gdispFillArea(gh->x, gh->y, gh->width, gh->height, gh->bgcolor);
+
+ #if GWIN_NEED_CONSOLE
+ if (gh->type == GW_CONSOLE) {
+ ((GConsoleObject *)gh)->cx = 0;
+ ((GConsoleObject *)gh)->cy = 0;
+ }
+ #endif
+}
+
+/**
+ * @brief Set a pixel in the window
+ * @note Uses the current foreground color to set the pixel
+ * @note May leave GDISP clipping to this window's dimensions
+ *
+ * @param[in] gh The window handle
+ * @param[in] x,y The coordinates of the pixel
+ *
+ * @api
+ */
+void gwinDrawPixel(GHandle gh, coord_t x, coord_t y) {
+ #if GDISP_NEED_CLIP
+ gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+ #endif
+ gdispDrawPixel(gh->x+x, gh->y+y, gh->color);
+}
+
+/**
+ * @brief Draw a line in the window
+ * @note Uses the current foreground color to draw the line
+ * @note May leave GDISP clipping to this window's dimensions
+ *
+ * @param[in] gh The window handle
+ * @param[in] x0,y0 The start position
+ * @param[in] x1,y1 The end position
+ *
+ * @api
+ */
+void gwinDrawLine(GHandle gh, coord_t x0, coord_t y0, coord_t x1, coord_t y1) {
+ #if GDISP_NEED_CLIP
+ gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+ #endif
+ gdispDrawLine(gh->x+x0, gh->y+y0, gh->x+x1, gh->y+y1, gh->color);
+}
+
+/**
+ * @brief Draw a box in the window
+ * @note Uses the current foreground color to draw the box
+ * @note May leave GDISP clipping to this window's dimensions
+ *
+ * @param[in] gh The window handle
+ * @param[in] x,y The start position
+ * @param[in] cx,cy The size of the box (outside dimensions)
+ *
+ * @api
+ */
+void gwinDrawBox(GHandle gh, coord_t x, coord_t y, coord_t cx, coord_t cy) {
+ #if GDISP_NEED_CLIP
+ gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+ #endif
+ gdispDrawBox(gh->x+x, gh->y+y, cx, cy, gh->color);
+}
+
+/**
+ * @brief Fill an rectangular area in the window
+ * @note Uses the current foreground color to fill the box
+ * @note May leave GDISP clipping to this window's dimensions
+ *
+ * @param[in] gh The window handle
+ * @param[in] x,y The start position
+ * @param[in] cx,cy The size of the box (outside dimensions)
+ *
+ * @api
+ */
+void gwinFillArea(GHandle gh, coord_t x, coord_t y, coord_t cx, coord_t cy) {
+ #if GDISP_NEED_CLIP
+ gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+ #endif
+ gdispFillArea(gh->x+x, gh->y+y, cx, cy, gh->color);
+}
+
+/**
+ * @brief Fill an area in the window using the supplied bitmap.
+ * @details The bitmap is in the pixel format specified by the low level driver
+ * @note If GDISP_NEED_ASYNC is defined then the buffer must be static
+ * or at least retained until this call has finished the blit. You can
+ * tell when all graphics drawing is finished by @p gdispIsBusy() going FALSE.
+ * @note May leave GDISP clipping to this window's dimensions
+ *
+ * @param[in] gh The window handle
+ * @param[in] x, y The start filled area
+ * @param[in] cx, cy The width and height to be filled
+ * @param[in] srcx, srcy The bitmap position to start the fill from
+ * @param[in] srccx The width of a line in the bitmap.
+ * @param[in] buffer The pixels to use to fill the area.
+ *
+ * @api
+ */
+void gwinBlitArea(GHandle gh, 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) {
+ #if GDISP_NEED_CLIP
+ gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+ #endif
+ gdispBlitAreaEx(gh->x+x, gh->y+y, cx, cy, srcx, srcy, srccx, buffer);
+}
+
+#if GDISP_NEED_CIRCLE || defined(__DOXYGEN__)
+/**
+ * @brief Draw a circle in the window.
+ * @note Uses the current foreground color to draw the circle
+ * @note May leave GDISP clipping to this window's dimensions
+ *
+ * @param[in] gh The window handle
+ * @param[in] x, y The center of the circle
+ * @param[in] radius The radius of the circle
+ *
+ * @api
+ */
+void gwinDrawCircle(GHandle gh, coord_t x, coord_t y, coord_t radius) {
+ #if GDISP_NEED_CLIP
+ gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+ #endif
+ gdispDrawCircle(gh->x+x, gh->y+y, radius, gh->color);
+}
+#endif
+
+#if GDISP_NEED_CIRCLE || defined(__DOXYGEN__)
+/**
+ * @brief Draw a filled circle in the window.
+ * @note Uses the current foreground color to draw the filled circle
+ * @note May leave GDISP clipping to this window's dimensions
+ *
+ * @param[in] gh The window handle
+ * @param[in] x, y The center of the circle
+ * @param[in] radius The radius of the circle
+ *
+ * @api
+ */
+void gwinFillCircle(GHandle gh, coord_t x, coord_t y, coord_t radius) {
+ #if GDISP_NEED_CLIP
+ gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+ #endif
+ gdispFillCircle(gh->x+x, gh->y+y, radius, gh->color);
+}
+#endif
+
+#if GDISP_NEED_ELLIPSE || defined(__DOXYGEN__)
+/**
+ * @brief Draw an ellipse.
+ * @note Uses the current foreground color to draw the ellipse
+ * @note May leave GDISP clipping to this window's dimensions
+ *
+ * @param[in] gh The window handle
+ * @param[in] x,y The center of the ellipse
+ * @param[in] a,b The dimensions of the ellipse
+ *
+ * @api
+ */
+void gwinDrawEllipse(GHandle gh, coord_t x, coord_t y, coord_t a, coord_t b) {
+ #if GDISP_NEED_CLIP
+ gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+ #endif
+ gdispDrawEllipse(gh->x+x, gh->y+y, a, b, gh->color);
+}
+#endif
+
+#if GDISP_NEED_ELLIPSE || defined(__DOXYGEN__)
+/**
+ * @brief Draw an filled ellipse.
+ * @note Uses the current foreground color to draw the filled ellipse
+ * @note May leave GDISP clipping to this window's dimensions
+ *
+ * @param[in] gh The window handle
+ * @param[in] x,y The center of the ellipse
+ * @param[in] a,b The dimensions of the ellipse
+ *
+ * @api
+ */
+void gwinFillEllipse(GHandle gh, coord_t x, coord_t y, coord_t a, coord_t b) {
+ #if GDISP_NEED_CLIP
+ gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+ #endif
+ gdispFillEllipse(gh->x+x, gh->y+y, a, b, gh->color);
+}
+#endif
+
+#if GDISP_NEED_ARC || defined(__DOXYGEN__)
+/*
+ * @brief Draw an arc in the window.
+ * @note Uses the current foreground color to draw the arc
+ * @note May leave GDISP clipping to this window's dimensions
+ *
+ * @param[in] gh The window handle
+ * @param[in] x,y The center point
+ * @param[in] radius The radius of the arc
+ * @param[in] start The start angle (0 to 360)
+ * @param[in] end The end angle (0 to 360)
+ *
+ * @api
+ */
+void gwinDrawArc(GHandle gh, coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle) {
+ #if GDISP_NEED_CLIP
+ gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+ #endif
+ gdispDrawArc(gh->x+x, gh->y+y, radius, startangle, endangle, gh->color);
+}
+#endif
+
+#if GDISP_NEED_ARC || defined(__DOXYGEN__)
+/*
+ * @brief Draw a filled arc in the window.
+ * @note Uses the current foreground color to draw the filled arc
+ * @note May leave GDISP clipping to this window's dimensions
+ *
+ * @param[in] gh The window handle
+ * @param[in] x,y The center point
+ * @param[in] radius The radius of the arc
+ * @param[in] start The start angle (0 to 360)
+ * @param[in] end The end angle (0 to 360)
+ *
+ * @api
+ */
+void gwinFillArc(GHandle gh, coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle) {
+ #if GDISP_NEED_CLIP
+ gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+ #endif
+ gdispFillArc(gh->x+x, gh->y+y, radius, startangle, endangle, gh->color);
+}
+#endif
+
+#if GDISP_NEED_PIXELREAD || defined(__DOXYGEN__)
+/**
+ * @brief Get the color of a pixel in the window.
+ * @return The color of the pixel.
+ * @note May leave GDISP clipping to this window's dimensions
+ *
+ * @param[in] gh The window handle
+ * @param[in] x,y The position in the window
+ *
+ * @api
+ */
+color_t gwinGetPixelColor(GHandle gh, coord_t x, coord_t y) {
+ #if GDISP_NEED_CLIP
+ gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+ #endif
+ return gdispGetPixelColor(gh->x+x, gh->y+y);
+}
+#endif
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+/**
+ * @brief Draw a text character at the specified position in the window.
+ * @pre The font must have been set.
+ * @note Uses the current foreground color to draw the character
+ * @note May leave GDISP clipping to this window's dimensions
+ *
+ * @param[in] gh The window handle
+ * @param[in] x,y The position for the text
+ * @param[in] c The character to draw
+ *
+ * @api
+ */
+void gwinDrawChar(GHandle gh, coord_t x, coord_t y, char c) {
+ if (!gh->font) return;
+ #if GDISP_NEED_CLIP
+ gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+ #endif
+ gdispDrawChar(gh->x+x, gh->y+y, c, gh->font, gh->color);
+}
+#endif
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+/**
+ * @brief Draw a text character with a filled background at the specified position in the window.
+ * @pre The font must have been set.
+ * @note Uses the current foreground color to draw the character and fills the background using the background drawing color
+ * @note May leave GDISP clipping to this window's dimensions
+ *
+ * @param[in] gh The window handle
+ * @param[in] x,y The position for the text
+ * @param[in] c The character to draw
+ *
+ * @api
+ */
+void gwinFillChar(GHandle gh, coord_t x, coord_t y, char c) {
+ if (!gh->font) return;
+ #if GDISP_NEED_CLIP
+ gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+ #endif
+ gdispFillChar(gh->x+x, gh->y+y, c, gh->font, gh->color, gh->bgcolor);
+}
+#endif
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+/**
+ * @brief Draw a text string in the window
+ * @pre The font must have been set.
+ * @note Uses the current foreground color to draw the character
+ * @note May leave GDISP clipping to this window's dimensions
+ *
+ * @param[in] gh The window handle
+ * @param[in] x,y The position for the text
+ * @param[in] str The string to draw
+ *
+ * @api
+ */
+void gwinDrawString(GHandle gh, coord_t x, coord_t y, const char *str) {
+ if (!gh->font) return;
+ #if GDISP_NEED_CLIP
+ gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+ #endif
+ gdispDrawString(gh->x+x, gh->y+y, str, gh->font, gh->color);
+}
+#endif
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+/**
+ * @brief Draw a text string with a filled background in the window
+ * @pre The font must have been set.
+ * @note Uses the current foreground color to draw the character and fills the background using the background drawing color
+ * @note May leave GDISP clipping to this window's dimensions
+ *
+ * @param[in] gh The window handle
+ * @param[in] x,y The position for the text
+ * @param[in] str The string to draw
+ *
+ * @api
+ */
+void gwinFillString(GHandle gh, coord_t x, coord_t y, const char *str) {
+ if (!gh->font) return;
+ #if GDISP_NEED_CLIP
+ gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+ #endif
+ gdispFillString(gh->x+x, gh->y+y, str, gh->font, gh->color, gh->bgcolor);
+}
+#endif
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+/**
+ * @brief Draw a text string verticly centered within the specified box.
+ * @pre The font must have been set.
+ * @note Uses the current foreground color to draw the character.
+ * @note The specified box does not need to align with the window box
+ * @note May leave GDISP clipping to this window's dimensions
+ *
+ * @param[in] gh The window handle
+ * @param[in] x,y The position for the text (need to define top-right or base-line - check code)
+ * @param[in] cx,cy The width and height of the box
+ * @param[in] str The string to draw
+ * @param[in] justify Justify the text left, center or right within the box
+ *
+ * @api
+ */
+void gwinDrawStringBox(GHandle gh, coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, justify_t justify) {
+ if (!gh->font) return;
+ #if GDISP_NEED_CLIP
+ gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+ #endif
+ gdispDrawStringBox(gh->x+x, gh->y+y, cx, cy, str, gh->font, gh->color, justify);
+}
+#endif
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+/**
+ * @brief Draw a text string verticly centered within the specified filled box.
+ * @pre The font must have been set.
+ * @note Uses the current foreground color to draw the character and fills the background using the background drawing color
+ * @note The entire box is filled. Note this box does not need to align with the window box
+ * @note May leave GDISP clipping to this window's dimensions
+ *
+ * @param[in] gh The window handle
+ * @param[in] x,y The position for the text (need to define top-right or base-line - check code)
+ * @param[in] cx,cy The width and height of the box
+ * @param[in] str The string to draw
+ * @param[in] justify Justify the text left, center or right within the box
+ *
+ * @api
+ */
+void gwinFillStringBox(GHandle gh, coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, justify_t justify) {
+ if (!gh->font) return;
+ #if GDISP_NEED_CLIP
+ gdispSetClip(gh->x, gh->y, gh->width, gh->height);
+ #endif
+ gdispFillStringBox(gh->x+x, gh->y+y, cx, cy, str, gh->font, gh->color, gh->bgcolor, justify);
+}
+#endif
+
+#endif /* GFX_USE_GWIN */
+/** @} */
+
diff --git a/src/gwin/gwin.mk b/src/gwin/gwin.mk
new file mode 100644
index 00000000..3c560f43
--- /dev/null
+++ b/src/gwin/gwin.mk
@@ -0,0 +1,5 @@
+GFXSRC += $(GFXLIB)/src/gwin/gwin.c \
+ $(GFXLIB)/src/gwin/console.c \
+ $(GFXLIB)/src/gwin/button.c \
+ $(GFXLIB)/src/gwin/graph.c
+
diff --git a/src/tdisp/tdisp.c b/src/tdisp/tdisp.c
new file mode 100644
index 00000000..3556e031
--- /dev/null
+++ b/src/tdisp/tdisp.c
@@ -0,0 +1,85 @@
+/*
+ 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 src/tdisp/tdisp.c
+ * @brief TDISP Driver code.
+ *
+ * @addtogroup TDISP
+ * @{
+ */
+#include "ch.h"
+#include "hal.h"
+#include "gfx.h"
+
+#if GFX_USE_TDISP || defined(__DOXYGEN__)
+
+static uint8_t _displaycontrol;
+
+bool_t tdispInit(void) {
+ bool_t ret;
+
+ ret = tdisp_lld_init();
+
+ return ret;
+}
+
+void tdispControl(uint16_t what, void *value) {
+ tdisp_lld_control(what, value);
+}
+
+void tdispClear(void) {
+ tdisp_lld_clear();
+}
+
+void tdispHome(void) {
+ tdisp_lld_home();
+}
+
+void tdispCreateChar(uint8_t address, char *charmap) {
+ tdisp_lld_create_char(address, charmap);
+}
+
+void tdispSetCursor(coord_t col, coord_t row) {
+ tdisp_lld_set_cursor(col, row);
+}
+
+void tdispDrawChar(char c) {
+ tdisp_lld_write_data(c);
+}
+
+void tdispDrawString(char *s) {
+ while(*s)
+ tdispDrawChar(*s++);
+}
+
+void tdispDrawCharLocation(coord_t col, coord_t row, char c) {
+ tdispSetCursor(col, row);
+ tdispDrawChar(c);
+}
+
+void tdispDrawStringLocation(coord_t col, coord_t row, char *s) {
+ tdispSetCursor(col, row);
+ tdispDrawString(s);
+}
+
+#endif /* GFX_USE_TDISP */
+/** @} */
+
diff --git a/src/tdisp/tdisp.mk b/src/tdisp/tdisp.mk
new file mode 100644
index 00000000..a33fa34a
--- /dev/null
+++ b/src/tdisp/tdisp.mk
@@ -0,0 +1,2 @@
+GFXSRC += $(GFXLIB)/src/tdisp/tdisp.c
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-07 02:26:36 +0000