RA8875 - Library to control a Graphics TFT connected to 4-…

Users » WiredHome » Code » RA8875

Library to control a Graphics TFT connected to 4-wire SPI - revised for the Raio RA8875 Display Controller.

Dependents: FRDM_RA8875_mPaint RA8875_Demo RA8875_KeyPadDemo SignalGenerator ... more

Enhanced touch-screen support - where it previous supported both the Resistive Touch and Capacitive Touch based on the FT5206 Touch Controller, now it also has support for the GSL1680 Touch Controller.

Offline Help Manual (Windows chm)

/media/uploads/WiredHome/ra8875.zip.bin (download, rename to .zip and unzip)

RA8875.cpp@198:9b6851107426, 2020-03-28 (annotated)

Committer:: WiredHome
Date:: Sat Mar 28 15:01:38 2020 +0000
Revision:: 198:9b6851107426
Parent:: 197:853d08e2fb53
Child:: 200:ae29b60d087c

BREAKING Changes - ; This update alters several APIs, renames some, and generally simplifies. It also has great improvement for Portrait mode orientation.

Who changed what in which revision?

User	Revision	Line number	New contents of line
WiredHome	152:a013ac0133e4	1	// RA8875 Display Controller Library.
WiredHome	152:a013ac0133e4	2	//
WiredHome	152:a013ac0133e4	3	// This is being created for a Raio RA8875-based display from buydisplay.com,
WiredHome	152:a013ac0133e4	4	// which is either 480 x 272 or 800 x 480, using a 4-wire SPI interface.
WiredHome	152:a013ac0133e4	5	// Support is provided for both a keypad and a resistive touch-screen.
WiredHome	152:a013ac0133e4	6	//
WiredHome	152:a013ac0133e4	7	// See the RA8875.h file for full details.
WiredHome	152:a013ac0133e4	8	//
WiredHome	152:a013ac0133e4	9	// 20161106: Updated the initialization to set the various registers based on
WiredHome	152:a013ac0133e4	10	// the BuyDisplay.com example code. This altered several registers
WiredHome	152:a013ac0133e4	11	// for the 800x480 display driver.
WiredHome	152:a013ac0133e4	12	//
WiredHome	19:3f82c1161fd2	13	#include "RA8875.h"
WiredHome	19:3f82c1161fd2	14
WiredHome	145:5eb2492acdda	15	//#include "Utility.h" // private memory manager
WiredHome	145:5eb2492acdda	16	#ifndef UTILITY_H
WiredHome	145:5eb2492acdda	17	#define swMalloc malloc // use the standard
WiredHome	145:5eb2492acdda	18	#define swFree free
WiredHome	145:5eb2492acdda	19	#endif
WiredHome	145:5eb2492acdda	20
WiredHome	197:853d08e2fb53	21	//#define DEBUG "RAIO"
WiredHome	19:3f82c1161fd2	22	// ...
WiredHome	19:3f82c1161fd2	23	// INFO("Stuff to show %d", var); // new-line is automatically appended
WiredHome	19:3f82c1161fd2	24	//
WiredHome	19:3f82c1161fd2	25	#if (defined(DEBUG) && !defined(TARGET_LPC11U24))
WiredHome	190:3132b7dfad82	26	#define INFO(x, ...) std::printf("[INF %s %4d] " x "\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome	190:3132b7dfad82	27	#define WARN(x, ...) std::printf("[WRN %s %4d] " x "\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome	190:3132b7dfad82	28	#define ERR(x, ...) std::printf("[ERR %s %4d] " x "\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome	98:ecebed9b80b2	29	static void HexDump(const char * title, const uint8_t * p, int count)
WiredHome	73:f22a18707b5e	30	{
WiredHome	73:f22a18707b5e	31	int i;
WiredHome	73:f22a18707b5e	32	char buf[100] = "0000: ";
WiredHome	73:f22a18707b5e	33
WiredHome	73:f22a18707b5e	34	if (*title)
WiredHome	73:f22a18707b5e	35	INFO("%s", title);
WiredHome	73:f22a18707b5e	36	for (i=0; i<count; ) {
WiredHome	73:f22a18707b5e	37	sprintf(buf + strlen(buf), "%02X ", *(p+i));
WiredHome	73:f22a18707b5e	38	if ((++i & 0x0F) == 0x00) {
WiredHome	73:f22a18707b5e	39	INFO("%s", buf);
WiredHome	73:f22a18707b5e	40	if (i < count)
WiredHome	73:f22a18707b5e	41	sprintf(buf, "%04X: ", i);
WiredHome	73:f22a18707b5e	42	else
WiredHome	73:f22a18707b5e	43	buf[0] = '\0';
WiredHome	73:f22a18707b5e	44	}
WiredHome	73:f22a18707b5e	45	}
WiredHome	73:f22a18707b5e	46	if (strlen(buf))
WiredHome	73:f22a18707b5e	47	INFO("%s", buf);
WiredHome	73:f22a18707b5e	48	}
WiredHome	19:3f82c1161fd2	49	#else
WiredHome	19:3f82c1161fd2	50	#define INFO(x, ...)
WiredHome	19:3f82c1161fd2	51	#define WARN(x, ...)
WiredHome	19:3f82c1161fd2	52	#define ERR(x, ...)
WiredHome	73:f22a18707b5e	53	#define HexDump(a, b, c)
WiredHome	19:3f82c1161fd2	54	#endif
WiredHome	19:3f82c1161fd2	55
WiredHome	109:7b94f06f085b	56	// Defaults. Users can override this with the init() method.
WiredHome	19:3f82c1161fd2	57	#define RA8875_DISPLAY_WIDTH 480
WiredHome	19:3f82c1161fd2	58	#define RA8875_DISPLAY_HEIGHT 272
WiredHome	43:3becae133285	59	#define RA8875_COLORDEPTH_BPP 16 /* Not an API */
WiredHome	19:3f82c1161fd2	60
WiredHome	19:3f82c1161fd2	61	#ifdef PERF_METRICS
WiredHome	19:3f82c1161fd2	62	#define PERFORMANCE_RESET performance.reset()
WiredHome	19:3f82c1161fd2	63	#define REGISTERPERFORMANCE(a) RegisterPerformance(a)
WiredHome	68:ab08efabfc88	64	#define COUNTIDLETIME(a) CountIdleTime(a)
WiredHome	73:f22a18707b5e	65	static const char *metricsName[] = {
WiredHome	109:7b94f06f085b	66	"Cls", "Pixel", "Pixel Stream", "Boolean Stream",
WiredHome	41:2956a0a221e5	67	"Read Pixel", "Read Pixel Stream",
WiredHome	73:f22a18707b5e	68	"Line",
WiredHome	73:f22a18707b5e	69	"Rectangle", "Rounded Rectangle",
WiredHome	68:ab08efabfc88	70	"Triangle", "Circle", "Ellipse"
WiredHome	19:3f82c1161fd2	71	};
WiredHome	91:ca5f829e6d27	72	uint16_t commandsUsed[256]; // track which commands are used with simple counter of number of hits.
WiredHome	19:3f82c1161fd2	73	#else
WiredHome	19:3f82c1161fd2	74	#define PERFORMANCE_RESET
WiredHome	19:3f82c1161fd2	75	#define REGISTERPERFORMANCE(a)
WiredHome	68:ab08efabfc88	76	#define COUNTIDLETIME(a)
WiredHome	19:3f82c1161fd2	77	#endif
WiredHome	19:3f82c1161fd2	78
WiredHome	73:f22a18707b5e	79	// When it is going to poll a register for completion, how many
WiredHome	19:3f82c1161fd2	80	// uSec should it wait between each polling activity.
WiredHome	19:3f82c1161fd2	81	#define POLLWAITuSec 10
WiredHome	19:3f82c1161fd2	82
WiredHome	75:ca78388cfd77	83	// Private RawKeyMap for the Keyboard interface
WiredHome	79:544eb4964795	84	static const uint8_t DefaultKeyMap[22] = {
WiredHome	77:9206c13aa527	85	0,
WiredHome	77:9206c13aa527	86	1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
WiredHome	75:ca78388cfd77	87	11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
WiredHome	75:ca78388cfd77	88	255
WiredHome	77:9206c13aa527	89	};
WiredHome	75:ca78388cfd77	90
WiredHome	79:544eb4964795	91	static const char * ErrMessages[] = {
WiredHome	79:544eb4964795	92	"noerror", ///< no errors, command completed successfully
WiredHome	89:04575562c961	93	"bad parameter", ///< one or more parameters are invalid
WiredHome	89:04575562c961	94	"file not found", ///< specified file could not be found
WiredHome	89:04575562c961	95	"not bmp format", ///< file is not a .bmp file
WiredHome	89:04575562c961	96	"not ico format", ///< file is not a .ico file
WiredHome	89:04575562c961	97	"not supported format", ///< file format is not yet supported
WiredHome	89:04575562c961	98	"image too big", ///< image is too large for the screen
WiredHome	89:04575562c961	99	"not enough ram", ///< could not allocate ram for scanline
WiredHome	125:7a0b70f56550	100	"touch cal. timeout", ///< calibration could not complete in time
WiredHome	125:7a0b70f56550	101	"external abort", ///< during an idle callback, the user code initiated an abort
WiredHome	79:544eb4964795	102	};
WiredHome	19:3f82c1161fd2	103
WiredHome	163:17526689a3ed	104	typedef struct {
WiredHome	163:17526689a3ed	105	uint8_t b;
WiredHome	163:17526689a3ed	106	uint8_t g;
WiredHome	163:17526689a3ed	107	uint8_t r;
WiredHome	163:17526689a3ed	108	uint8_t a;
WiredHome	163:17526689a3ed	109	} rgbTrio_t;
WiredHome	163:17526689a3ed	110
WiredHome	197:853d08e2fb53	111	/// This is defined as a "Web-Safe" color palette of 216 colors.
WiredHome	164:76edd7d9cb68	112	///
WiredHome	164:76edd7d9cb68	113	/// It is defined so it can be emitted into a BMP file as the color palette, and it is then used
WiredHome	164:76edd7d9cb68	114	/// for downscaling from higher resolution color depth to an 8-bit format.
WiredHome	164:76edd7d9cb68	115	///
WiredHome	163:17526689a3ed	116	static const rgbTrio_t WebColorPalette[] = {
WiredHome	163:17526689a3ed	117	{0x00,0x00,0x00,0xFF}, {0x00,0x00,0x33,0xFF}, {0x00,0x00,0x66,0xFF}, {0x00,0x00,0x99,0xFF}, {0x00,0x00,0xCC,0xFF}, {0x00,0x00,0xFF,0xFF},
WiredHome	163:17526689a3ed	118	{0x00,0x33,0x00,0xFF}, {0x00,0x33,0x33,0xFF}, {0x00,0x33,0x66,0xFF}, {0x00,0x33,0x99,0xFF}, {0x00,0x33,0xCC,0xFF}, {0x00,0x33,0xFF,0xFF},
WiredHome	163:17526689a3ed	119	{0x00,0x66,0x00,0xFF}, {0x00,0x66,0x33,0xFF}, {0x00,0x66,0x66,0xFF}, {0x00,0x66,0x99,0xFF}, {0x00,0x66,0xCC,0xFF}, {0x00,0x66,0xFF,0xFF},
WiredHome	163:17526689a3ed	120	{0x00,0x99,0x00,0xFF}, {0x00,0x99,0x33,0xFF}, {0x00,0x99,0x66,0xFF}, {0x00,0x99,0x99,0xFF}, {0x00,0x99,0xCC,0xFF}, {0x00,0x99,0xFF,0xFF},
WiredHome	163:17526689a3ed	121	{0x00,0xCC,0x00,0xFF}, {0x00,0xCC,0x33,0xFF}, {0x00,0xCC,0x66,0xFF}, {0x00,0xCC,0x99,0xFF}, {0x00,0xCC,0xCC,0xFF}, {0x00,0xCC,0xFF,0xFF},
WiredHome	163:17526689a3ed	122	{0x00,0xFF,0x00,0xFF}, {0x00,0xFF,0x33,0xFF}, {0x00,0xFF,0x66,0xFF}, {0x00,0xFF,0x99,0xFF}, {0x00,0xFF,0xCC,0xFF}, {0x00,0xFF,0xFF,0xFF},
WiredHome	163:17526689a3ed	123	{0x33,0x00,0x00,0xFF}, {0x33,0x00,0x33,0xFF}, {0x33,0x00,0x66,0xFF}, {0x33,0x00,0x99,0xFF}, {0x33,0x00,0xCC,0xFF}, {0x33,0x00,0xFF,0xFF},
WiredHome	163:17526689a3ed	124	{0x33,0x33,0x00,0xFF}, {0x33,0x33,0x33,0xFF}, {0x33,0x33,0x66,0xFF}, {0x33,0x33,0x99,0xFF}, {0x33,0x33,0xCC,0xFF}, {0x33,0x33,0xFF,0xFF},
WiredHome	163:17526689a3ed	125	{0x33,0x66,0x00,0xFF}, {0x33,0x66,0x33,0xFF}, {0x33,0x66,0x66,0xFF}, {0x33,0x66,0x99,0xFF}, {0x33,0x66,0xCC,0xFF}, {0x33,0x66,0xFF,0xFF},
WiredHome	163:17526689a3ed	126	{0x33,0x99,0x00,0xFF}, {0x33,0x99,0x33,0xFF}, {0x33,0x99,0x66,0xFF}, {0x33,0x99,0x99,0xFF}, {0x33,0x99,0xCC,0xFF}, {0x33,0x99,0xFF,0xFF},
WiredHome	163:17526689a3ed	127	{0x33,0xCC,0x00,0xFF}, {0x33,0xCC,0x33,0xFF}, {0x33,0xCC,0x66,0xFF}, {0x33,0xCC,0x99,0xFF}, {0x33,0xCC,0xCC,0xFF}, {0x33,0xCC,0xFF,0xFF},
WiredHome	163:17526689a3ed	128	{0x33,0xFF,0x00,0xFF}, {0x33,0xFF,0x33,0xFF}, {0x33,0xFF,0x66,0xFF}, {0x33,0xFF,0x99,0xFF}, {0x33,0xFF,0xCC,0xFF}, {0x33,0xFF,0xFF,0xFF},
WiredHome	163:17526689a3ed	129	{0x66,0x00,0x00,0xFF}, {0x66,0x00,0x33,0xFF}, {0x66,0x00,0x66,0xFF}, {0x66,0x00,0x99,0xFF}, {0x66,0x00,0xCC,0xFF}, {0x66,0x00,0xFF,0xFF},
WiredHome	163:17526689a3ed	130	{0x66,0x33,0x00,0xFF}, {0x66,0x33,0x33,0xFF}, {0x66,0x33,0x66,0xFF}, {0x66,0x33,0x99,0xFF}, {0x66,0x33,0xCC,0xFF}, {0x66,0x33,0xFF,0xFF},
WiredHome	163:17526689a3ed	131	{0x66,0x66,0x00,0xFF}, {0x66,0x66,0x33,0xFF}, {0x66,0x66,0x66,0xFF}, {0x66,0x66,0x99,0xFF}, {0x66,0x66,0xCC,0xFF}, {0x66,0x66,0xFF,0xFF},
WiredHome	163:17526689a3ed	132	{0x66,0x99,0x00,0xFF}, {0x66,0x99,0x33,0xFF}, {0x66,0x99,0x66,0xFF}, {0x66,0x99,0x99,0xFF}, {0x66,0x99,0xCC,0xFF}, {0x66,0x99,0xFF,0xFF},
WiredHome	163:17526689a3ed	133	{0x66,0xCC,0x00,0xFF}, {0x66,0xCC,0x33,0xFF}, {0x66,0xCC,0x66,0xFF}, {0x66,0xCC,0x99,0xFF}, {0x66,0xCC,0xCC,0xFF}, {0x66,0xCC,0xFF,0xFF},
WiredHome	163:17526689a3ed	134	{0x66,0xFF,0x00,0xFF}, {0x66,0xFF,0x33,0xFF}, {0x66,0xFF,0x66,0xFF}, {0x66,0xFF,0x99,0xFF}, {0x66,0xFF,0xCC,0xFF}, {0x66,0xFF,0xFF,0xFF},
WiredHome	163:17526689a3ed	135	{0x99,0x00,0x00,0xFF}, {0x99,0x00,0x33,0xFF}, {0x99,0x00,0x66,0xFF}, {0x99,0x00,0x99,0xFF}, {0x99,0x00,0xCC,0xFF}, {0x99,0x00,0xFF,0xFF},
WiredHome	163:17526689a3ed	136	{0x99,0x33,0x00,0xFF}, {0x99,0x33,0x33,0xFF}, {0x99,0x33,0x66,0xFF}, {0x99,0x33,0x99,0xFF}, {0x99,0x33,0xCC,0xFF}, {0x99,0x33,0xFF,0xFF},
WiredHome	163:17526689a3ed	137	{0x99,0x66,0x00,0xFF}, {0x99,0x66,0x33,0xFF}, {0x99,0x66,0x66,0xFF}, {0x99,0x66,0x99,0xFF}, {0x99,0x66,0xCC,0xFF}, {0x99,0x66,0xFF,0xFF},
WiredHome	163:17526689a3ed	138	{0x99,0x99,0x00,0xFF}, {0x99,0x99,0x33,0xFF}, {0x99,0x99,0x66,0xFF}, {0x99,0x99,0x99,0xFF}, {0x99,0x99,0xCC,0xFF}, {0x99,0x99,0xFF,0xFF},
WiredHome	163:17526689a3ed	139	{0x99,0xCC,0x00,0xFF}, {0x99,0xCC,0x33,0xFF}, {0x99,0xCC,0x66,0xFF}, {0x99,0xCC,0x99,0xFF}, {0x99,0xCC,0xCC,0xFF}, {0x99,0xCC,0xFF,0xFF},
WiredHome	163:17526689a3ed	140	{0x99,0xFF,0x00,0xFF}, {0x99,0xFF,0x33,0xFF}, {0x99,0xFF,0x66,0xFF}, {0x99,0xFF,0x99,0xFF}, {0x99,0xFF,0xCC,0xFF}, {0x99,0xFF,0xFF,0xFF},
WiredHome	163:17526689a3ed	141	{0xCC,0x00,0x00,0xFF}, {0xCC,0x00,0x33,0xFF}, {0xCC,0x00,0x66,0xFF}, {0xCC,0x00,0x99,0xFF}, {0xCC,0x00,0xCC,0xFF}, {0xCC,0x00,0xFF,0xFF},
WiredHome	163:17526689a3ed	142	{0xCC,0x33,0x00,0xFF}, {0xCC,0x33,0x33,0xFF}, {0xCC,0x33,0x66,0xFF}, {0xCC,0x33,0x99,0xFF}, {0xCC,0x33,0xCC,0xFF}, {0xCC,0x33,0xFF,0xFF},
WiredHome	163:17526689a3ed	143	{0xCC,0x66,0x00,0xFF}, {0xCC,0x66,0x33,0xFF}, {0xCC,0x66,0x66,0xFF}, {0xCC,0x66,0x99,0xFF}, {0xCC,0x66,0xCC,0xFF}, {0xCC,0x66,0xFF,0xFF},
WiredHome	163:17526689a3ed	144	{0xCC,0x99,0x00,0xFF}, {0xCC,0x99,0x33,0xFF}, {0xCC,0x99,0x66,0xFF}, {0xCC,0x99,0x99,0xFF}, {0xCC,0x99,0xCC,0xFF}, {0xCC,0x99,0xFF,0xFF},
WiredHome	163:17526689a3ed	145	{0xCC,0xCC,0x00,0xFF}, {0xCC,0xCC,0x33,0xFF}, {0xCC,0xCC,0x66,0xFF}, {0xCC,0xCC,0x99,0xFF}, {0xCC,0xCC,0xCC,0xFF}, {0xCC,0xCC,0xFF,0xFF},
WiredHome	163:17526689a3ed	146	{0xCC,0xFF,0x00,0xFF}, {0xCC,0xFF,0x33,0xFF}, {0xCC,0xFF,0x66,0xFF}, {0xCC,0xFF,0x99,0xFF}, {0xCC,0xFF,0xCC,0xFF}, {0xCC,0xFF,0xFF,0xFF},
WiredHome	163:17526689a3ed	147	{0xFF,0x00,0x00,0xFF}, {0xFF,0x00,0x33,0xFF}, {0xFF,0x00,0x66,0xFF}, {0xFF,0x00,0x99,0xFF}, {0xFF,0x00,0xCC,0xFF}, {0xFF,0x00,0xFF,0xFF},
WiredHome	163:17526689a3ed	148	{0xFF,0x33,0x00,0xFF}, {0xFF,0x33,0x33,0xFF}, {0xFF,0x33,0x66,0xFF}, {0xFF,0x33,0x99,0xFF}, {0xFF,0x33,0xCC,0xFF}, {0xFF,0x33,0xFF,0xFF},
WiredHome	163:17526689a3ed	149	{0xFF,0x66,0x00,0xFF}, {0xFF,0x66,0x33,0xFF}, {0xFF,0x66,0x66,0xFF}, {0xFF,0x66,0x99,0xFF}, {0xFF,0x66,0xCC,0xFF}, {0xFF,0x66,0xFF,0xFF},
WiredHome	163:17526689a3ed	150	{0xFF,0x99,0x00,0xFF}, {0xFF,0x99,0x33,0xFF}, {0xFF,0x99,0x66,0xFF}, {0xFF,0x99,0x99,0xFF}, {0xFF,0x99,0xCC,0xFF}, {0xFF,0x99,0xFF,0xFF},
WiredHome	163:17526689a3ed	151	{0xFF,0xCC,0x00,0xFF}, {0xFF,0xCC,0x33,0xFF}, {0xFF,0xCC,0x66,0xFF}, {0xFF,0xCC,0x99,0xFF}, {0xFF,0xCC,0xCC,0xFF}, {0xFF,0xCC,0xFF,0xFF},
WiredHome	163:17526689a3ed	152	{0xFF,0xFF,0x00,0xFF}, {0xFF,0xFF,0x33,0xFF}, {0xFF,0xFF,0x66,0xFF}, {0xFF,0xFF,0x99,0xFF}, {0xFF,0xFF,0xCC,0xFF}, {0xFF,0xFF,0xFF,0xFF},
WiredHome	163:17526689a3ed	153
WiredHome	190:3132b7dfad82	154	{0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF},
WiredHome	190:3132b7dfad82	155	{0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF},
WiredHome	190:3132b7dfad82	156	{0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF},
WiredHome	190:3132b7dfad82	157	{0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF},
WiredHome	190:3132b7dfad82	158	{0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF},
WiredHome	190:3132b7dfad82	159	{0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF},
WiredHome	190:3132b7dfad82	160	{0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF},
WiredHome	163:17526689a3ed	161	};
WiredHome	163:17526689a3ed	162
WiredHome	164:76edd7d9cb68	163	#define sqr(a) ((a) * (a))
WiredHome	164:76edd7d9cb68	164
WiredHome	164:76edd7d9cb68	165	/// Find the nearest color match in the lookup table.
WiredHome	164:76edd7d9cb68	166	///
WiredHome	164:76edd7d9cb68	167	/// The typical process is to find the difference between a given color and each entry in
WiredHome	164:76edd7d9cb68	168	/// the table. The difference is defined as:
WiredHome	164:76edd7d9cb68	169	/// diff = sqrt(sqr(r - table[i].r) + sqr(g - table[i].g) + sqr(b - table[i].b))
WiredHome	164:76edd7d9cb68	170	/// The square root function is very CPU intensive, especially w/o a floating point unit,
WiredHome	164:76edd7d9cb68	171	/// so that step is omitted to speed it up a bit.
WiredHome	164:76edd7d9cb68	172	///
WiredHome	163:17526689a3ed	173	static int FindNearestWebColor(uint8_t r, uint8_t g, uint8_t b) {
WiredHome	163:17526689a3ed	174	int bestNdx = 0;
WiredHome	164:76edd7d9cb68	175	float bestDiff = (sqr(r - WebColorPalette[0].r) + sqr(g - WebColorPalette[0].g) + sqr(b - WebColorPalette[0].b));
WiredHome	163:17526689a3ed	176	for (int i=1; i<216; i++) {
WiredHome	164:76edd7d9cb68	177	float thisDiff = (sqr(r - WebColorPalette[i].r) + sqr(g - WebColorPalette[i].g) + sqr(b - WebColorPalette[i].b));
WiredHome	163:17526689a3ed	178	if (thisDiff < bestDiff) {
WiredHome	163:17526689a3ed	179	bestDiff = thisDiff;
WiredHome	163:17526689a3ed	180	bestNdx = i;
WiredHome	163:17526689a3ed	181	}
WiredHome	163:17526689a3ed	182	}
WiredHome	163:17526689a3ed	183	return bestNdx;
WiredHome	163:17526689a3ed	184	}
WiredHome	163:17526689a3ed	185
WiredHome	166:53fd4a876dac	186	// Non-Touch, or Resistive Touch when later initialized that way
WiredHome	166:53fd4a876dac	187	//
WiredHome	190:3132b7dfad82	188	RA8875::RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset,
WiredHome	124:1690a7ae871c	189	const char *name)
WiredHome	58:26658a56112a	190	: GraphicsDisplay(name)
WiredHome	58:26658a56112a	191	, spi(mosi, miso, sclk)
WiredHome	19:3f82c1161fd2	192	, cs(csel)
WiredHome	19:3f82c1161fd2	193	, res(reset)
WiredHome	19:3f82c1161fd2	194	{
WiredHome	178:ae472eb22740	195	INFO("RA8875");
WiredHome	182:8832d03a2a29	196	InitAllMemberVars();
WiredHome	176:4ab96d33a8ec	197	touchInfo = (touchInfo_T )malloc(RESISTIVE_TOUCH_POINTS sizeof(touchInfo_T));
WiredHome	176:4ab96d33a8ec	198	if (touchInfo)
WiredHome	176:4ab96d33a8ec	199	useTouchPanel = TP_RES;
WiredHome	19:3f82c1161fd2	200	}
WiredHome	19:3f82c1161fd2	201
WiredHome	166:53fd4a876dac	202	// Touch, based on FT5206 Controller Chip
WiredHome	166:53fd4a876dac	203	//
WiredHome	190:3132b7dfad82	204	RA8875::RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset,
WiredHome	190:3132b7dfad82	205	PinName sda, PinName scl, PinName irq, const char * name)
WiredHome	124:1690a7ae871c	206	: GraphicsDisplay(name)
WiredHome	124:1690a7ae871c	207	, spi(mosi, miso, sclk)
WiredHome	124:1690a7ae871c	208	, cs(csel)
WiredHome	124:1690a7ae871c	209	, res(reset)
WiredHome	124:1690a7ae871c	210	{
WiredHome	178:ae472eb22740	211	INFO("RA8875");
WiredHome	182:8832d03a2a29	212	InitAllMemberVars();
WiredHome	124:1690a7ae871c	213	m_irq = new InterruptIn(irq);
WiredHome	124:1690a7ae871c	214	m_i2c = new I2C(sda, scl);
WiredHome	178:ae472eb22740	215	INFO("m_i2c = %p", m_i2c);
WiredHome	190:3132b7dfad82	216
WiredHome	165:695c24cc5197	217	// Cap touch panel config
WiredHome	166:53fd4a876dac	218	touchInfo = (touchInfo_T )malloc(FT5206_TOUCH_POINTS sizeof(touchInfo_T));
WiredHome	166:53fd4a876dac	219	if (touchInfo)
WiredHome	166:53fd4a876dac	220	useTouchPanel = TP_FT5206;
WiredHome	165:695c24cc5197	221	m_addr = (FT5206_I2C_ADDRESS << 1);
WiredHome	165:695c24cc5197	222	m_i2c->frequency(FT5206_I2C_FREQUENCY);
WiredHome	190:3132b7dfad82	223
WiredHome	124:1690a7ae871c	224	// Interrupt
WiredHome	124:1690a7ae871c	225	m_irq->mode(PullUp);
WiredHome	155:b3f225ae572c	226	#if MBED_VERSION >= MBED_ENCODE_VERSION(5,8,0)
WiredHome	155:b3f225ae572c	227	eventThread.start(callback(&queue, &EventQueue::dispatch_forever));
WiredHome	155:b3f225ae572c	228	m_irq->fall(queue.event(callback(this, &RA8875::TouchPanelISR)));
WiredHome	181:0032d1b8f5d4	229	#elif (MBED_MAJOR_VERSION >= 5) \|\| (MBED_LIBRARY_VERSION > 127)
WiredHome	145:5eb2492acdda	230	m_irq->fall(callback(this, &RA8875::TouchPanelISR));
WiredHome	150:35a4db3081c1	231	#else
WiredHome	150:35a4db3081c1	232	m_irq->fall(this, &RA8875::TouchPanelISR);
WiredHome	150:35a4db3081c1	233	#endif
WiredHome	178:ae472eb22740	234	m_irq->enable_irq();
WiredHome	124:1690a7ae871c	235	TouchPanelInit();
WiredHome	178:ae472eb22740	236	INFO("RA8875 end.");
WiredHome	124:1690a7ae871c	237	}
WiredHome	124:1690a7ae871c	238
WiredHome	166:53fd4a876dac	239
WiredHome	166:53fd4a876dac	240	// Touch, based on GSL1680 Controller Chip
WiredHome	166:53fd4a876dac	241	//
WiredHome	190:3132b7dfad82	242	RA8875::RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset,
WiredHome	190:3132b7dfad82	243	PinName sda, PinName scl, PinName wake, PinName irq, const char * name)
WiredHome	165:695c24cc5197	244	: GraphicsDisplay(name)
WiredHome	165:695c24cc5197	245	, spi(mosi, miso, sclk)
WiredHome	165:695c24cc5197	246	, cs(csel)
WiredHome	165:695c24cc5197	247	, res(reset)
WiredHome	165:695c24cc5197	248	{
WiredHome	178:ae472eb22740	249	INFO("RA8875");
WiredHome	182:8832d03a2a29	250	InitAllMemberVars();
WiredHome	190:3132b7dfad82	251
WiredHome	165:695c24cc5197	252	m_irq = new InterruptIn(irq);
WiredHome	165:695c24cc5197	253	m_i2c = new I2C(sda, scl);
WiredHome	165:695c24cc5197	254
WiredHome	165:695c24cc5197	255	// Cap touch panel config
WiredHome	166:53fd4a876dac	256	touchInfo = (touchInfo_T )malloc(FT5206_TOUCH_POINTS sizeof(touchInfo_T));
WiredHome	166:53fd4a876dac	257	if (touchInfo)
WiredHome	166:53fd4a876dac	258	useTouchPanel = TP_GSL1680;
WiredHome	165:695c24cc5197	259	m_addr = (GSL1680_I2C_ADDRESS << 1);
WiredHome	165:695c24cc5197	260	m_i2c->frequency(GSL1680_I2C_FREQUENCY);
WiredHome	165:695c24cc5197	261	m_wake = new DigitalOut(wake);
WiredHome	165:695c24cc5197	262
WiredHome	165:695c24cc5197	263	// Interrupt
WiredHome	165:695c24cc5197	264	m_irq->mode(PullUp);
WiredHome	165:695c24cc5197	265	m_irq->enable_irq();
WiredHome	165:695c24cc5197	266	#if MBED_VERSION >= MBED_ENCODE_VERSION(5,8,0)
WiredHome	165:695c24cc5197	267	eventThread.start(callback(&queue, &EventQueue::dispatch_forever));
WiredHome	165:695c24cc5197	268	m_irq->fall(queue.event(callback(this, &RA8875::TouchPanelISR)));
WiredHome	181:0032d1b8f5d4	269	#elif (MBED_MAJOR_VERSION >= 5) \|\| (MBED_LIBRARY_VERSION > 127)
WiredHome	165:695c24cc5197	270	m_irq->fall(callback(this, &RA8875::TouchPanelISR));
WiredHome	165:695c24cc5197	271	#else
WiredHome	165:695c24cc5197	272	m_irq->fall(this, &RA8875::TouchPanelISR);
WiredHome	165:695c24cc5197	273	#endif
WiredHome	165:695c24cc5197	274	TouchPanelInit();
WiredHome	165:695c24cc5197	275	}
WiredHome	165:695c24cc5197	276
WiredHome	165:695c24cc5197	277
WiredHome	124:1690a7ae871c	278
WiredHome	19:3f82c1161fd2	279	//RA8875::~RA8875()
WiredHome	19:3f82c1161fd2	280	//{
WiredHome	19:3f82c1161fd2	281	//}
WiredHome	19:3f82c1161fd2	282
WiredHome	182:8832d03a2a29	283	void RA8875::InitAllMemberVars() {
WiredHome	182:8832d03a2a29	284	tpFQFN = NULL;
WiredHome	182:8832d03a2a29	285	tpCalMessage = NULL;
WiredHome	182:8832d03a2a29	286	c_callback = NULL;
WiredHome	182:8832d03a2a29	287	obj_callback = NULL;
WiredHome	182:8832d03a2a29	288	method_callback = NULL;
WiredHome	182:8832d03a2a29	289	idle_callback = NULL;
WiredHome	182:8832d03a2a29	290	fontScaleX = fontScaleY = 1;
WiredHome	182:8832d03a2a29	291	m_addr = 0;
WiredHome	182:8832d03a2a29	292	m_wake = NULL; // not used for FT5206
WiredHome	182:8832d03a2a29	293	m_irq = NULL;
WiredHome	182:8832d03a2a29	294	m_i2c = NULL;
WiredHome	182:8832d03a2a29	295	touchInfo = NULL;
WiredHome	182:8832d03a2a29	296	useTouchPanel = TP_NONE;
WiredHome	182:8832d03a2a29	297	touchState = no_touch;
WiredHome	182:8832d03a2a29	298	numberOfTouchPoints = 0;
WiredHome	182:8832d03a2a29	299	gesture = 0;
WiredHome	198:9b6851107426	300	panelTouched = false;
WiredHome	182:8832d03a2a29	301	touchSample = 0;
WiredHome	182:8832d03a2a29	302	memset(&tpMatrix, 0, sizeof(tpMatrix_t));
WiredHome	182:8832d03a2a29	303	pKeyMap = NULL;
WiredHome	182:8832d03a2a29	304	spiWriteSpeed = false;
WiredHome	182:8832d03a2a29	305	spiwritefreq = 1000000;
WiredHome	182:8832d03a2a29	306	spireadfreq = 1000000;
WiredHome	182:8832d03a2a29	307	screenbpp = 16;
WiredHome	198:9b6851107426	308	virt_screenwidth = 0;
WiredHome	198:9b6851107426	309	virt_screenheight = 0;
WiredHome	182:8832d03a2a29	310	memset(&windowrect, 0, sizeof(rect_t));
WiredHome	182:8832d03a2a29	311	font = NULL;
WiredHome	182:8832d03a2a29	312	extFontHeight = 0;
WiredHome	182:8832d03a2a29	313	extFontWidth = 0;
WiredHome	182:8832d03a2a29	314	cursor_x = 0;
WiredHome	182:8832d03a2a29	315	cursor_y = 0;
WiredHome	182:8832d03a2a29	316	_printFH = NULL;
WiredHome	190:3132b7dfad82	317	roundCap = false;
WiredHome	182:8832d03a2a29	318	screen_orientation = normal;
WiredHome	182:8832d03a2a29	319	#ifdef PERF_METRICS
WiredHome	182:8832d03a2a29	320	ClearPerformance();
WiredHome	182:8832d03a2a29	321	#endif
WiredHome	182:8832d03a2a29	322	}
WiredHome	154:ad2450fc3dc3	323
WiredHome	131:5bd6ba2ee4a1	324	RetCode_t RA8875::init(int width, int height, int color_bpp, uint8_t poweron, bool keypadon, bool touchscreenon)
WiredHome	79:544eb4964795	325	{
WiredHome	178:ae472eb22740	326	INFO("RA8875::init()");
WiredHome	98:ecebed9b80b2	327	font = NULL; // no external font, use internal.
WiredHome	98:ecebed9b80b2	328	pKeyMap = DefaultKeyMap; // set default key map
WiredHome	98:ecebed9b80b2	329	_select(false); // deselect the display
WiredHome	98:ecebed9b80b2	330	frequency(RA8875_DEFAULT_SPI_FREQ); // data rate
WiredHome	79:544eb4964795	331	Reset();
WiredHome	134:f028ed71a0af	332	// Set PLL based on display size from buy-display.com sample code
WiredHome	198:9b6851107426	333	// RAIO Reference display values noted: 800w: 0x0B, 480w: 0x0A
WiredHome	134:f028ed71a0af	334	if (width == 800) {
WiredHome	198:9b6851107426	335	WriteCommand(RA8875_PLLC1, 0x0C); // PLLC1 - Phase Lock Loop registers [RAIO 0B]
WiredHome	134:f028ed71a0af	336	} else {
WiredHome	198:9b6851107426	337	WriteCommand(RA8875_PLLC1, 0x0B); // PLLC1 - Phase Lock Loop registers [RAIO 0A]
WiredHome	134:f028ed71a0af	338	}
WiredHome	197:853d08e2fb53	339	wait_us(1000);
WiredHome	175:7be3a1fb7fc2	340	WriteCommand(RA8875_PLLC2, 0x02);
WiredHome	197:853d08e2fb53	341	wait_us(1000);
WiredHome	79:544eb4964795	342
WiredHome	79:544eb4964795	343	// System Config Register (SYSR)
WiredHome	105:4f116006ba1f	344	screenbpp = color_bpp;
WiredHome	79:544eb4964795	345	if (color_bpp == 16) {
WiredHome	175:7be3a1fb7fc2	346	WriteCommand(RA8875_SYSR, 0x0C); // 16-bpp (65K colors) color depth, 8-bit interface
WiredHome	79:544eb4964795	347	} else { // color_bpp == 8
WiredHome	175:7be3a1fb7fc2	348	WriteCommand(RA8875_SYSR, 0x00); // 8-bpp (256 colors)
WiredHome	79:544eb4964795	349	}
WiredHome	134:f028ed71a0af	350
WiredHome	134:f028ed71a0af	351	// Set Pixel Clock Setting Register (PCSR) based on display size from buy-display.com sample code
WiredHome	134:f028ed71a0af	352	if (width == 800) {
WiredHome	175:7be3a1fb7fc2	353	WriteCommand(RA8875_PCSR, 0x81); // PDAT on PCLK falling edge, PCLK = 4 x System Clock
WiredHome	197:853d08e2fb53	354	wait_us(1000);
WiredHome	134:f028ed71a0af	355
WiredHome	134:f028ed71a0af	356	// Horizontal Settings
WiredHome	198:9b6851107426	357	virt_screenwidth = width;
WiredHome	175:7be3a1fb7fc2	358	WriteCommand(RA8875_HDWR, width/8 - 1); //HDWR//Horizontal Display Width Setting Bit[6:0]
WiredHome	198:9b6851107426	359	WriteCommand(RA8875_HNDFTR, 0x00); //HNDFCR//Horizontal Non-Display Period fine tune Bit[3:0]
WiredHome	198:9b6851107426	360	WriteCommand(RA8875_HNDR, 0x03); //HNDR//Horizontal Non-Display Period Bit[4:0] [RAIO 0x01]
WiredHome	198:9b6851107426	361	WriteCommand(RA8875_HSTR, 0x03); //HSTR//HSYNC Start Position[4:0] [RAIO 0x00]
WiredHome	198:9b6851107426	362	WriteCommand(RA8875_HPWR, 0x0B); //HPWR//HSYNC Polarity ,The period width of HSYNC. [RAIO 0x05]
WiredHome	134:f028ed71a0af	363
WiredHome	134:f028ed71a0af	364	// Vertical Settings
WiredHome	198:9b6851107426	365	virt_screenheight = height;
WiredHome	175:7be3a1fb7fc2	366	WriteCommand(RA8875_VDHR0, (height-1)&0xFF); //VDHR0 //Vertical Display Height Bit [7:0]
WiredHome	175:7be3a1fb7fc2	367	WriteCommand(RA8875_VDHR1, (height-1)>>8); //VDHR1 //Vertical Display Height Bit [8]
WiredHome	198:9b6851107426	368	WriteCommand(RA8875_VNDR0, 0x20); //VNDR0 //Vertical Non-Display Period Bit [7:0] [RAIO 0x02]
WiredHome	175:7be3a1fb7fc2	369	WriteCommand(RA8875_VNDR1, 0x00); //VNDR1 //Vertical Non-Display Period Bit [8]
WiredHome	198:9b6851107426	370	WriteCommand(RA8875_VSTR0, 0x16); //VSTR0 //VSYNC Start Position[7:0] [RAIO 0x07]
WiredHome	175:7be3a1fb7fc2	371	WriteCommand(RA8875_VSTR1, 0x00); //VSTR1 //VSYNC Start Position[8]
WiredHome	198:9b6851107426	372	WriteCommand(RA8875_VPWR, 0x01); //VPWR //VSYNC Polarity ,VSYNC Pulse Width[6:0] [RAIO 0x09]
WiredHome	134:f028ed71a0af	373	} else {
WiredHome	175:7be3a1fb7fc2	374	WriteCommand(RA8875_PCSR, 0x82); // PDAT on PCLK falling edge, PCLK = 4 x System Clock
WiredHome	197:853d08e2fb53	375	wait_us(1000);
WiredHome	134:f028ed71a0af	376
WiredHome	134:f028ed71a0af	377	// Horizontal Settings
WiredHome	198:9b6851107426	378	virt_screenwidth = width;
WiredHome	175:7be3a1fb7fc2	379	WriteCommand(RA8875_HDWR, width/8 - 1); //HDWR//Horizontal Display Width Setting Bit[6:0]
WiredHome	175:7be3a1fb7fc2	380	WriteCommand(RA8875_HNDFTR, 0x02); //HNDFCR//Horizontal Non-Display Period fine tune Bit[3:0]
WiredHome	175:7be3a1fb7fc2	381	WriteCommand(RA8875_HNDR, 0x03); //HNDR//Horizontal Non-Display Period Bit[4:0]
WiredHome	175:7be3a1fb7fc2	382	WriteCommand(RA8875_HSTR, 0x01); //HSTR//HSYNC Start Position[4:0]
WiredHome	175:7be3a1fb7fc2	383	WriteCommand(RA8875_HPWR, 0x03); //HPWR//HSYNC Polarity ,The period width of HSYNC.
WiredHome	134:f028ed71a0af	384
WiredHome	134:f028ed71a0af	385	// Vertical Settings
WiredHome	198:9b6851107426	386	virt_screenheight = height;
WiredHome	175:7be3a1fb7fc2	387	WriteCommand(RA8875_VDHR0, (height-1)&0xFF); //VDHR0 //Vertical Display Height Bit [7:0]
WiredHome	175:7be3a1fb7fc2	388	WriteCommand(RA8875_VDHR1, (height-1)>>8); //VDHR1 //Vertical Display Height Bit [8]
WiredHome	175:7be3a1fb7fc2	389	WriteCommand(RA8875_VNDR0, 0x0F); //VNDR0 //Vertical Non-Display Period Bit [7:0]
WiredHome	175:7be3a1fb7fc2	390	WriteCommand(RA8875_VNDR1, 0x00); //VNDR1 //Vertical Non-Display Period Bit [8]
WiredHome	175:7be3a1fb7fc2	391	WriteCommand(RA8875_VSTR0, 0x0e); //VSTR0 //VSYNC Start Position[7:0]
WiredHome	175:7be3a1fb7fc2	392	WriteCommand(RA8875_VSTR1, 0x06); //VSTR1 //VSYNC Start Position[8]
WiredHome	175:7be3a1fb7fc2	393	WriteCommand(RA8875_VPWR, 0x01); //VPWR //VSYNC Polarity ,VSYNC Pulse Width[6:0]
WiredHome	134:f028ed71a0af	394	}
WiredHome	79:544eb4964795	395
WiredHome	79:544eb4964795	396	if (width >= 800 && height >= 480 && color_bpp > 8) {
WiredHome	175:7be3a1fb7fc2	397	WriteCommand(RA8875_DPCR, 0x00); // DPCR - 1-layer mode when the resolution is too high
WiredHome	79:544eb4964795	398	} else {
WiredHome	175:7be3a1fb7fc2	399	WriteCommand(RA8875_DPCR, 0x80); // DPCR - 2-layer mode
WiredHome	79:544eb4964795	400	}
WiredHome	79:544eb4964795	401
WiredHome	79:544eb4964795	402	// Set display image to Blue on Black as default
WiredHome	198:9b6851107426	403	SetWindow(0,0, width-1, height-1); // Initialize to full screen
WiredHome	79:544eb4964795	404	SetTextCursorControl();
WiredHome	79:544eb4964795	405	foreground(Blue);
WiredHome	79:544eb4964795	406	background(Black);
WiredHome	79:544eb4964795	407	cls(3);
WiredHome	79:544eb4964795	408
WiredHome	79:544eb4964795	409	Power(poweron);
WiredHome	131:5bd6ba2ee4a1	410	Backlight_u8(poweron);
WiredHome	81:01da2e34283d	411	if (keypadon)
WiredHome	81:01da2e34283d	412	KeypadInit();
WiredHome	124:1690a7ae871c	413	if (touchscreenon) {
WiredHome	124:1690a7ae871c	414	if (useTouchPanel == TP_NONE)
WiredHome	124:1690a7ae871c	415	useTouchPanel = TP_RES;
WiredHome	178:ae472eb22740	416	if (useTouchPanel == TP_RES)
WiredHome	178:ae472eb22740	417	TouchPanelInit(); // only init again if resistive (due to HW reset applied above).
WiredHome	124:1690a7ae871c	418	}
WiredHome	79:544eb4964795	419	#ifdef PERF_METRICS
WiredHome	79:544eb4964795	420	performance.start();
WiredHome	79:544eb4964795	421	ClearPerformance();
WiredHome	79:544eb4964795	422	#endif
WiredHome	178:ae472eb22740	423	INFO("RA8875::init() end");
WiredHome	79:544eb4964795	424	return noerror;
WiredHome	79:544eb4964795	425	}
WiredHome	79:544eb4964795	426
WiredHome	79:544eb4964795	427
WiredHome	79:544eb4964795	428	RetCode_t RA8875::Reset(void)
WiredHome	79:544eb4964795	429	{
WiredHome	79:544eb4964795	430	RetCode_t ret;
WiredHome	190:3132b7dfad82	431
WiredHome	198:9b6851107426	432	#if 1
WiredHome	94:203729061e48	433	if (res != (PinName)NC) {
WiredHome	94:203729061e48	434	res = 0; // Active low - assert reset
WiredHome	197:853d08e2fb53	435	wait_us(2000); // must be > 1024 clock periods. (@25 MHz, this is 40.96 usec)
WiredHome	94:203729061e48	436	res = 1; // de-assert reset
WiredHome	94:203729061e48	437	}
WiredHome	94:203729061e48	438	#endif
WiredHome	175:7be3a1fb7fc2	439	ret = WriteCommand(RA8875_PWRR, 0x01); // Apply Display Off, Reset
WiredHome	197:853d08e2fb53	440	wait_us(2000); // no idea if I need to wait, or how long
WiredHome	79:544eb4964795	441	if (ret == noerror) {
WiredHome	175:7be3a1fb7fc2	442	ret = WriteCommand(RA8875_PWRR, 0x00); // Display off, Remove reset
WiredHome	197:853d08e2fb53	443	wait_us(2000); // no idea if I need to wait, or how long
WiredHome	79:544eb4964795	444	}
WiredHome	79:544eb4964795	445	return ret;
WiredHome	79:544eb4964795	446	}
WiredHome	79:544eb4964795	447
WiredHome	79:544eb4964795	448
WiredHome	79:544eb4964795	449	const char * RA8875::GetErrorMessage(RetCode_t code)
WiredHome	79:544eb4964795	450	{
WiredHome	79:544eb4964795	451	if (code >= LastErrCode)
WiredHome	79:544eb4964795	452	code = bad_parameter;
WiredHome	79:544eb4964795	453	return ErrMessages[code];
WiredHome	79:544eb4964795	454	}
WiredHome	79:544eb4964795	455
WiredHome	79:544eb4964795	456
WiredHome	61:8f3153bf0baa	457	uint16_t RA8875::GetDrawingLayer(void)
WiredHome	61:8f3153bf0baa	458	{
WiredHome	61:8f3153bf0baa	459	return (ReadCommand(0x41) & 0x01);
WiredHome	61:8f3153bf0baa	460	}
WiredHome	43:3becae133285	461
WiredHome	79:544eb4964795	462
WiredHome	198:9b6851107426	463	uint16_t RA8875::SelectDrawingLayer(uint16_t layer)
WiredHome	43:3becae133285	464	{
WiredHome	198:9b6851107426	465	uint16_t prevLayer;
WiredHome	142:6e9bff59878a	466	unsigned char mwcr1 = ReadCommand(0x41); // retain all but the currently selected layer
WiredHome	198:9b6851107426	467	prevLayer = (mwcr1 & 1);
WiredHome	142:6e9bff59878a	468	mwcr1 &= ~0x01; // remove the current layer
WiredHome	198:9b6851107426	469	if (virt_screenwidth >= 800 && virt_screenheight >= 480 && screenbpp > 8) {
WiredHome	142:6e9bff59878a	470	layer = 0;
WiredHome	43:3becae133285	471	} else if (layer > 1) {
WiredHome	142:6e9bff59878a	472	layer = 0;
WiredHome	43:3becae133285	473	}
WiredHome	198:9b6851107426	474	WriteCommand(RA8875_MWCR1, mwcr1 \| layer);
WiredHome	198:9b6851107426	475	return prevLayer;
WiredHome	43:3becae133285	476	}
WiredHome	43:3becae133285	477
WiredHome	44:207594dece70	478
WiredHome	82:f7d300f26540	479	RA8875::LayerMode_T RA8875::GetLayerMode(void)
WiredHome	82:f7d300f26540	480	{
WiredHome	82:f7d300f26540	481	return (LayerMode_T)(ReadCommand(0x52) & 0x7);
WiredHome	82:f7d300f26540	482	}
WiredHome	82:f7d300f26540	483
WiredHome	82:f7d300f26540	484
WiredHome	198:9b6851107426	485	RA8875::LayerMode_T RA8875::SetLayerMode(LayerMode_T mode)
WiredHome	44:207594dece70	486	{
WiredHome	198:9b6851107426	487	unsigned char ltpr0 = ReadCommand(0x52); // retain all but the display layer mode
WiredHome	198:9b6851107426	488	LayerMode_T oldLayer = (LayerMode_T)(ltpr0 & 0x07);
WiredHome	53:86d24b9480b9	489	if (mode <= (LayerMode_T)6) {
WiredHome	198:9b6851107426	490	WriteCommand(RA8875_LTPR0, (ltpr0 & ~0x07) \| (mode & 0x07));
WiredHome	53:86d24b9480b9	491	}
WiredHome	198:9b6851107426	492	return oldLayer;
WiredHome	44:207594dece70	493	}
WiredHome	44:207594dece70	494
WiredHome	44:207594dece70	495
WiredHome	44:207594dece70	496	RetCode_t RA8875::SetLayerTransparency(uint8_t layer1, uint8_t layer2)
WiredHome	44:207594dece70	497	{
WiredHome	44:207594dece70	498	if (layer1 > 8)
WiredHome	44:207594dece70	499	layer1 = 8;
WiredHome	44:207594dece70	500	if (layer2 > 8)
WiredHome	44:207594dece70	501	layer2 = 8;
WiredHome	175:7be3a1fb7fc2	502	WriteCommand(RA8875_LTPR1, ((layer2 & 0xF) << 4) \| (layer1 & 0xF));
WiredHome	44:207594dece70	503	return noerror;
WiredHome	44:207594dece70	504	}
WiredHome	44:207594dece70	505
WiredHome	44:207594dece70	506
WiredHome	198:9b6851107426	507	color_t RA8875::SetBackgroundTransparencyColor(color_t color)
WiredHome	53:86d24b9480b9	508	{
WiredHome	198:9b6851107426	509	color_t oldColor = _readColorTrio(0x67);
WiredHome	198:9b6851107426	510	_writeColorTrio(0x67, color);
WiredHome	198:9b6851107426	511	return oldColor;
WiredHome	53:86d24b9480b9	512	}
WiredHome	53:86d24b9480b9	513
WiredHome	79:544eb4964795	514
WiredHome	73:f22a18707b5e	515	color_t RA8875::GetBackgroundTransparencyColor(void)
WiredHome	73:f22a18707b5e	516	{
WiredHome	73:f22a18707b5e	517	RGBQUAD q;
WiredHome	190:3132b7dfad82	518
WiredHome	73:f22a18707b5e	519	q.rgbRed = ReadCommand(0x67);
WiredHome	73:f22a18707b5e	520	q.rgbGreen = ReadCommand(0x68);
WiredHome	73:f22a18707b5e	521	q.rgbBlue = ReadCommand(0x69);
WiredHome	73:f22a18707b5e	522	return RGBQuadToRGB16(&q, 0);
WiredHome	73:f22a18707b5e	523	}
WiredHome	73:f22a18707b5e	524
WiredHome	71:dcac8efd842d	525
WiredHome	77:9206c13aa527	526	RetCode_t RA8875::KeypadInit(bool scanEnable, bool longDetect, uint8_t sampleTime, uint8_t scanFrequency,
WiredHome	77:9206c13aa527	527	uint8_t longTimeAdjustment, bool interruptEnable, bool wakeupEnable)
WiredHome	71:dcac8efd842d	528	{
WiredHome	71:dcac8efd842d	529	uint8_t value = 0;
WiredHome	77:9206c13aa527	530
WiredHome	71:dcac8efd842d	531	if (sampleTime > 3 \|\| scanFrequency > 7 \|\| longTimeAdjustment > 3)
WiredHome	71:dcac8efd842d	532	return bad_parameter;
WiredHome	71:dcac8efd842d	533	value \|= (scanEnable) ? 0x80 : 0x00;
WiredHome	71:dcac8efd842d	534	value \|= (longDetect) ? 0x40 : 0x00;
WiredHome	71:dcac8efd842d	535	value \|= (sampleTime & 0x03) << 4;
WiredHome	71:dcac8efd842d	536	value \|= (scanFrequency & 0x07);
WiredHome	175:7be3a1fb7fc2	537	WriteCommand(RA8875_KSCR1, value); // KSCR1 - Enable Key Scan (and ignore possibility of an error)
WiredHome	77:9206c13aa527	538
WiredHome	71:dcac8efd842d	539	value = 0;
WiredHome	71:dcac8efd842d	540	value \|= (wakeupEnable) ? 0x80 : 0x00;
WiredHome	71:dcac8efd842d	541	value \|= (longTimeAdjustment & 0x03) << 2;
WiredHome	175:7be3a1fb7fc2	542	WriteCommand(RA8875_KSCR2, value); // KSCR2 - (and ignore possibility of an error)
WiredHome	77:9206c13aa527	543
WiredHome	75:ca78388cfd77	544	value = ReadCommand(0xF0); // (and ignore possibility of an error)
WiredHome	71:dcac8efd842d	545	value &= ~0x10;
WiredHome	71:dcac8efd842d	546	value \|= (interruptEnable) ? 0x10 : 0x00;
WiredHome	175:7be3a1fb7fc2	547	return WriteCommand(RA8875_INTC1, value); // INT
WiredHome	71:dcac8efd842d	548	}
WiredHome	71:dcac8efd842d	549
WiredHome	79:544eb4964795	550
WiredHome	75:ca78388cfd77	551	RetCode_t RA8875::SetKeyMap(const uint8_t * CodeList)
WiredHome	75:ca78388cfd77	552	{
WiredHome	75:ca78388cfd77	553	pKeyMap = CodeList;
WiredHome	75:ca78388cfd77	554	return noerror;
WiredHome	75:ca78388cfd77	555	}
WiredHome	75:ca78388cfd77	556
WiredHome	79:544eb4964795	557
WiredHome	75:ca78388cfd77	558	bool RA8875::readable(void)
WiredHome	71:dcac8efd842d	559	{
WiredHome	71:dcac8efd842d	560	return (ReadCommand(0xF1) & 0x10); // check KS status - true if kbhit
WiredHome	71:dcac8efd842d	561	}
WiredHome	71:dcac8efd842d	562
WiredHome	79:544eb4964795	563
WiredHome	75:ca78388cfd77	564	uint8_t RA8875::getc(void)
WiredHome	71:dcac8efd842d	565	{
WiredHome	79:544eb4964795	566	//#define GETC_DEV // for development
WiredHome	77:9206c13aa527	567	#ifdef GETC_DEV
WiredHome	75:ca78388cfd77	568	uint8_t keyCode1, keyCode2;
WiredHome	77:9206c13aa527	569	#endif
WiredHome	75:ca78388cfd77	570	uint8_t keyCode3;
WiredHome	75:ca78388cfd77	571	static uint8_t count = 0;
WiredHome	75:ca78388cfd77	572	uint8_t col, row;
WiredHome	75:ca78388cfd77	573	uint8_t key;
WiredHome	190:3132b7dfad82	574
WiredHome	75:ca78388cfd77	575	while (!readable()) {
WiredHome	71:dcac8efd842d	576	wait_us(POLLWAITuSec);
WiredHome	75:ca78388cfd77	577	// COUNTIDLETIME(POLLWAITuSec); // As it is voluntary to call the getc and pend. Don't tally it.
WiredHome	123:2f45e80fec5f	578	if (idle_callback) {
WiredHome	149:c62c4b2d6a15	579	if (external_abort == (*idle_callback)(getc_wait, 0)) {
WiredHome	123:2f45e80fec5f	580	return 0;
WiredHome	123:2f45e80fec5f	581	}
WiredHome	123:2f45e80fec5f	582	}
WiredHome	71:dcac8efd842d	583	}
WiredHome	71:dcac8efd842d	584	// read the key press number
WiredHome	71:dcac8efd842d	585	uint8_t keyNumReg = ReadCommand(0xC1) & 0x03;
WiredHome	75:ca78388cfd77	586	count++;
WiredHome	75:ca78388cfd77	587	switch (keyNumReg) {
WiredHome	75:ca78388cfd77	588	case 0x01: // one key
WiredHome	75:ca78388cfd77	589	keyCode3 = ReadCommand(0xC2);
WiredHome	77:9206c13aa527	590	#ifdef GETC_DEV
WiredHome	75:ca78388cfd77	591	keyCode2 = 0;
WiredHome	75:ca78388cfd77	592	keyCode1 = 0;
WiredHome	77:9206c13aa527	593	#endif
WiredHome	75:ca78388cfd77	594	break;
WiredHome	75:ca78388cfd77	595	case 0x02: // two keys
WiredHome	75:ca78388cfd77	596	keyCode3 = ReadCommand(0xC3);
WiredHome	77:9206c13aa527	597	#ifdef GETC_DEV
WiredHome	75:ca78388cfd77	598	keyCode2 = ReadCommand(0xC2);
WiredHome	75:ca78388cfd77	599	keyCode1 = 0;
WiredHome	77:9206c13aa527	600	#endif
WiredHome	75:ca78388cfd77	601	break;
WiredHome	75:ca78388cfd77	602	case 0x03: // three keys
WiredHome	75:ca78388cfd77	603	keyCode3 = ReadCommand(0xC4);
WiredHome	77:9206c13aa527	604	#ifdef GETC_DEV
WiredHome	75:ca78388cfd77	605	keyCode2 = ReadCommand(0xC3);
WiredHome	75:ca78388cfd77	606	keyCode1 = ReadCommand(0xC2);
WiredHome	77:9206c13aa527	607	#endif
WiredHome	75:ca78388cfd77	608	break;
WiredHome	75:ca78388cfd77	609	default: // no keys (key released)
WiredHome	75:ca78388cfd77	610	keyCode3 = 0xFF;
WiredHome	77:9206c13aa527	611	#ifdef GETC_DEV
WiredHome	75:ca78388cfd77	612	keyCode2 = 0;
WiredHome	75:ca78388cfd77	613	keyCode1 = 0;
WiredHome	77:9206c13aa527	614	#endif
WiredHome	75:ca78388cfd77	615	break;
WiredHome	75:ca78388cfd77	616	}
WiredHome	75:ca78388cfd77	617	if (keyCode3 == 0xFF)
WiredHome	75:ca78388cfd77	618	key = pKeyMap[0]; // Key value 0
WiredHome	75:ca78388cfd77	619	else {
WiredHome	75:ca78388cfd77	620	row = (keyCode3 >> 4) & 0x03;
WiredHome	75:ca78388cfd77	621	col = (keyCode3 & 7);
WiredHome	75:ca78388cfd77	622	key = row * 5 + col + 1; // Keys value 1 - 20
WiredHome	75:ca78388cfd77	623	if (key > 21) {
WiredHome	75:ca78388cfd77	624	key = 21;
WiredHome	75:ca78388cfd77	625	}
WiredHome	75:ca78388cfd77	626	key = pKeyMap[key];
WiredHome	75:ca78388cfd77	627	key \|= (keyCode3 & 0x80); // combine the key held flag
WiredHome	75:ca78388cfd77	628	}
WiredHome	77:9206c13aa527	629	#if GETC_DEV // for Development only
WiredHome	75:ca78388cfd77	630	SetTextCursor(0, 20);
WiredHome	75:ca78388cfd77	631	printf(" Reg: %02x\r\n", keyNumReg);
WiredHome	75:ca78388cfd77	632	printf(" key1: %02x\r\n", keyCode1);
WiredHome	75:ca78388cfd77	633	printf(" key2: %02x\r\n", keyCode2);
WiredHome	75:ca78388cfd77	634	printf(" key3: %02x\r\n", keyCode3);
WiredHome	75:ca78388cfd77	635	printf(" count: %02X\r\n", count);
WiredHome	75:ca78388cfd77	636	printf(" key: %02X\r\n", key);
WiredHome	77:9206c13aa527	637	#endif
WiredHome	175:7be3a1fb7fc2	638	WriteCommand(RA8875_INTC2, 0x10); // Clear KS status
WiredHome	75:ca78388cfd77	639	return key;
WiredHome	71:dcac8efd842d	640	}
WiredHome	71:dcac8efd842d	641
WiredHome	79:544eb4964795	642
WiredHome	19:3f82c1161fd2	643	#ifdef PERF_METRICS
WiredHome	19:3f82c1161fd2	644	void RA8875::ClearPerformance()
WiredHome	19:3f82c1161fd2	645	{
WiredHome	100:0b084475d5a9	646	int i;
WiredHome	190:3132b7dfad82	647
WiredHome	100:0b084475d5a9	648	for (i=0; i<METRICCOUNT; i++)
WiredHome	19:3f82c1161fd2	649	metrics[i] = 0;
WiredHome	75:ca78388cfd77	650	idletime_usec = 0;
WiredHome	100:0b084475d5a9	651	for (i=0; i<256; i++)
WiredHome	100:0b084475d5a9	652	commandsUsed[i] = 0;
WiredHome	19:3f82c1161fd2	653	}
WiredHome	19:3f82c1161fd2	654
WiredHome	79:544eb4964795	655
WiredHome	19:3f82c1161fd2	656	void RA8875::RegisterPerformance(method_e method)
WiredHome	19:3f82c1161fd2	657	{
WiredHome	19:3f82c1161fd2	658	unsigned long elapsed = performance.read_us();
WiredHome	73:f22a18707b5e	659
WiredHome	19:3f82c1161fd2	660	if (method < METRICCOUNT && elapsed > metrics[method])
WiredHome	19:3f82c1161fd2	661	metrics[method] = elapsed;
WiredHome	19:3f82c1161fd2	662	}
WiredHome	19:3f82c1161fd2	663
WiredHome	79:544eb4964795	664
WiredHome	66:468a11f05580	665	void RA8875::CountIdleTime(uint32_t t)
WiredHome	66:468a11f05580	666	{
WiredHome	75:ca78388cfd77	667	idletime_usec += t;
WiredHome	66:468a11f05580	668	}
WiredHome	44:207594dece70	669
WiredHome	79:544eb4964795	670
WiredHome	41:2956a0a221e5	671	void RA8875::ReportPerformance(Serial & pc)
WiredHome	19:3f82c1161fd2	672	{
WiredHome	100:0b084475d5a9	673	int i;
WiredHome	190:3132b7dfad82	674
WiredHome	41:2956a0a221e5	675	pc.printf("\r\nPerformance Metrics\r\n");
WiredHome	100:0b084475d5a9	676	for (i=0; i<METRICCOUNT; i++) {
WiredHome	41:2956a0a221e5	677	pc.printf("%10d uS %s\r\n", metrics[i], metricsName[i]);
WiredHome	66:468a11f05580	678	}
WiredHome	75:ca78388cfd77	679	pc.printf("%10d uS Idle time polling display for ready.\r\n", idletime_usec);
WiredHome	91:ca5f829e6d27	680	for (i=0; i<256; i++) {
WiredHome	91:ca5f829e6d27	681	if (commandsUsed[i])
WiredHome	100:0b084475d5a9	682	pc.printf("Command %02X used %5d times.\r\n", i, commandsUsed[i]);
WiredHome	91:ca5f829e6d27	683	}
WiredHome	19:3f82c1161fd2	684	}
WiredHome	19:3f82c1161fd2	685	#endif
WiredHome	19:3f82c1161fd2	686
WiredHome	44:207594dece70	687
WiredHome	190:3132b7dfad82	688	rect_t RA8875::AlignRectInRect(rect_t toAlign, rect_t inRect, valign_t v, halign_t h) {
WiredHome	190:3132b7dfad82	689	rect_t newRect; dim_t width; dim_t height;
WiredHome	198:9b6851107426	690	width = toAlign.p2.x - toAlign.p1.x + 1;
WiredHome	198:9b6851107426	691	height = toAlign.p2.y - toAlign.p1.y + 1;
WiredHome	198:9b6851107426	692	INFO("Align(%d,%d)-(%d,%d) in (%d,%d)-(%d,%d) v:%d, h:%d",
WiredHome	198:9b6851107426	693	toAlign.p1.x,toAlign.p1.y,toAlign.p2.x,toAlign.p2.y,
WiredHome	198:9b6851107426	694	inRect.p1.x,inRect.p1.y,inRect.p2.x,inRect.p2.y,
WiredHome	198:9b6851107426	695	v,h
WiredHome	198:9b6851107426	696	);
WiredHome	190:3132b7dfad82	697	switch (h) {
WiredHome	190:3132b7dfad82	698	case left:
WiredHome	190:3132b7dfad82	699	default:
WiredHome	190:3132b7dfad82	700	newRect.p1.x = inRect.p1.x;
WiredHome	198:9b6851107426	701	newRect.p2.x = newRect.p1.x + width - 1;
WiredHome	190:3132b7dfad82	702	break;
WiredHome	190:3132b7dfad82	703	case center:
WiredHome	190:3132b7dfad82	704	newRect.p1.x = (inRect.p1.x + inRect.p2.x + 1) / 2 - width / 2;
WiredHome	198:9b6851107426	705	newRect.p2.x = newRect.p1.x + width - 1;
WiredHome	190:3132b7dfad82	706	break;
WiredHome	190:3132b7dfad82	707	case right:
WiredHome	198:9b6851107426	708	newRect.p1.x = inRect.p2.x - width - 1;
WiredHome	198:9b6851107426	709	newRect.p2.x = newRect.p1.x + width - 1;
WiredHome	190:3132b7dfad82	710	break;
WiredHome	190:3132b7dfad82	711	}
WiredHome	190:3132b7dfad82	712	switch (v) {
WiredHome	190:3132b7dfad82	713	case top:
WiredHome	190:3132b7dfad82	714	default:
WiredHome	190:3132b7dfad82	715	newRect.p1.y = inRect.p1.y;
WiredHome	198:9b6851107426	716	newRect.p2.y = newRect.p1.y + height - 1;
WiredHome	190:3132b7dfad82	717	break;
WiredHome	190:3132b7dfad82	718	case middle:
WiredHome	190:3132b7dfad82	719	newRect.p1.y = (inRect.p1.y + inRect.p2.y + 1) / 2 - height / 2;
WiredHome	198:9b6851107426	720	newRect.p2.y = newRect.p1.y + height - 1;
WiredHome	190:3132b7dfad82	721	break;
WiredHome	190:3132b7dfad82	722	case bottom:
WiredHome	198:9b6851107426	723	newRect.p1.y = inRect.p2.y - height - 1;
WiredHome	198:9b6851107426	724	newRect.p2.y = newRect.p1.y + height - 1;
WiredHome	190:3132b7dfad82	725	break;
WiredHome	190:3132b7dfad82	726	}
WiredHome	190:3132b7dfad82	727	return newRect;
WiredHome	190:3132b7dfad82	728	}
WiredHome	190:3132b7dfad82	729
WiredHome	190:3132b7dfad82	730
WiredHome	82:f7d300f26540	731	bool RA8875::Intersect(rect_t rect, point_t p)
WiredHome	82:f7d300f26540	732	{
WiredHome	82:f7d300f26540	733	if (p.x >= min(rect.p1.x, rect.p2.x) && p.x <= max(rect.p1.x, rect.p2.x)
WiredHome	82:f7d300f26540	734	&& p.y >= min(rect.p1.y, rect.p2.y) && p.y <= max(rect.p1.y, rect.p2.y))
WiredHome	82:f7d300f26540	735	return true;
WiredHome	82:f7d300f26540	736	else
WiredHome	82:f7d300f26540	737	return false;
WiredHome	82:f7d300f26540	738	}
WiredHome	82:f7d300f26540	739
WiredHome	82:f7d300f26540	740
WiredHome	131:5bd6ba2ee4a1	741	bool RA8875::Intersect(rect_t rect1, rect_t rect2)
WiredHome	131:5bd6ba2ee4a1	742	{
WiredHome	147:3494792458d9	743	#if 1
WiredHome	147:3494792458d9	744	// If one rectangle is on left side of other
WiredHome	147:3494792458d9	745	if (max(rect1.p1.x,rect1.p2.x) < min(rect2.p1.x,rect2.p2.x)
WiredHome	147:3494792458d9	746	\|\| min(rect1.p1.x, rect1.p2.x) > max(rect2.p1.x, rect2.p2.x))
WiredHome	147:3494792458d9	747	return false;
WiredHome	147:3494792458d9	748	// If one rectangle is above other
WiredHome	147:3494792458d9	749	if (max(rect1.p1.y, rect1.p2.y) < min(rect2.p1.y, rect2.p2.y)
WiredHome	147:3494792458d9	750	\|\| min(rect1.p1.y, rect1.p2.y) > max(rect2.p1.y, rect2.p2.y))
WiredHome	147:3494792458d9	751	return false;
WiredHome	147:3494792458d9	752	return true; // all that's left is they overlap
WiredHome	147:3494792458d9	753	#else
WiredHome	131:5bd6ba2ee4a1	754	point_t bl, tr;
WiredHome	131:5bd6ba2ee4a1	755	bl.x = rect2.p1.x;
WiredHome	131:5bd6ba2ee4a1	756	bl.y = rect2.p2.y;
WiredHome	131:5bd6ba2ee4a1	757	tr.x = rect2.p2.x;
WiredHome	131:5bd6ba2ee4a1	758	tr.y = rect2.p1.y;
WiredHome	131:5bd6ba2ee4a1	759	if (Intersect(rect1, rect2.p1) \|\| Intersect(rect1, rect2.p2)
WiredHome	147:3494792458d9	760	\|\| Intersect(rect1, bl) \|\| Intersect(rect1, tr))
WiredHome	131:5bd6ba2ee4a1	761	return true;
WiredHome	131:5bd6ba2ee4a1	762	else
WiredHome	131:5bd6ba2ee4a1	763	return false;
WiredHome	147:3494792458d9	764	#endif
WiredHome	131:5bd6ba2ee4a1	765	}
WiredHome	131:5bd6ba2ee4a1	766
WiredHome	131:5bd6ba2ee4a1	767
WiredHome	147:3494792458d9	768	bool RA8875::Intersect(rect_t * pRect1, const rect_t * pRect2)
WiredHome	147:3494792458d9	769	{
WiredHome	147:3494792458d9	770	if (Intersect(pRect1, pRect2)) {
WiredHome	147:3494792458d9	771	rect_t iSect;
WiredHome	190:3132b7dfad82	772
WiredHome	148:33e99de1aca6	773	iSect.p1.x = max(min(pRect1->p1.x,pRect1->p2.x),min(pRect2->p1.x,pRect2->p2.x));
WiredHome	148:33e99de1aca6	774	iSect.p1.y = max(min(pRect1->p1.y,pRect1->p2.y),min(pRect2->p1.y,pRect2->p2.y));
WiredHome	148:33e99de1aca6	775	iSect.p2.x = min(max(pRect1->p1.x,pRect1->p2.x),max(pRect2->p1.x,pRect2->p2.x));
WiredHome	148:33e99de1aca6	776	iSect.p2.y = min(max(pRect1->p1.y,pRect1->p2.y),max(pRect2->p1.y,pRect2->p2.y));
WiredHome	147:3494792458d9	777	*pRect1 = iSect;
WiredHome	147:3494792458d9	778	return true;
WiredHome	147:3494792458d9	779	} else {
WiredHome	147:3494792458d9	780	return false;
WiredHome	147:3494792458d9	781	}
WiredHome	147:3494792458d9	782	}
WiredHome	147:3494792458d9	783
WiredHome	82:f7d300f26540	784
WiredHome	38:38d503b4fad6	785	RetCode_t RA8875::WriteCommandW(uint8_t command, uint16_t data)
WiredHome	38:38d503b4fad6	786	{
WiredHome	38:38d503b4fad6	787	WriteCommand(command, data & 0xFF);
WiredHome	38:38d503b4fad6	788	WriteCommand(command+1, data >> 8);
WiredHome	38:38d503b4fad6	789	return noerror;
WiredHome	38:38d503b4fad6	790	}
WiredHome	38:38d503b4fad6	791
WiredHome	44:207594dece70	792
WiredHome	19:3f82c1161fd2	793	RetCode_t RA8875::WriteCommand(unsigned char command, unsigned int data)
WiredHome	19:3f82c1161fd2	794	{
WiredHome	91:ca5f829e6d27	795	#ifdef PERF_METRICS
WiredHome	92:ce1ab76e8614	796	if (commandsUsed[command] < 65535)
WiredHome	91:ca5f829e6d27	797	commandsUsed[command]++;
WiredHome	91:ca5f829e6d27	798	#endif
WiredHome	79:544eb4964795	799	_select(true);
WiredHome	83:7bad0068cca0	800	_spiwrite(0x80); // RS:1 (Cmd/Status), RW:0 (Write)
WiredHome	79:544eb4964795	801	_spiwrite(command);
WiredHome	19:3f82c1161fd2	802	if (data <= 0xFF) { // only if in the valid range
WiredHome	79:544eb4964795	803	_spiwrite(0x00);
WiredHome	79:544eb4964795	804	_spiwrite(data);
WiredHome	19:3f82c1161fd2	805	}
WiredHome	79:544eb4964795	806	_select(false);
WiredHome	19:3f82c1161fd2	807	return noerror;
WiredHome	19:3f82c1161fd2	808	}
WiredHome	19:3f82c1161fd2	809
WiredHome	44:207594dece70	810
WiredHome	38:38d503b4fad6	811	RetCode_t RA8875::WriteDataW(uint16_t data)
WiredHome	38:38d503b4fad6	812	{
WiredHome	79:544eb4964795	813	_select(true);
WiredHome	83:7bad0068cca0	814	_spiwrite(0x00); // RS:0 (Data), RW:0 (Write)
WiredHome	79:544eb4964795	815	_spiwrite(data & 0xFF);
WiredHome	79:544eb4964795	816	_spiwrite(data >> 8);
WiredHome	79:544eb4964795	817	_select(false);
WiredHome	38:38d503b4fad6	818	return noerror;
WiredHome	38:38d503b4fad6	819	}
WiredHome	38:38d503b4fad6	820
WiredHome	44:207594dece70	821
WiredHome	19:3f82c1161fd2	822	RetCode_t RA8875::WriteData(unsigned char data)
WiredHome	19:3f82c1161fd2	823	{
WiredHome	79:544eb4964795	824	_select(true);
WiredHome	83:7bad0068cca0	825	_spiwrite(0x00); // RS:0 (Data), RW:0 (Write)
WiredHome	79:544eb4964795	826	_spiwrite(data);
WiredHome	79:544eb4964795	827	_select(false);
WiredHome	19:3f82c1161fd2	828	return noerror;
WiredHome	19:3f82c1161fd2	829	}
WiredHome	19:3f82c1161fd2	830
WiredHome	44:207594dece70	831
WiredHome	19:3f82c1161fd2	832	unsigned char RA8875::ReadCommand(unsigned char command)
WiredHome	19:3f82c1161fd2	833	{
WiredHome	19:3f82c1161fd2	834	WriteCommand(command);
WiredHome	19:3f82c1161fd2	835	return ReadData();
WiredHome	19:3f82c1161fd2	836	}
WiredHome	19:3f82c1161fd2	837
WiredHome	136:224e03d5c31f	838	uint16_t RA8875::ReadCommandW(unsigned char command)
WiredHome	136:224e03d5c31f	839	{
WiredHome	136:224e03d5c31f	840	WriteCommand(command);
WiredHome	136:224e03d5c31f	841	return ReadDataW();
WiredHome	136:224e03d5c31f	842	}
WiredHome	44:207594dece70	843
WiredHome	19:3f82c1161fd2	844	unsigned char RA8875::ReadData(void)
WiredHome	19:3f82c1161fd2	845	{
WiredHome	19:3f82c1161fd2	846	unsigned char data;
WiredHome	73:f22a18707b5e	847
WiredHome	79:544eb4964795	848	_select(true);
WiredHome	83:7bad0068cca0	849	_spiwrite(0x40); // RS:0 (Data), RW:1 (Read)
WiredHome	79:544eb4964795	850	data = _spiread();
WiredHome	79:544eb4964795	851	_select(false);
WiredHome	19:3f82c1161fd2	852	return data;
WiredHome	19:3f82c1161fd2	853	}
WiredHome	19:3f82c1161fd2	854
WiredHome	44:207594dece70	855
WiredHome	41:2956a0a221e5	856	uint16_t RA8875::ReadDataW(void)
WiredHome	41:2956a0a221e5	857	{
WiredHome	41:2956a0a221e5	858	uint16_t data;
WiredHome	73:f22a18707b5e	859
WiredHome	79:544eb4964795	860	_select(true);
WiredHome	83:7bad0068cca0	861	_spiwrite(0x40); // RS:0 (Data), RW:1 (Read)
WiredHome	79:544eb4964795	862	data = _spiread();
WiredHome	79:544eb4964795	863	data \|= (_spiread() << 8);
WiredHome	79:544eb4964795	864	_select(false);
WiredHome	41:2956a0a221e5	865	return data;
WiredHome	41:2956a0a221e5	866	}
WiredHome	41:2956a0a221e5	867
WiredHome	44:207594dece70	868
WiredHome	19:3f82c1161fd2	869	unsigned char RA8875::ReadStatus(void)
WiredHome	19:3f82c1161fd2	870	{
WiredHome	19:3f82c1161fd2	871	unsigned char data;
WiredHome	73:f22a18707b5e	872
WiredHome	79:544eb4964795	873	_select(true);
WiredHome	83:7bad0068cca0	874	_spiwrite(0xC0); // RS:1 (Cmd/Status), RW:1 (Read) (Read STSR)
WiredHome	79:544eb4964795	875	data = _spiread();
WiredHome	79:544eb4964795	876	_select(false);
WiredHome	19:3f82c1161fd2	877	return data;
WiredHome	19:3f82c1161fd2	878	}
WiredHome	19:3f82c1161fd2	879
WiredHome	79:544eb4964795	880
WiredHome	66:468a11f05580	881	/// @todo add a timeout and return false, but how long
WiredHome	66:468a11f05580	882	/// to wait since some operations can be very long.
WiredHome	66:468a11f05580	883	bool RA8875::_WaitWhileBusy(uint8_t mask)
WiredHome	66:468a11f05580	884	{
WiredHome	66:468a11f05580	885	int i = 20000/POLLWAITuSec; // 20 msec max
WiredHome	66:468a11f05580	886
WiredHome	67:9f834f0ff97d	887	while (i-- && ReadStatus() & mask) {
WiredHome	66:468a11f05580	888	wait_us(POLLWAITuSec);
WiredHome	68:ab08efabfc88	889	COUNTIDLETIME(POLLWAITuSec);
WiredHome	123:2f45e80fec5f	890	if (idle_callback) {
WiredHome	149:c62c4b2d6a15	891	if (external_abort == (*idle_callback)(status_wait, 0)) {
WiredHome	123:2f45e80fec5f	892	return false;
WiredHome	123:2f45e80fec5f	893	}
WiredHome	123:2f45e80fec5f	894	}
WiredHome	67:9f834f0ff97d	895	}
WiredHome	66:468a11f05580	896	if (i)
WiredHome	66:468a11f05580	897	return true;
WiredHome	66:468a11f05580	898	else
WiredHome	66:468a11f05580	899	return false;
WiredHome	66:468a11f05580	900	}
WiredHome	66:468a11f05580	901
WiredHome	79:544eb4964795	902
WiredHome	66:468a11f05580	903	/// @todo add a timeout and return false, but how long
WiredHome	66:468a11f05580	904	/// to wait since some operations can be very long.
WiredHome	66:468a11f05580	905	bool RA8875::_WaitWhileReg(uint8_t reg, uint8_t mask)
WiredHome	66:468a11f05580	906	{
WiredHome	66:468a11f05580	907	int i = 20000/POLLWAITuSec; // 20 msec max
WiredHome	66:468a11f05580	908
WiredHome	67:9f834f0ff97d	909	while (i-- && ReadCommand(reg) & mask) {
WiredHome	66:468a11f05580	910	wait_us(POLLWAITuSec);
WiredHome	68:ab08efabfc88	911	COUNTIDLETIME(POLLWAITuSec);
WiredHome	123:2f45e80fec5f	912	if (idle_callback) {
WiredHome	149:c62c4b2d6a15	913	if (external_abort == (*idle_callback)(command_wait, 0)) {
WiredHome	123:2f45e80fec5f	914	return false;
WiredHome	123:2f45e80fec5f	915	}
WiredHome	123:2f45e80fec5f	916	}
WiredHome	67:9f834f0ff97d	917	}
WiredHome	66:468a11f05580	918	if (i)
WiredHome	66:468a11f05580	919	return true;
WiredHome	66:468a11f05580	920	else
WiredHome	66:468a11f05580	921	return false;
WiredHome	66:468a11f05580	922	}
WiredHome	66:468a11f05580	923
WiredHome	106:c80828f5dea4	924	// RRRR RGGG GGGB BBBB
WiredHome	106:c80828f5dea4	925	// 4321 0543 2104 3210
WiredHome	106:c80828f5dea4	926	// RRRG GGBB
WiredHome	106:c80828f5dea4	927	// 2102 1010
WiredHome	105:4f116006ba1f	928	uint8_t RA8875::_cvt16to8(color_t c16)
WiredHome	105:4f116006ba1f	929	{
WiredHome	105:4f116006ba1f	930	return ((c16 >> 8) & 0xE0)
WiredHome	105:4f116006ba1f	931	\| ((c16 >> 6) & 0x1C)
WiredHome	105:4f116006ba1f	932	\| ((c16 >> 3) & 0x03);
WiredHome	105:4f116006ba1f	933	}
WiredHome	105:4f116006ba1f	934
WiredHome	106:c80828f5dea4	935	// RRRG GGBB
WiredHome	106:c80828f5dea4	936	// 2102 1010
WiredHome	106:c80828f5dea4	937	// RRRR RGGG GGGB BBBB
WiredHome	106:c80828f5dea4	938	// 2101 0543 2104 3210
WiredHome	105:4f116006ba1f	939	color_t RA8875::_cvt8to16(uint8_t c8)
WiredHome	105:4f116006ba1f	940	{
WiredHome	106:c80828f5dea4	941	color_t c16;
WiredHome	106:c80828f5dea4	942	color_t temp = (color_t)c8;
WiredHome	190:3132b7dfad82	943
WiredHome	106:c80828f5dea4	944	c16 = ((temp & 0xE0) << 8)
WiredHome	106:c80828f5dea4	945	\| ((temp & 0xC0) << 5)
WiredHome	106:c80828f5dea4	946	\| ((temp & 0x1C) << 6)
WiredHome	106:c80828f5dea4	947	\| ((temp & 0x1C) << 3)
WiredHome	106:c80828f5dea4	948	\| ((temp & 0x03) << 3)
WiredHome	106:c80828f5dea4	949	\| ((temp & 0x03) << 1)
WiredHome	106:c80828f5dea4	950	\| ((temp & 0x03) >> 1);
WiredHome	106:c80828f5dea4	951	c16 = (c16 << 8) \| (c16 >> 8);
WiredHome	105:4f116006ba1f	952	return c16;
WiredHome	105:4f116006ba1f	953	}
WiredHome	66:468a11f05580	954
WiredHome	133:e36dcfc2d756	955	RetCode_t RA8875::_writeColorTrio(uint8_t regAddr, color_t color)
WiredHome	133:e36dcfc2d756	956	{
WiredHome	133:e36dcfc2d756	957	RetCode_t rt = noerror;
WiredHome	190:3132b7dfad82	958
WiredHome	133:e36dcfc2d756	959	if (screenbpp == 16) {
WiredHome	133:e36dcfc2d756	960	WriteCommand(regAddr+0, (color>>11)); // BGCR0
WiredHome	133:e36dcfc2d756	961	WriteCommand(regAddr+1, (unsigned char)(color>>5)); // BGCR1
WiredHome	133:e36dcfc2d756	962	rt = WriteCommand(regAddr+2, (unsigned char)(color)); // BGCR2
WiredHome	133:e36dcfc2d756	963	} else {
WiredHome	133:e36dcfc2d756	964	uint8_t r, g, b;
WiredHome	190:3132b7dfad82	965
WiredHome	133:e36dcfc2d756	966	// RRRR RGGG GGGB BBBB RGB
WiredHome	133:e36dcfc2d756	967	// RRR GGG B B
WiredHome	133:e36dcfc2d756	968	r = (uint8_t)((color) >> 13);
WiredHome	133:e36dcfc2d756	969	g = (uint8_t)((color) >> 8);
WiredHome	133:e36dcfc2d756	970	b = (uint8_t)((color) >> 3);
WiredHome	133:e36dcfc2d756	971	WriteCommand(regAddr+0, r); // BGCR0
WiredHome	133:e36dcfc2d756	972	WriteCommand(regAddr+1, g); // BGCR1
WiredHome	133:e36dcfc2d756	973	rt = WriteCommand(regAddr+2, b); // BGCR2
WiredHome	133:e36dcfc2d756	974	}
WiredHome	133:e36dcfc2d756	975	return rt;
WiredHome	133:e36dcfc2d756	976	}
WiredHome	133:e36dcfc2d756	977
WiredHome	133:e36dcfc2d756	978	color_t RA8875::_readColorTrio(uint8_t regAddr)
WiredHome	133:e36dcfc2d756	979	{
WiredHome	133:e36dcfc2d756	980	color_t color;
WiredHome	133:e36dcfc2d756	981	uint8_t r, g, b;
WiredHome	190:3132b7dfad82	982
WiredHome	133:e36dcfc2d756	983	r = ReadCommand(regAddr+0);
WiredHome	133:e36dcfc2d756	984	g = ReadCommand(regAddr+1);
WiredHome	133:e36dcfc2d756	985	b = ReadCommand(regAddr+2);
WiredHome	133:e36dcfc2d756	986	if (screenbpp == 16) {
WiredHome	133:e36dcfc2d756	987	// 000R RRRR 00GG GGGG 000B BBBB
WiredHome	133:e36dcfc2d756	988	// RRRR RGGG GGGB BBBB
WiredHome	133:e36dcfc2d756	989	color = (r & 0x1F) << 11;
WiredHome	133:e36dcfc2d756	990	color \|= (g & 0x3F) << 5;
WiredHome	133:e36dcfc2d756	991	color \|= (b & 0x1F);
WiredHome	133:e36dcfc2d756	992	} else {
WiredHome	133:e36dcfc2d756	993	// RRRG GGBB
WiredHome	133:e36dcfc2d756	994	// RRRR RGGG GGGB BBBB
WiredHome	133:e36dcfc2d756	995	color = (r & 0x07) << 13;
WiredHome	133:e36dcfc2d756	996	color \|= (g & 0x07) << 8;
WiredHome	133:e36dcfc2d756	997	color \|= (b & 0x03) << 3;
WiredHome	133:e36dcfc2d756	998	}
WiredHome	133:e36dcfc2d756	999	return color;
WiredHome	133:e36dcfc2d756	1000	}
WiredHome	133:e36dcfc2d756	1001
WiredHome	133:e36dcfc2d756	1002
WiredHome	37:f19b7e7449dc	1003	dim_t RA8875::fontwidth(void)
WiredHome	19:3f82c1161fd2	1004	{
WiredHome	19:3f82c1161fd2	1005	if (font == NULL)
WiredHome	198:9b6851107426	1006	return (((ReadCommand(RA8875_FNCR1) >> 2) & 0x3) + 1) * 8;
WiredHome	19:3f82c1161fd2	1007	else
WiredHome	98:ecebed9b80b2	1008	return extFontWidth;
WiredHome	19:3f82c1161fd2	1009	}
WiredHome	19:3f82c1161fd2	1010
WiredHome	44:207594dece70	1011
WiredHome	37:f19b7e7449dc	1012	dim_t RA8875::fontheight(void)
WiredHome	19:3f82c1161fd2	1013	{
WiredHome	19:3f82c1161fd2	1014	if (font == NULL)
WiredHome	198:9b6851107426	1015	return (((ReadCommand(RA8875_FNCR1) >> 0) & 0x3) + 1) * 16;
WiredHome	19:3f82c1161fd2	1016	else
WiredHome	98:ecebed9b80b2	1017	return extFontHeight;
WiredHome	19:3f82c1161fd2	1018	}
WiredHome	19:3f82c1161fd2	1019
WiredHome	44:207594dece70	1020
WiredHome	198:9b6851107426	1021	point_t RA8875::locate(textloc_t column, textloc_t row)
WiredHome	19:3f82c1161fd2	1022	{
WiredHome	32:0e4f2ae512e2	1023	return SetTextCursor(column * fontwidth(), row * fontheight());
WiredHome	19:3f82c1161fd2	1024	}
WiredHome	19:3f82c1161fd2	1025
WiredHome	44:207594dece70	1026
WiredHome	19:3f82c1161fd2	1027	int RA8875::columns(void)
WiredHome	19:3f82c1161fd2	1028	{
WiredHome	198:9b6851107426	1029	return virt_screenwidth / fontwidth();
WiredHome	19:3f82c1161fd2	1030	}
WiredHome	19:3f82c1161fd2	1031
WiredHome	44:207594dece70	1032
WiredHome	19:3f82c1161fd2	1033	int RA8875::rows(void)
WiredHome	19:3f82c1161fd2	1034	{
WiredHome	198:9b6851107426	1035	return virt_screenheight / fontheight();
WiredHome	19:3f82c1161fd2	1036	}
WiredHome	19:3f82c1161fd2	1037
WiredHome	44:207594dece70	1038
WiredHome	38:38d503b4fad6	1039	dim_t RA8875::width(void)
WiredHome	19:3f82c1161fd2	1040	{
WiredHome	198:9b6851107426	1041	return virt_screenwidth;
WiredHome	19:3f82c1161fd2	1042	}
WiredHome	19:3f82c1161fd2	1043
WiredHome	44:207594dece70	1044
WiredHome	38:38d503b4fad6	1045	dim_t RA8875::height(void)
WiredHome	19:3f82c1161fd2	1046	{
WiredHome	198:9b6851107426	1047	return virt_screenheight;
WiredHome	19:3f82c1161fd2	1048	}
WiredHome	19:3f82c1161fd2	1049
WiredHome	44:207594dece70	1050
WiredHome	43:3becae133285	1051	dim_t RA8875::color_bpp(void)
WiredHome	43:3becae133285	1052	{
WiredHome	105:4f116006ba1f	1053	return screenbpp;
WiredHome	43:3becae133285	1054	}
WiredHome	43:3becae133285	1055
WiredHome	190:3132b7dfad82	1056	bool RA8875::SetWordWrap(bool _wordwrap) {
WiredHome	190:3132b7dfad82	1057	bool prevWrap = wordwrap;
WiredHome	190:3132b7dfad82	1058	wordwrap = _wordwrap;
WiredHome	190:3132b7dfad82	1059	return prevWrap;
WiredHome	190:3132b7dfad82	1060	}
WiredHome	190:3132b7dfad82	1061
WiredHome	198:9b6851107426	1062	point_t RA8875::SetTextCursor(point_t p)
WiredHome	103:7e0464ca6c5c	1063	{
WiredHome	103:7e0464ca6c5c	1064	return SetTextCursor(p.x, p.y);
WiredHome	103:7e0464ca6c5c	1065	}
WiredHome	44:207594dece70	1066
WiredHome	198:9b6851107426	1067	point_t RA8875::SetTextCursor(loc_t x, loc_t y)
WiredHome	19:3f82c1161fd2	1068	{
WiredHome	198:9b6851107426	1069	point_t oldCursor = GetTextCursor();
WiredHome	75:ca78388cfd77	1070	cursor_x = x; // set these values for non-internal fonts
WiredHome	75:ca78388cfd77	1071	cursor_y = y;
WiredHome	198:9b6851107426	1072	switch (screen_orientation) {
WiredHome	198:9b6851107426	1073	default:
WiredHome	198:9b6851107426	1074	case rotate_0:
WiredHome	198:9b6851107426	1075	case rotate_180:
WiredHome	198:9b6851107426	1076	WriteCommandW(RA8875_FCURXL, x);
WiredHome	198:9b6851107426	1077	WriteCommandW(RA8875_FCURYL, y);
WiredHome	198:9b6851107426	1078	break;
WiredHome	198:9b6851107426	1079	case rotate_90:
WiredHome	198:9b6851107426	1080	case rotate_270:
WiredHome	198:9b6851107426	1081	WriteCommandW(RA8875_FCURXL, y);
WiredHome	198:9b6851107426	1082	WriteCommandW(RA8875_FCURYL, x);
WiredHome	198:9b6851107426	1083	break;
WiredHome	198:9b6851107426	1084	}
WiredHome	198:9b6851107426	1085	return oldCursor;
WiredHome	19:3f82c1161fd2	1086	}
WiredHome	19:3f82c1161fd2	1087
WiredHome	103:7e0464ca6c5c	1088	point_t RA8875::GetTextCursor(void)
WiredHome	103:7e0464ca6c5c	1089	{
WiredHome	198:9b6851107426	1090	point_t p, tempPt;
WiredHome	198:9b6851107426	1091
WiredHome	198:9b6851107426	1092	if (font == NULL) {
WiredHome	198:9b6851107426	1093	p.x = ReadCommand(RA8875_FCURXL) \| (ReadCommand(RA8875_FCURXH) << 8);
WiredHome	198:9b6851107426	1094	p.y = ReadCommand(RA8875_FCURYL) \| (ReadCommand(RA8875_FCURYH) << 8);
WiredHome	198:9b6851107426	1095	switch (screen_orientation) {
WiredHome	198:9b6851107426	1096	case rotate_0:
WiredHome	198:9b6851107426	1097	case rotate_180:
WiredHome	198:9b6851107426	1098	// Nothing
WiredHome	198:9b6851107426	1099	break;
WiredHome	198:9b6851107426	1100	case rotate_90:
WiredHome	198:9b6851107426	1101	case rotate_270:
WiredHome	198:9b6851107426	1102	tempPt.x = p.y;
WiredHome	198:9b6851107426	1103	tempPt.y = p.x;
WiredHome	198:9b6851107426	1104	p = tempPt;
WiredHome	198:9b6851107426	1105	break;
WiredHome	198:9b6851107426	1106	default:
WiredHome	198:9b6851107426	1107	p.x = 0;
WiredHome	198:9b6851107426	1108	p.y = 0;
WiredHome	198:9b6851107426	1109	break;
WiredHome	198:9b6851107426	1110	}
WiredHome	198:9b6851107426	1111	} else {
WiredHome	198:9b6851107426	1112	p.x = cursor_x;
WiredHome	198:9b6851107426	1113	p.y = cursor_y;
WiredHome	198:9b6851107426	1114	}
WiredHome	198:9b6851107426	1115	//INFO("GetCursor hw: (%d,%d)", p.x, p.y);
WiredHome	103:7e0464ca6c5c	1116	return p;
WiredHome	103:7e0464ca6c5c	1117	}
WiredHome	44:207594dece70	1118
WiredHome	37:f19b7e7449dc	1119	loc_t RA8875::GetTextCursor_Y(void)
WiredHome	29:422616aa04bd	1120	{
WiredHome	198:9b6851107426	1121	point_t p = GetTextCursor();
WiredHome	198:9b6851107426	1122	INFO("GetTextCursor_Y = %d", p.y);
WiredHome	198:9b6851107426	1123	return p.y;
WiredHome	29:422616aa04bd	1124	}
WiredHome	29:422616aa04bd	1125
WiredHome	44:207594dece70	1126
WiredHome	37:f19b7e7449dc	1127	loc_t RA8875::GetTextCursor_X(void)
WiredHome	29:422616aa04bd	1128	{
WiredHome	198:9b6851107426	1129	point_t p = GetTextCursor();
WiredHome	198:9b6851107426	1130	INFO("GetTextCursor_X = %d", p.x);
WiredHome	198:9b6851107426	1131	return p.x;
WiredHome	29:422616aa04bd	1132	}
WiredHome	29:422616aa04bd	1133
WiredHome	44:207594dece70	1134
WiredHome	24:8ca861acf12d	1135	RetCode_t RA8875::SetTextCursorControl(cursor_t cursor, bool blink)
WiredHome	23:a50ded45dbaf	1136	{
WiredHome	194:53c18f0e7922	1137	unsigned char mwcr0 = ReadCommand(RA8875_MWCR0) & 0x0F; // retain direction, auto-increase
WiredHome	194:53c18f0e7922	1138	unsigned char mwcr1 = ReadCommand(RA8875_MWCR1) & 0x01; // retain currently selected layer
WiredHome	24:8ca861acf12d	1139	unsigned char horz = 0;
WiredHome	24:8ca861acf12d	1140	unsigned char vert = 0;
WiredHome	73:f22a18707b5e	1141
WiredHome	194:53c18f0e7922	1142	mwcr0 \|= 0x80; // text mode
WiredHome	24:8ca861acf12d	1143	if (cursor != NOCURSOR)
WiredHome	194:53c18f0e7922	1144	mwcr0 \|= 0x40; // visible
WiredHome	23:a50ded45dbaf	1145	if (blink)
WiredHome	194:53c18f0e7922	1146	mwcr0 \|= 0x20; // blink
WiredHome	175:7be3a1fb7fc2	1147	WriteCommand(RA8875_MWCR0, mwcr0); // configure the cursor
WiredHome	175:7be3a1fb7fc2	1148	WriteCommand(RA8875_MWCR1, mwcr1); // close the graphics cursor
WiredHome	194:53c18f0e7922	1149	WriteCommand(RA8875_BTCR, 0x1f); // The cursor flashing cycle
WiredHome	24:8ca861acf12d	1150	switch (cursor) {
WiredHome	24:8ca861acf12d	1151	case IBEAM:
WiredHome	24:8ca861acf12d	1152	horz = 0x01;
WiredHome	24:8ca861acf12d	1153	vert = 0x1F;
WiredHome	24:8ca861acf12d	1154	break;
WiredHome	24:8ca861acf12d	1155	case UNDER:
WiredHome	24:8ca861acf12d	1156	horz = 0x07;
WiredHome	24:8ca861acf12d	1157	vert = 0x01;
WiredHome	24:8ca861acf12d	1158	break;
WiredHome	24:8ca861acf12d	1159	case BLOCK:
WiredHome	24:8ca861acf12d	1160	horz = 0x07;
WiredHome	24:8ca861acf12d	1161	vert = 0x1F;
WiredHome	24:8ca861acf12d	1162	break;
WiredHome	24:8ca861acf12d	1163	case NOCURSOR:
WiredHome	24:8ca861acf12d	1164	default:
WiredHome	24:8ca861acf12d	1165	break;
WiredHome	24:8ca861acf12d	1166	}
WiredHome	175:7be3a1fb7fc2	1167	WriteCommand(RA8875_CURHS, horz); // The cursor size horz
WiredHome	175:7be3a1fb7fc2	1168	WriteCommand(RA8875_CURVS, vert); // The cursor size vert
WiredHome	23:a50ded45dbaf	1169	return noerror;
WiredHome	23:a50ded45dbaf	1170	}
WiredHome	23:a50ded45dbaf	1171
WiredHome	44:207594dece70	1172
WiredHome	19:3f82c1161fd2	1173	RetCode_t RA8875::SetTextFont(RA8875::font_t font)
WiredHome	19:3f82c1161fd2	1174	{
WiredHome	19:3f82c1161fd2	1175	if (/font >= RA8875::ISO8859_1 && / font <= RA8875::ISO8859_4) {
WiredHome	175:7be3a1fb7fc2	1176	WriteCommand(RA8875_FNCR0, (unsigned int)(font));
WiredHome	19:3f82c1161fd2	1177	return noerror;
WiredHome	19:3f82c1161fd2	1178	} else {
WiredHome	19:3f82c1161fd2	1179	return bad_parameter;
WiredHome	19:3f82c1161fd2	1180	}
WiredHome	19:3f82c1161fd2	1181	}
WiredHome	19:3f82c1161fd2	1182
WiredHome	198:9b6851107426	1183	orientation_t RA8875::GetGraphicsOrientation()
WiredHome	191:0fad2e45e196	1184	{
WiredHome	195:17e176dbd6eb	1185	return screen_orientation;
WiredHome	191:0fad2e45e196	1186	}
WiredHome	44:207594dece70	1187
WiredHome	198:9b6851107426	1188	orientation_t RA8875::SetGraphicsOrientation(orientation_t angle)
WiredHome	84:e102021864b5	1189	{
WiredHome	194:53c18f0e7922	1190	uint8_t dpcrVal = ReadCommand(RA8875_DPCR);
WiredHome	194:53c18f0e7922	1191	uint8_t mwcr0 = ReadCommand(RA8875_MWCR0);
WiredHome	198:9b6851107426	1192	uint8_t mrcd = ReadCommand(RA8875_MRCD);
WiredHome	198:9b6851107426	1193	dim_t tempWidth, tempHeight;
WiredHome	198:9b6851107426	1194	orientation_t oldAngle = screen_orientation;
WiredHome	198:9b6851107426	1195
WiredHome	84:e102021864b5	1196	dpcrVal &= ~0x0C; // remove the old scan direction bits
WiredHome	194:53c18f0e7922	1197	mwcr0 &= 0xE3; // remove the old direction bits
WiredHome	198:9b6851107426	1198	mrcd &= 0xFC; // remove the old direction bits
WiredHome	84:e102021864b5	1199	switch (angle) {
WiredHome	198:9b6851107426	1200	case normal:
WiredHome	84:e102021864b5	1201	//dpcrVal \|= 0x00;
WiredHome	198:9b6851107426	1202	tempWidth = max(virt_screenwidth, virt_screenheight);
WiredHome	198:9b6851107426	1203	tempHeight = min(virt_screenwidth, virt_screenheight);
WiredHome	84:e102021864b5	1204	break;
WiredHome	198:9b6851107426	1205	case rotate_90:
WiredHome	84:e102021864b5	1206	dpcrVal \|= 0x08;
WiredHome	198:9b6851107426	1207	mwcr0 \|= 0x08;
WiredHome	198:9b6851107426	1208	mrcd \|= 0x02;
WiredHome	198:9b6851107426	1209	tempWidth = min(virt_screenwidth, virt_screenheight);
WiredHome	198:9b6851107426	1210	tempHeight = max(virt_screenwidth, virt_screenheight);
WiredHome	84:e102021864b5	1211	break;
WiredHome	198:9b6851107426	1212	case rotate_180:
WiredHome	84:e102021864b5	1213	dpcrVal \|= 0x0C;
WiredHome	194:53c18f0e7922	1214	//mwcr0 \|= 0x00;
WiredHome	198:9b6851107426	1215	//mrcd \|= 0x00;
WiredHome	198:9b6851107426	1216	tempWidth = max(virt_screenwidth, virt_screenheight);
WiredHome	198:9b6851107426	1217	tempHeight = min(virt_screenwidth, virt_screenheight);
WiredHome	84:e102021864b5	1218	break;
WiredHome	198:9b6851107426	1219	case rotate_270:
WiredHome	84:e102021864b5	1220	dpcrVal \|= 0x04;
WiredHome	198:9b6851107426	1221	mwcr0 \|= 0x08;
WiredHome	198:9b6851107426	1222	mrcd \|= 0x02;
WiredHome	198:9b6851107426	1223	tempWidth = min(virt_screenwidth, virt_screenheight);
WiredHome	198:9b6851107426	1224	tempHeight = max(virt_screenwidth, virt_screenheight);
WiredHome	84:e102021864b5	1225	break;
WiredHome	84:e102021864b5	1226	default:
WiredHome	198:9b6851107426	1227	return invalid;
WiredHome	84:e102021864b5	1228	}
WiredHome	195:17e176dbd6eb	1229	screen_orientation = angle;
WiredHome	198:9b6851107426	1230	virt_screenwidth = tempWidth;
WiredHome	198:9b6851107426	1231	virt_screenheight = tempHeight;
WiredHome	198:9b6851107426	1232	WriteCommand(RA8875_MRCD, mrcd);
WiredHome	194:53c18f0e7922	1233	WriteCommand(RA8875_MWCR0, mwcr0);
WiredHome	198:9b6851107426	1234	WriteCommand(RA8875_DPCR, dpcrVal);
WiredHome	198:9b6851107426	1235	return oldAngle;
WiredHome	198:9b6851107426	1236	}
WiredHome	198:9b6851107426	1237
WiredHome	198:9b6851107426	1238	orientation_t RA8875::SetTextFontOrientation(orientation_t angle)
WiredHome	198:9b6851107426	1239	{
WiredHome	198:9b6851107426	1240	uint8_t fncr1Val = ReadCommand(RA8875_FNCR1);
WiredHome	198:9b6851107426	1241	orientation_t oldAngle = text_orientation;
WiredHome	198:9b6851107426	1242
WiredHome	198:9b6851107426	1243	fncr1Val &= ~0x10; // remove the old direction bit
WiredHome	198:9b6851107426	1244	switch (angle) {
WiredHome	198:9b6851107426	1245	case normal:
WiredHome	198:9b6851107426	1246	//fncr1Val \|= 0x10;
WiredHome	198:9b6851107426	1247	break;
WiredHome	198:9b6851107426	1248	case rotate_90:
WiredHome	198:9b6851107426	1249	fncr1Val \|= 0x10;
WiredHome	198:9b6851107426	1250	break;
WiredHome	198:9b6851107426	1251	case rotate_180:
WiredHome	198:9b6851107426	1252	//fncr1Val \|= 0x00;
WiredHome	198:9b6851107426	1253	break;
WiredHome	198:9b6851107426	1254	case rotate_270:
WiredHome	198:9b6851107426	1255	fncr1Val \|= 0x10;
WiredHome	198:9b6851107426	1256	break;
WiredHome	198:9b6851107426	1257	default:
WiredHome	198:9b6851107426	1258	return invalid;
WiredHome	198:9b6851107426	1259	}
WiredHome	194:53c18f0e7922	1260	WriteCommand(RA8875_FNCR1, fncr1Val);
WiredHome	198:9b6851107426	1261	return oldAngle;
WiredHome	84:e102021864b5	1262	}
WiredHome	84:e102021864b5	1263
WiredHome	19:3f82c1161fd2	1264	RetCode_t RA8875::SetTextFontControl(fill_t fillit,
WiredHome	73:f22a18707b5e	1265	RA8875::HorizontalScale hScale,
WiredHome	73:f22a18707b5e	1266	RA8875::VerticalScale vScale,
WiredHome	73:f22a18707b5e	1267	RA8875::alignment_t alignment)
WiredHome	19:3f82c1161fd2	1268	{
WiredHome	73:f22a18707b5e	1269	if (hScale >= 1 && hScale <= 4 &&
WiredHome	73:f22a18707b5e	1270	vScale >= 1 && vScale <= 4) {
WiredHome	198:9b6851107426	1271	uint8_t fncr1Val = ReadCommand(RA8875_FNCR1);
WiredHome	190:3132b7dfad82	1272
WiredHome	186:910fc2335c45	1273	fncr1Val &= 0x10; // remove all except the font rotation bit
WiredHome	19:3f82c1161fd2	1274	if (alignment == align_full)
WiredHome	84:e102021864b5	1275	fncr1Val \|= 0x80;
WiredHome	19:3f82c1161fd2	1276	if (fillit == NOFILL)
WiredHome	84:e102021864b5	1277	fncr1Val \|= 0x40;
WiredHome	84:e102021864b5	1278	fncr1Val \|= ((hScale - 1) << 2);
WiredHome	84:e102021864b5	1279	fncr1Val \|= ((vScale - 1) << 0);
WiredHome	175:7be3a1fb7fc2	1280	return WriteCommand(RA8875_FNCR1, fncr1Val);
WiredHome	19:3f82c1161fd2	1281	} else {
WiredHome	19:3f82c1161fd2	1282	return bad_parameter;
WiredHome	19:3f82c1161fd2	1283	}
WiredHome	19:3f82c1161fd2	1284	}
WiredHome	19:3f82c1161fd2	1285
WiredHome	190:3132b7dfad82	1286	fill_t RA8875::SetTextFontFill(fill_t fillit)
WiredHome	190:3132b7dfad82	1287	{
WiredHome	190:3132b7dfad82	1288	fill_t prevFill = FILL;
WiredHome	198:9b6851107426	1289	uint8_t fncr1Val = ReadCommand(RA8875_FNCR1);
WiredHome	190:3132b7dfad82	1290
WiredHome	190:3132b7dfad82	1291	if (fncr1Val & 0x40)
WiredHome	190:3132b7dfad82	1292	prevFill = NOFILL;
WiredHome	190:3132b7dfad82	1293	fncr1Val &= ~0x40;
WiredHome	190:3132b7dfad82	1294	if (fillit == NOFILL)
WiredHome	190:3132b7dfad82	1295	fncr1Val \|= 0x40;
WiredHome	190:3132b7dfad82	1296	WriteCommand(RA8875_FNCR1, fncr1Val);
WiredHome	190:3132b7dfad82	1297	return prevFill;
WiredHome	190:3132b7dfad82	1298	}
WiredHome	44:207594dece70	1299
WiredHome	19:3f82c1161fd2	1300	RetCode_t RA8875::SetTextFontSize(RA8875::HorizontalScale hScale, RA8875::VerticalScale vScale)
WiredHome	19:3f82c1161fd2	1301	{
WiredHome	198:9b6851107426	1302	unsigned char reg = ReadCommand(RA8875_FNCR1);
WiredHome	73:f22a18707b5e	1303
WiredHome	40:04aa280dfa39	1304	if (vScale == -1)
WiredHome	40:04aa280dfa39	1305	vScale = hScale;
WiredHome	19:3f82c1161fd2	1306	if (hScale >= 1 && hScale <= 4 && vScale >= 1 && vScale <= 4) {
WiredHome	198:9b6851107426	1307	fontScaleX = hScale; // save for use with a Soft Font
WiredHome	153:8a85efb3eb71	1308	fontScaleY = vScale;
WiredHome	198:9b6851107426	1309	reg &= 0xF0; // keep the high nibble as is.
WiredHome	19:3f82c1161fd2	1310	reg \|= ((hScale - 1) << 2);
WiredHome	19:3f82c1161fd2	1311	reg \|= ((vScale - 1) << 0);
WiredHome	175:7be3a1fb7fc2	1312	WriteCommand(RA8875_FNCR1, reg);
WiredHome	19:3f82c1161fd2	1313	return noerror;
WiredHome	19:3f82c1161fd2	1314	} else {
WiredHome	19:3f82c1161fd2	1315	return bad_parameter;
WiredHome	19:3f82c1161fd2	1316	}
WiredHome	19:3f82c1161fd2	1317	}
WiredHome	19:3f82c1161fd2	1318
WiredHome	127:db7f2c704693	1319	RetCode_t RA8875::GetTextFontSize(RA8875::HorizontalScale * hScale, RA8875::VerticalScale * vScale)
WiredHome	127:db7f2c704693	1320	{
WiredHome	198:9b6851107426	1321	unsigned char reg = ReadCommand(RA8875_FNCR1);
WiredHome	127:db7f2c704693	1322
WiredHome	127:db7f2c704693	1323	if (hScale)
WiredHome	190:3132b7dfad82	1324	*hScale = 1 + ((reg >> 2) & 0x03);
WiredHome	127:db7f2c704693	1325	if (vScale)
WiredHome	190:3132b7dfad82	1326	*vScale = 1 + (reg & 0x03);
WiredHome	127:db7f2c704693	1327	return noerror;
WiredHome	127:db7f2c704693	1328	}
WiredHome	44:207594dece70	1329
WiredHome	190:3132b7dfad82	1330	dim_t RA8875::GetTextWidth(const char * text, bool charOnly)
WiredHome	190:3132b7dfad82	1331	{
WiredHome	190:3132b7dfad82	1332	if (font == NULL) {
WiredHome	190:3132b7dfad82	1333	if (charOnly)
WiredHome	198:9b6851107426	1334	return fontwidth();
WiredHome	190:3132b7dfad82	1335	else
WiredHome	198:9b6851107426	1336	return fontwidth() * strlen(text);
WiredHome	190:3132b7dfad82	1337	} else {
WiredHome	190:3132b7dfad82	1338	dim_t width = 0;
WiredHome	190:3132b7dfad82	1339
WiredHome	190:3132b7dfad82	1340	while (*text) {
WiredHome	190:3132b7dfad82	1341	dim_t cWidth;
WiredHome	190:3132b7dfad82	1342	if (getCharMetrics(*text, &cWidth, NULL))
WiredHome	190:3132b7dfad82	1343	width += cWidth;
WiredHome	190:3132b7dfad82	1344	if (charOnly)
WiredHome	190:3132b7dfad82	1345	break;
WiredHome	190:3132b7dfad82	1346	text++;
WiredHome	190:3132b7dfad82	1347	}
WiredHome	190:3132b7dfad82	1348	return width * fontScaleX;
WiredHome	190:3132b7dfad82	1349	}
WiredHome	190:3132b7dfad82	1350	}
WiredHome	190:3132b7dfad82	1351
WiredHome	19:3f82c1161fd2	1352	int RA8875::_putc(int c)
WiredHome	19:3f82c1161fd2	1353	{
WiredHome	29:422616aa04bd	1354	if (font == NULL) {
WiredHome	29:422616aa04bd	1355	return _internal_putc(c);
WiredHome	29:422616aa04bd	1356	} else {
WiredHome	29:422616aa04bd	1357	return _external_putc(c);
WiredHome	29:422616aa04bd	1358	}
WiredHome	29:422616aa04bd	1359	}
WiredHome	29:422616aa04bd	1360
WiredHome	194:53c18f0e7922	1361
WiredHome	194:53c18f0e7922	1362
WiredHome	101:e0aad446094a	1363	// Questions to ponder -
WiredHome	101:e0aad446094a	1364	// - if we choose to wrap to the next line, because the character won't fit on the current line,
WiredHome	101:e0aad446094a	1365	// should it erase the space to the width of the screen (in case there is leftover junk there)?
WiredHome	101:e0aad446094a	1366	// - it currently wraps from the bottom of the screen back to the top. I have pondered what
WiredHome	101:e0aad446094a	1367	// it might take to scroll the screen - but haven't thought hard enough about it.
WiredHome	101:e0aad446094a	1368	//
WiredHome	29:422616aa04bd	1369	int RA8875::_external_putc(int c)
WiredHome	29:422616aa04bd	1370	{
WiredHome	19:3f82c1161fd2	1371	if (c) {
WiredHome	19:3f82c1161fd2	1372	if (c == '\r') {
WiredHome	111:efe436c43aba	1373	cursor_x = windowrect.p1.x;
WiredHome	29:422616aa04bd	1374	} else if (c == '\n') {
WiredHome	98:ecebed9b80b2	1375	cursor_y += extFontHeight;
WiredHome	29:422616aa04bd	1376	} else {
WiredHome	109:7b94f06f085b	1377	dim_t charWidth, charHeight;
WiredHome	198:9b6851107426	1378	const uint8_t * charRecord = getCharMetrics(c, &charWidth, &charHeight);
WiredHome	101:e0aad446094a	1379	if (charRecord) {
WiredHome	101:e0aad446094a	1380	//cursor_x += advance;
WiredHome	111:efe436c43aba	1381	if (cursor_x + charWidth >= windowrect.p2.x) {
WiredHome	111:efe436c43aba	1382	cursor_x = windowrect.p1.x;
WiredHome	101:e0aad446094a	1383	cursor_y += charHeight;
WiredHome	29:422616aa04bd	1384	}
WiredHome	111:efe436c43aba	1385	if (cursor_y + charHeight >= windowrect.p2.y) {
WiredHome	111:efe436c43aba	1386	cursor_y = windowrect.p1.y; // @todo Should it scroll?
WiredHome	101:e0aad446094a	1387	}
WiredHome	101:e0aad446094a	1388	(void)character(cursor_x, cursor_y, c);
WiredHome	153:8a85efb3eb71	1389	cursor_x += charWidth * fontScaleX;
WiredHome	29:422616aa04bd	1390	}
WiredHome	29:422616aa04bd	1391	}
WiredHome	29:422616aa04bd	1392	}
WiredHome	29:422616aa04bd	1393	return c;
WiredHome	29:422616aa04bd	1394	}
WiredHome	29:422616aa04bd	1395
WiredHome	44:207594dece70	1396
WiredHome	29:422616aa04bd	1397	int RA8875::_internal_putc(int c)
WiredHome	29:422616aa04bd	1398	{
WiredHome	29:422616aa04bd	1399	if (c) {
WiredHome	198:9b6851107426	1400	unsigned char mwcr0 = ReadCommand(RA8875_MWCR0);
WiredHome	194:53c18f0e7922	1401	if ((mwcr0 & 0x80) == 0x00)
WiredHome	175:7be3a1fb7fc2	1402	WriteCommand(RA8875_MWCR0, 0x80 \| mwcr0); // Put in Text mode if not already
WiredHome	198:9b6851107426	1403	if (c == '\r' \|\| c == '\n') {
WiredHome	198:9b6851107426	1404	point_t cur = GetTextCursor();
WiredHome	198:9b6851107426	1405	if (c == '\r') {
WiredHome	198:9b6851107426	1406	cur.x = windowrect.p1.x;
WiredHome	198:9b6851107426	1407	} else if (c == '\n') {
WiredHome	198:9b6851107426	1408	cur.y += fontheight();
WiredHome	198:9b6851107426	1409	if (cur.y >= windowrect.p2.y) // @TODO after bottom of active window, then scroll window?
WiredHome	198:9b6851107426	1410	cur.y = windowrect.p1.y;
WiredHome	198:9b6851107426	1411	}
WiredHome	198:9b6851107426	1412	SetTextCursor(cur);
WiredHome	19:3f82c1161fd2	1413	} else {
WiredHome	175:7be3a1fb7fc2	1414	WriteCommand(RA8875_MRWC); // RA8875 Internal Fonts
WiredHome	79:544eb4964795	1415	_select(true);
WiredHome	29:422616aa04bd	1416	WriteData(c);
WiredHome	66:468a11f05580	1417	_WaitWhileBusy(0x80);
WiredHome	79:544eb4964795	1418	_select(false);
WiredHome	19:3f82c1161fd2	1419	}
WiredHome	19:3f82c1161fd2	1420	}
WiredHome	19:3f82c1161fd2	1421	return c;
WiredHome	19:3f82c1161fd2	1422	}
WiredHome	19:3f82c1161fd2	1423
WiredHome	44:207594dece70	1424
WiredHome	32:0e4f2ae512e2	1425	RetCode_t RA8875::_StartGraphicsStream(void)
WiredHome	32:0e4f2ae512e2	1426	{
WiredHome	194:53c18f0e7922	1427	unsigned char mwcr0;
WiredHome	194:53c18f0e7922	1428
WiredHome	196:56820026701b	1429	mwcr0 = ReadCommand(RA8875_MWCR0) & ~0x80;
WiredHome	196:56820026701b	1430	mwcr0 \|= 0x00;
WiredHome	198:9b6851107426	1431	//INFO("_StartGraphicsStream mwcr0: %02X", mwcr0);
WiredHome	198:9b6851107426	1432	WriteCommand(RA8875_MWCR0, mwcr0); // Graphics write mode
WiredHome	198:9b6851107426	1433	WriteCommand(RA8875_MRWC); // Prepare for streaming data
WiredHome	32:0e4f2ae512e2	1434	return noerror;
WiredHome	32:0e4f2ae512e2	1435	}
WiredHome	32:0e4f2ae512e2	1436
WiredHome	44:207594dece70	1437
WiredHome	32:0e4f2ae512e2	1438	RetCode_t RA8875::_EndGraphicsStream(void)
WiredHome	32:0e4f2ae512e2	1439	{
WiredHome	32:0e4f2ae512e2	1440	return noerror;
WiredHome	32:0e4f2ae512e2	1441	}
WiredHome	32:0e4f2ae512e2	1442
WiredHome	44:207594dece70	1443
WiredHome	55:dfbabef7003e	1444	RetCode_t RA8875::_putp(color_t pixel)
WiredHome	32:0e4f2ae512e2	1445	{
WiredHome	38:38d503b4fad6	1446	WriteDataW((pixel>>8) \| (pixel<<8));
WiredHome	73:f22a18707b5e	1447	return noerror;
WiredHome	32:0e4f2ae512e2	1448	}
WiredHome	29:422616aa04bd	1449
WiredHome	44:207594dece70	1450
WiredHome	196:56820026701b	1451	void RA8875::puts(point_t pt, const char * string)
WiredHome	196:56820026701b	1452	{
WiredHome	196:56820026701b	1453	SetTextCursor(pt);
WiredHome	196:56820026701b	1454	puts(string);
WiredHome	196:56820026701b	1455	}
WiredHome	196:56820026701b	1456
WiredHome	37:f19b7e7449dc	1457	void RA8875::puts(loc_t x, loc_t y, const char * string)
WiredHome	19:3f82c1161fd2	1458	{
WiredHome	19:3f82c1161fd2	1459	SetTextCursor(x,y);
WiredHome	19:3f82c1161fd2	1460	puts(string);
WiredHome	19:3f82c1161fd2	1461	}
WiredHome	19:3f82c1161fd2	1462
WiredHome	44:207594dece70	1463
WiredHome	19:3f82c1161fd2	1464	void RA8875::puts(const char * string)
WiredHome	19:3f82c1161fd2	1465	{
WiredHome	198:9b6851107426	1466	INFO("puts len(%d), (%s)", strlen(string), string);
WiredHome	37:f19b7e7449dc	1467	if (font == NULL) {
WiredHome	198:9b6851107426	1468	unsigned char mwcr0 = ReadCommand(RA8875_MWCR0);
WiredHome	194:53c18f0e7922	1469	if ((mwcr0 & 0x80) == 0x00)
WiredHome	194:53c18f0e7922	1470	WriteCommand(RA8875_MWCR0, 0x80 \| mwcr0); // Put in Text mode if not already
WiredHome	37:f19b7e7449dc	1471	}
WiredHome	194:53c18f0e7922	1472	while (string && *string) { // @TODO calling individual _putc is slower... optimizations?
WiredHome	190:3132b7dfad82	1473	if (wordwrap) {
WiredHome	190:3132b7dfad82	1474	const char * p = string;
WiredHome	190:3132b7dfad82	1475	const char * pSpace = NULL;
WiredHome	190:3132b7dfad82	1476	dim_t txtPos;
WiredHome	190:3132b7dfad82	1477	bool newLineNeeded = false;
WiredHome	190:3132b7dfad82	1478
WiredHome	198:9b6851107426	1479	point_t cursor = GetTextCursor();
WiredHome	198:9b6851107426	1480	//INFO("cursor (%d,%d)", cursor.x, cursor.y);
WiredHome	190:3132b7dfad82	1481	txtPos = cursor.x;
WiredHome	198:9b6851107426	1482	INFO("(%d,%d) string: '%s'", cursor.x, cursor.y, string);
WiredHome	190:3132b7dfad82	1483	// find what fits in the window
WiredHome	190:3132b7dfad82	1484	do {
WiredHome	190:3132b7dfad82	1485	if (*p == ' ')
WiredHome	190:3132b7dfad82	1486	pSpace = p;
WiredHome	190:3132b7dfad82	1487	if (*p == '\r') {
WiredHome	190:3132b7dfad82	1488	pSpace = p;
WiredHome	190:3132b7dfad82	1489	break;
WiredHome	190:3132b7dfad82	1490	}
WiredHome	190:3132b7dfad82	1491	if (*p == '\n') {
WiredHome	190:3132b7dfad82	1492	break;
WiredHome	190:3132b7dfad82	1493	}
WiredHome	190:3132b7dfad82	1494	dim_t cWidth = GetTextWidth(p, true);
WiredHome	198:9b6851107426	1495	INFO("txtPos: %d, cWidth: %d, p2.x: %d", txtPos, cWidth, windowrect.p2.x);
WiredHome	190:3132b7dfad82	1496	if (txtPos + cWidth < windowrect.p2.x) {
WiredHome	190:3132b7dfad82	1497	txtPos += cWidth;
WiredHome	190:3132b7dfad82	1498	} else {
WiredHome	190:3132b7dfad82	1499	newLineNeeded = true;
WiredHome	190:3132b7dfad82	1500	break;
WiredHome	190:3132b7dfad82	1501	}
WiredHome	198:9b6851107426	1502	INFO("+ %c width %d, ttl Width %d < %d", *p, cWidth, txtPos, windowrect.p2.x);
WiredHome	190:3132b7dfad82	1503	p++;
WiredHome	190:3132b7dfad82	1504	} while (*p);
WiredHome	198:9b6851107426	1505	INFO("p: len(%d), (%s)", strlen(p), p);
WiredHome	190:3132b7dfad82	1506	if (*p != ' ' && pSpace) {
WiredHome	190:3132b7dfad82	1507	p = pSpace;
WiredHome	198:9b6851107426	1508	INFO("p: len(%d), (%s)", strlen(p), p);
WiredHome	190:3132b7dfad82	1509	}
WiredHome	198:9b6851107426	1510	char dbgBuf[256];
WiredHome	198:9b6851107426	1511	strncpy(dbgBuf, string, (p - string));
WiredHome	198:9b6851107426	1512	dbgBuf[p - string] = '\0';
WiredHome	198:9b6851107426	1513	INFO("chunk: %d < w.p2.x: %d - '%s'", txtPos, windowrect.p2.x, dbgBuf);
WiredHome	190:3132b7dfad82	1514	if (txtPos < windowrect.p2.x) {
WiredHome	190:3132b7dfad82	1515	while (*string && string <= p) {
WiredHome	198:9b6851107426	1516	INFO("string %02X", string);
WiredHome	198:9b6851107426	1517	if (*string == '\r') {
WiredHome	198:9b6851107426	1518	cursor = GetTextCursor();
WiredHome	198:9b6851107426	1519	SetTextCursor(windowrect.p1.x, cursor.y);
WiredHome	198:9b6851107426	1520	} else if (*string == '\n') {
WiredHome	198:9b6851107426	1521	cursor = GetTextCursor();
WiredHome	198:9b6851107426	1522	SetTextCursor(cursor.x, cursor.y + fontheight());
WiredHome	198:9b6851107426	1523	} else {
WiredHome	198:9b6851107426	1524	INFO("cursor (%d,%d) - %c", cursor.x, cursor.y, *string);
WiredHome	198:9b6851107426	1525	_putc(*string);
WiredHome	198:9b6851107426	1526	}
WiredHome	198:9b6851107426	1527	string++;
WiredHome	190:3132b7dfad82	1528	}
WiredHome	190:3132b7dfad82	1529	}
WiredHome	190:3132b7dfad82	1530	while (*string == ' ')
WiredHome	190:3132b7dfad82	1531	string++;
WiredHome	190:3132b7dfad82	1532	if (newLineNeeded) {
WiredHome	190:3132b7dfad82	1533	cursor.y += fontheight();
WiredHome	190:3132b7dfad82	1534	SetTextCursor(cursor);
WiredHome	190:3132b7dfad82	1535	INFO("\r\n");
WiredHome	190:3132b7dfad82	1536	}
WiredHome	190:3132b7dfad82	1537	INFO("### '%s'\r\n\r\n", string);
WiredHome	190:3132b7dfad82	1538	// if != ' ', find ' ', accumulating width along the way
WiredHome	190:3132b7dfad82	1539	// if the width fits, print the chars
WiredHome	190:3132b7dfad82	1540	} else {
WiredHome	19:3f82c1161fd2	1541	_putc(*string++);
WiredHome	19:3f82c1161fd2	1542	}
WiredHome	19:3f82c1161fd2	1543	}
WiredHome	198:9b6851107426	1544	//point_t cursor = GetTextCursor();
WiredHome	198:9b6851107426	1545	//INFO("cursor (%d,%d)", cursor.x, cursor.y);
WiredHome	19:3f82c1161fd2	1546	}
WiredHome	19:3f82c1161fd2	1547
WiredHome	44:207594dece70	1548
WiredHome	37:f19b7e7449dc	1549	RetCode_t RA8875::SetGraphicsCursor(loc_t x, loc_t y)
WiredHome	19:3f82c1161fd2	1550	{
WiredHome	198:9b6851107426	1551	switch (screen_orientation) {
WiredHome	198:9b6851107426	1552	case rotate_0:
WiredHome	198:9b6851107426	1553	case rotate_180:
WiredHome	198:9b6851107426	1554	WriteCommandW(RA8875_CURH0, x);
WiredHome	198:9b6851107426	1555	WriteCommandW(RA8875_CURV0, y);
WiredHome	198:9b6851107426	1556	break;
WiredHome	198:9b6851107426	1557	case rotate_90:
WiredHome	198:9b6851107426	1558	case rotate_270:
WiredHome	198:9b6851107426	1559	WriteCommandW(RA8875_CURH0, y);
WiredHome	198:9b6851107426	1560	WriteCommandW(RA8875_CURV0, x);
WiredHome	198:9b6851107426	1561	break;
WiredHome	198:9b6851107426	1562	case invalid:
WiredHome	198:9b6851107426	1563	return bad_parameter;
WiredHome	198:9b6851107426	1564	}
WiredHome	19:3f82c1161fd2	1565	return noerror;
WiredHome	19:3f82c1161fd2	1566	}
WiredHome	19:3f82c1161fd2	1567
WiredHome	136:224e03d5c31f	1568	RetCode_t RA8875::SetGraphicsCursor(point_t p)
WiredHome	136:224e03d5c31f	1569	{
WiredHome	136:224e03d5c31f	1570	return SetGraphicsCursor(p.x, p.y);
WiredHome	136:224e03d5c31f	1571	}
WiredHome	136:224e03d5c31f	1572
WiredHome	136:224e03d5c31f	1573	point_t RA8875::GetGraphicsCursor(void)
WiredHome	136:224e03d5c31f	1574	{
WiredHome	136:224e03d5c31f	1575	point_t p;
WiredHome	190:3132b7dfad82	1576
WiredHome	198:9b6851107426	1577	switch (screen_orientation) {
WiredHome	198:9b6851107426	1578	case rotate_0:
WiredHome	198:9b6851107426	1579	case rotate_180:
WiredHome	198:9b6851107426	1580	p.x = ReadCommandW(RA8875_CURH0);
WiredHome	198:9b6851107426	1581	p.y = ReadCommandW(RA8875_CURV0);
WiredHome	198:9b6851107426	1582	break;
WiredHome	198:9b6851107426	1583	case rotate_90:
WiredHome	198:9b6851107426	1584	case rotate_270:
WiredHome	198:9b6851107426	1585	p.y = ReadCommandW(RA8875_CURH0);
WiredHome	198:9b6851107426	1586	p.x = ReadCommandW(RA8875_CURV0);
WiredHome	198:9b6851107426	1587	break;
WiredHome	198:9b6851107426	1588	case invalid:
WiredHome	198:9b6851107426	1589	p.x = p.y = 0;
WiredHome	198:9b6851107426	1590	break;
WiredHome	198:9b6851107426	1591	}
WiredHome	136:224e03d5c31f	1592	return p;
WiredHome	136:224e03d5c31f	1593	}
WiredHome	44:207594dece70	1594
WiredHome	41:2956a0a221e5	1595	RetCode_t RA8875::SetGraphicsCursorRead(loc_t x, loc_t y)
WiredHome	41:2956a0a221e5	1596	{
WiredHome	198:9b6851107426	1597	switch (screen_orientation) {
WiredHome	198:9b6851107426	1598	case rotate_0:
WiredHome	198:9b6851107426	1599	case rotate_180:
WiredHome	198:9b6851107426	1600	WriteCommandW(RA8875_RCURH0, x);
WiredHome	198:9b6851107426	1601	WriteCommandW(RA8875_RCURV0, y);
WiredHome	198:9b6851107426	1602	break;
WiredHome	198:9b6851107426	1603	case rotate_90:
WiredHome	198:9b6851107426	1604	case rotate_270:
WiredHome	198:9b6851107426	1605	WriteCommandW(RA8875_RCURH0, y);
WiredHome	198:9b6851107426	1606	WriteCommandW(RA8875_RCURV0, x);
WiredHome	198:9b6851107426	1607	break;
WiredHome	198:9b6851107426	1608	case invalid:
WiredHome	198:9b6851107426	1609	return bad_parameter;
WiredHome	198:9b6851107426	1610	}
WiredHome	41:2956a0a221e5	1611	return noerror;
WiredHome	41:2956a0a221e5	1612	}
WiredHome	41:2956a0a221e5	1613
WiredHome	198:9b6851107426	1614
WiredHome	198:9b6851107426	1615	rect_t RA8875::GetWindow() {
WiredHome	198:9b6851107426	1616	return windowrect;
WiredHome	198:9b6851107426	1617	}
WiredHome	198:9b6851107426	1618
WiredHome	198:9b6851107426	1619	rect_t RA8875::SetWindow(rect_t r)
WiredHome	111:efe436c43aba	1620	{
WiredHome	198:9b6851107426	1621	return SetWindow(r.p1.x, r.p1.y, r.p2.x, r.p2.y);
WiredHome	111:efe436c43aba	1622	}
WiredHome	44:207594dece70	1623
WiredHome	198:9b6851107426	1624	rect_t RA8875::SetWindow(loc_t x1, loc_t y1, loc_t x2, loc_t y2)
WiredHome	19:3f82c1161fd2	1625	{
WiredHome	198:9b6851107426	1626	const rect_t nullRect = { 0,0,0,0 }; // in case it is invalid
WiredHome	198:9b6851107426	1627	rect_t oldWin = windowrect;
WiredHome	198:9b6851107426	1628	dim_t tempWidth, tempHeight;
WiredHome	198:9b6851107426	1629	//INFO("SetWindow(%d,%d)-(%d,%d)", x1,y1, x2,y2);
WiredHome	198:9b6851107426	1630	// Correct the initial values (0,-1) - (0,-1)
WiredHome	198:9b6851107426	1631	if (x2 == (loc_t)-1) x2 = virt_screenwidth - 1;
WiredHome	198:9b6851107426	1632	if (y2 == (loc_t)-1) y2 = virt_screenheight - 1;
WiredHome	198:9b6851107426	1633	// Sanity check the parameters.
WiredHome	198:9b6851107426	1634	if (x1 < 0 \|\| y1 < 0 \|\| x2 < 0 \|\| y2 < 0
WiredHome	198:9b6851107426	1635	\|\| x1 >= virt_screenwidth \|\| y1 >= virt_screenheight
WiredHome	198:9b6851107426	1636	\|\| x2 >= virt_screenwidth \|\| y2 >= virt_screenheight) {
WiredHome	198:9b6851107426	1637	return nullRect;
WiredHome	198:9b6851107426	1638	}
WiredHome	198:9b6851107426	1639	windowrect.p1.x = x1;
WiredHome	198:9b6851107426	1640	windowrect.p1.y = y1;
WiredHome	198:9b6851107426	1641	windowrect.p2.x = x2;
WiredHome	198:9b6851107426	1642	windowrect.p2.y = y2;
WiredHome	198:9b6851107426	1643	switch (screen_orientation) {
WiredHome	198:9b6851107426	1644	case rotate_0:
WiredHome	198:9b6851107426	1645	case rotate_180:
WiredHome	198:9b6851107426	1646	tempWidth = max(virt_screenwidth, virt_screenheight);
WiredHome	198:9b6851107426	1647	tempHeight = min(virt_screenwidth, virt_screenheight);
WiredHome	198:9b6851107426	1648	virt_screenwidth = tempWidth;
WiredHome	198:9b6851107426	1649	virt_screenheight = tempHeight;
WiredHome	198:9b6851107426	1650	//GraphicsDisplay::SetWindow(x1, y1, x2, y2);
WiredHome	198:9b6851107426	1651	WriteCommandW(RA8875_HSAW0, x1);
WiredHome	198:9b6851107426	1652	WriteCommandW(RA8875_VSAW0, y1);
WiredHome	198:9b6851107426	1653	WriteCommandW(RA8875_HEAW0, x2);
WiredHome	198:9b6851107426	1654	WriteCommandW(RA8875_VEAW0, y2);
WiredHome	198:9b6851107426	1655	break;
WiredHome	198:9b6851107426	1656	case rotate_90:
WiredHome	198:9b6851107426	1657	case rotate_270:
WiredHome	198:9b6851107426	1658	tempWidth = min(virt_screenwidth, virt_screenheight);
WiredHome	198:9b6851107426	1659	tempHeight = max(virt_screenwidth, virt_screenheight);
WiredHome	198:9b6851107426	1660	virt_screenwidth = tempWidth;
WiredHome	198:9b6851107426	1661	virt_screenheight = tempHeight;
WiredHome	198:9b6851107426	1662	//GraphicsDisplay::SetWindow(x1, y1, x2, y2);
WiredHome	198:9b6851107426	1663	WriteCommandW(RA8875_HSAW0, y1);
WiredHome	198:9b6851107426	1664	WriteCommandW(RA8875_VSAW0, x1);
WiredHome	198:9b6851107426	1665	WriteCommandW(RA8875_HEAW0, y2);
WiredHome	198:9b6851107426	1666	WriteCommandW(RA8875_VEAW0, x2);
WiredHome	198:9b6851107426	1667	break;
WiredHome	198:9b6851107426	1668	case invalid:
WiredHome	198:9b6851107426	1669	break;
WiredHome	198:9b6851107426	1670	}
WiredHome	198:9b6851107426	1671	return oldWin;
WiredHome	19:3f82c1161fd2	1672	}
WiredHome	19:3f82c1161fd2	1673
WiredHome	61:8f3153bf0baa	1674	RetCode_t RA8875::cls(uint16_t layers)
WiredHome	19:3f82c1161fd2	1675	{
WiredHome	198:9b6851107426	1676	RetCode_t ret = noerror;
WiredHome	198:9b6851107426	1677
WiredHome	198:9b6851107426	1678	INFO("cls(%d)", layers);
WiredHome	19:3f82c1161fd2	1679	PERFORMANCE_RESET;
WiredHome	61:8f3153bf0baa	1680	if (layers == 0) {
WiredHome	61:8f3153bf0baa	1681	ret = clsw(FULLWINDOW);
WiredHome	61:8f3153bf0baa	1682	} else if (layers > 3) {
WiredHome	61:8f3153bf0baa	1683	ret = bad_parameter;
WiredHome	61:8f3153bf0baa	1684	} else {
WiredHome	61:8f3153bf0baa	1685	uint16_t prevLayer = GetDrawingLayer();
WiredHome	61:8f3153bf0baa	1686	if (layers & 1) {
WiredHome	61:8f3153bf0baa	1687	SelectDrawingLayer(0);
WiredHome	61:8f3153bf0baa	1688	clsw(FULLWINDOW);
WiredHome	61:8f3153bf0baa	1689	}
WiredHome	61:8f3153bf0baa	1690	if (layers & 2) {
WiredHome	61:8f3153bf0baa	1691	SelectDrawingLayer(1);
WiredHome	61:8f3153bf0baa	1692	clsw(FULLWINDOW);
WiredHome	61:8f3153bf0baa	1693	}
WiredHome	142:6e9bff59878a	1694	SelectDrawingLayer(prevLayer);
WiredHome	61:8f3153bf0baa	1695	}
WiredHome	198:9b6851107426	1696	SetTextCursor(0,0);
WiredHome	178:ae472eb22740	1697	//ret = locate(0,0);
WiredHome	19:3f82c1161fd2	1698	REGISTERPERFORMANCE(PRF_CLS);
WiredHome	61:8f3153bf0baa	1699	return ret;
WiredHome	19:3f82c1161fd2	1700	}
WiredHome	19:3f82c1161fd2	1701
WiredHome	44:207594dece70	1702
WiredHome	19:3f82c1161fd2	1703	RetCode_t RA8875::clsw(RA8875::Region_t region)
WiredHome	19:3f82c1161fd2	1704	{
WiredHome	195:17e176dbd6eb	1705	INFO("clsw(%d)", region);
WiredHome	19:3f82c1161fd2	1706	PERFORMANCE_RESET;
WiredHome	175:7be3a1fb7fc2	1707	WriteCommand(RA8875_MCLR, (region == ACTIVEWINDOW) ? 0xC0 : 0x80);
WiredHome	198:9b6851107426	1708	if (!_WaitWhileReg(RA8875_MCLR, 0x80)) {
WiredHome	198:9b6851107426	1709	WriteCommand(RA8875_MCLR, 0x00); // Abort clearing on request
WiredHome	131:5bd6ba2ee4a1	1710	REGISTERPERFORMANCE(PRF_CLS);
WiredHome	131:5bd6ba2ee4a1	1711	return external_abort;
WiredHome	131:5bd6ba2ee4a1	1712	}
WiredHome	19:3f82c1161fd2	1713	REGISTERPERFORMANCE(PRF_CLS);
WiredHome	19:3f82c1161fd2	1714	return noerror;
WiredHome	19:3f82c1161fd2	1715	}
WiredHome	19:3f82c1161fd2	1716
WiredHome	44:207594dece70	1717
WiredHome	87:ee2240581aa7	1718	RetCode_t RA8875::pixel(point_t p, color_t color)
WiredHome	87:ee2240581aa7	1719	{
WiredHome	87:ee2240581aa7	1720	return pixel(p.x, p.y, color);
WiredHome	87:ee2240581aa7	1721	}
WiredHome	87:ee2240581aa7	1722
WiredHome	87:ee2240581aa7	1723	RetCode_t RA8875::pixel(point_t p)
WiredHome	87:ee2240581aa7	1724	{
WiredHome	87:ee2240581aa7	1725	return pixel(p.x, p.y);
WiredHome	87:ee2240581aa7	1726	}
WiredHome	87:ee2240581aa7	1727
WiredHome	37:f19b7e7449dc	1728	RetCode_t RA8875::pixel(loc_t x, loc_t y, color_t color)
WiredHome	19:3f82c1161fd2	1729	{
WiredHome	62:ba5d33438fda	1730	RetCode_t ret;
WiredHome	73:f22a18707b5e	1731
WiredHome	62:ba5d33438fda	1732	PERFORMANCE_RESET;
WiredHome	62:ba5d33438fda	1733	ret = pixelStream(&color, 1, x,y);
WiredHome	62:ba5d33438fda	1734	REGISTERPERFORMANCE(PRF_DRAWPIXEL);
WiredHome	62:ba5d33438fda	1735	return ret;
WiredHome	19:3f82c1161fd2	1736	}
WiredHome	19:3f82c1161fd2	1737
WiredHome	44:207594dece70	1738
WiredHome	37:f19b7e7449dc	1739	RetCode_t RA8875::pixel(loc_t x, loc_t y)
WiredHome	19:3f82c1161fd2	1740	{
WiredHome	19:3f82c1161fd2	1741	RetCode_t ret;
WiredHome	73:f22a18707b5e	1742
WiredHome	19:3f82c1161fd2	1743	PERFORMANCE_RESET;
WiredHome	19:3f82c1161fd2	1744	color_t color = GetForeColor();
WiredHome	62:ba5d33438fda	1745	ret = pixelStream(&color, 1, x, y);
WiredHome	41:2956a0a221e5	1746	REGISTERPERFORMANCE(PRF_DRAWPIXEL);
WiredHome	19:3f82c1161fd2	1747	return ret;
WiredHome	19:3f82c1161fd2	1748	}
WiredHome	19:3f82c1161fd2	1749
WiredHome	44:207594dece70	1750
WiredHome	41:2956a0a221e5	1751	RetCode_t RA8875::pixelStream(color_t * p, uint32_t count, loc_t x, loc_t y)
WiredHome	41:2956a0a221e5	1752	{
WiredHome	41:2956a0a221e5	1753	PERFORMANCE_RESET;
WiredHome	41:2956a0a221e5	1754	SetGraphicsCursor(x, y);
WiredHome	109:7b94f06f085b	1755	_StartGraphicsStream();
WiredHome	79:544eb4964795	1756	_select(true);
WiredHome	79:544eb4964795	1757	_spiwrite(0x00); // Cmd: write data
WiredHome	41:2956a0a221e5	1758	while (count--) {
WiredHome	105:4f116006ba1f	1759	if (screenbpp == 16) {
WiredHome	105:4f116006ba1f	1760	_spiwrite(*p >> 8);
WiredHome	105:4f116006ba1f	1761	_spiwrite(*p & 0xFF);
WiredHome	105:4f116006ba1f	1762	} else {
WiredHome	105:4f116006ba1f	1763	_spiwrite(_cvt16to8(*p));
WiredHome	105:4f116006ba1f	1764	}
WiredHome	41:2956a0a221e5	1765	p++;
WiredHome	41:2956a0a221e5	1766	}
WiredHome	79:544eb4964795	1767	_select(false);
WiredHome	109:7b94f06f085b	1768	_EndGraphicsStream();
WiredHome	41:2956a0a221e5	1769	REGISTERPERFORMANCE(PRF_PIXELSTREAM);
WiredHome	41:2956a0a221e5	1770	return(noerror);
WiredHome	41:2956a0a221e5	1771	}
WiredHome	41:2956a0a221e5	1772
WiredHome	153:8a85efb3eb71	1773	// With a font scale X = 1, a pixel stream is "abcdefg..."
WiredHome	153:8a85efb3eb71	1774	// With a font scale X = 2, a pixel stream is "aabbccddeeffgg..."
WiredHome	153:8a85efb3eb71	1775	// With a font scale Y = 2, a pixel stream is "abcdefg..."
WiredHome	153:8a85efb3eb71	1776	// "abcdefg..."
WiredHome	153:8a85efb3eb71	1777	//
WiredHome	190:3132b7dfad82	1778	RetCode_t RA8875::booleanStream(loc_t x, loc_t y, dim_t w, dim_t h, const uint8_t * boolStream)
WiredHome	109:7b94f06f085b	1779	{
WiredHome	109:7b94f06f085b	1780	PERFORMANCE_RESET;
WiredHome	190:3132b7dfad82	1781	const uint8_t * rowStream = boolStream;
WiredHome	198:9b6851107426	1782	rect_t restore = SetWindow(x, y, x + w * fontScaleX - 1, y + h * fontScaleY - 1);
WiredHome	109:7b94f06f085b	1783	SetGraphicsCursor(x, y);
WiredHome	109:7b94f06f085b	1784	_StartGraphicsStream();
WiredHome	109:7b94f06f085b	1785	_select(true);
WiredHome	109:7b94f06f085b	1786	_spiwrite(0x00); // Cmd: write data
WiredHome	109:7b94f06f085b	1787	while (h--) {
WiredHome	153:8a85efb3eb71	1788	for (int dy=0; dy<fontScaleY; dy++) { // Vertical Font Scale Factor
WiredHome	153:8a85efb3eb71	1789	uint8_t pixels = w;
WiredHome	153:8a85efb3eb71	1790	uint8_t bitmask = 0x01;
WiredHome	190:3132b7dfad82	1791	rowStream = boolStream;
WiredHome	153:8a85efb3eb71	1792	while (pixels) {
WiredHome	153:8a85efb3eb71	1793	uint8_t byte = *rowStream;
WiredHome	153:8a85efb3eb71	1794	//INFO("byte, mask: %02X, %02X", byte, bitmask);
WiredHome	153:8a85efb3eb71	1795	color_t c = (byte & bitmask) ? _foreground : _background;
WiredHome	190:3132b7dfad82	1796
WiredHome	153:8a85efb3eb71	1797	for (int dx=0; dx<fontScaleX; dx++) { // Horizontal Font Scale Factor
WiredHome	153:8a85efb3eb71	1798	if (screenbpp == 16) {
WiredHome	153:8a85efb3eb71	1799	_spiwrite(c >> 8);
WiredHome	153:8a85efb3eb71	1800	_spiwrite(c & 0xFF);
WiredHome	153:8a85efb3eb71	1801	} else {
WiredHome	153:8a85efb3eb71	1802	_spiwrite(_cvt16to8(c));
WiredHome	153:8a85efb3eb71	1803	}
WiredHome	109:7b94f06f085b	1804	}
WiredHome	153:8a85efb3eb71	1805	bitmask <<= 1;
WiredHome	153:8a85efb3eb71	1806	if (pixels > 1 && bitmask == 0) {
WiredHome	153:8a85efb3eb71	1807	bitmask = 0x01;
WiredHome	153:8a85efb3eb71	1808	rowStream++;
WiredHome	153:8a85efb3eb71	1809	}
WiredHome	153:8a85efb3eb71	1810	pixels--;
WiredHome	109:7b94f06f085b	1811	}
WiredHome	109:7b94f06f085b	1812	}
WiredHome	153:8a85efb3eb71	1813	boolStream += (rowStream - boolStream + 1);
WiredHome	109:7b94f06f085b	1814	}
WiredHome	109:7b94f06f085b	1815	_select(false);
WiredHome	109:7b94f06f085b	1816	_EndGraphicsStream();
WiredHome	198:9b6851107426	1817	SetWindow(restore);
WiredHome	109:7b94f06f085b	1818	REGISTERPERFORMANCE(PRF_BOOLSTREAM);
WiredHome	109:7b94f06f085b	1819	return(noerror);
WiredHome	109:7b94f06f085b	1820	}
WiredHome	44:207594dece70	1821
WiredHome	41:2956a0a221e5	1822	color_t RA8875::getPixel(loc_t x, loc_t y)
WiredHome	41:2956a0a221e5	1823	{
WiredHome	41:2956a0a221e5	1824	color_t pixel;
WiredHome	194:53c18f0e7922	1825	unsigned char mwcr0;
WiredHome	73:f22a18707b5e	1826
WiredHome	41:2956a0a221e5	1827	PERFORMANCE_RESET;
WiredHome	194:53c18f0e7922	1828	mwcr0 = ReadCommand(RA8875_MWCR0);
WiredHome	194:53c18f0e7922	1829	if (mwcr0 & 0x80)
WiredHome	194:53c18f0e7922	1830	WriteCommand(RA8875_MWCR0, mwcr0 & ~0x80); // Graphics write mode
WiredHome	41:2956a0a221e5	1831	SetGraphicsCursorRead(x, y);
WiredHome	175:7be3a1fb7fc2	1832	WriteCommand(RA8875_MRWC);
WiredHome	79:544eb4964795	1833	_select(true);
WiredHome	79:544eb4964795	1834	_spiwrite(0x40); // Cmd: read data
WiredHome	79:544eb4964795	1835	_spiwrite(0x00); // dummy read
WiredHome	105:4f116006ba1f	1836	if (screenbpp == 16) {
WiredHome	105:4f116006ba1f	1837	pixel = _spiread();
WiredHome	105:4f116006ba1f	1838	pixel \|= (_spiread() << 8);
WiredHome	105:4f116006ba1f	1839	} else {
WiredHome	105:4f116006ba1f	1840	pixel = _cvt8to16(_spiread());
WiredHome	105:4f116006ba1f	1841	}
WiredHome	79:544eb4964795	1842	_select(false);
WiredHome	41:2956a0a221e5	1843	REGISTERPERFORMANCE(PRF_READPIXEL);
WiredHome	41:2956a0a221e5	1844	return pixel;
WiredHome	41:2956a0a221e5	1845	}
WiredHome	41:2956a0a221e5	1846
WiredHome	44:207594dece70	1847
WiredHome	41:2956a0a221e5	1848	RetCode_t RA8875::getPixelStream(color_t * p, uint32_t count, loc_t x, loc_t y)
WiredHome	41:2956a0a221e5	1849	{
WiredHome	41:2956a0a221e5	1850	color_t pixel;
WiredHome	194:53c18f0e7922	1851	unsigned char mwcr0;
WiredHome	86:e86b355940f4	1852	RetCode_t ret = noerror;
WiredHome	73:f22a18707b5e	1853
WiredHome	41:2956a0a221e5	1854	PERFORMANCE_RESET;
WiredHome	194:53c18f0e7922	1855	mwcr0 = ReadCommand(RA8875_MWCR0);
WiredHome	194:53c18f0e7922	1856	if (mwcr0 & 0x80)
WiredHome	194:53c18f0e7922	1857	WriteCommand(RA8875_MWCR0, mwcr0 & ~0x80); // Graphics write mode
WiredHome	86:e86b355940f4	1858	ret = SetGraphicsCursorRead(x, y);
WiredHome	175:7be3a1fb7fc2	1859	ret = WriteCommand(RA8875_MRWC);
WiredHome	79:544eb4964795	1860	_select(true);
WiredHome	79:544eb4964795	1861	_spiwrite(0x40); // Cmd: read data
WiredHome	79:544eb4964795	1862	_spiwrite(0x00); // dummy read
WiredHome	106:c80828f5dea4	1863	if (screenbpp == 16)
WiredHome	106:c80828f5dea4	1864	_spiwrite(0x00); // dummy read is only necessary when in 16-bit mode
WiredHome	41:2956a0a221e5	1865	while (count--) {
WiredHome	105:4f116006ba1f	1866	if (screenbpp == 16) {
WiredHome	105:4f116006ba1f	1867	pixel = _spiread();
WiredHome	105:4f116006ba1f	1868	pixel \|= (_spiread() << 8);
WiredHome	105:4f116006ba1f	1869	} else {
WiredHome	105:4f116006ba1f	1870	pixel = _cvt8to16(_spiread());
WiredHome	105:4f116006ba1f	1871	}
WiredHome	41:2956a0a221e5	1872	*p++ = pixel;
WiredHome	41:2956a0a221e5	1873	}
WiredHome	79:544eb4964795	1874	_select(false);
WiredHome	41:2956a0a221e5	1875	REGISTERPERFORMANCE(PRF_READPIXELSTREAM);
WiredHome	86:e86b355940f4	1876	return ret;
WiredHome	41:2956a0a221e5	1877	}
WiredHome	41:2956a0a221e5	1878
WiredHome	44:207594dece70	1879
WiredHome	83:7bad0068cca0	1880	RetCode_t RA8875::line(point_t p1, point_t p2)
WiredHome	83:7bad0068cca0	1881	{
WiredHome	83:7bad0068cca0	1882	return line(p1.x, p1.y, p2.x, p2.y);
WiredHome	83:7bad0068cca0	1883	}
WiredHome	83:7bad0068cca0	1884
WiredHome	83:7bad0068cca0	1885
WiredHome	83:7bad0068cca0	1886	RetCode_t RA8875::line(point_t p1, point_t p2, color_t color)
WiredHome	83:7bad0068cca0	1887	{
WiredHome	83:7bad0068cca0	1888	return line(p1.x, p1.y, p2.x, p2.y, color);
WiredHome	83:7bad0068cca0	1889	}
WiredHome	83:7bad0068cca0	1890
WiredHome	83:7bad0068cca0	1891
WiredHome	37:f19b7e7449dc	1892	RetCode_t RA8875::line(loc_t x1, loc_t y1, loc_t x2, loc_t y2, color_t color)
WiredHome	19:3f82c1161fd2	1893	{
WiredHome	19:3f82c1161fd2	1894	foreground(color);
WiredHome	19:3f82c1161fd2	1895	return line(x1,y1,x2,y2);
WiredHome	19:3f82c1161fd2	1896	}
WiredHome	19:3f82c1161fd2	1897
WiredHome	44:207594dece70	1898
WiredHome	37:f19b7e7449dc	1899	RetCode_t RA8875::line(loc_t x1, loc_t y1, loc_t x2, loc_t y2)
WiredHome	19:3f82c1161fd2	1900	{
WiredHome	19:3f82c1161fd2	1901	PERFORMANCE_RESET;
WiredHome	62:ba5d33438fda	1902	if (x1 == x2 && y1 == y2) {
WiredHome	198:9b6851107426	1903	switch (screen_orientation) {
WiredHome	198:9b6851107426	1904	case invalid:
WiredHome	198:9b6851107426	1905	return bad_parameter;
WiredHome	198:9b6851107426	1906	//break;
WiredHome	198:9b6851107426	1907	case rotate_0:
WiredHome	198:9b6851107426	1908	case rotate_180:
WiredHome	198:9b6851107426	1909	pixel(x1, y1);
WiredHome	198:9b6851107426	1910	break;
WiredHome	198:9b6851107426	1911	case rotate_90:
WiredHome	198:9b6851107426	1912	case rotate_270:
WiredHome	198:9b6851107426	1913	pixel(y1, x1);
WiredHome	198:9b6851107426	1914	break;
WiredHome	198:9b6851107426	1915	}
WiredHome	62:ba5d33438fda	1916	} else {
WiredHome	198:9b6851107426	1917	switch (screen_orientation) {
WiredHome	198:9b6851107426	1918	case invalid:
WiredHome	198:9b6851107426	1919	return bad_parameter;
WiredHome	198:9b6851107426	1920	//break;
WiredHome	198:9b6851107426	1921	case rotate_0:
WiredHome	198:9b6851107426	1922	case rotate_180:
WiredHome	198:9b6851107426	1923	WriteCommandW(RA8875_DLHSR0, x1);
WiredHome	198:9b6851107426	1924	WriteCommandW(RA8875_DLVSR0, y1);
WiredHome	198:9b6851107426	1925	WriteCommandW(RA8875_DLHER0, x2);
WiredHome	198:9b6851107426	1926	WriteCommandW(RA8875_DLVER0, y2);
WiredHome	198:9b6851107426	1927	break;
WiredHome	198:9b6851107426	1928	case rotate_90:
WiredHome	198:9b6851107426	1929	case rotate_270:
WiredHome	198:9b6851107426	1930	WriteCommandW(RA8875_DLHSR0, y1);
WiredHome	198:9b6851107426	1931	WriteCommandW(RA8875_DLVSR0, x1);
WiredHome	198:9b6851107426	1932	WriteCommandW(RA8875_DLHER0, y2);
WiredHome	198:9b6851107426	1933	WriteCommandW(RA8875_DLVER0, x2);
WiredHome	198:9b6851107426	1934	break;
WiredHome	198:9b6851107426	1935	}
WiredHome	60:2dfd574f63bd	1936	unsigned char drawCmd = 0x00; // Line
WiredHome	175:7be3a1fb7fc2	1937	WriteCommand(RA8875_DCR, drawCmd);
WiredHome	175:7be3a1fb7fc2	1938	WriteCommand(RA8875_DCR, 0x80 + drawCmd); // Start drawing.
WiredHome	131:5bd6ba2ee4a1	1939	if (!_WaitWhileReg(0x90, 0x80)) {
WiredHome	131:5bd6ba2ee4a1	1940	REGISTERPERFORMANCE(PRF_DRAWLINE);
WiredHome	131:5bd6ba2ee4a1	1941	return external_abort;
WiredHome	131:5bd6ba2ee4a1	1942	}
WiredHome	60:2dfd574f63bd	1943	}
WiredHome	19:3f82c1161fd2	1944	REGISTERPERFORMANCE(PRF_DRAWLINE);
WiredHome	19:3f82c1161fd2	1945	return noerror;
WiredHome	19:3f82c1161fd2	1946	}
WiredHome	19:3f82c1161fd2	1947
WiredHome	144:ba002c4b21b3	1948
WiredHome	144:ba002c4b21b3	1949	RetCode_t RA8875::ThickLine(point_t p1, point_t p2, dim_t thickness, color_t color)
WiredHome	144:ba002c4b21b3	1950	{
WiredHome	198:9b6851107426	1951	//INFO("ThickLine()");
WiredHome	144:ba002c4b21b3	1952	if (thickness == 1) {
WiredHome	144:ba002c4b21b3	1953	line(p1,p2, color);
WiredHome	144:ba002c4b21b3	1954	} else {
WiredHome	178:ae472eb22740	1955	if (p1.x == p2.x) {
WiredHome	178:ae472eb22740	1956	// vertical
WiredHome	190:3132b7dfad82	1957	if (roundCap) {
WiredHome	190:3132b7dfad82	1958	fillcircle(p1, thickness / 2, color);
WiredHome	190:3132b7dfad82	1959	fillcircle(p2, thickness / 2, color);
WiredHome	190:3132b7dfad82	1960	}
WiredHome	178:ae472eb22740	1961	fillrect(p1.x-thickness/2,p1.y, p2.x+thickness/2,p2.y, color);
WiredHome	178:ae472eb22740	1962	} else if (p1.y == p2.y) {
WiredHome	178:ae472eb22740	1963	// horizontal
WiredHome	190:3132b7dfad82	1964	if (roundCap) {
WiredHome	190:3132b7dfad82	1965	fillcircle(p1, thickness / 2, color);
WiredHome	190:3132b7dfad82	1966	fillcircle(p2, thickness / 2, color);
WiredHome	190:3132b7dfad82	1967	}
WiredHome	178:ae472eb22740	1968	fillrect(p1.x,p1.y-thickness/2, p2.x,p2.y+thickness/2, color);
WiredHome	178:ae472eb22740	1969	} else {
WiredHome	178:ae472eb22740	1970	// some diagonal, drawn rather slowly with filled circles
WiredHome	178:ae472eb22740	1971	// @todo draw the end-points with circles, then draw the diagonal
WiredHome	197:853d08e2fb53	1972	// with 2 triangles.
WiredHome	178:ae472eb22740	1973	//Round-caps
WiredHome	190:3132b7dfad82	1974	if (roundCap) {
WiredHome	190:3132b7dfad82	1975	fillcircle(p1, thickness / 2, color);
WiredHome	190:3132b7dfad82	1976	fillcircle(p2, thickness / 2, color);
WiredHome	190:3132b7dfad82	1977	}
WiredHome	178:ae472eb22740	1978	// Compute the perpendicular points to draw the triangles
WiredHome	178:ae472eb22740	1979	// + fillTriangle: p1a,p1b,p2a
WiredHome	178:ae472eb22740	1980	// / + p1a p1a,p2a,p2b
WiredHome	178:ae472eb22740	1981	// + +p1+ . . . . .
WiredHome	178:ae472eb22740	1982	// p1b + / . angle
WiredHome	197:853d08e2fb53	1983	// + .
WiredHome	178:ae472eb22740	1984	// .
WiredHome	178:ae472eb22740	1985	//
WiredHome	178:ae472eb22740	1986	// . +
WiredHome	178:ae472eb22740	1987	// / + p2a
WiredHome	178:ae472eb22740	1988	// + +p2+
WiredHome	178:ae472eb22740	1989	// p2b + /
WiredHome	178:ae472eb22740	1990	// +
WiredHome	178:ae472eb22740	1991	point_t pTri[4];
WiredHome	178:ae472eb22740	1992	float slope = (p2.y - p1.y) / (p2.x - p1.x);
WiredHome	178:ae472eb22740	1993	slope = -1/slope;
WiredHome	178:ae472eb22740	1994	//centerline
WiredHome	178:ae472eb22740	1995	//line(p1,p2,color);
WiredHome	190:3132b7dfad82	1996	float dx = (thickness/2 / sqrt(thickness/2 + (slope * slope)));
WiredHome	178:ae472eb22740	1997	float dy = slope * dx;
WiredHome	178:ae472eb22740	1998	pTri[0].x = p1.x + dx;
WiredHome	178:ae472eb22740	1999	pTri[0].y = p1.y + dy;
WiredHome	178:ae472eb22740	2000	pTri[1].x = p1.x - dx;
WiredHome	178:ae472eb22740	2001	pTri[1].y = p1.y - dy;
WiredHome	178:ae472eb22740	2002	pTri[2].x = p2.x + dx;
WiredHome	178:ae472eb22740	2003	pTri[2].y = p2.y + dy;
WiredHome	178:ae472eb22740	2004	pTri[3].x = p2.x - dx;
WiredHome	178:ae472eb22740	2005	pTri[3].y = p2.y - dy;
WiredHome	178:ae472eb22740	2006	filltriangle(pTri[0],pTri[1],pTri[3], color);
WiredHome	178:ae472eb22740	2007	filltriangle(pTri[0],pTri[2],pTri[3], color);
WiredHome	178:ae472eb22740	2008	}
WiredHome	144:ba002c4b21b3	2009	}
WiredHome	144:ba002c4b21b3	2010	return noerror;
WiredHome	144:ba002c4b21b3	2011	}
WiredHome	144:ba002c4b21b3	2012
WiredHome	144:ba002c4b21b3	2013
WiredHome	190:3132b7dfad82	2014	bool RA8875::SetEndCap(bool _roundCap) {
WiredHome	190:3132b7dfad82	2015	bool prevCap = roundCap;
WiredHome	190:3132b7dfad82	2016	roundCap = _roundCap;
WiredHome	190:3132b7dfad82	2017	return prevCap;
WiredHome	190:3132b7dfad82	2018	}
WiredHome	190:3132b7dfad82	2019
WiredHome	190:3132b7dfad82	2020
WiredHome	107:f9ccffcb84f1	2021	//
WiredHome	107:f9ccffcb84f1	2022	// Rectangle functions all mostly helpers to the basic rectangle function
WiredHome	107:f9ccffcb84f1	2023	//
WiredHome	107:f9ccffcb84f1	2024
WiredHome	81:01da2e34283d	2025	RetCode_t RA8875::fillrect(rect_t r, color_t color, fill_t fillit)
WiredHome	81:01da2e34283d	2026	{
WiredHome	81:01da2e34283d	2027	return rect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, color, fillit);
WiredHome	81:01da2e34283d	2028	}
WiredHome	44:207594dece70	2029
WiredHome	73:f22a18707b5e	2030	RetCode_t RA8875::fillrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	2031	color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	2032	{
WiredHome	19:3f82c1161fd2	2033	return rect(x1,y1,x2,y2,color,fillit);
WiredHome	19:3f82c1161fd2	2034	}
WiredHome	19:3f82c1161fd2	2035
WiredHome	81:01da2e34283d	2036	RetCode_t RA8875::rect(rect_t r, color_t color, fill_t fillit)
WiredHome	81:01da2e34283d	2037	{
WiredHome	81:01da2e34283d	2038	return rect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, color, fillit);
WiredHome	81:01da2e34283d	2039	}
WiredHome	44:207594dece70	2040
WiredHome	73:f22a18707b5e	2041	RetCode_t RA8875::rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	2042	color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	2043	{
WiredHome	19:3f82c1161fd2	2044	foreground(color);
WiredHome	19:3f82c1161fd2	2045	return rect(x1,y1,x2,y2,fillit);
WiredHome	19:3f82c1161fd2	2046	}
WiredHome	19:3f82c1161fd2	2047
WiredHome	73:f22a18707b5e	2048	RetCode_t RA8875::rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	2049	fill_t fillit)
WiredHome	19:3f82c1161fd2	2050	{
WiredHome	85:022bba13c5c4	2051	RetCode_t ret = noerror;
WiredHome	19:3f82c1161fd2	2052	PERFORMANCE_RESET;
WiredHome	85:022bba13c5c4	2053	// check for bad_parameter
WiredHome	198:9b6851107426	2054	if (x1 < 0 \|\| x1 >= virt_screenwidth \|\| x2 < 0 \|\| x2 >= virt_screenwidth
WiredHome	198:9b6851107426	2055	\|\| y1 < 0 \|\| y1 >= virt_screenheight \|\| y2 < 0 \|\| y2 >= virt_screenheight) {
WiredHome	85:022bba13c5c4	2056	ret = bad_parameter;
WiredHome	100:0b084475d5a9	2057	} else {
WiredHome	85:022bba13c5c4	2058	if (x1 == x2 && y1 == y2) {
WiredHome	85:022bba13c5c4	2059	pixel(x1, y1);
WiredHome	85:022bba13c5c4	2060	} else if (x1 == x2) {
WiredHome	85:022bba13c5c4	2061	line(x1, y1, x2, y2);
WiredHome	85:022bba13c5c4	2062	} else if (y1 == y2) {
WiredHome	85:022bba13c5c4	2063	line(x1, y1, x2, y2);
WiredHome	85:022bba13c5c4	2064	} else {
WiredHome	198:9b6851107426	2065	switch (screen_orientation) {
WiredHome	198:9b6851107426	2066	case rotate_0:
WiredHome	198:9b6851107426	2067	case rotate_180:
WiredHome	198:9b6851107426	2068	WriteCommandW(RA8875_DLHSR0, x1);
WiredHome	198:9b6851107426	2069	WriteCommandW(RA8875_DLVSR0, y1);
WiredHome	198:9b6851107426	2070	WriteCommandW(RA8875_DLHER0, x2);
WiredHome	198:9b6851107426	2071	WriteCommandW(RA8875_DLVER0, y2);
WiredHome	198:9b6851107426	2072	break;
WiredHome	198:9b6851107426	2073	case rotate_90:
WiredHome	198:9b6851107426	2074	case rotate_270:
WiredHome	198:9b6851107426	2075	WriteCommandW(RA8875_DLHSR0, y1);
WiredHome	198:9b6851107426	2076	WriteCommandW(RA8875_DLVSR0, x1);
WiredHome	198:9b6851107426	2077	WriteCommandW(RA8875_DLHER0, y2);
WiredHome	198:9b6851107426	2078	WriteCommandW(RA8875_DLVER0, x2);
WiredHome	198:9b6851107426	2079	break;
WiredHome	198:9b6851107426	2080	case invalid:
WiredHome	198:9b6851107426	2081	REGISTERPERFORMANCE(PRF_DRAWRECTANGLE);
WiredHome	198:9b6851107426	2082	ret = bad_parameter;
WiredHome	198:9b6851107426	2083	return ret;
WiredHome	198:9b6851107426	2084	//break;
WiredHome	198:9b6851107426	2085	}
WiredHome	85:022bba13c5c4	2086	unsigned char drawCmd = 0x10; // Rectangle
WiredHome	85:022bba13c5c4	2087	if (fillit == FILL)
WiredHome	85:022bba13c5c4	2088	drawCmd \|= 0x20;
WiredHome	175:7be3a1fb7fc2	2089	WriteCommand(RA8875_DCR, drawCmd);
WiredHome	175:7be3a1fb7fc2	2090	ret = WriteCommand(RA8875_DCR, 0x80 + drawCmd); // Start drawing.
WiredHome	131:5bd6ba2ee4a1	2091	if (!_WaitWhileReg(0x90, 0x80)) {
WiredHome	131:5bd6ba2ee4a1	2092	REGISTERPERFORMANCE(PRF_DRAWRECTANGLE);
WiredHome	131:5bd6ba2ee4a1	2093	return external_abort;
WiredHome	131:5bd6ba2ee4a1	2094	}
WiredHome	85:022bba13c5c4	2095	}
WiredHome	19:3f82c1161fd2	2096	}
WiredHome	19:3f82c1161fd2	2097	REGISTERPERFORMANCE(PRF_DRAWRECTANGLE);
WiredHome	85:022bba13c5c4	2098	return ret;
WiredHome	19:3f82c1161fd2	2099	}
WiredHome	19:3f82c1161fd2	2100
WiredHome	44:207594dece70	2101
WiredHome	107:f9ccffcb84f1	2102	//
WiredHome	107:f9ccffcb84f1	2103	// rounded rectangle functions are mostly helpers to the base round rect
WiredHome	107:f9ccffcb84f1	2104	//
WiredHome	107:f9ccffcb84f1	2105
WiredHome	107:f9ccffcb84f1	2106	RetCode_t RA8875::fillroundrect(rect_t r, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome	107:f9ccffcb84f1	2107	{
WiredHome	107:f9ccffcb84f1	2108	return roundrect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, radius1, radius2, color, fillit);
WiredHome	107:f9ccffcb84f1	2109	}
WiredHome	107:f9ccffcb84f1	2110
WiredHome	73:f22a18707b5e	2111	RetCode_t RA8875::fillroundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	2112	dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	2113	{
WiredHome	19:3f82c1161fd2	2114	foreground(color);
WiredHome	19:3f82c1161fd2	2115	return roundrect(x1,y1,x2,y2,radius1,radius2,fillit);
WiredHome	19:3f82c1161fd2	2116	}
WiredHome	19:3f82c1161fd2	2117
WiredHome	107:f9ccffcb84f1	2118	RetCode_t RA8875::roundrect(rect_t r, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome	107:f9ccffcb84f1	2119	{
WiredHome	107:f9ccffcb84f1	2120	return roundrect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, radius1, radius2, color, fillit);
WiredHome	107:f9ccffcb84f1	2121	}
WiredHome	44:207594dece70	2122
WiredHome	73:f22a18707b5e	2123	RetCode_t RA8875::roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	2124	dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	2125	{
WiredHome	19:3f82c1161fd2	2126	foreground(color);
WiredHome	19:3f82c1161fd2	2127	return roundrect(x1,y1,x2,y2,radius1,radius2,fillit);
WiredHome	19:3f82c1161fd2	2128	}
WiredHome	19:3f82c1161fd2	2129
WiredHome	44:207594dece70	2130
WiredHome	73:f22a18707b5e	2131	RetCode_t RA8875::roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	2132	dim_t radius1, dim_t radius2, fill_t fillit)
WiredHome	19:3f82c1161fd2	2133	{
WiredHome	19:3f82c1161fd2	2134	RetCode_t ret = noerror;
WiredHome	73:f22a18707b5e	2135
WiredHome	178:ae472eb22740	2136	INFO("roundrect()");
WiredHome	19:3f82c1161fd2	2137	PERFORMANCE_RESET;
WiredHome	198:9b6851107426	2138	if (x1 < 0 \|\| x1 >= virt_screenwidth \|\| x2 < 0 \|\| x2 >= virt_screenwidth
WiredHome	198:9b6851107426	2139	\|\| y1 < 0 \|\| y1 >= virt_screenheight \|\| y2 < 0 \|\| y2 >= virt_screenheight) {
WiredHome	85:022bba13c5c4	2140	ret = bad_parameter;
WiredHome	85:022bba13c5c4	2141	} else if (x1 > x2 \|\| y1 > y2 \|\| (radius1 > (x2-x1)/2) \|\| (radius2 > (y2-y1)/2) ) {
WiredHome	21:3c1efb192927	2142	ret = bad_parameter;
WiredHome	21:3c1efb192927	2143	} else if (x1 == x2 && y1 == y2) {
WiredHome	19:3f82c1161fd2	2144	pixel(x1, y1);
WiredHome	19:3f82c1161fd2	2145	} else if (x1 == x2) {
WiredHome	19:3f82c1161fd2	2146	line(x1, y1, x2, y2);
WiredHome	19:3f82c1161fd2	2147	} else if (y1 == y2) {
WiredHome	19:3f82c1161fd2	2148	line(x1, y1, x2, y2);
WiredHome	19:3f82c1161fd2	2149	} else {
WiredHome	198:9b6851107426	2150	switch (screen_orientation) {
WiredHome	198:9b6851107426	2151	case rotate_0:
WiredHome	198:9b6851107426	2152	case rotate_180:
WiredHome	198:9b6851107426	2153	WriteCommandW(RA8875_DLHSR0, x1);
WiredHome	198:9b6851107426	2154	WriteCommandW(RA8875_DLVSR0, y1);
WiredHome	198:9b6851107426	2155	WriteCommandW(RA8875_DLHER0, x2);
WiredHome	198:9b6851107426	2156	WriteCommandW(RA8875_DLVER0, y2);
WiredHome	198:9b6851107426	2157	WriteCommandW(RA8875_ELLA0, radius1);
WiredHome	198:9b6851107426	2158	WriteCommandW(RA8875_ELLB0, radius2);
WiredHome	198:9b6851107426	2159	break;
WiredHome	198:9b6851107426	2160	case rotate_90:
WiredHome	198:9b6851107426	2161	case rotate_270:
WiredHome	198:9b6851107426	2162	WriteCommandW(RA8875_DLHSR0, y1);
WiredHome	198:9b6851107426	2163	WriteCommandW(RA8875_DLVSR0, x1);
WiredHome	198:9b6851107426	2164	WriteCommandW(RA8875_DLHER0, y2);
WiredHome	198:9b6851107426	2165	WriteCommandW(RA8875_DLVER0, x2);
WiredHome	198:9b6851107426	2166	WriteCommandW(RA8875_ELLA0, radius2);
WiredHome	198:9b6851107426	2167	WriteCommandW(RA8875_ELLB0, radius1);
WiredHome	198:9b6851107426	2168	break;
WiredHome	198:9b6851107426	2169	case invalid:
WiredHome	198:9b6851107426	2170	REGISTERPERFORMANCE(PRF_DRAWROUNDEDRECTANGLE);
WiredHome	198:9b6851107426	2171	return bad_parameter;
WiredHome	198:9b6851107426	2172	//break;
WiredHome	198:9b6851107426	2173	}
WiredHome	21:3c1efb192927	2174	// Should not need this...
WiredHome	175:7be3a1fb7fc2	2175	WriteCommandW(RA8875_DEHR0, 0);
WiredHome	175:7be3a1fb7fc2	2176	WriteCommandW(RA8875_DEVR0, 0);
WiredHome	19:3f82c1161fd2	2177	unsigned char drawCmd = 0x20; // Rounded Rectangle
WiredHome	19:3f82c1161fd2	2178	if (fillit == FILL)
WiredHome	19:3f82c1161fd2	2179	drawCmd \|= 0x40;
WiredHome	175:7be3a1fb7fc2	2180	WriteCommand(RA8875_ELLIPSE, drawCmd);
WiredHome	175:7be3a1fb7fc2	2181	WriteCommand(RA8875_ELLIPSE, 0x80 + drawCmd); // Start drawing.
WiredHome	131:5bd6ba2ee4a1	2182	if (!_WaitWhileReg(0xA0, 0x80)) {
WiredHome	131:5bd6ba2ee4a1	2183	REGISTERPERFORMANCE(PRF_DRAWROUNDEDRECTANGLE);
WiredHome	131:5bd6ba2ee4a1	2184	return external_abort;
WiredHome	131:5bd6ba2ee4a1	2185	}
WiredHome	19:3f82c1161fd2	2186	}
WiredHome	19:3f82c1161fd2	2187	REGISTERPERFORMANCE(PRF_DRAWROUNDEDRECTANGLE);
WiredHome	19:3f82c1161fd2	2188	return ret;
WiredHome	19:3f82c1161fd2	2189	}
WiredHome	19:3f82c1161fd2	2190
WiredHome	44:207594dece70	2191
WiredHome	107:f9ccffcb84f1	2192	//
WiredHome	107:f9ccffcb84f1	2193	// triangle functions
WiredHome	107:f9ccffcb84f1	2194	//
WiredHome	178:ae472eb22740	2195	RetCode_t RA8875::filltriangle(point_t p1, point_t p2, point_t p3, color_t color, fill_t fillit)
WiredHome	178:ae472eb22740	2196	{
WiredHome	178:ae472eb22740	2197	return filltriangle(p1.x,p1.y, p2.x,p2.y, p3.x,p3.y, color, fillit);
WiredHome	178:ae472eb22740	2198	}
WiredHome	178:ae472eb22740	2199
WiredHome	178:ae472eb22740	2200	RetCode_t RA8875::triangle(point_t p1, point_t p2, point_t p3, color_t color, fill_t fillit)
WiredHome	178:ae472eb22740	2201	{
WiredHome	178:ae472eb22740	2202	return triangle(p1.x,p1.y, p2.x,p2.y, p3.x,p3.y, color, fillit);
WiredHome	178:ae472eb22740	2203	}
WiredHome	107:f9ccffcb84f1	2204
WiredHome	73:f22a18707b5e	2205	RetCode_t RA8875::triangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	2206	loc_t x3, loc_t y3, color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	2207	{
WiredHome	20:6e2e4a8372eb	2208	RetCode_t ret;
WiredHome	20:6e2e4a8372eb	2209
WiredHome	198:9b6851107426	2210	if (x1 < 0 \|\| x1 >= virt_screenwidth \|\| x2 < 0 \|\| x2 >= virt_screenwidth \|\| x3 < 0 \|\| x3 >= virt_screenwidth
WiredHome	198:9b6851107426	2211	\|\| y1 < 0 \|\| y1 >= virt_screenheight \|\| y2 < 0 \|\| y2 >= virt_screenheight \|\| y3 < 0 \|\| y3 >= virt_screenheight)
WiredHome	85:022bba13c5c4	2212	ret = bad_parameter;
WiredHome	19:3f82c1161fd2	2213	foreground(color);
WiredHome	20:6e2e4a8372eb	2214	ret = triangle(x1,y1,x2,y2,x3,y3,fillit);
WiredHome	20:6e2e4a8372eb	2215	return ret;
WiredHome	19:3f82c1161fd2	2216	}
WiredHome	19:3f82c1161fd2	2217
WiredHome	44:207594dece70	2218
WiredHome	73:f22a18707b5e	2219	RetCode_t RA8875::filltriangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	2220	loc_t x3, loc_t y3, color_t color, fill_t fillit)
WiredHome	73:f22a18707b5e	2221	{
WiredHome	73:f22a18707b5e	2222	RetCode_t ret;
WiredHome	73:f22a18707b5e	2223
WiredHome	73:f22a18707b5e	2224	foreground(color);
WiredHome	73:f22a18707b5e	2225	ret = triangle(x1,y1,x2,y2,x3,y3,fillit);
WiredHome	73:f22a18707b5e	2226	return ret;
WiredHome	73:f22a18707b5e	2227	}
WiredHome	73:f22a18707b5e	2228
WiredHome	73:f22a18707b5e	2229
WiredHome	73:f22a18707b5e	2230	RetCode_t RA8875::triangle(loc_t x1, loc_t y1 ,loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	2231	loc_t x3, loc_t y3, fill_t fillit)
WiredHome	19:3f82c1161fd2	2232	{
WiredHome	19:3f82c1161fd2	2233	RetCode_t ret = noerror;
WiredHome	73:f22a18707b5e	2234
WiredHome	178:ae472eb22740	2235	INFO("triangle");
WiredHome	19:3f82c1161fd2	2236	PERFORMANCE_RESET;
WiredHome	19:3f82c1161fd2	2237	if (x1 == x2 && y1 == y2 && x1 == x3 && y1 == y3) {
WiredHome	19:3f82c1161fd2	2238	pixel(x1, y1);
WiredHome	19:3f82c1161fd2	2239	} else {
WiredHome	198:9b6851107426	2240	switch (screen_orientation) {
WiredHome	198:9b6851107426	2241	case rotate_0:
WiredHome	198:9b6851107426	2242	case rotate_180:
WiredHome	198:9b6851107426	2243	WriteCommandW(RA8875_DLHSR0, x1);
WiredHome	198:9b6851107426	2244	WriteCommandW(RA8875_DLVSR0, y1);
WiredHome	198:9b6851107426	2245	WriteCommandW(RA8875_DLHER0, x2);
WiredHome	198:9b6851107426	2246	WriteCommandW(RA8875_DLVER0, y2);
WiredHome	198:9b6851107426	2247	WriteCommandW(RA8875_DTPH0, x3);
WiredHome	198:9b6851107426	2248	WriteCommandW(RA8875_DTPV0, y3);
WiredHome	198:9b6851107426	2249	break;
WiredHome	198:9b6851107426	2250	case rotate_90:
WiredHome	198:9b6851107426	2251	case rotate_270:
WiredHome	198:9b6851107426	2252	WriteCommandW(RA8875_DLHSR0, y1);
WiredHome	198:9b6851107426	2253	WriteCommandW(RA8875_DLVSR0, x1);
WiredHome	198:9b6851107426	2254	WriteCommandW(RA8875_DLHER0, y2);
WiredHome	198:9b6851107426	2255	WriteCommandW(RA8875_DLVER0, x2);
WiredHome	198:9b6851107426	2256	WriteCommandW(RA8875_DTPH0, y3);
WiredHome	198:9b6851107426	2257	WriteCommandW(RA8875_DTPV0, x3);
WiredHome	198:9b6851107426	2258	break;
WiredHome	198:9b6851107426	2259	case invalid:
WiredHome	198:9b6851107426	2260	REGISTERPERFORMANCE(PRF_DRAWTRIANGLE);
WiredHome	198:9b6851107426	2261	return bad_parameter;
WiredHome	198:9b6851107426	2262	//break;
WiredHome	198:9b6851107426	2263	}
WiredHome	19:3f82c1161fd2	2264	unsigned char drawCmd = 0x01; // Triangle
WiredHome	19:3f82c1161fd2	2265	if (fillit == FILL)
WiredHome	19:3f82c1161fd2	2266	drawCmd \|= 0x20;
WiredHome	175:7be3a1fb7fc2	2267	WriteCommand(RA8875_DCR, drawCmd);
WiredHome	175:7be3a1fb7fc2	2268	WriteCommand(RA8875_DCR, 0x80 + drawCmd); // Start drawing.
WiredHome	131:5bd6ba2ee4a1	2269	if (!_WaitWhileReg(0x90, 0x80)) {
WiredHome	131:5bd6ba2ee4a1	2270	REGISTERPERFORMANCE(PRF_DRAWTRIANGLE);
WiredHome	131:5bd6ba2ee4a1	2271	return external_abort;
WiredHome	131:5bd6ba2ee4a1	2272	}
WiredHome	19:3f82c1161fd2	2273	}
WiredHome	19:3f82c1161fd2	2274	REGISTERPERFORMANCE(PRF_DRAWTRIANGLE);
WiredHome	19:3f82c1161fd2	2275	return ret;
WiredHome	19:3f82c1161fd2	2276	}
WiredHome	19:3f82c1161fd2	2277
WiredHome	83:7bad0068cca0	2278
WiredHome	83:7bad0068cca0	2279	RetCode_t RA8875::circle(point_t p, dim_t radius,
WiredHome	83:7bad0068cca0	2280	color_t color, fill_t fillit)
WiredHome	83:7bad0068cca0	2281	{
WiredHome	83:7bad0068cca0	2282	foreground(color);
WiredHome	83:7bad0068cca0	2283	return circle(p.x,p.y,radius,fillit);
WiredHome	83:7bad0068cca0	2284	}
WiredHome	83:7bad0068cca0	2285
WiredHome	83:7bad0068cca0	2286
WiredHome	83:7bad0068cca0	2287	RetCode_t RA8875::fillcircle(point_t p, dim_t radius,
WiredHome	83:7bad0068cca0	2288	color_t color, fill_t fillit)
WiredHome	83:7bad0068cca0	2289	{
WiredHome	83:7bad0068cca0	2290	foreground(color);
WiredHome	83:7bad0068cca0	2291	return circle(p.x,p.y,radius,fillit);
WiredHome	83:7bad0068cca0	2292	}
WiredHome	83:7bad0068cca0	2293
WiredHome	83:7bad0068cca0	2294
WiredHome	83:7bad0068cca0	2295	RetCode_t RA8875::circle(point_t p, dim_t radius, fill_t fillit)
WiredHome	83:7bad0068cca0	2296	{
WiredHome	83:7bad0068cca0	2297	return circle(p.x,p.y,radius,fillit);
WiredHome	83:7bad0068cca0	2298	}
WiredHome	83:7bad0068cca0	2299
WiredHome	83:7bad0068cca0	2300
WiredHome	73:f22a18707b5e	2301	RetCode_t RA8875::circle(loc_t x, loc_t y, dim_t radius,
WiredHome	73:f22a18707b5e	2302	color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	2303	{
WiredHome	19:3f82c1161fd2	2304	foreground(color);
WiredHome	19:3f82c1161fd2	2305	return circle(x,y,radius,fillit);
WiredHome	19:3f82c1161fd2	2306	}
WiredHome	19:3f82c1161fd2	2307
WiredHome	44:207594dece70	2308
WiredHome	73:f22a18707b5e	2309	RetCode_t RA8875::fillcircle(loc_t x, loc_t y, dim_t radius,
WiredHome	73:f22a18707b5e	2310	color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	2311	{
WiredHome	19:3f82c1161fd2	2312	foreground(color);
WiredHome	19:3f82c1161fd2	2313	return circle(x,y,radius,fillit);
WiredHome	19:3f82c1161fd2	2314	}
WiredHome	19:3f82c1161fd2	2315
WiredHome	37:f19b7e7449dc	2316	RetCode_t RA8875::circle(loc_t x, loc_t y, dim_t radius, fill_t fillit)
WiredHome	19:3f82c1161fd2	2317	{
WiredHome	19:3f82c1161fd2	2318	RetCode_t ret = noerror;
WiredHome	190:3132b7dfad82	2319
WiredHome	178:ae472eb22740	2320	INFO("circle");
WiredHome	19:3f82c1161fd2	2321	PERFORMANCE_RESET;
WiredHome	183:808f272e481e	2322	if ((x - radius) < 0 \|\| (x + radius) > width()
WiredHome	181:0032d1b8f5d4	2323	\|\| (y - radius) < 0 \|\| (y + radius) > height()) {
WiredHome	19:3f82c1161fd2	2324	ret = bad_parameter;
WiredHome	19:3f82c1161fd2	2325	} else if (radius == 1) {
WiredHome	19:3f82c1161fd2	2326	pixel(x,y);
WiredHome	19:3f82c1161fd2	2327	} else {
WiredHome	198:9b6851107426	2328	switch (screen_orientation) {
WiredHome	198:9b6851107426	2329	case rotate_0:
WiredHome	198:9b6851107426	2330	case rotate_180:
WiredHome	198:9b6851107426	2331	WriteCommandW(RA8875_DCHR0, x);
WiredHome	198:9b6851107426	2332	WriteCommandW(RA8875_DCVR0, y);
WiredHome	198:9b6851107426	2333	break;
WiredHome	198:9b6851107426	2334	case rotate_90:
WiredHome	198:9b6851107426	2335	case rotate_270:
WiredHome	198:9b6851107426	2336	WriteCommandW(RA8875_DCHR0, y);
WiredHome	198:9b6851107426	2337	WriteCommandW(RA8875_DCVR0, x);
WiredHome	198:9b6851107426	2338	break;
WiredHome	198:9b6851107426	2339	case invalid:
WiredHome	198:9b6851107426	2340	REGISTERPERFORMANCE(PRF_DRAWCIRCLE);
WiredHome	198:9b6851107426	2341	return bad_parameter;
WiredHome	198:9b6851107426	2342	//break;
WiredHome	198:9b6851107426	2343	}
WiredHome	175:7be3a1fb7fc2	2344	WriteCommand(RA8875_DCRR, radius & 0xFF);
WiredHome	19:3f82c1161fd2	2345	unsigned char drawCmd = 0x00; // Circle
WiredHome	19:3f82c1161fd2	2346	if (fillit == FILL)
WiredHome	19:3f82c1161fd2	2347	drawCmd \|= 0x20;
WiredHome	175:7be3a1fb7fc2	2348	WriteCommand(RA8875_DCR, drawCmd);
WiredHome	175:7be3a1fb7fc2	2349	WriteCommand(RA8875_DCR, 0x40 + drawCmd); // Start drawing.
WiredHome	131:5bd6ba2ee4a1	2350	if (!_WaitWhileReg(0x90, 0x40)) {
WiredHome	131:5bd6ba2ee4a1	2351	REGISTERPERFORMANCE(PRF_DRAWCIRCLE);
WiredHome	131:5bd6ba2ee4a1	2352	return external_abort;
WiredHome	131:5bd6ba2ee4a1	2353	}
WiredHome	19:3f82c1161fd2	2354	}
WiredHome	19:3f82c1161fd2	2355	REGISTERPERFORMANCE(PRF_DRAWCIRCLE);
WiredHome	19:3f82c1161fd2	2356	return ret;
WiredHome	19:3f82c1161fd2	2357	}
WiredHome	19:3f82c1161fd2	2358
WiredHome	44:207594dece70	2359
WiredHome	37:f19b7e7449dc	2360	RetCode_t RA8875::ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	2361	{
WiredHome	19:3f82c1161fd2	2362	foreground(color);
WiredHome	25:9556a3a9b7cc	2363	return ellipse(x,y,radius1,radius2,fillit);
WiredHome	19:3f82c1161fd2	2364	}
WiredHome	19:3f82c1161fd2	2365
WiredHome	44:207594dece70	2366
WiredHome	37:f19b7e7449dc	2367	RetCode_t RA8875::fillellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome	25:9556a3a9b7cc	2368	{
WiredHome	25:9556a3a9b7cc	2369	foreground(color);
WiredHome	25:9556a3a9b7cc	2370	return ellipse(x,y,radius1,radius2,fillit);
WiredHome	25:9556a3a9b7cc	2371	}
WiredHome	44:207594dece70	2372
WiredHome	73:f22a18707b5e	2373
WiredHome	37:f19b7e7449dc	2374	RetCode_t RA8875::ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, fill_t fillit)
WiredHome	19:3f82c1161fd2	2375	{
WiredHome	19:3f82c1161fd2	2376	RetCode_t ret = noerror;
WiredHome	73:f22a18707b5e	2377
WiredHome	178:ae472eb22740	2378	INFO("ellipse");
WiredHome	19:3f82c1161fd2	2379	PERFORMANCE_RESET;
WiredHome	198:9b6851107426	2380	if ((x - radius1) < 0 \|\| (x + radius1) > virt_screenwidth
WiredHome	198:9b6851107426	2381	\|\| (y - radius2) < 0 \|\| (y + radius2) > virt_screenheight) {
WiredHome	85:022bba13c5c4	2382	ret = bad_parameter;
WiredHome	25:9556a3a9b7cc	2383	} else if (radius1 == 1 && radius2 == 1) {
WiredHome	19:3f82c1161fd2	2384	pixel(x, y);
WiredHome	19:3f82c1161fd2	2385	} else {
WiredHome	198:9b6851107426	2386	switch (screen_orientation) {
WiredHome	198:9b6851107426	2387	case rotate_0:
WiredHome	198:9b6851107426	2388	case rotate_180:
WiredHome	198:9b6851107426	2389	WriteCommandW(RA8875_DEHR0, x);
WiredHome	198:9b6851107426	2390	WriteCommandW(RA8875_DEVR0, y);
WiredHome	198:9b6851107426	2391	break;
WiredHome	198:9b6851107426	2392	case rotate_90:
WiredHome	198:9b6851107426	2393	case rotate_270:
WiredHome	198:9b6851107426	2394	WriteCommandW(RA8875_DEHR0, y);
WiredHome	198:9b6851107426	2395	WriteCommandW(RA8875_DEVR0, x);
WiredHome	198:9b6851107426	2396	break;
WiredHome	198:9b6851107426	2397	case invalid:
WiredHome	198:9b6851107426	2398	REGISTERPERFORMANCE(PRF_DRAWELLIPSE);
WiredHome	198:9b6851107426	2399	return bad_parameter;
WiredHome	198:9b6851107426	2400	//break;
WiredHome	198:9b6851107426	2401	}
WiredHome	175:7be3a1fb7fc2	2402	WriteCommandW(RA8875_ELLA0, radius1);
WiredHome	175:7be3a1fb7fc2	2403	WriteCommandW(RA8875_ELLB0, radius2);
WiredHome	19:3f82c1161fd2	2404	unsigned char drawCmd = 0x00; // Ellipse
WiredHome	19:3f82c1161fd2	2405	if (fillit == FILL)
WiredHome	19:3f82c1161fd2	2406	drawCmd \|= 0x40;
WiredHome	175:7be3a1fb7fc2	2407	WriteCommand(RA8875_ELLIPSE, drawCmd);
WiredHome	175:7be3a1fb7fc2	2408	WriteCommand(RA8875_ELLIPSE, 0x80 + drawCmd); // Start drawing.
WiredHome	131:5bd6ba2ee4a1	2409	if (!_WaitWhileReg(0xA0, 0x80)) {
WiredHome	131:5bd6ba2ee4a1	2410	REGISTERPERFORMANCE(PRF_DRAWELLIPSE);
WiredHome	131:5bd6ba2ee4a1	2411	return external_abort;
WiredHome	131:5bd6ba2ee4a1	2412	}
WiredHome	19:3f82c1161fd2	2413	}
WiredHome	19:3f82c1161fd2	2414	REGISTERPERFORMANCE(PRF_DRAWELLIPSE);
WiredHome	19:3f82c1161fd2	2415	return ret;
WiredHome	19:3f82c1161fd2	2416	}
WiredHome	19:3f82c1161fd2	2417
WiredHome	44:207594dece70	2418
WiredHome	68:ab08efabfc88	2419	RetCode_t RA8875::frequency(unsigned long Hz, unsigned long Hz2)
WiredHome	19:3f82c1161fd2	2420	{
WiredHome	66:468a11f05580	2421	spiwritefreq = Hz;
WiredHome	68:ab08efabfc88	2422	if (Hz2 != 0)
WiredHome	68:ab08efabfc88	2423	spireadfreq = Hz2;
WiredHome	68:ab08efabfc88	2424	else
WiredHome	68:ab08efabfc88	2425	spireadfreq = Hz/2;
WiredHome	68:ab08efabfc88	2426	_setWriteSpeed(true);
WiredHome	19:3f82c1161fd2	2427	// __ ___
WiredHome	19:3f82c1161fd2	2428	// Clock ___A Rising edge latched
WiredHome	19:3f82c1161fd2	2429	// ___ ____
WiredHome	19:3f82c1161fd2	2430	// Data ___X____
WiredHome	19:3f82c1161fd2	2431	spi.format(8, 3); // 8 bits and clock to data phase 0
WiredHome	19:3f82c1161fd2	2432	return noerror;
WiredHome	19:3f82c1161fd2	2433	}
WiredHome	19:3f82c1161fd2	2434
WiredHome	68:ab08efabfc88	2435	void RA8875::_setWriteSpeed(bool writeSpeed)
WiredHome	68:ab08efabfc88	2436	{
WiredHome	68:ab08efabfc88	2437	if (writeSpeed) {
WiredHome	68:ab08efabfc88	2438	spi.frequency(spiwritefreq);
WiredHome	68:ab08efabfc88	2439	spiWriteSpeed = true;
WiredHome	68:ab08efabfc88	2440	} else {
WiredHome	68:ab08efabfc88	2441	spi.frequency(spireadfreq);
WiredHome	68:ab08efabfc88	2442	spiWriteSpeed = false;
WiredHome	68:ab08efabfc88	2443	}
WiredHome	68:ab08efabfc88	2444	}
WiredHome	44:207594dece70	2445
WiredHome	131:5bd6ba2ee4a1	2446
WiredHome	131:5bd6ba2ee4a1	2447
WiredHome	131:5bd6ba2ee4a1	2448	RetCode_t RA8875::BlockMove(uint8_t dstLayer, uint8_t dstDataSelect, point_t dstPoint,
WiredHome	131:5bd6ba2ee4a1	2449	uint8_t srcLayer, uint8_t srcDataSelect, point_t srcPoint,
WiredHome	137:9e09f6081ef1	2450	dim_t bte_width, dim_t bte_height,
WiredHome	131:5bd6ba2ee4a1	2451	uint8_t bte_op_code, uint8_t bte_rop_code)
WiredHome	131:5bd6ba2ee4a1	2452	{
WiredHome	131:5bd6ba2ee4a1	2453	uint8_t cmd;
WiredHome	131:5bd6ba2ee4a1	2454
WiredHome	131:5bd6ba2ee4a1	2455	PERFORMANCE_RESET;
WiredHome	137:9e09f6081ef1	2456	///@todo range check and error return rather than to secretly fix
WiredHome	131:5bd6ba2ee4a1	2457	srcPoint.x &= 0x3FF; // prevent high bits from doing unexpected things
WiredHome	131:5bd6ba2ee4a1	2458	srcPoint.y &= 0x1FF;
WiredHome	131:5bd6ba2ee4a1	2459	dstPoint.x &= 0x3FF;
WiredHome	131:5bd6ba2ee4a1	2460	dstPoint.y &= 0x1FF;
WiredHome	175:7be3a1fb7fc2	2461	WriteCommandW(RA8875_HSBE0, srcPoint.x);
WiredHome	175:7be3a1fb7fc2	2462	WriteCommandW(RA8875_VSBE0, ((dim_t)(srcLayer & 1) << 15) \| srcPoint.y);
WiredHome	175:7be3a1fb7fc2	2463	WriteCommandW(RA8875_HDBE0, dstPoint.x);
WiredHome	175:7be3a1fb7fc2	2464	WriteCommandW(RA8875_VDBE0, ((dim_t)(dstLayer & 1) << 15) \| dstPoint.y);
WiredHome	175:7be3a1fb7fc2	2465	WriteCommandW(RA8875_BEWR0, bte_width);
WiredHome	175:7be3a1fb7fc2	2466	WriteCommandW(RA8875_BEHR0, bte_height);
WiredHome	175:7be3a1fb7fc2	2467	WriteCommand(RA8875_BECR1, ((bte_rop_code & 0x0F) << 4) \| (bte_op_code & 0x0F));
WiredHome	131:5bd6ba2ee4a1	2468	cmd = ((srcDataSelect & 1) << 6) \| ((dstDataSelect & 1) << 5);
WiredHome	175:7be3a1fb7fc2	2469	WriteCommand(RA8875_BECR0, 0x80 \| cmd); // enable the BTE
WiredHome	131:5bd6ba2ee4a1	2470	if (!_WaitWhileBusy(0x40)) {
WiredHome	131:5bd6ba2ee4a1	2471	REGISTERPERFORMANCE(PRF_BLOCKMOVE);
WiredHome	131:5bd6ba2ee4a1	2472	return external_abort;
WiredHome	131:5bd6ba2ee4a1	2473	}
WiredHome	131:5bd6ba2ee4a1	2474	REGISTERPERFORMANCE(PRF_BLOCKMOVE);
WiredHome	131:5bd6ba2ee4a1	2475	return noerror;
WiredHome	131:5bd6ba2ee4a1	2476	}
WiredHome	131:5bd6ba2ee4a1	2477
WiredHome	131:5bd6ba2ee4a1	2478
WiredHome	19:3f82c1161fd2	2479	RetCode_t RA8875::Power(bool on)
WiredHome	19:3f82c1161fd2	2480	{
WiredHome	175:7be3a1fb7fc2	2481	WriteCommand(RA8875_PWRR, (on) ? 0x80 : 0x00);
WiredHome	19:3f82c1161fd2	2482	return noerror;
WiredHome	19:3f82c1161fd2	2483	}
WiredHome	19:3f82c1161fd2	2484
WiredHome	44:207594dece70	2485
WiredHome	131:5bd6ba2ee4a1	2486	RetCode_t RA8875::Backlight_u8(uint8_t brightness)
WiredHome	19:3f82c1161fd2	2487	{
WiredHome	19:3f82c1161fd2	2488	static bool is_enabled = false;
WiredHome	190:3132b7dfad82	2489
WiredHome	19:3f82c1161fd2	2490	if (brightness == 0) {
WiredHome	175:7be3a1fb7fc2	2491	WriteCommand(RA8875_P1CR); // Disable the PWM
WiredHome	19:3f82c1161fd2	2492	WriteData(0x00);
WiredHome	19:3f82c1161fd2	2493	is_enabled = false;
WiredHome	19:3f82c1161fd2	2494	} else if (!is_enabled) {
WiredHome	175:7be3a1fb7fc2	2495	WriteCommand(RA8875_P1CR); // Enable the PWM
WiredHome	19:3f82c1161fd2	2496	WriteData(0x80);
WiredHome	175:7be3a1fb7fc2	2497	WriteCommand(RA8875_P1CR); // Not sure why this is needed, but following the pattern
WiredHome	19:3f82c1161fd2	2498	WriteData(0x81); // open PWM (SYS_CLK / 2 as best I can tell)
WiredHome	19:3f82c1161fd2	2499	is_enabled = true;
WiredHome	19:3f82c1161fd2	2500	}
WiredHome	175:7be3a1fb7fc2	2501	WriteCommand(RA8875_P1DCR, brightness); // Brightness parameter 0xff-0x00
WiredHome	19:3f82c1161fd2	2502	return noerror;
WiredHome	19:3f82c1161fd2	2503	}
WiredHome	19:3f82c1161fd2	2504
WiredHome	86:e86b355940f4	2505	uint8_t RA8875::GetBacklight_u8(void)
WiredHome	86:e86b355940f4	2506	{
WiredHome	86:e86b355940f4	2507	return ReadCommand(0x8b);
WiredHome	86:e86b355940f4	2508	}
WiredHome	44:207594dece70	2509
WiredHome	19:3f82c1161fd2	2510	RetCode_t RA8875::Backlight(float brightness)
WiredHome	19:3f82c1161fd2	2511	{
WiredHome	19:3f82c1161fd2	2512	unsigned char b;
WiredHome	73:f22a18707b5e	2513
WiredHome	29:422616aa04bd	2514	if (brightness >= 1.0)
WiredHome	19:3f82c1161fd2	2515	b = 255;
WiredHome	29:422616aa04bd	2516	else if (brightness <= 0.0)
WiredHome	19:3f82c1161fd2	2517	b = 0;
WiredHome	19:3f82c1161fd2	2518	else
WiredHome	19:3f82c1161fd2	2519	b = (unsigned char)(brightness * 255);
WiredHome	19:3f82c1161fd2	2520	return Backlight_u8(b);
WiredHome	19:3f82c1161fd2	2521	}
WiredHome	19:3f82c1161fd2	2522
WiredHome	86:e86b355940f4	2523	float RA8875::GetBacklight(void)
WiredHome	86:e86b355940f4	2524	{
WiredHome	86:e86b355940f4	2525	return (float)(GetBacklight_u8())/255;
WiredHome	86:e86b355940f4	2526	}
WiredHome	44:207594dece70	2527
WiredHome	98:ecebed9b80b2	2528	RetCode_t RA8875::SelectUserFont(const uint8_t * _font)
WiredHome	98:ecebed9b80b2	2529	{
WiredHome	178:ae472eb22740	2530	INFO("SelectUserFont(%p)", _font);
WiredHome	98:ecebed9b80b2	2531	if (_font) {
WiredHome	98:ecebed9b80b2	2532	HexDump("Font Memory", _font, 16);
WiredHome	98:ecebed9b80b2	2533	extFontHeight = _font[6];
WiredHome	98:ecebed9b80b2	2534	uint32_t totalWidth = 0;
WiredHome	98:ecebed9b80b2	2535	uint16_t firstChar = _font[3] * 256 + _font[2];
WiredHome	98:ecebed9b80b2	2536	uint16_t lastChar = _font[5] * 256 + _font[4];
WiredHome	98:ecebed9b80b2	2537	uint16_t i;
WiredHome	190:3132b7dfad82	2538
WiredHome	98:ecebed9b80b2	2539	for (i=firstChar; i<=lastChar; i++) {
WiredHome	98:ecebed9b80b2	2540	// 8 bytes of preamble to the first level lookup table
WiredHome	98:ecebed9b80b2	2541	uint16_t offsetToCharLookup = 8 + 4 * (i - firstChar); // 4-bytes: width(pixels), 16-bit offset from table start, 0
WiredHome	98:ecebed9b80b2	2542	totalWidth += _font[offsetToCharLookup];
WiredHome	98:ecebed9b80b2	2543	}
WiredHome	98:ecebed9b80b2	2544	extFontWidth = totalWidth / (lastChar - firstChar);
WiredHome	98:ecebed9b80b2	2545	INFO("Font Metrics: Avg W: %2d, H: %2d, First:%d, Last:%d", extFontWidth, extFontHeight, firstChar, lastChar);
WiredHome	98:ecebed9b80b2	2546	}
WiredHome	198:9b6851107426	2547	SetTextCursor(GetTextCursor()); // soft-font cursor -> hw cursor
WiredHome	98:ecebed9b80b2	2548	font = _font;
WiredHome	98:ecebed9b80b2	2549	return GraphicsDisplay::SelectUserFont(_font);
WiredHome	98:ecebed9b80b2	2550	}
WiredHome	44:207594dece70	2551
WiredHome	198:9b6851107426	2552	color_t RA8875::background(color_t color)
WiredHome	19:3f82c1161fd2	2553	{
WiredHome	198:9b6851107426	2554	color_t oldColor = GetBackColor();
WiredHome	37:f19b7e7449dc	2555	GraphicsDisplay::background(color);
WiredHome	198:9b6851107426	2556	_writeColorTrio(0x60, color);
WiredHome	198:9b6851107426	2557	return oldColor;
WiredHome	19:3f82c1161fd2	2558	}
WiredHome	19:3f82c1161fd2	2559
WiredHome	44:207594dece70	2560
WiredHome	198:9b6851107426	2561	color_t RA8875::background(unsigned char r, unsigned char g, unsigned char b)
WiredHome	19:3f82c1161fd2	2562	{
WiredHome	198:9b6851107426	2563	return background(RGB(r,g,b));
WiredHome	19:3f82c1161fd2	2564	}
WiredHome	19:3f82c1161fd2	2565
WiredHome	198:9b6851107426	2566	color_t RA8875::GetBackColor(void)
WiredHome	19:3f82c1161fd2	2567	{
WiredHome	198:9b6851107426	2568	return _readColorTrio(0x60);
WiredHome	19:3f82c1161fd2	2569	}
WiredHome	19:3f82c1161fd2	2570
WiredHome	44:207594dece70	2571
WiredHome	198:9b6851107426	2572	color_t RA8875::foreground(color_t color)
WiredHome	19:3f82c1161fd2	2573	{
WiredHome	198:9b6851107426	2574	color_t oldColor = GetForeColor();
WiredHome	198:9b6851107426	2575	GraphicsDisplay::foreground(color);
WiredHome	198:9b6851107426	2576	_writeColorTrio(0x63, color);
WiredHome	198:9b6851107426	2577	return oldColor;
WiredHome	19:3f82c1161fd2	2578	}
WiredHome	19:3f82c1161fd2	2579
WiredHome	44:207594dece70	2580
WiredHome	198:9b6851107426	2581	color_t RA8875::foreground(unsigned char r, unsigned char g, unsigned char b)
WiredHome	198:9b6851107426	2582	{
WiredHome	198:9b6851107426	2583	return foreground(RGB(r,g,b));
WiredHome	198:9b6851107426	2584	}
WiredHome	198:9b6851107426	2585
WiredHome	37:f19b7e7449dc	2586	color_t RA8875::GetForeColor(void)
WiredHome	19:3f82c1161fd2	2587	{
WiredHome	133:e36dcfc2d756	2588	return _readColorTrio(0x63);
WiredHome	19:3f82c1161fd2	2589	}
WiredHome	19:3f82c1161fd2	2590
WiredHome	44:207594dece70	2591
WiredHome	198:9b6851107426	2592
WiredHome	19:3f82c1161fd2	2593	color_t RA8875::DOSColor(int i)
WiredHome	73:f22a18707b5e	2594	{
WiredHome	73:f22a18707b5e	2595	const color_t colors[16] = {
WiredHome	19:3f82c1161fd2	2596	Black, Blue, Green, Cyan,
WiredHome	19:3f82c1161fd2	2597	Red, Magenta, Brown, Gray,
WiredHome	19:3f82c1161fd2	2598	Charcoal, BrightBlue, BrightGreen, BrightCyan,
WiredHome	19:3f82c1161fd2	2599	Orange, Pink, Yellow, White
WiredHome	73:f22a18707b5e	2600	};
WiredHome	85:022bba13c5c4	2601	if (i >= 0 && i < 16)
WiredHome	19:3f82c1161fd2	2602	return colors[i];
WiredHome	19:3f82c1161fd2	2603	else
WiredHome	19:3f82c1161fd2	2604	return 0;
WiredHome	73:f22a18707b5e	2605	}
WiredHome	19:3f82c1161fd2	2606
WiredHome	44:207594dece70	2607
WiredHome	73:f22a18707b5e	2608	const char * RA8875::DOSColorNames(int i)
WiredHome	73:f22a18707b5e	2609	{
WiredHome	73:f22a18707b5e	2610	const char * names[16] = {
WiredHome	19:3f82c1161fd2	2611	"Black", "Blue", "Green", "Cyan",
WiredHome	19:3f82c1161fd2	2612	"Red", "Magenta", "Brown", "Gray",
WiredHome	19:3f82c1161fd2	2613	"Charcoal", "BrightBlue", "BrightGreen", "BrightCyan",
WiredHome	19:3f82c1161fd2	2614	"Orange", "Pink", "Yellow", "White"
WiredHome	73:f22a18707b5e	2615	};
WiredHome	85:022bba13c5c4	2616	if (i >= 0 && i < 16)
WiredHome	19:3f82c1161fd2	2617	return names[i];
WiredHome	19:3f82c1161fd2	2618	else
WiredHome	19:3f82c1161fd2	2619	return NULL;
WiredHome	73:f22a18707b5e	2620	}
WiredHome	19:3f82c1161fd2	2621
WiredHome	19:3f82c1161fd2	2622
WiredHome	19:3f82c1161fd2	2623	///////////////////////////////////////////////////////////////
WiredHome	19:3f82c1161fd2	2624	// Private functions
WiredHome	19:3f82c1161fd2	2625
WiredHome	79:544eb4964795	2626	unsigned char RA8875::_spiwrite(unsigned char data)
WiredHome	19:3f82c1161fd2	2627	{
WiredHome	19:3f82c1161fd2	2628	unsigned char retval;
WiredHome	73:f22a18707b5e	2629
WiredHome	68:ab08efabfc88	2630	if (!spiWriteSpeed)
WiredHome	68:ab08efabfc88	2631	_setWriteSpeed(true);
WiredHome	19:3f82c1161fd2	2632	retval = spi.write(data);
WiredHome	19:3f82c1161fd2	2633	return retval;
WiredHome	19:3f82c1161fd2	2634	}
WiredHome	19:3f82c1161fd2	2635
WiredHome	44:207594dece70	2636
WiredHome	79:544eb4964795	2637	unsigned char RA8875::_spiread(void)
WiredHome	19:3f82c1161fd2	2638	{
WiredHome	19:3f82c1161fd2	2639	unsigned char retval;
WiredHome	19:3f82c1161fd2	2640	unsigned char data = 0;
WiredHome	73:f22a18707b5e	2641
WiredHome	68:ab08efabfc88	2642	if (spiWriteSpeed)
WiredHome	68:ab08efabfc88	2643	_setWriteSpeed(false);
WiredHome	19:3f82c1161fd2	2644	retval = spi.write(data);
WiredHome	19:3f82c1161fd2	2645	return retval;
WiredHome	19:3f82c1161fd2	2646	}
WiredHome	19:3f82c1161fd2	2647
WiredHome	44:207594dece70	2648
WiredHome	79:544eb4964795	2649	RetCode_t RA8875::_select(bool chipsel)
WiredHome	19:3f82c1161fd2	2650	{
WiredHome	19:3f82c1161fd2	2651	cs = (chipsel == true) ? 0 : 1;
WiredHome	19:3f82c1161fd2	2652	return noerror;
WiredHome	19:3f82c1161fd2	2653	}
WiredHome	19:3f82c1161fd2	2654
WiredHome	44:207594dece70	2655
WiredHome	72:ecffe56af969	2656	RetCode_t RA8875::PrintScreen(uint16_t layer, loc_t x, loc_t y, dim_t w, dim_t h, const char *Name_BMP)
WiredHome	72:ecffe56af969	2657	{
WiredHome	74:686faa218914	2658	(void)layer;
WiredHome	190:3132b7dfad82	2659
WiredHome	96:40b74dd3695b	2660	// AttachPrintHandler(this, RA8875::_printCallback);
WiredHome	96:40b74dd3695b	2661	// return PrintScreen(x,y,w,h);
WiredHome	74:686faa218914	2662	return PrintScreen(x, y, w, h, Name_BMP);
WiredHome	72:ecffe56af969	2663	}
WiredHome	72:ecffe56af969	2664
WiredHome	96:40b74dd3695b	2665	RetCode_t RA8875::_printCallback(RA8875::filecmd_t cmd, uint8_t * buffer, uint16_t size)
WiredHome	96:40b74dd3695b	2666	{
WiredHome	96:40b74dd3695b	2667	HexDump("CB", buffer, size);
WiredHome	96:40b74dd3695b	2668	switch(cmd) {
WiredHome	96:40b74dd3695b	2669	case RA8875::OPEN:
WiredHome	96:40b74dd3695b	2670	//pc.printf("About to write %lu bytes\r\n", (uint32_t )buffer);
WiredHome	96:40b74dd3695b	2671	_printFH = fopen("file.bmp", "w+b");
WiredHome	96:40b74dd3695b	2672	if (_printFH == 0)
WiredHome	96:40b74dd3695b	2673	return file_not_found;
WiredHome	96:40b74dd3695b	2674	break;
WiredHome	96:40b74dd3695b	2675	case RA8875::WRITE:
WiredHome	96:40b74dd3695b	2676	//pc.printf(" Write %4u bytes\r\n", size);
WiredHome	96:40b74dd3695b	2677	fwrite(buffer, 1, size, _printFH);
WiredHome	96:40b74dd3695b	2678	break;
WiredHome	96:40b74dd3695b	2679	case RA8875::CLOSE:
WiredHome	96:40b74dd3695b	2680	//pc.printf(" close\r\n");
WiredHome	96:40b74dd3695b	2681	fclose(_printFH);
WiredHome	96:40b74dd3695b	2682	_printFH = 0;
WiredHome	96:40b74dd3695b	2683	break;
WiredHome	96:40b74dd3695b	2684	default:
WiredHome	96:40b74dd3695b	2685	//pc.printf("Unexpected callback %d\r\n", cmd);
WiredHome	96:40b74dd3695b	2686	return file_not_found;
WiredHome	96:40b74dd3695b	2687	//break;
WiredHome	96:40b74dd3695b	2688	}
WiredHome	96:40b74dd3695b	2689	return noerror;
WiredHome	96:40b74dd3695b	2690	}
WiredHome	96:40b74dd3695b	2691
WiredHome	162:a2d7f1988711	2692	int RA8875::RoundUp(int value, int roundTo)
WiredHome	162:a2d7f1988711	2693	{
WiredHome	190:3132b7dfad82	2694	if (roundTo == 0)
WiredHome	162:a2d7f1988711	2695	return 0;
WiredHome	162:a2d7f1988711	2696	return ((value + roundTo - 1) / roundTo) * roundTo;
WiredHome	162:a2d7f1988711	2697	}
WiredHome	162:a2d7f1988711	2698
WiredHome	164:76edd7d9cb68	2699	RetCode_t RA8875::PrintScreen(loc_t x, loc_t y, dim_t w, dim_t h, uint8_t bitsPerPixel)
WiredHome	96:40b74dd3695b	2700	{
WiredHome	96:40b74dd3695b	2701	BITMAPFILEHEADER BMP_Header;
WiredHome	96:40b74dd3695b	2702	BITMAPINFOHEADER BMP_Info;
WiredHome	96:40b74dd3695b	2703	uint8_t * lineBuffer = NULL;
WiredHome	96:40b74dd3695b	2704	color_t * pixelBuffer = NULL;
WiredHome	96:40b74dd3695b	2705	color_t * pixelBuffer2 = NULL;
WiredHome	190:3132b7dfad82	2706
WiredHome	164:76edd7d9cb68	2707	INFO("(%d,%d)-(%d,%d)x%d", x,y,w,h,bitsPerPixel);
WiredHome	198:9b6851107426	2708	if (x >= 0 && x < virt_screenwidth
WiredHome	198:9b6851107426	2709	&& y >= 0 && y < virt_screenheight
WiredHome	198:9b6851107426	2710	&& w > 0 && x + w <= virt_screenwidth
WiredHome	198:9b6851107426	2711	&& h > 0 && y + h <= virt_screenheight) {
WiredHome	96:40b74dd3695b	2712	BMP_Header.bfType = BF_TYPE;
WiredHome	96:40b74dd3695b	2713	BMP_Header.bfReserved1 = 0;
WiredHome	96:40b74dd3695b	2714	BMP_Header.bfReserved2 = 0;
WiredHome	164:76edd7d9cb68	2715	switch (bitsPerPixel) {
WiredHome	164:76edd7d9cb68	2716	case 24:
WiredHome	164:76edd7d9cb68	2717	BMP_Header.bfOffBits = sizeof(BMP_Header) + sizeof(BMP_Info);
WiredHome	164:76edd7d9cb68	2718	BMP_Header.bfSize = (h * RoundUp(w * sizeof(RGBQUAD),4)) + BMP_Header.bfOffBits;
WiredHome	164:76edd7d9cb68	2719	break;
WiredHome	164:76edd7d9cb68	2720	case 8:
WiredHome	164:76edd7d9cb68	2721	default:
WiredHome	164:76edd7d9cb68	2722	BMP_Header.bfOffBits = sizeof(BMP_Header) + sizeof(BMP_Info) + sizeof(WebColorPalette);
WiredHome	198:9b6851107426	2723	INFO("Initial Offset to Bitstream %lX", BMP_Header.bfOffBits);
WiredHome	164:76edd7d9cb68	2724	//if (BMP_Header.bfOffBits & 0x03) {
WiredHome	164:76edd7d9cb68	2725	// BMP_Header.bfOffBits += (4 - (BMP_Header.bfOffBits & 0x03));
WiredHome	164:76edd7d9cb68	2726	//}
WiredHome	164:76edd7d9cb68	2727	BMP_Header.bfSize = (h * RoundUp(w * 1,4)) + BMP_Header.bfOffBits;
WiredHome	164:76edd7d9cb68	2728	break;
WiredHome	164:76edd7d9cb68	2729	}
WiredHome	198:9b6851107426	2730	INFO("Offset to Bitstream %lX", BMP_Header.bfOffBits);
WiredHome	162:a2d7f1988711	2731
WiredHome	162:a2d7f1988711	2732	// Bytes in the line buffer
WiredHome	164:76edd7d9cb68	2733	int lineBufSize = RoundUp(((bitsPerPixel == 24) ? 3 : 1) * w, 4);
WiredHome	162:a2d7f1988711	2734	INFO("LineBufSize: %d", lineBufSize);
WiredHome	96:40b74dd3695b	2735
WiredHome	96:40b74dd3695b	2736	BMP_Info.biSize = sizeof(BMP_Info);
WiredHome	96:40b74dd3695b	2737	BMP_Info.biWidth = w;
WiredHome	96:40b74dd3695b	2738	BMP_Info.biHeight = h;
WiredHome	96:40b74dd3695b	2739	BMP_Info.biPlanes = 1;
WiredHome	164:76edd7d9cb68	2740	BMP_Info.biBitCount = bitsPerPixel;
WiredHome	96:40b74dd3695b	2741	BMP_Info.biCompression = BI_RGB;
WiredHome	162:a2d7f1988711	2742	BMP_Info.biSizeImage = lineBufSize * h;
WiredHome	96:40b74dd3695b	2743	BMP_Info.biXPelsPerMeter = 0;
WiredHome	96:40b74dd3695b	2744	BMP_Info.biYPelsPerMeter = 0;
WiredHome	164:76edd7d9cb68	2745	// for 24-bit, there is no palette, so these are zero
WiredHome	164:76edd7d9cb68	2746	// for 8-bit, there can be up to 256 RGB values in the palette
WiredHome	190:3132b7dfad82	2747
WiredHome	164:76edd7d9cb68	2748	BMP_Info.biClrUsed = (bitsPerPixel == 24) ? 0 : sizeof(WebColorPalette)/sizeof(WebColorPalette[0]); // for 8b/pixel
WiredHome	164:76edd7d9cb68	2749	BMP_Info.biClrImportant = BMP_Info.biClrUsed;
WiredHome	96:40b74dd3695b	2750
WiredHome	96:40b74dd3695b	2751	// Allocate the memory we need to proceed
WiredHome	145:5eb2492acdda	2752	lineBuffer = (uint8_t *)swMalloc(lineBufSize);
WiredHome	96:40b74dd3695b	2753	if (lineBuffer == NULL) {
WiredHome	96:40b74dd3695b	2754	ERR("Not enough RAM for PrintScreen lineBuffer");
WiredHome	96:40b74dd3695b	2755	return(not_enough_ram);
WiredHome	96:40b74dd3695b	2756	}
WiredHome	162:a2d7f1988711	2757	memset(lineBuffer, 0, lineBufSize); // zero-Fill
WiredHome	96:40b74dd3695b	2758
WiredHome	96:40b74dd3695b	2759	#define DOUBLEBUF /* one larger buffer instead of two */
WiredHome	190:3132b7dfad82	2760
WiredHome	96:40b74dd3695b	2761	#ifdef DOUBLEBUF
WiredHome	197:853d08e2fb53	2762	// In the "#else", pixelBuffer2 malloc returns a value,
WiredHome	197:853d08e2fb53	2763	// but is actually causing a failure later.
WiredHome	96:40b74dd3695b	2764	// This test helps determine if it is truly out of memory,
WiredHome	96:40b74dd3695b	2765	// or if malloc is broken.
WiredHome	145:5eb2492acdda	2766	pixelBuffer = (color_t )swMalloc(2 w * sizeof(color_t));
WiredHome	182:8832d03a2a29	2767	if (pixelBuffer)
WiredHome	182:8832d03a2a29	2768	pixelBuffer2 = pixelBuffer + (w * sizeof(color_t));
WiredHome	182:8832d03a2a29	2769	else
WiredHome	182:8832d03a2a29	2770	pixelBuffer2 = NULL;
WiredHome	96:40b74dd3695b	2771	#else
WiredHome	145:5eb2492acdda	2772	pixelBuffer = (color_t )swMalloc(w sizeof(color_t));
WiredHome	145:5eb2492acdda	2773	pixelBuffer2 = (color_t )swMalloc(w sizeof(color_t));
WiredHome	96:40b74dd3695b	2774	#endif
WiredHome	96:40b74dd3695b	2775	if (pixelBuffer == NULL \|\| pixelBuffer2 == NULL) {
WiredHome	96:40b74dd3695b	2776	ERR("Not enough RAM for pixelBuffer");
WiredHome	96:40b74dd3695b	2777	#ifndef DOUBLEBUF
WiredHome	96:40b74dd3695b	2778	if (pixelBuffer2)
WiredHome	145:5eb2492acdda	2779	swFree(pixelBuffer2);
WiredHome	96:40b74dd3695b	2780	#endif
WiredHome	96:40b74dd3695b	2781	if (pixelBuffer)
WiredHome	145:5eb2492acdda	2782	swFree(pixelBuffer);
WiredHome	145:5eb2492acdda	2783	swFree(lineBuffer);
WiredHome	96:40b74dd3695b	2784	return(not_enough_ram);
WiredHome	96:40b74dd3695b	2785	}
WiredHome	96:40b74dd3695b	2786
WiredHome	96:40b74dd3695b	2787	// Get the file primed...
WiredHome	164:76edd7d9cb68	2788	/// @todo check return value for possibility of a fatal error
WiredHome	96:40b74dd3695b	2789	privateCallback(OPEN, (uint8_t *)&BMP_Header.bfSize, 4);
WiredHome	96:40b74dd3695b	2790
WiredHome	96:40b74dd3695b	2791	// Be optimistic - don't check for errors.
WiredHome	198:9b6851107426	2792	//HexDump("BMP_Header", (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome	96:40b74dd3695b	2793	//fwrite(&BMP_Header, sizeof(char), sizeof(BMP_Header), Image);
WiredHome	96:40b74dd3695b	2794	privateCallback(WRITE, (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome	96:40b74dd3695b	2795
WiredHome	198:9b6851107426	2796	//HexDump("BMP_Info", (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome	96:40b74dd3695b	2797	//fwrite(&BMP_Info, sizeof(char), sizeof(BMP_Info), Image);
WiredHome	96:40b74dd3695b	2798	privateCallback(WRITE, (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome	164:76edd7d9cb68	2799	if (bitsPerPixel != 24) {
WiredHome	198:9b6851107426	2800	//HexDump("Palette", (uint8_t *)&WebColorPalette, sizeof(WebColorPalette));
WiredHome	164:76edd7d9cb68	2801	//fwrite(&WebColorPalette, sizeof(char), sizeof(WebColorPalette), Image);
WiredHome	164:76edd7d9cb68	2802	privateCallback(WRITE, (uint8_t *)&WebColorPalette, sizeof(WebColorPalette));
WiredHome	164:76edd7d9cb68	2803	if (0 && sizeof(WebColorPalette) % 4) {
WiredHome	164:76edd7d9cb68	2804	const uint8_t padd[] = { 0, 0, 0 };
WiredHome	164:76edd7d9cb68	2805	//fwrite(&padd, sizeof(char), (sizeof(BMP_Header) + sizeof(BMP_Info) + sizeof(WebColorPalette)) % 4, Image);
WiredHome	164:76edd7d9cb68	2806	privateCallback(WRITE, (uint8_t *)&padd, (sizeof(BMP_Header) + sizeof(BMP_Info) + sizeof(WebColorPalette)) % 4);
WiredHome	164:76edd7d9cb68	2807	}
WiredHome	164:76edd7d9cb68	2808	}
WiredHome	96:40b74dd3695b	2809	//color_t transparency = GetBackgroundTransparencyColor();
WiredHome	96:40b74dd3695b	2810	LayerMode_T ltpr0 = GetLayerMode();
WiredHome	96:40b74dd3695b	2811	uint16_t prevLayer = GetDrawingLayer();
WiredHome	96:40b74dd3695b	2812	// If only one of the layers is visible, select that layer
WiredHome	96:40b74dd3695b	2813	switch(ltpr0) {
WiredHome	96:40b74dd3695b	2814	case ShowLayer0:
WiredHome	96:40b74dd3695b	2815	SelectDrawingLayer(0);
WiredHome	96:40b74dd3695b	2816	break;
WiredHome	96:40b74dd3695b	2817	case ShowLayer1:
WiredHome	96:40b74dd3695b	2818	SelectDrawingLayer(1);
WiredHome	96:40b74dd3695b	2819	break;
WiredHome	96:40b74dd3695b	2820	default:
WiredHome	96:40b74dd3695b	2821	break;
WiredHome	96:40b74dd3695b	2822	}
WiredHome	96:40b74dd3695b	2823
WiredHome	96:40b74dd3695b	2824	// Read the display from the last line toward the top
WiredHome	96:40b74dd3695b	2825	// so we can write the file in one pass.
WiredHome	96:40b74dd3695b	2826	for (int j = h - 1; j >= 0; j--) {
WiredHome	182:8832d03a2a29	2827	if (idle_callback && h >= 1) {
WiredHome	149:c62c4b2d6a15	2828	(idle_callback)(progress, (h - 1 - j) 100 / (h - 1));
WiredHome	149:c62c4b2d6a15	2829	}
WiredHome	96:40b74dd3695b	2830	if (ltpr0 >= 2) // Need to combine the layers...
WiredHome	96:40b74dd3695b	2831	SelectDrawingLayer(0); // so read layer 0 first
WiredHome	96:40b74dd3695b	2832	// Read one line of pixels to a local buffer
WiredHome	198:9b6851107426	2833	INFO("x,y %d,%d", x, y + j);
WiredHome	96:40b74dd3695b	2834	if (getPixelStream(pixelBuffer, w, x,y+j) != noerror) {
WiredHome	96:40b74dd3695b	2835	ERR("getPixelStream error, and no recovery handler...");
WiredHome	96:40b74dd3695b	2836	}
WiredHome	96:40b74dd3695b	2837	if (ltpr0 >= 2) { // Need to combine the layers...
WiredHome	96:40b74dd3695b	2838	SelectDrawingLayer(1); // so read layer 1 next
WiredHome	96:40b74dd3695b	2839	if (getPixelStream(pixelBuffer2, w, x,y+j) != noerror) {
WiredHome	96:40b74dd3695b	2840	ERR("getPixelStream error, and no recovery handler...");
WiredHome	96:40b74dd3695b	2841	}
WiredHome	96:40b74dd3695b	2842	}
WiredHome	164:76edd7d9cb68	2843	INFO("Line: %3d", j);
WiredHome	164:76edd7d9cb68	2844	//HexDump("Raster", (uint8_t )pixelBuffer, w sizeof(color_t));
WiredHome	96:40b74dd3695b	2845	// Convert the local buffer to RGBQUAD format
WiredHome	96:40b74dd3695b	2846	int lb = 0;
WiredHome	96:40b74dd3695b	2847	for (int i=0; i<w; i++) {
WiredHome	162:a2d7f1988711	2848	color_t tColor = pixelBuffer[x+i];
WiredHome	162:a2d7f1988711	2849	tColor = (tColor >> 8) \| (tColor << 8); // Byte Swap
WiredHome	162:a2d7f1988711	2850	RGBQUAD q0 = RGB16ToRGBQuad(tColor); // Scale to 24-bits
WiredHome	162:a2d7f1988711	2851	tColor = pixelBuffer2[x+i];
WiredHome	162:a2d7f1988711	2852	tColor = (tColor >> 8) \| (tColor << 8); // Byte Swap
WiredHome	162:a2d7f1988711	2853	RGBQUAD q1 = RGB16ToRGBQuad(tColor); // Scale to 24-bits
WiredHome	96:40b74dd3695b	2854	switch (ltpr0) {
WiredHome	96:40b74dd3695b	2855	case 0:
WiredHome	96:40b74dd3695b	2856	case 1:
WiredHome	96:40b74dd3695b	2857	case 2: // lighten-overlay (@TODO Not supported yet)
WiredHome	96:40b74dd3695b	2858	case 6: // Floating Windows (@TODO not sure how to support)
WiredHome	96:40b74dd3695b	2859	default: // Reserved...
WiredHome	164:76edd7d9cb68	2860	//lineBuffer[lb++] = q0.rgbBlue;
WiredHome	164:76edd7d9cb68	2861	//lineBuffer[lb++] = q0.rgbGreen;
WiredHome	164:76edd7d9cb68	2862	//lineBuffer[lb++] = q0.rgbRed;
WiredHome	164:76edd7d9cb68	2863	break;
WiredHome	164:76edd7d9cb68	2864	case 3: // transparent mode (@TODO Read the background color register for transparent)
WiredHome	164:76edd7d9cb68	2865	case 4: // boolean or
WiredHome	164:76edd7d9cb68	2866	q0.rgbBlue = q0.rgbBlue \| q1.rgbBlue;
WiredHome	164:76edd7d9cb68	2867	q0.rgbGreen = q0.rgbGreen \| q1.rgbGreen;
WiredHome	164:76edd7d9cb68	2868	q0.rgbRed = q0.rgbRed \| q1.rgbRed;
WiredHome	164:76edd7d9cb68	2869	break;
WiredHome	164:76edd7d9cb68	2870	case 5: // boolean AND
WiredHome	164:76edd7d9cb68	2871	q0.rgbBlue = q0.rgbBlue & q1.rgbBlue;
WiredHome	164:76edd7d9cb68	2872	q0.rgbGreen = q0.rgbGreen & q1.rgbGreen;
WiredHome	164:76edd7d9cb68	2873	q0.rgbRed = q0.rgbRed & q1.rgbRed;
WiredHome	164:76edd7d9cb68	2874	break;
WiredHome	164:76edd7d9cb68	2875	}
WiredHome	164:76edd7d9cb68	2876	switch (bitsPerPixel) {
WiredHome	164:76edd7d9cb68	2877	case 24:
WiredHome	96:40b74dd3695b	2878	lineBuffer[lb++] = q0.rgbBlue;
WiredHome	96:40b74dd3695b	2879	lineBuffer[lb++] = q0.rgbGreen;
WiredHome	96:40b74dd3695b	2880	lineBuffer[lb++] = q0.rgbRed;
WiredHome	96:40b74dd3695b	2881	break;
WiredHome	164:76edd7d9cb68	2882	case 8:
WiredHome	164:76edd7d9cb68	2883	default:
WiredHome	164:76edd7d9cb68	2884	lineBuffer[lb++] = FindNearestWebColor(q0.rgbRed,q0.rgbGreen,q0.rgbBlue);
WiredHome	96:40b74dd3695b	2885	break;
WiredHome	96:40b74dd3695b	2886	}
WiredHome	96:40b74dd3695b	2887	}
WiredHome	198:9b6851107426	2888	if (j == h - 1) {
WiredHome	198:9b6851107426	2889	HexDump("Line", lineBuffer, lineBufSize);
WiredHome	198:9b6851107426	2890	}
WiredHome	96:40b74dd3695b	2891	// Write to disk
WiredHome	162:a2d7f1988711	2892	privateCallback(WRITE, (uint8_t *)lineBuffer, lineBufSize);
WiredHome	96:40b74dd3695b	2893	}
WiredHome	96:40b74dd3695b	2894	SelectDrawingLayer(prevLayer);
WiredHome	96:40b74dd3695b	2895	privateCallback(CLOSE, NULL, 0);
WiredHome	96:40b74dd3695b	2896	#ifndef DOUBLEBUF
WiredHome	96:40b74dd3695b	2897	if (pixelBuffer2)
WiredHome	145:5eb2492acdda	2898	swFree(pixelBuffer2);
WiredHome	96:40b74dd3695b	2899	#endif
WiredHome	96:40b74dd3695b	2900	if (pixelBuffer)
WiredHome	145:5eb2492acdda	2901	swFree(pixelBuffer);
WiredHome	145:5eb2492acdda	2902	swFree(lineBuffer);
WiredHome	96:40b74dd3695b	2903	INFO("Image closed");
WiredHome	96:40b74dd3695b	2904	return noerror;
WiredHome	96:40b74dd3695b	2905	} else {
WiredHome	96:40b74dd3695b	2906	return bad_parameter;
WiredHome	96:40b74dd3695b	2907	}
WiredHome	96:40b74dd3695b	2908	}
WiredHome	79:544eb4964795	2909
WiredHome	163:17526689a3ed	2910
WiredHome	164:76edd7d9cb68	2911
WiredHome	163:17526689a3ed	2912	RetCode_t RA8875::PrintScreen(loc_t x, loc_t y, dim_t w, dim_t h, const char *Name_BMP, uint8_t bitsPerPixel)
WiredHome	72:ecffe56af969	2913	{
WiredHome	72:ecffe56af969	2914	BITMAPFILEHEADER BMP_Header;
WiredHome	72:ecffe56af969	2915	BITMAPINFOHEADER BMP_Info;
WiredHome	86:e86b355940f4	2916	uint8_t * lineBuffer = NULL;
WiredHome	86:e86b355940f4	2917	color_t * pixelBuffer = NULL;
WiredHome	86:e86b355940f4	2918	color_t * pixelBuffer2 = NULL;
WiredHome	190:3132b7dfad82	2919
WiredHome	198:9b6851107426	2920	//INFO("(%d,%d)-(%d,%d)x%d %s", x,y,w,h,bitsPerPixel,Name_BMP);
WiredHome	198:9b6851107426	2921	if (x >= 0 && x < virt_screenwidth
WiredHome	198:9b6851107426	2922	&& y >= 0 && y < virt_screenheight
WiredHome	198:9b6851107426	2923	&& w > 0 && x + w <= virt_screenwidth
WiredHome	198:9b6851107426	2924	&& h > 0 && y + h <= virt_screenheight) {
WiredHome	72:ecffe56af969	2925	BMP_Header.bfType = BF_TYPE;
WiredHome	72:ecffe56af969	2926	BMP_Header.bfReserved1 = 0;
WiredHome	72:ecffe56af969	2927	BMP_Header.bfReserved2 = 0;
WiredHome	163:17526689a3ed	2928	switch (bitsPerPixel) {
WiredHome	163:17526689a3ed	2929	case 24:
WiredHome	163:17526689a3ed	2930	BMP_Header.bfOffBits = sizeof(BMP_Header) + sizeof(BMP_Info);
WiredHome	163:17526689a3ed	2931	BMP_Header.bfSize = (h * RoundUp(w * sizeof(RGBQUAD),4)) + BMP_Header.bfOffBits;
WiredHome	163:17526689a3ed	2932	break;
WiredHome	163:17526689a3ed	2933	case 8:
WiredHome	163:17526689a3ed	2934	default:
WiredHome	163:17526689a3ed	2935	BMP_Header.bfOffBits = sizeof(BMP_Header) + sizeof(BMP_Info) + sizeof(WebColorPalette);
WiredHome	198:9b6851107426	2936	//INFO("Initial Offset to Bitstream %lX", BMP_Header.bfOffBits);
WiredHome	163:17526689a3ed	2937	//if (BMP_Header.bfOffBits & 0x03) {
WiredHome	163:17526689a3ed	2938	// BMP_Header.bfOffBits += (4 - (BMP_Header.bfOffBits & 0x03));
WiredHome	163:17526689a3ed	2939	//}
WiredHome	163:17526689a3ed	2940	BMP_Header.bfSize = (h * RoundUp(w * 1,4)) + BMP_Header.bfOffBits;
WiredHome	163:17526689a3ed	2941	break;
WiredHome	163:17526689a3ed	2942	}
WiredHome	198:9b6851107426	2943	//INFO("Offset to Bitstream %lX", BMP_Header.bfOffBits);
WiredHome	162:a2d7f1988711	2944
WiredHome	162:a2d7f1988711	2945	// Bytes in the line buffer
WiredHome	163:17526689a3ed	2946	int lineBufSize = RoundUp(((bitsPerPixel == 24) ? 3 : 1) * w, 4);
WiredHome	198:9b6851107426	2947	//INFO("LineBufSize: %d", lineBufSize);
WiredHome	73:f22a18707b5e	2948
WiredHome	72:ecffe56af969	2949	BMP_Info.biSize = sizeof(BMP_Info);
WiredHome	72:ecffe56af969	2950	BMP_Info.biWidth = w;
WiredHome	72:ecffe56af969	2951	BMP_Info.biHeight = h;
WiredHome	72:ecffe56af969	2952	BMP_Info.biPlanes = 1;
WiredHome	163:17526689a3ed	2953	BMP_Info.biBitCount = bitsPerPixel;
WiredHome	72:ecffe56af969	2954	BMP_Info.biCompression = BI_RGB;
WiredHome	162:a2d7f1988711	2955	BMP_Info.biSizeImage = lineBufSize * h;
WiredHome	72:ecffe56af969	2956	BMP_Info.biXPelsPerMeter = 0;
WiredHome	72:ecffe56af969	2957	BMP_Info.biYPelsPerMeter = 0;
WiredHome	163:17526689a3ed	2958	// for 24-bit, there is no palette, so these are zero
WiredHome	163:17526689a3ed	2959	// for 8-bit, there can be up to 256 RGB values in the palette
WiredHome	190:3132b7dfad82	2960
WiredHome	163:17526689a3ed	2961	BMP_Info.biClrUsed = (bitsPerPixel == 24) ? 0 : sizeof(WebColorPalette)/sizeof(WebColorPalette[0]); // for 8b/pixel
WiredHome	163:17526689a3ed	2962	BMP_Info.biClrImportant = BMP_Info.biClrUsed;
WiredHome	72:ecffe56af969	2963
WiredHome	86:e86b355940f4	2964	// Allocate the memory we need to proceed
WiredHome	145:5eb2492acdda	2965	lineBuffer = (uint8_t *)swMalloc(lineBufSize);
WiredHome	86:e86b355940f4	2966	if (lineBuffer == NULL) {
WiredHome	86:e86b355940f4	2967	ERR("Not enough RAM for PrintScreen lineBuffer");
WiredHome	86:e86b355940f4	2968	return(not_enough_ram);
WiredHome	86:e86b355940f4	2969	}
WiredHome	162:a2d7f1988711	2970	memset(lineBuffer, 0, lineBufSize); // zero-Fill
WiredHome	86:e86b355940f4	2971
WiredHome	86:e86b355940f4	2972	#define DOUBLEBUF /* one larger buffer instead of two */
WiredHome	190:3132b7dfad82	2973
WiredHome	86:e86b355940f4	2974	#ifdef DOUBLEBUF
WiredHome	197:853d08e2fb53	2975	// In the "#else", pixelBuffer2 malloc returns a value,
WiredHome	197:853d08e2fb53	2976	// but is actually causing a failure later.
WiredHome	86:e86b355940f4	2977	// This test helps determine if it is truly out of memory,
WiredHome	86:e86b355940f4	2978	// or if malloc is broken.
WiredHome	145:5eb2492acdda	2979	pixelBuffer = (color_t )swMalloc(2 w * sizeof(color_t));
WiredHome	182:8832d03a2a29	2980	if (pixelBuffer)
WiredHome	182:8832d03a2a29	2981	pixelBuffer2 = pixelBuffer + (w * sizeof(color_t));
WiredHome	182:8832d03a2a29	2982	else
WiredHome	182:8832d03a2a29	2983	pixelBuffer2 = NULL;
WiredHome	86:e86b355940f4	2984	#else
WiredHome	145:5eb2492acdda	2985	pixelBuffer = (color_t )swMalloc(w sizeof(color_t));
WiredHome	145:5eb2492acdda	2986	pixelBuffer2 = (color_t )swMalloc(w sizeof(color_t));
WiredHome	86:e86b355940f4	2987	#endif
WiredHome	86:e86b355940f4	2988	if (pixelBuffer == NULL \|\| pixelBuffer2 == NULL) {
WiredHome	86:e86b355940f4	2989	ERR("Not enough RAM for pixelBuffer");
WiredHome	86:e86b355940f4	2990	#ifndef DOUBLEBUF
WiredHome	86:e86b355940f4	2991	if (pixelBuffer2)
WiredHome	145:5eb2492acdda	2992	swFree(pixelBuffer2);
WiredHome	86:e86b355940f4	2993	#endif
WiredHome	86:e86b355940f4	2994	if (pixelBuffer)
WiredHome	145:5eb2492acdda	2995	swFree(pixelBuffer);
WiredHome	145:5eb2492acdda	2996	swFree(lineBuffer);
WiredHome	86:e86b355940f4	2997	return(not_enough_ram);
WiredHome	86:e86b355940f4	2998	}
WiredHome	86:e86b355940f4	2999
WiredHome	72:ecffe56af969	3000	FILE *Image = fopen(Name_BMP, "wb");
WiredHome	72:ecffe56af969	3001	if (!Image) {
WiredHome	86:e86b355940f4	3002	ERR("Can't open file for write");
WiredHome	86:e86b355940f4	3003	#ifndef DOUBLEBUF
WiredHome	86:e86b355940f4	3004	if (pixelBuffer2)
WiredHome	145:5eb2492acdda	3005	swFree(pixelBuffer2);
WiredHome	86:e86b355940f4	3006	#endif
WiredHome	86:e86b355940f4	3007	if (pixelBuffer)
WiredHome	145:5eb2492acdda	3008	swFree(pixelBuffer);
WiredHome	145:5eb2492acdda	3009	swFree(lineBuffer);
WiredHome	72:ecffe56af969	3010	return(file_not_found);
WiredHome	72:ecffe56af969	3011	}
WiredHome	72:ecffe56af969	3012
WiredHome	72:ecffe56af969	3013	// Be optimistic - don't check for errors.
WiredHome	198:9b6851107426	3014	//HexDump("BMP_Header", (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome	95:ef538bd687c0	3015	fwrite(&BMP_Header, sizeof(char), sizeof(BMP_Header), Image);
WiredHome	73:f22a18707b5e	3016
WiredHome	198:9b6851107426	3017	//HexDump("BMP_Info", (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome	95:ef538bd687c0	3018	fwrite(&BMP_Info, sizeof(char), sizeof(BMP_Info), Image);
WiredHome	190:3132b7dfad82	3019
WiredHome	163:17526689a3ed	3020	if (bitsPerPixel != 24) {
WiredHome	198:9b6851107426	3021	//HexDump("Palette", (uint8_t *)&WebColorPalette, sizeof(WebColorPalette));
WiredHome	163:17526689a3ed	3022	fwrite(&WebColorPalette, sizeof(char), sizeof(WebColorPalette), Image);
WiredHome	163:17526689a3ed	3023	if (0 && sizeof(WebColorPalette) % 4) {
WiredHome	163:17526689a3ed	3024	const uint8_t padd[] = { 0, 0, 0 };
WiredHome	190:3132b7dfad82	3025	fwrite(&padd, sizeof(char),
WiredHome	163:17526689a3ed	3026	(sizeof(BMP_Header) + sizeof(BMP_Info) + sizeof(WebColorPalette)) % 4, Image);
WiredHome	163:17526689a3ed	3027	}
WiredHome	163:17526689a3ed	3028	}
WiredHome	95:ef538bd687c0	3029	//color_t transparency = GetBackgroundTransparencyColor();
WiredHome	95:ef538bd687c0	3030	LayerMode_T ltpr0 = GetLayerMode();
WiredHome	73:f22a18707b5e	3031
WiredHome	73:f22a18707b5e	3032	uint16_t prevLayer = GetDrawingLayer();
WiredHome	73:f22a18707b5e	3033	// If only one of the layers is visible, select that layer
WiredHome	73:f22a18707b5e	3034	switch(ltpr0) {
WiredHome	95:ef538bd687c0	3035	case ShowLayer0:
WiredHome	73:f22a18707b5e	3036	SelectDrawingLayer(0);
WiredHome	73:f22a18707b5e	3037	break;
WiredHome	95:ef538bd687c0	3038	case ShowLayer1:
WiredHome	73:f22a18707b5e	3039	SelectDrawingLayer(1);
WiredHome	73:f22a18707b5e	3040	break;
WiredHome	73:f22a18707b5e	3041	default:
WiredHome	73:f22a18707b5e	3042	break;
WiredHome	73:f22a18707b5e	3043	}
WiredHome	73:f22a18707b5e	3044
WiredHome	72:ecffe56af969	3045	// Read the display from the last line toward the top
WiredHome	72:ecffe56af969	3046	// so we can write the file in one pass.
WiredHome	72:ecffe56af969	3047	for (int j = h - 1; j >= 0; j--) {
WiredHome	182:8832d03a2a29	3048	if (idle_callback && h >= 1) {
WiredHome	149:c62c4b2d6a15	3049	(idle_callback)(progress, (h - 1 - j) 100 / (h - 1));
WiredHome	149:c62c4b2d6a15	3050	}
WiredHome	149:c62c4b2d6a15	3051
WiredHome	73:f22a18707b5e	3052	if (ltpr0 >= 2) // Need to combine the layers...
WiredHome	73:f22a18707b5e	3053	SelectDrawingLayer(0); // so read layer 0 first
WiredHome	198:9b6851107426	3054
WiredHome	72:ecffe56af969	3055	// Read one line of pixels to a local buffer
WiredHome	72:ecffe56af969	3056	if (getPixelStream(pixelBuffer, w, x,y+j) != noerror) {
WiredHome	72:ecffe56af969	3057	ERR("getPixelStream error, and no recovery handler...");
WiredHome	72:ecffe56af969	3058	}
WiredHome	73:f22a18707b5e	3059	if (ltpr0 >= 2) { // Need to combine the layers...
WiredHome	86:e86b355940f4	3060	SelectDrawingLayer(1); // so read layer 1 next
WiredHome	73:f22a18707b5e	3061	if (getPixelStream(pixelBuffer2, w, x,y+j) != noerror) {
WiredHome	73:f22a18707b5e	3062	ERR("getPixelStream error, and no recovery handler...");
WiredHome	73:f22a18707b5e	3063	}
WiredHome	73:f22a18707b5e	3064	}
WiredHome	198:9b6851107426	3065	//INFO("Line: %3d", j);
WiredHome	163:17526689a3ed	3066	//HexDump("Raster", (uint8_t )pixelBuffer, w sizeof(color_t));
WiredHome	72:ecffe56af969	3067	// Convert the local buffer to RGBQUAD format
WiredHome	72:ecffe56af969	3068	int lb = 0;
WiredHome	72:ecffe56af969	3069	for (int i=0; i<w; i++) {
WiredHome	162:a2d7f1988711	3070	color_t tColor = pixelBuffer[x+i];
WiredHome	162:a2d7f1988711	3071	tColor = (tColor >> 8) \| (tColor << 8); // Byte Swap
WiredHome	162:a2d7f1988711	3072	RGBQUAD q0 = RGB16ToRGBQuad(tColor); // Scale to 24-bits
WiredHome	162:a2d7f1988711	3073	tColor = pixelBuffer2[x+i];
WiredHome	162:a2d7f1988711	3074	tColor = (tColor >> 8) \| (tColor << 8); // Byte Swap
WiredHome	162:a2d7f1988711	3075	RGBQUAD q1 = RGB16ToRGBQuad(tColor); // Scale to 24-bits
WiredHome	73:f22a18707b5e	3076	switch (ltpr0) {
WiredHome	73:f22a18707b5e	3077	case 0:
WiredHome	73:f22a18707b5e	3078	case 1:
WiredHome	73:f22a18707b5e	3079	case 2: // lighten-overlay (@TODO Not supported yet)
WiredHome	73:f22a18707b5e	3080	case 6: // Floating Windows (@TODO not sure how to support)
WiredHome	73:f22a18707b5e	3081	default: // Reserved...
WiredHome	163:17526689a3ed	3082	//lineBuffer[lb++] = q0.rgbBlue;
WiredHome	163:17526689a3ed	3083	//lineBuffer[lb++] = q0.rgbGreen;
WiredHome	163:17526689a3ed	3084	//lineBuffer[lb++] = q0.rgbRed;
WiredHome	163:17526689a3ed	3085	break;
WiredHome	163:17526689a3ed	3086	case 3: // transparent mode (@TODO Read the background color register for transparent)
WiredHome	163:17526689a3ed	3087	case 4: // boolean or
WiredHome	163:17526689a3ed	3088	q0.rgbBlue = q0.rgbBlue \| q1.rgbBlue;
WiredHome	163:17526689a3ed	3089	q0.rgbGreen = q0.rgbGreen \| q1.rgbGreen;
WiredHome	163:17526689a3ed	3090	q0.rgbRed = q0.rgbRed \| q1.rgbRed;
WiredHome	163:17526689a3ed	3091	break;
WiredHome	163:17526689a3ed	3092	case 5: // boolean AND
WiredHome	163:17526689a3ed	3093	q0.rgbBlue = q0.rgbBlue & q1.rgbBlue;
WiredHome	163:17526689a3ed	3094	q0.rgbGreen = q0.rgbGreen & q1.rgbGreen;
WiredHome	163:17526689a3ed	3095	q0.rgbRed = q0.rgbRed & q1.rgbRed;
WiredHome	163:17526689a3ed	3096	break;
WiredHome	163:17526689a3ed	3097	}
WiredHome	163:17526689a3ed	3098	switch (bitsPerPixel) {
WiredHome	163:17526689a3ed	3099	case 24:
WiredHome	73:f22a18707b5e	3100	lineBuffer[lb++] = q0.rgbBlue;
WiredHome	73:f22a18707b5e	3101	lineBuffer[lb++] = q0.rgbGreen;
WiredHome	73:f22a18707b5e	3102	lineBuffer[lb++] = q0.rgbRed;
WiredHome	73:f22a18707b5e	3103	break;
WiredHome	163:17526689a3ed	3104	case 8:
WiredHome	163:17526689a3ed	3105	default:
WiredHome	163:17526689a3ed	3106	lineBuffer[lb++] = FindNearestWebColor(q0.rgbRed,q0.rgbGreen,q0.rgbBlue);
WiredHome	73:f22a18707b5e	3107	break;
WiredHome	73:f22a18707b5e	3108	}
WiredHome	72:ecffe56af969	3109	}
WiredHome	162:a2d7f1988711	3110	//if (j == h - 1) {
WiredHome	163:17526689a3ed	3111	// HexDump("Line", lineBuffer, lineBufSize);
WiredHome	162:a2d7f1988711	3112	//}
WiredHome	72:ecffe56af969	3113	// Write to disk
WiredHome	162:a2d7f1988711	3114	fwrite(lineBuffer, sizeof(char), lineBufSize, Image);
WiredHome	72:ecffe56af969	3115	}
WiredHome	73:f22a18707b5e	3116	SelectDrawingLayer(prevLayer);
WiredHome	72:ecffe56af969	3117	fclose(Image);
WiredHome	86:e86b355940f4	3118	#ifndef DOUBLEBUF
WiredHome	86:e86b355940f4	3119	if (pixelBuffer2)
WiredHome	145:5eb2492acdda	3120	swFree(pixelBuffer2);
WiredHome	86:e86b355940f4	3121	#endif
WiredHome	86:e86b355940f4	3122	if (pixelBuffer)
WiredHome	145:5eb2492acdda	3123	swFree(pixelBuffer);
WiredHome	145:5eb2492acdda	3124	swFree(lineBuffer);
WiredHome	198:9b6851107426	3125	//INFO("Image closed");
WiredHome	72:ecffe56af969	3126	return noerror;
WiredHome	72:ecffe56af969	3127	} else {
WiredHome	72:ecffe56af969	3128	return bad_parameter;
WiredHome	72:ecffe56af969	3129	}
WiredHome	72:ecffe56af969	3130	}
WiredHome	72:ecffe56af969	3131
WiredHome	72:ecffe56af969	3132
WiredHome	72:ecffe56af969	3133	// ##########################################################################
WiredHome	72:ecffe56af969	3134	// ##########################################################################
WiredHome	72:ecffe56af969	3135	// ##########################################################################
WiredHome	72:ecffe56af969	3136
WiredHome	23:a50ded45dbaf	3137	#ifdef TESTENABLE
WiredHome	23:a50ded45dbaf	3138
WiredHome	98:ecebed9b80b2	3139	#include "BPG_Arial08x08.h"
WiredHome	98:ecebed9b80b2	3140	#include "BPG_Arial20x20.h"
WiredHome	37:f19b7e7449dc	3141
WiredHome	23:a50ded45dbaf	3142	// ______________ ______________ ______________ _______________
WiredHome	23:a50ded45dbaf	3143	// /_____ _____/ / ___________/ / ___________/ /_____ ______/
WiredHome	23:a50ded45dbaf	3144	// / / / / / / / /
WiredHome	23:a50ded45dbaf	3145	// / / / /___ / /__________ / /
WiredHome	23:a50ded45dbaf	3146	// / / / ____/ /__________ / / /
WiredHome	23:a50ded45dbaf	3147	// / / / / / / / /
WiredHome	23:a50ded45dbaf	3148	// / / / /__________ ___________/ / / /
WiredHome	23:a50ded45dbaf	3149	// /__/ /_____________/ /_____________/ /__/
WiredHome	23:a50ded45dbaf	3150	//
WiredHome	23:a50ded45dbaf	3151	// Everything from here down is test code.
WiredHome	75:ca78388cfd77	3152	//
WiredHome	41:2956a0a221e5	3153	bool SuppressSlowStuff = false;
WiredHome	23:a50ded45dbaf	3154
WiredHome	49:c5182231d1b9	3155	void TextWrapTest(RA8875 & display, Serial & pc)
WiredHome	49:c5182231d1b9	3156	{
WiredHome	49:c5182231d1b9	3157	if (!SuppressSlowStuff)
WiredHome	49:c5182231d1b9	3158	pc.printf("Text Wrap Test\r\n");
WiredHome	49:c5182231d1b9	3159	display.background(Black);
WiredHome	49:c5182231d1b9	3160	display.foreground(Blue);
WiredHome	49:c5182231d1b9	3161	display.cls();
WiredHome	49:c5182231d1b9	3162	display.Backlight_u8(255);
WiredHome	100:0b084475d5a9	3163	display.puts("Text Wrap Test.\r\n");
WiredHome	52:e6039a823420	3164	for (int i=1; i<60; i++) {
WiredHome	52:e6039a823420	3165	display.printf("L%2d\n", i % 17);
WiredHome	49:c5182231d1b9	3166	if (!SuppressSlowStuff)
WiredHome	197:853d08e2fb53	3167	wait_us(100000);
WiredHome	49:c5182231d1b9	3168	}
WiredHome	49:c5182231d1b9	3169	if (!SuppressSlowStuff)
WiredHome	197:853d08e2fb53	3170	wait_us(3000000);
WiredHome	49:c5182231d1b9	3171	}
WiredHome	49:c5182231d1b9	3172
WiredHome	75:ca78388cfd77	3173
WiredHome	75:ca78388cfd77	3174	void ShowKey(RA8875 & display, int key)
WiredHome	75:ca78388cfd77	3175	{
WiredHome	75:ca78388cfd77	3176	loc_t col, row;
WiredHome	75:ca78388cfd77	3177	dim_t r1 = 25;
WiredHome	75:ca78388cfd77	3178	color_t color = (key & 0x80) ? Red : Green;
WiredHome	75:ca78388cfd77	3179
WiredHome	75:ca78388cfd77	3180	key &= 0x7F; // remove the long-press flag
WiredHome	75:ca78388cfd77	3181	row = (key - 1) / 5;
WiredHome	75:ca78388cfd77	3182	col = (key - 1) % 5;
WiredHome	75:ca78388cfd77	3183	if (col > 5) col = 5;
WiredHome	75:ca78388cfd77	3184	if (row > 4) row = 4;
WiredHome	75:ca78388cfd77	3185	display.circle(450 - + (2 * r1) * col, 200 - (2 * r1) * row, r1-2, color, FILL);
WiredHome	75:ca78388cfd77	3186	}
WiredHome	75:ca78388cfd77	3187
WiredHome	75:ca78388cfd77	3188	void HideKey(RA8875 & display, int key)
WiredHome	75:ca78388cfd77	3189	{
WiredHome	75:ca78388cfd77	3190	loc_t col, row;
WiredHome	75:ca78388cfd77	3191	dim_t r1 = 25;
WiredHome	75:ca78388cfd77	3192
WiredHome	75:ca78388cfd77	3193	row = (key - 1) / 5;
WiredHome	75:ca78388cfd77	3194	col = (key - 1) % 5;
WiredHome	75:ca78388cfd77	3195	if (col > 5) col = 5;
WiredHome	75:ca78388cfd77	3196	if (row > 4) row = 4;
WiredHome	75:ca78388cfd77	3197	display.background(Black);
WiredHome	75:ca78388cfd77	3198	display.circle(450 - (2 * r1) * col, 200 - (2 * r1) * row, r1-2, Black, FILL);
WiredHome	75:ca78388cfd77	3199	display.circle(450 - (2 * r1) * col, 200 - (2 * r1) * row, r1-2, Blue);
WiredHome	75:ca78388cfd77	3200	}
WiredHome	75:ca78388cfd77	3201
WiredHome	75:ca78388cfd77	3202	void KeyPadTest(RA8875 & display, Serial & pc)
WiredHome	75:ca78388cfd77	3203	{
WiredHome	75:ca78388cfd77	3204	const uint8_t myMap[22] = {
WiredHome	77:9206c13aa527	3205	0,
WiredHome	75:ca78388cfd77	3206	'a', 'b', 'c', 'd', 'e',
WiredHome	75:ca78388cfd77	3207	'f', 'g', 'h', 'i', 'j',
WiredHome	75:ca78388cfd77	3208	'k', 'l', 'm', 'n', 'o',
WiredHome	75:ca78388cfd77	3209	'p', 'q', 'r', 's', 't',
WiredHome	75:ca78388cfd77	3210	'x'
WiredHome	75:ca78388cfd77	3211	};
WiredHome	77:9206c13aa527	3212
WiredHome	75:ca78388cfd77	3213	display.background(Black);
WiredHome	75:ca78388cfd77	3214	display.foreground(Blue);
WiredHome	75:ca78388cfd77	3215	display.cls();
WiredHome	75:ca78388cfd77	3216	display.Backlight_u8(255);
WiredHome	100:0b084475d5a9	3217	display.puts("KeyPad Test. Touch the keypad...");
WiredHome	75:ca78388cfd77	3218	pc.printf("\r\n"
WiredHome	75:ca78388cfd77	3219	"Raw KeyPad Test. Keypad returns the key-number.\r\n"
WiredHome	75:ca78388cfd77	3220	"Press [most] any PC keyboard key to advance to next test.\r\n");
WiredHome	75:ca78388cfd77	3221	RetCode_t ret = display.KeypadInit(true, true, 3, 7, 3);
WiredHome	75:ca78388cfd77	3222	if (ret != noerror)
WiredHome	75:ca78388cfd77	3223	pc.printf("returncode from KeypadInit is %d\r\n", ret);
WiredHome	75:ca78388cfd77	3224	int lastKey = 0;
WiredHome	75:ca78388cfd77	3225	while (!pc.readable()) {
WiredHome	75:ca78388cfd77	3226	if (display.readable()) {
WiredHome	75:ca78388cfd77	3227	int key = display.getc();
WiredHome	75:ca78388cfd77	3228	if (key) {
WiredHome	75:ca78388cfd77	3229	if (((key & 0x7F) != lastKey) && (lastKey != 0))
WiredHome	75:ca78388cfd77	3230	HideKey(display, lastKey);
WiredHome	75:ca78388cfd77	3231	ShowKey(display, key);
WiredHome	75:ca78388cfd77	3232	lastKey = key & 0x7F;
WiredHome	75:ca78388cfd77	3233	} else {
WiredHome	75:ca78388cfd77	3234	// erase the last one
WiredHome	75:ca78388cfd77	3235	if (lastKey)
WiredHome	75:ca78388cfd77	3236	HideKey(display, lastKey);
WiredHome	75:ca78388cfd77	3237	}
WiredHome	75:ca78388cfd77	3238	}
WiredHome	75:ca78388cfd77	3239	}
WiredHome	75:ca78388cfd77	3240	(void)pc.getc();
WiredHome	75:ca78388cfd77	3241	pc.printf("\r\n"
WiredHome	75:ca78388cfd77	3242	"Map KeyPad Test. Keypad returns the remapped key 'a' - 't'.\r\n"
WiredHome	75:ca78388cfd77	3243	"Press [most] any PC keyboard key to advance to exit test.\r\n");
WiredHome	75:ca78388cfd77	3244	display.SetKeyMap(myMap);
WiredHome	75:ca78388cfd77	3245	while (!pc.readable()) {
WiredHome	75:ca78388cfd77	3246	if (display.readable()) {
WiredHome	75:ca78388cfd77	3247	int key = display.getc();
WiredHome	75:ca78388cfd77	3248	bool longPress = key & 0x80;
WiredHome	75:ca78388cfd77	3249	display.SetTextCursor(0, 120);
WiredHome	75:ca78388cfd77	3250	display.printf("Long Press: %d\r\n", longPress);
WiredHome	75:ca78388cfd77	3251	display.printf(" Remapped: %c %02X\r\n", (key) ? key & 0x7F : ' ', key);
WiredHome	75:ca78388cfd77	3252	}
WiredHome	75:ca78388cfd77	3253	}
WiredHome	75:ca78388cfd77	3254	(void)pc.getc();
WiredHome	75:ca78388cfd77	3255	display.SetKeyMap();
WiredHome	75:ca78388cfd77	3256	pc.printf("\r\n");
WiredHome	75:ca78388cfd77	3257	}
WiredHome	75:ca78388cfd77	3258
WiredHome	23:a50ded45dbaf	3259	void TextCursorTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3260	{
WiredHome	75:ca78388cfd77	3261	const char * iCursor = "The I-Beam cursor should be visible for this text.\r\n";
WiredHome	75:ca78388cfd77	3262	const char * uCursor = "The Underscore cursor should be visible for this text.\r\n";
WiredHome	75:ca78388cfd77	3263	const char * bCursor = "The Block cursor should be visible for this text.\r\n";
WiredHome	37:f19b7e7449dc	3264	const char * bbCursor = "The Blinking Block cursor should be visible for this text.\r\n";
WiredHome	23:a50ded45dbaf	3265	const char * p;
WiredHome	100:0b084475d5a9	3266	int delay = 60;
WiredHome	73:f22a18707b5e	3267
WiredHome	41:2956a0a221e5	3268	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3269	pc.printf("Text Cursor Test\r\n");
WiredHome	73:f22a18707b5e	3270	else
WiredHome	41:2956a0a221e5	3271	delay = 0;
WiredHome	23:a50ded45dbaf	3272	display.background(Black);
WiredHome	23:a50ded45dbaf	3273	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3274	display.cls();
WiredHome	25:9556a3a9b7cc	3275	display.Backlight_u8(255);
WiredHome	100:0b084475d5a9	3276	display.puts("Text Cursor Test.");
WiredHome	73:f22a18707b5e	3277
WiredHome	23:a50ded45dbaf	3278	// visible, non-blinking
WiredHome	24:8ca861acf12d	3279	display.SetTextCursor(0,20);
WiredHome	53:86d24b9480b9	3280	display.SetTextCursorControl(RA8875::IBEAM, false);
WiredHome	24:8ca861acf12d	3281	p = iCursor;
WiredHome	23:a50ded45dbaf	3282	while (*p) {
WiredHome	24:8ca861acf12d	3283	display._putc(*p++);
WiredHome	41:2956a0a221e5	3284	wait_ms(delay);
WiredHome	24:8ca861acf12d	3285	}
WiredHome	24:8ca861acf12d	3286
WiredHome	53:86d24b9480b9	3287	display.SetTextCursorControl(RA8875::UNDER, false);
WiredHome	24:8ca861acf12d	3288	p = uCursor;
WiredHome	24:8ca861acf12d	3289	while (*p) {
WiredHome	24:8ca861acf12d	3290	display._putc(*p++);
WiredHome	41:2956a0a221e5	3291	wait_ms(delay);
WiredHome	23:a50ded45dbaf	3292	}
WiredHome	73:f22a18707b5e	3293
WiredHome	53:86d24b9480b9	3294	display.SetTextCursorControl(RA8875::BLOCK, false);
WiredHome	24:8ca861acf12d	3295	p = bCursor;
WiredHome	24:8ca861acf12d	3296	while (*p) {
WiredHome	24:8ca861acf12d	3297	display._putc(*p++);
WiredHome	41:2956a0a221e5	3298	wait_ms(delay);
WiredHome	24:8ca861acf12d	3299	}
WiredHome	24:8ca861acf12d	3300
WiredHome	53:86d24b9480b9	3301	display.SetTextCursorControl(RA8875::BLOCK, true);
WiredHome	24:8ca861acf12d	3302	p = bbCursor;
WiredHome	24:8ca861acf12d	3303	while (*p) {
WiredHome	24:8ca861acf12d	3304	display._putc(*p++);
WiredHome	41:2956a0a221e5	3305	wait_ms(delay);
WiredHome	24:8ca861acf12d	3306	}
WiredHome	41:2956a0a221e5	3307	wait_ms(delay * 20);
WiredHome	53:86d24b9480b9	3308	display.SetTextCursorControl(RA8875::NOCURSOR, false);
WiredHome	23:a50ded45dbaf	3309	}
WiredHome	23:a50ded45dbaf	3310
WiredHome	44:207594dece70	3311
WiredHome	23:a50ded45dbaf	3312	void BacklightTest(RA8875 & display, Serial & pc, float ramptime)
WiredHome	23:a50ded45dbaf	3313	{
WiredHome	29:422616aa04bd	3314	char buf[60];
WiredHome	41:2956a0a221e5	3315	unsigned int w = (ramptime * 1000)/ 256;
WiredHome	41:2956a0a221e5	3316	int delay = 200;
WiredHome	41:2956a0a221e5	3317
WiredHome	41:2956a0a221e5	3318	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3319	pc.printf("Backlight Test - ramp over %f sec.\r\n", ramptime);
WiredHome	41:2956a0a221e5	3320	else {
WiredHome	41:2956a0a221e5	3321	delay = 0;
WiredHome	41:2956a0a221e5	3322	w = 0;
WiredHome	41:2956a0a221e5	3323	}
WiredHome	23:a50ded45dbaf	3324	display.Backlight_u8(0);
WiredHome	29:422616aa04bd	3325	display.background(White);
WiredHome	23:a50ded45dbaf	3326	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3327	display.cls();
WiredHome	100:0b084475d5a9	3328	display.puts("RA8875 Backlight Test - Ramp up.");
WiredHome	41:2956a0a221e5	3329	wait_ms(delay);
WiredHome	38:38d503b4fad6	3330	for (int i=0; i <= 255; i++) {
WiredHome	182:8832d03a2a29	3331	snprintf(buf, sizeof(buf), "%3d, %4u", i, w);
WiredHome	37:f19b7e7449dc	3332	display.puts(100,100,buf);
WiredHome	23:a50ded45dbaf	3333	display.Backlight_u8(i);
WiredHome	29:422616aa04bd	3334	wait_ms(w);
WiredHome	23:a50ded45dbaf	3335	}
WiredHome	23:a50ded45dbaf	3336	}
WiredHome	23:a50ded45dbaf	3337
WiredHome	44:207594dece70	3338
WiredHome	23:a50ded45dbaf	3339	void BacklightTest2(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3340	{
WiredHome	41:2956a0a221e5	3341	int delay = 20;
WiredHome	41:2956a0a221e5	3342
WiredHome	41:2956a0a221e5	3343	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3344	pc.printf("Backlight Test 2\r\n");
WiredHome	41:2956a0a221e5	3345	else
WiredHome	41:2956a0a221e5	3346	delay = 0;
WiredHome	41:2956a0a221e5	3347
WiredHome	23:a50ded45dbaf	3348	// Dim it out at the end of the tests.
WiredHome	37:f19b7e7449dc	3349	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3350	display.puts(0,0, "Ramp Backlight down.");
WiredHome	23:a50ded45dbaf	3351	// Ramp it off
WiredHome	23:a50ded45dbaf	3352	for (int i=255; i != 0; i--) {
WiredHome	23:a50ded45dbaf	3353	display.Backlight_u8(i);
WiredHome	41:2956a0a221e5	3354	wait_ms(delay);
WiredHome	23:a50ded45dbaf	3355	}
WiredHome	23:a50ded45dbaf	3356	display.Backlight_u8(0);
WiredHome	23:a50ded45dbaf	3357	}
WiredHome	23:a50ded45dbaf	3358
WiredHome	44:207594dece70	3359
WiredHome	23:a50ded45dbaf	3360	void ExternalFontTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3361	{
WiredHome	41:2956a0a221e5	3362	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3363	pc.printf("External Font Test\r\n");
WiredHome	23:a50ded45dbaf	3364	display.background(Black);
WiredHome	23:a50ded45dbaf	3365	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3366	display.cls();
WiredHome	100:0b084475d5a9	3367	display.puts("External Font Test.");
WiredHome	23:a50ded45dbaf	3368	display.Backlight(1);
WiredHome	37:f19b7e7449dc	3369
WiredHome	98:ecebed9b80b2	3370	display.SelectUserFont(BPG_Arial08x08);
WiredHome	73:f22a18707b5e	3371	display.puts(0,30, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\r\n");
WiredHome	37:f19b7e7449dc	3372
WiredHome	98:ecebed9b80b2	3373	display.SelectUserFont(BPG_Arial20x20);
WiredHome	37:f19b7e7449dc	3374	display.puts("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\r\n");
WiredHome	190:3132b7dfad82	3375
WiredHome	98:ecebed9b80b2	3376	display.SelectUserFont();
WiredHome	73:f22a18707b5e	3377
WiredHome	37:f19b7e7449dc	3378	display.puts("Normal font again.");
WiredHome	37:f19b7e7449dc	3379	//display.window(0,0, display.width(), display.height());
WiredHome	23:a50ded45dbaf	3380	}
WiredHome	23:a50ded45dbaf	3381
WiredHome	44:207594dece70	3382
WiredHome	23:a50ded45dbaf	3383	void DOSColorTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3384	{
WiredHome	41:2956a0a221e5	3385	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3386	pc.printf("DOS Color Test\r\n");
WiredHome	23:a50ded45dbaf	3387	display.background(Black);
WiredHome	23:a50ded45dbaf	3388	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3389	display.cls();
WiredHome	100:0b084475d5a9	3390	display.puts("DOS Colors - Fore");
WiredHome	23:a50ded45dbaf	3391	display.puts(280,0, "Back");
WiredHome	23:a50ded45dbaf	3392	display.background(Gray);
WiredHome	23:a50ded45dbaf	3393	for (int i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	3394	display.foreground(display.DOSColor(i));
WiredHome	23:a50ded45dbaf	3395	display.puts(160, i*16, display.DOSColorNames(i));
WiredHome	23:a50ded45dbaf	3396	display.background(Black);
WiredHome	23:a50ded45dbaf	3397	}
WiredHome	23:a50ded45dbaf	3398	display.foreground(White);
WiredHome	23:a50ded45dbaf	3399	for (int i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	3400	display.background(display.DOSColor(i));
WiredHome	23:a50ded45dbaf	3401	display.puts(360, i*16, display.DOSColorNames(i));
WiredHome	23:a50ded45dbaf	3402	display.foreground(White);
WiredHome	23:a50ded45dbaf	3403	}
WiredHome	23:a50ded45dbaf	3404	}
WiredHome	23:a50ded45dbaf	3405
WiredHome	44:207594dece70	3406
WiredHome	23:a50ded45dbaf	3407	void WebColorTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3408	{
WiredHome	41:2956a0a221e5	3409	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3410	pc.printf("Web Color Test\r\n");
WiredHome	23:a50ded45dbaf	3411	display.background(Black);
WiredHome	23:a50ded45dbaf	3412	display.foreground(Blue);
WiredHome	32:0e4f2ae512e2	3413	display.window(0,0, display.width(), display.height());
WiredHome	23:a50ded45dbaf	3414	display.cls();
WiredHome	59:fb40aad4efd4	3415	display.SetTextFontSize(1,1);
WiredHome	59:fb40aad4efd4	3416	display.puts(200,0, "Web Color Test");
WiredHome	59:fb40aad4efd4	3417	display.SetTextCursor(0,0);
WiredHome	59:fb40aad4efd4	3418	display.puts(" ");
WiredHome	59:fb40aad4efd4	3419	for (int i=0; i<16; i++)
WiredHome	59:fb40aad4efd4	3420	display.printf("%X", i&0xF);
WiredHome	59:fb40aad4efd4	3421	display.puts("\r\n0 ");
WiredHome	23:a50ded45dbaf	3422	for (int i=0; i<sizeof(WebColors)/sizeof(WebColors[0]); i++) {
WiredHome	23:a50ded45dbaf	3423	display.background(WebColors[i]);
WiredHome	23:a50ded45dbaf	3424	display.puts(" ");
WiredHome	59:fb40aad4efd4	3425	if (i % 16 == 15 && i < 255) {
WiredHome	59:fb40aad4efd4	3426	display.printf("\r\n%X ", ((i+1)/16));
WiredHome	59:fb40aad4efd4	3427	}
WiredHome	23:a50ded45dbaf	3428	}
WiredHome	23:a50ded45dbaf	3429	display.SetTextFontSize(1,1);
WiredHome	23:a50ded45dbaf	3430	}
WiredHome	23:a50ded45dbaf	3431
WiredHome	44:207594dece70	3432
WiredHome	37:f19b7e7449dc	3433	void PixelTest(RA8875 & display, Serial & pc)
WiredHome	37:f19b7e7449dc	3434	{
WiredHome	37:f19b7e7449dc	3435	int i, c, x, y;
WiredHome	37:f19b7e7449dc	3436
WiredHome	41:2956a0a221e5	3437	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3438	pc.printf("Pixel Test\r\n");
WiredHome	37:f19b7e7449dc	3439	display.background(Black);
WiredHome	37:f19b7e7449dc	3440	display.foreground(Blue);
WiredHome	37:f19b7e7449dc	3441	display.cls();
WiredHome	100:0b084475d5a9	3442	display.puts("Pixel Test");
WiredHome	37:f19b7e7449dc	3443	for (i=0; i<1000; i++) {
WiredHome	37:f19b7e7449dc	3444	x = rand() % 480;
WiredHome	37:f19b7e7449dc	3445	y = 16 + rand() % (272-16);
WiredHome	37:f19b7e7449dc	3446	c = rand() % 16;
WiredHome	37:f19b7e7449dc	3447	//pc.printf(" (%d,%d) - %d\r\n", x,y,r1);
WiredHome	37:f19b7e7449dc	3448	display.pixel(x,y, display.DOSColor(c));
WiredHome	37:f19b7e7449dc	3449	}
WiredHome	37:f19b7e7449dc	3450	}
WiredHome	37:f19b7e7449dc	3451
WiredHome	44:207594dece70	3452
WiredHome	23:a50ded45dbaf	3453	void LineTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3454	{
WiredHome	23:a50ded45dbaf	3455	int i, x, y, x2, y2;
WiredHome	23:a50ded45dbaf	3456
WiredHome	41:2956a0a221e5	3457	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3458	pc.printf("Line Test\r\n");
WiredHome	23:a50ded45dbaf	3459	display.background(Black);
WiredHome	23:a50ded45dbaf	3460	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3461	display.cls();
WiredHome	100:0b084475d5a9	3462	display.puts("Line Test");
WiredHome	23:a50ded45dbaf	3463	for (i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	3464	// Lines
WiredHome	23:a50ded45dbaf	3465	x = rand() % 480;
WiredHome	23:a50ded45dbaf	3466	y = rand() % 272;
WiredHome	23:a50ded45dbaf	3467	x2 = rand() % 480;
WiredHome	23:a50ded45dbaf	3468	y2 = rand() % 272;
WiredHome	23:a50ded45dbaf	3469	display.line(x,y, x2,y2, display.DOSColor(i));
WiredHome	23:a50ded45dbaf	3470	}
WiredHome	62:ba5d33438fda	3471	display.foreground(BrightRed);
WiredHome	62:ba5d33438fda	3472	display.foreground(BrightGreen);
WiredHome	62:ba5d33438fda	3473	display.foreground(BrightBlue);
WiredHome	62:ba5d33438fda	3474	display.line(55,50, 79,74, BrightRed);
WiredHome	62:ba5d33438fda	3475	display.line(57,50, 81,74, BrightGreen);
WiredHome	62:ba5d33438fda	3476	display.line(59,50, 83,74, BrightBlue);
WiredHome	62:ba5d33438fda	3477	// horz
WiredHome	62:ba5d33438fda	3478	display.line(30,40, 32,40, BrightRed);
WiredHome	62:ba5d33438fda	3479	display.line(30,42, 32,42, BrightGreen);
WiredHome	62:ba5d33438fda	3480	display.line(30,44, 32,44, BrightBlue);
WiredHome	62:ba5d33438fda	3481	// vert
WiredHome	62:ba5d33438fda	3482	display.line(20,40, 20,42, BrightRed);
WiredHome	62:ba5d33438fda	3483	display.line(22,40, 22,42, BrightGreen);
WiredHome	62:ba5d33438fda	3484	display.line(24,40, 24,42, BrightBlue);
WiredHome	62:ba5d33438fda	3485	// compare point to line-point
WiredHome	62:ba5d33438fda	3486	display.pixel(20,50, BrightRed);
WiredHome	62:ba5d33438fda	3487	display.pixel(22,50, BrightGreen);
WiredHome	62:ba5d33438fda	3488	display.pixel(24,50, BrightBlue);
WiredHome	62:ba5d33438fda	3489	display.line(20,52, 20,52, BrightRed);
WiredHome	62:ba5d33438fda	3490	display.line(22,52, 22,52, BrightGreen);
WiredHome	62:ba5d33438fda	3491	display.line(24,52, 24,52, BrightBlue);
WiredHome	73:f22a18707b5e	3492
WiredHome	62:ba5d33438fda	3493	// point
WiredHome	62:ba5d33438fda	3494	display.line(50,50, 50,50, Red);
WiredHome	62:ba5d33438fda	3495	display.line(52,52, 52,52, Green);
WiredHome	62:ba5d33438fda	3496	display.line(54,54, 54,54, Blue);
WiredHome	62:ba5d33438fda	3497	display.line(60,60, 60,60, BrightRed);
WiredHome	62:ba5d33438fda	3498	display.line(62,62, 62,62, BrightGreen);
WiredHome	62:ba5d33438fda	3499	display.line(64,64, 64,64, BrightBlue);
WiredHome	62:ba5d33438fda	3500	display.line(70,70, 70,70, DarkRed);
WiredHome	62:ba5d33438fda	3501	display.line(72,72, 72,72, DarkGreen);
WiredHome	62:ba5d33438fda	3502	display.line(74,74, 74,74, DarkBlue);
WiredHome	23:a50ded45dbaf	3503	}
WiredHome	23:a50ded45dbaf	3504
WiredHome	44:207594dece70	3505
WiredHome	23:a50ded45dbaf	3506	void RectangleTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3507	{
WiredHome	23:a50ded45dbaf	3508	int i, x1,y1, x2,y2;
WiredHome	23:a50ded45dbaf	3509
WiredHome	41:2956a0a221e5	3510	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3511	pc.printf("Rectangle Test\r\n");
WiredHome	23:a50ded45dbaf	3512	display.background(Black);
WiredHome	23:a50ded45dbaf	3513	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3514	display.cls();
WiredHome	100:0b084475d5a9	3515	display.puts("Rectangle Test");
WiredHome	23:a50ded45dbaf	3516	for (i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	3517	x1 = rand() % 240;
WiredHome	23:a50ded45dbaf	3518	y1 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3519	x2 = rand() % 240;
WiredHome	23:a50ded45dbaf	3520	y2 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3521	display.rect(x1,y1, x2,y2, display.DOSColor(i));
WiredHome	23:a50ded45dbaf	3522
WiredHome	23:a50ded45dbaf	3523	x1 = 240 + rand() % 240;
WiredHome	23:a50ded45dbaf	3524	y1 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3525	x2 = 240 + rand() % 240;
WiredHome	23:a50ded45dbaf	3526	y2 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3527	display.rect(x1,y1, x2,y2, FILL);
WiredHome	23:a50ded45dbaf	3528	}
WiredHome	23:a50ded45dbaf	3529	}
WiredHome	23:a50ded45dbaf	3530
WiredHome	44:207594dece70	3531
WiredHome	44:207594dece70	3532	void LayerTest(RA8875 & display, Serial & pc)
WiredHome	44:207594dece70	3533	{
WiredHome	44:207594dece70	3534	loc_t i, x1,y1, x2,y2, r1,r2;
WiredHome	44:207594dece70	3535
WiredHome	44:207594dece70	3536	if (!SuppressSlowStuff)
WiredHome	44:207594dece70	3537	pc.printf("Layer Test\r\n");
WiredHome	44:207594dece70	3538
WiredHome	50:2c4f474a2453	3539	display.SelectDrawingLayer(0);
WiredHome	44:207594dece70	3540	display.background(Black);
WiredHome	44:207594dece70	3541	display.foreground(Blue);
WiredHome	44:207594dece70	3542	display.cls();
WiredHome	100:0b084475d5a9	3543	display.puts("Layer 0");
WiredHome	44:207594dece70	3544	for (i=0; i<16; i++) {
WiredHome	44:207594dece70	3545	x1 = rand() % 240;
WiredHome	44:207594dece70	3546	y1 = 50 + rand() % 200;
WiredHome	44:207594dece70	3547	x2 = x1 + rand() % 100;
WiredHome	44:207594dece70	3548	y2 = y1 + rand() % 100;
WiredHome	44:207594dece70	3549	r1 = rand() % (x2 - x1)/2;
WiredHome	44:207594dece70	3550	r2 = rand() % (y2 - y1)/2;
WiredHome	44:207594dece70	3551	display.roundrect(x1,y1, x2,y2, r1,r2, display.DOSColor(i));
WiredHome	44:207594dece70	3552	if (!SuppressSlowStuff)
WiredHome	197:853d08e2fb53	3553	wait_us(20000);
WiredHome	44:207594dece70	3554	}
WiredHome	44:207594dece70	3555	if (!SuppressSlowStuff)
WiredHome	197:853d08e2fb53	3556	wait_us(1000000);
WiredHome	44:207594dece70	3557
WiredHome	50:2c4f474a2453	3558	display.SelectDrawingLayer(1);
WiredHome	44:207594dece70	3559	display.background(Black);
WiredHome	44:207594dece70	3560	display.foreground(Yellow);
WiredHome	44:207594dece70	3561	display.cls();
WiredHome	44:207594dece70	3562	display.puts(240,0, "Layer 1");
WiredHome	44:207594dece70	3563	for (i=0; i<16; i++) {
WiredHome	44:207594dece70	3564	x1 = 300 + rand() % 100;
WiredHome	44:207594dece70	3565	y1 = 70 + rand() % 200;
WiredHome	44:207594dece70	3566	r1 = rand() % min(y1 - 20, 100);
WiredHome	44:207594dece70	3567	display.circle(x1,y1,r1, display.DOSColor(i));
WiredHome	44:207594dece70	3568	if (!SuppressSlowStuff)
WiredHome	197:853d08e2fb53	3569	wait_us(20000);
WiredHome	44:207594dece70	3570	}
WiredHome	56:7a85d226ad0d	3571	display.SetLayerMode(RA8875::ShowLayer1); // Show it after the build-up
WiredHome	44:207594dece70	3572	if (!SuppressSlowStuff)
WiredHome	197:853d08e2fb53	3573	wait_us(2000000);
WiredHome	44:207594dece70	3574
WiredHome	50:2c4f474a2453	3575	display.SelectDrawingLayer(0);
WiredHome	56:7a85d226ad0d	3576	display.SetLayerMode(RA8875::ShowLayer0); // Show Layer 0 again
WiredHome	44:207594dece70	3577	if (!SuppressSlowStuff)
WiredHome	197:853d08e2fb53	3578	wait_us(1000000);
WiredHome	53:86d24b9480b9	3579	display.SetLayerMode(RA8875::TransparentMode); // Transparent mode
WiredHome	44:207594dece70	3580	if (!SuppressSlowStuff)
WiredHome	197:853d08e2fb53	3581	wait_us(1000000);
WiredHome	44:207594dece70	3582	for (i=0; i<=8; i++) {
WiredHome	44:207594dece70	3583	display.SetLayerTransparency(i, 8-i);
WiredHome	44:207594dece70	3584	if (!SuppressSlowStuff)
WiredHome	197:853d08e2fb53	3585	wait_us(200000);
WiredHome	44:207594dece70	3586	}
WiredHome	73:f22a18707b5e	3587
WiredHome	44:207594dece70	3588	// Restore before we exit
WiredHome	44:207594dece70	3589	display.SetLayerTransparency(0, 0);
WiredHome	56:7a85d226ad0d	3590	display.SetLayerMode(RA8875::ShowLayer0); // Restore to layer 0
WiredHome	44:207594dece70	3591	}
WiredHome	44:207594dece70	3592
WiredHome	44:207594dece70	3593
WiredHome	23:a50ded45dbaf	3594	void RoundRectTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3595	{
WiredHome	37:f19b7e7449dc	3596	loc_t i, x1,y1, x2,y2, r1,r2;
WiredHome	23:a50ded45dbaf	3597
WiredHome	41:2956a0a221e5	3598	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3599	pc.printf("Round Rectangle Test\r\n");
WiredHome	23:a50ded45dbaf	3600	display.background(Black);
WiredHome	23:a50ded45dbaf	3601	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3602	display.cls();
WiredHome	100:0b084475d5a9	3603	display.puts("Rounded Rectangle Test");
WiredHome	73:f22a18707b5e	3604
WiredHome	23:a50ded45dbaf	3605	for (i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	3606	x1 = rand() % 240;
WiredHome	23:a50ded45dbaf	3607	y1 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3608	x2 = x1 + rand() % 100;
WiredHome	23:a50ded45dbaf	3609	y2 = y1 + rand() % 100;
WiredHome	23:a50ded45dbaf	3610	r1 = rand() % (x2 - x1)/2;
WiredHome	23:a50ded45dbaf	3611	r2 = rand() % (y2 - y1)/2;
WiredHome	23:a50ded45dbaf	3612	display.roundrect(x1,y1, x2,y2, 5,8, display.DOSColor(i));
WiredHome	23:a50ded45dbaf	3613
WiredHome	23:a50ded45dbaf	3614	x1 = 240 + rand() % 240;
WiredHome	23:a50ded45dbaf	3615	y1 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3616	x2 = x1 + rand() % 100;
WiredHome	23:a50ded45dbaf	3617	y2 = y1 + rand() % 100;
WiredHome	23:a50ded45dbaf	3618	r1 = rand() % (x2 - x1)/2;
WiredHome	23:a50ded45dbaf	3619	r2 = rand() % (y2 - y1)/2;
WiredHome	23:a50ded45dbaf	3620	display.roundrect(x1,y1, x2,y2, r1,r2, FILL);
WiredHome	23:a50ded45dbaf	3621	}
WiredHome	23:a50ded45dbaf	3622	}
WiredHome	23:a50ded45dbaf	3623
WiredHome	44:207594dece70	3624
WiredHome	23:a50ded45dbaf	3625	void TriangleTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3626	{
WiredHome	23:a50ded45dbaf	3627	int i, x1, y1, x2, y2, x3, y3;
WiredHome	23:a50ded45dbaf	3628
WiredHome	41:2956a0a221e5	3629	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3630	pc.printf("Triangle Test\r\n");
WiredHome	23:a50ded45dbaf	3631	display.background(Black);
WiredHome	23:a50ded45dbaf	3632	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3633	display.cls();
WiredHome	23:a50ded45dbaf	3634	display.puts(0,0, "Triangle Test");
WiredHome	23:a50ded45dbaf	3635
WiredHome	23:a50ded45dbaf	3636	x1 = 150;
WiredHome	23:a50ded45dbaf	3637	y1 = 2;
WiredHome	23:a50ded45dbaf	3638	x2 = 190;
WiredHome	23:a50ded45dbaf	3639	y2 = 7;
WiredHome	23:a50ded45dbaf	3640	x3 = 170;
WiredHome	23:a50ded45dbaf	3641	y3 = 16;
WiredHome	23:a50ded45dbaf	3642	display.triangle(x1,y1, x2,y2, x3,y3);
WiredHome	23:a50ded45dbaf	3643
WiredHome	23:a50ded45dbaf	3644	x1 = 200;
WiredHome	23:a50ded45dbaf	3645	y1 = 2;
WiredHome	23:a50ded45dbaf	3646	x2 = 240;
WiredHome	23:a50ded45dbaf	3647	y2 = 7;
WiredHome	23:a50ded45dbaf	3648	x3 = 220;
WiredHome	23:a50ded45dbaf	3649	y3 = 16;
WiredHome	23:a50ded45dbaf	3650	display.filltriangle(x1,y1, x2,y2, x3,y3, BrightRed);
WiredHome	23:a50ded45dbaf	3651
WiredHome	23:a50ded45dbaf	3652	x1 = 300;
WiredHome	23:a50ded45dbaf	3653	y1 = 2;
WiredHome	23:a50ded45dbaf	3654	x2 = 340;
WiredHome	23:a50ded45dbaf	3655	y2 = 7;
WiredHome	23:a50ded45dbaf	3656	x3 = 320;
WiredHome	23:a50ded45dbaf	3657	y3 = 16;
WiredHome	23:a50ded45dbaf	3658	display.triangle(x1,y1, x2,y2, x3,y3, NOFILL);
WiredHome	23:a50ded45dbaf	3659
WiredHome	23:a50ded45dbaf	3660	x1 = 400;
WiredHome	23:a50ded45dbaf	3661	y1 = 2;
WiredHome	23:a50ded45dbaf	3662	x2 = 440;
WiredHome	23:a50ded45dbaf	3663	y2 = 7;
WiredHome	23:a50ded45dbaf	3664	x3 = 420;
WiredHome	23:a50ded45dbaf	3665	y3 = 16;
WiredHome	23:a50ded45dbaf	3666	display.triangle(x1,y1, x2,y2, x3,y3, Blue);
WiredHome	23:a50ded45dbaf	3667
WiredHome	23:a50ded45dbaf	3668	for (i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	3669	x1 = rand() % 240;
WiredHome	23:a50ded45dbaf	3670	y1 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3671	x2 = rand() % 240;
WiredHome	23:a50ded45dbaf	3672	y2 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3673	x3 = rand() % 240;
WiredHome	23:a50ded45dbaf	3674	y3 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3675	display.triangle(x1,y1, x2,y2, x3,y3, display.DOSColor(i));
WiredHome	23:a50ded45dbaf	3676	x1 = 240 + rand() % 240;
WiredHome	23:a50ded45dbaf	3677	y1 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3678	x2 = 240 + rand() % 240;
WiredHome	23:a50ded45dbaf	3679	y2 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3680	x3 = 240 + rand() % 240;
WiredHome	23:a50ded45dbaf	3681	y3 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3682	display.triangle(x1,y1, x2,y2, x3,y3, FILL);
WiredHome	23:a50ded45dbaf	3683	}
WiredHome	23:a50ded45dbaf	3684	}
WiredHome	23:a50ded45dbaf	3685
WiredHome	44:207594dece70	3686
WiredHome	23:a50ded45dbaf	3687	void CircleTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3688	{
WiredHome	23:a50ded45dbaf	3689	int i, x, y, r1;
WiredHome	23:a50ded45dbaf	3690
WiredHome	41:2956a0a221e5	3691	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3692	pc.printf("Circle Test\r\n");
WiredHome	23:a50ded45dbaf	3693	display.background(Black);
WiredHome	23:a50ded45dbaf	3694	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3695	display.cls();
WiredHome	100:0b084475d5a9	3696	display.puts("Circle Test");
WiredHome	23:a50ded45dbaf	3697	for (i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	3698	x = 100 + rand() % 100;
WiredHome	23:a50ded45dbaf	3699	y = 70 + rand() % 200;
WiredHome	23:a50ded45dbaf	3700	r1 = rand() % min(y - 20, 100);
WiredHome	23:a50ded45dbaf	3701	//pc.printf(" (%d,%d) - %d\r\n", x,y,r1);
WiredHome	23:a50ded45dbaf	3702	display.circle(x,y,r1, display.DOSColor(i));
WiredHome	23:a50ded45dbaf	3703
WiredHome	23:a50ded45dbaf	3704	x = 300 + rand() % 100;
WiredHome	23:a50ded45dbaf	3705	y = 70 + rand() % 200;
WiredHome	23:a50ded45dbaf	3706	r1 = rand() % min(y - 20, 100);
WiredHome	23:a50ded45dbaf	3707	//pc.printf(" (%d,%d) - %d FILL\r\n", x,y,r1);
WiredHome	23:a50ded45dbaf	3708	display.circle(x,y,r1, display.DOSColor(i), FILL);
WiredHome	23:a50ded45dbaf	3709	}
WiredHome	23:a50ded45dbaf	3710	}
WiredHome	23:a50ded45dbaf	3711
WiredHome	44:207594dece70	3712
WiredHome	23:a50ded45dbaf	3713	void EllipseTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3714	{
WiredHome	23:a50ded45dbaf	3715	int i,x,y,r1,r2;
WiredHome	23:a50ded45dbaf	3716
WiredHome	41:2956a0a221e5	3717	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3718	pc.printf("Ellipse Test\r\n");
WiredHome	23:a50ded45dbaf	3719	display.background(Black);
WiredHome	23:a50ded45dbaf	3720	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3721	display.cls();
WiredHome	100:0b084475d5a9	3722	display.puts("Ellipse Test");
WiredHome	23:a50ded45dbaf	3723	for (i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	3724	x = 100 + rand() % 100;
WiredHome	23:a50ded45dbaf	3725	y = 70 + rand() % 200;
WiredHome	23:a50ded45dbaf	3726	r1 = rand() % min(y - 20, 100);
WiredHome	23:a50ded45dbaf	3727	r2 = rand() % min(y - 20, 100);
WiredHome	23:a50ded45dbaf	3728	display.ellipse(x,y,r1,r2, display.DOSColor(i));
WiredHome	23:a50ded45dbaf	3729
WiredHome	23:a50ded45dbaf	3730	x = 300 + rand() % 100;
WiredHome	23:a50ded45dbaf	3731	y = 70 + rand() % 200;
WiredHome	23:a50ded45dbaf	3732	r1 = rand() % min(y - 20, 100);
WiredHome	23:a50ded45dbaf	3733	r2 = rand() % min(y - 20, 100);
WiredHome	23:a50ded45dbaf	3734	display.ellipse(x,y,r1,r2, FILL);
WiredHome	23:a50ded45dbaf	3735	}
WiredHome	23:a50ded45dbaf	3736	}
WiredHome	23:a50ded45dbaf	3737
WiredHome	44:207594dece70	3738
WiredHome	37:f19b7e7449dc	3739	void TestGraphicsBitmap(RA8875 & display, Serial & pc)
WiredHome	37:f19b7e7449dc	3740	{
WiredHome	37:f19b7e7449dc	3741	LocalFileSystem local("local");
WiredHome	41:2956a0a221e5	3742	if (!SuppressSlowStuff)
WiredHome	73:f22a18707b5e	3743	pc.printf("Bitmap File Load\r\n");
WiredHome	37:f19b7e7449dc	3744	display.background(Black);
WiredHome	37:f19b7e7449dc	3745	display.foreground(Blue);
WiredHome	37:f19b7e7449dc	3746	display.cls();
WiredHome	100:0b084475d5a9	3747	display.puts("Graphics Test, loading /local/TestPat.bmp");
WiredHome	37:f19b7e7449dc	3748	wait(3);
WiredHome	37:f19b7e7449dc	3749
WiredHome	37:f19b7e7449dc	3750	int r = display.RenderBitmapFile(0,0, "/local/TestPat.bmp");
WiredHome	59:fb40aad4efd4	3751	if (!SuppressSlowStuff)
WiredHome	59:fb40aad4efd4	3752	pc.printf(" returned %d\r\n", r);
WiredHome	37:f19b7e7449dc	3753	}
WiredHome	37:f19b7e7449dc	3754
WiredHome	44:207594dece70	3755
WiredHome	77:9206c13aa527	3756	void TouchPanelTest(RA8875 & display, Serial & pc)
WiredHome	77:9206c13aa527	3757	{
WiredHome	77:9206c13aa527	3758	Timer t;
WiredHome	98:ecebed9b80b2	3759	int x, y;
WiredHome	78:faf49c381591	3760	tpMatrix_t calmatrix;
WiredHome	190:3132b7dfad82	3761
WiredHome	77:9206c13aa527	3762	display.background(Black);
WiredHome	77:9206c13aa527	3763	display.foreground(Blue);
WiredHome	77:9206c13aa527	3764	display.cls();
WiredHome	100:0b084475d5a9	3765	display.puts("Touch Panel Test\r\n");
WiredHome	78:faf49c381591	3766	pc.printf("Touch Panel Test\r\n");
WiredHome	77:9206c13aa527	3767	display.TouchPanelInit();
WiredHome	78:faf49c381591	3768	pc.printf(" TP: c - calibrate, r - restore, t - test\r\n");
WiredHome	78:faf49c381591	3769	int c = pc.getc();
WiredHome	78:faf49c381591	3770	if (c == 'c') {
WiredHome	78:faf49c381591	3771	point_t pTest[3] =
WiredHome	78:faf49c381591	3772	{ { 50, 50 }, {450, 150}, {225,250} };
WiredHome	78:faf49c381591	3773	point_t pSample[3];
WiredHome	78:faf49c381591	3774	for (int i=0; i<3; i++) {
WiredHome	78:faf49c381591	3775	display.foreground(Blue);
WiredHome	78:faf49c381591	3776	display.printf(" (%3d,%3d) => ", pTest[i].x, pTest[i].y);
WiredHome	78:faf49c381591	3777	display.line(pTest[i].x-10, pTest[i].y, pTest[i].x+10, pTest[i].y, White);
WiredHome	78:faf49c381591	3778	display.line(pTest[i].x, pTest[i].y-10, pTest[i].x, pTest[i].y+10, White);
WiredHome	79:544eb4964795	3779	while (!display.TouchPanelA2DFiltered(&x, &y))
WiredHome	197:853d08e2fb53	3780	wait_us(20000);
WiredHome	78:faf49c381591	3781	pSample[i].x = x;
WiredHome	78:faf49c381591	3782	pSample[i].y = y;
WiredHome	78:faf49c381591	3783	display.line(pTest[i].x-10, pTest[i].y, pTest[i].x+10, pTest[i].y, Black);
WiredHome	78:faf49c381591	3784	display.line(pTest[i].x, pTest[i].y-10, pTest[i].x, pTest[i].y+10, Black);
WiredHome	78:faf49c381591	3785	display.foreground(Blue);
WiredHome	78:faf49c381591	3786	display.printf(" (%4d,%4d)\r\n", x,y);
WiredHome	79:544eb4964795	3787	while (display.TouchPanelA2DFiltered(&x, &y))
WiredHome	197:853d08e2fb53	3788	wait_us(20000);
WiredHome	78:faf49c381591	3789	wait(2);
WiredHome	78:faf49c381591	3790	}
WiredHome	81:01da2e34283d	3791	display.TouchPanelComputeCalibration(pTest, pSample, &calmatrix);
WiredHome	78:faf49c381591	3792	display.printf(" Writing calibration to tpcal.cfg\r\n");
WiredHome	78:faf49c381591	3793	FILE * fh = fopen("/local/tpcal.cfg", "wb");
WiredHome	78:faf49c381591	3794	if (fh) {
WiredHome	78:faf49c381591	3795	fwrite(&calmatrix, sizeof(calmatrix), 1, fh);
WiredHome	78:faf49c381591	3796	fclose(fh);
WiredHome	78:faf49c381591	3797	}
WiredHome	78:faf49c381591	3798	display.printf(" Calibration is complete.");
WiredHome	78:faf49c381591	3799	} else if (c == 'r') {
WiredHome	78:faf49c381591	3800	display.printf(" Reading calibration from tpcal.cfg\r\n");
WiredHome	78:faf49c381591	3801	FILE * fh = fopen("/local/tpcal.cfg", "rb");
WiredHome	78:faf49c381591	3802	if (fh) {
WiredHome	78:faf49c381591	3803	fread(&calmatrix, sizeof(calmatrix), 1, fh);
WiredHome	78:faf49c381591	3804	fclose(fh);
WiredHome	78:faf49c381591	3805	}
WiredHome	78:faf49c381591	3806	display.printf(" Calibration is complete.");
WiredHome	78:faf49c381591	3807	display.TouchPanelSetMatrix(&calmatrix);
WiredHome	77:9206c13aa527	3808	}
WiredHome	77:9206c13aa527	3809	t.start();
WiredHome	77:9206c13aa527	3810	do {
WiredHome	77:9206c13aa527	3811	point_t point = {0, 0};
WiredHome	79:544eb4964795	3812	if (display.TouchPanelReadable(&point)) {
WiredHome	77:9206c13aa527	3813	display.pixel(point.x, point.y, Red);
WiredHome	77:9206c13aa527	3814	}
WiredHome	77:9206c13aa527	3815	} while (t.read_ms() < 30000);
WiredHome	77:9206c13aa527	3816	pc.printf(">");
WiredHome	77:9206c13aa527	3817	}
WiredHome	77:9206c13aa527	3818
WiredHome	77:9206c13aa527	3819
WiredHome	41:2956a0a221e5	3820	void SpeedTest(RA8875 & display, Serial & pc)
WiredHome	41:2956a0a221e5	3821	{
WiredHome	41:2956a0a221e5	3822	Timer t;
WiredHome	41:2956a0a221e5	3823	SuppressSlowStuff = true;
WiredHome	41:2956a0a221e5	3824	pc.printf("\r\nSpeedTest disables delays, runs tests, reports overall time.\r\n");
WiredHome	41:2956a0a221e5	3825	t.start();
WiredHome	41:2956a0a221e5	3826	// do stuff fast
WiredHome	41:2956a0a221e5	3827	TextCursorTest(display, pc);
WiredHome	49:c5182231d1b9	3828	TextWrapTest(display, pc);
WiredHome	41:2956a0a221e5	3829	BacklightTest(display, pc, 0);
WiredHome	41:2956a0a221e5	3830	BacklightTest2(display, pc);
WiredHome	41:2956a0a221e5	3831	ExternalFontTest(display, pc);
WiredHome	41:2956a0a221e5	3832	DOSColorTest(display, pc);
WiredHome	41:2956a0a221e5	3833	WebColorTest(display, pc);
WiredHome	41:2956a0a221e5	3834	PixelTest(display, pc);
WiredHome	41:2956a0a221e5	3835	LineTest(display, pc);
WiredHome	41:2956a0a221e5	3836	RectangleTest(display, pc);
WiredHome	41:2956a0a221e5	3837	RoundRectTest(display, pc);
WiredHome	41:2956a0a221e5	3838	TriangleTest(display, pc);
WiredHome	41:2956a0a221e5	3839	CircleTest(display, pc);
WiredHome	41:2956a0a221e5	3840	EllipseTest(display, pc);
WiredHome	44:207594dece70	3841	LayerTest(display, pc);
WiredHome	41:2956a0a221e5	3842	//TestGraphicsBitmap(display, pc);
WiredHome	41:2956a0a221e5	3843	pc.printf("SpeedTest completed in %d msec\r\n", t.read_ms());
WiredHome	73:f22a18707b5e	3844	#ifdef PERF_METRICS
WiredHome	41:2956a0a221e5	3845	display.ReportPerformance(pc);
WiredHome	73:f22a18707b5e	3846	#endif
WiredHome	41:2956a0a221e5	3847	SuppressSlowStuff = false;
WiredHome	41:2956a0a221e5	3848	}
WiredHome	41:2956a0a221e5	3849
WiredHome	44:207594dece70	3850
WiredHome	41:2956a0a221e5	3851	void PrintScreen(RA8875 & display, Serial & pc)
WiredHome	41:2956a0a221e5	3852	{
WiredHome	41:2956a0a221e5	3853	if (!SuppressSlowStuff)
WiredHome	73:f22a18707b5e	3854	pc.printf("PrintScreen\r\n");
WiredHome	41:2956a0a221e5	3855	display.PrintScreen( 0,0, 480,272, "/local/Capture.bmp");
WiredHome	41:2956a0a221e5	3856	}
WiredHome	41:2956a0a221e5	3857
WiredHome	44:207594dece70	3858
WiredHome	23:a50ded45dbaf	3859	void RunTestSet(RA8875 & lcd, Serial & pc)
WiredHome	23:a50ded45dbaf	3860	{
WiredHome	23:a50ded45dbaf	3861	int q = 0;
WiredHome	23:a50ded45dbaf	3862	int automode = 0;
WiredHome	49:c5182231d1b9	3863	const unsigned char modelist[] = "BDWtGLlFROTPCEbw"; // auto-test in this order.
WiredHome	23:a50ded45dbaf	3864
WiredHome	23:a50ded45dbaf	3865	while(1) {
WiredHome	23:a50ded45dbaf	3866	pc.printf("\r\n"
WiredHome	41:2956a0a221e5	3867	"B - Backlight up b - backlight dim\r\n"
WiredHome	41:2956a0a221e5	3868	"D - DOS Colors W - Web Colors\r\n"
WiredHome	41:2956a0a221e5	3869	"t - text cursor G - Graphics Bitmap\r\n"
WiredHome	41:2956a0a221e5	3870	"L - Lines F - external Font\r\n"
WiredHome	41:2956a0a221e5	3871	"R - Rectangles O - rOund rectangles\r\n"
WiredHome	41:2956a0a221e5	3872	"T - Triangles P - Pixels \r\n"
WiredHome	41:2956a0a221e5	3873	"C - Circles E - Ellipses\r\n"
WiredHome	41:2956a0a221e5	3874	"A - Auto Test mode S - Speed Test\r\n"
WiredHome	77:9206c13aa527	3875	"K - Keypad Test s - touch screen test\r\n"
WiredHome	41:2956a0a221e5	3876	"p - print screen r - reset \r\n"
WiredHome	49:c5182231d1b9	3877	"l - layer test w - wrapping text \r\n"
WiredHome	73:f22a18707b5e	3878	#ifdef PERF_METRICS
WiredHome	41:2956a0a221e5	3879	"0 - clear performance 1 - report performance\r\n"
WiredHome	73:f22a18707b5e	3880	#endif
WiredHome	23:a50ded45dbaf	3881	"> ");
WiredHome	23:a50ded45dbaf	3882	if (automode == -1 \|\| pc.readable()) {
WiredHome	23:a50ded45dbaf	3883	automode = -1;
WiredHome	37:f19b7e7449dc	3884	q = pc.getc();
WiredHome	37:f19b7e7449dc	3885	while (pc.readable())
WiredHome	37:f19b7e7449dc	3886	pc.getc();
WiredHome	23:a50ded45dbaf	3887	} else if (automode >= 0) {
WiredHome	23:a50ded45dbaf	3888	q = modelist[automode];
WiredHome	23:a50ded45dbaf	3889	}
WiredHome	23:a50ded45dbaf	3890	switch(q) {
WiredHome	73:f22a18707b5e	3891	#ifdef PERF_METRICS
WiredHome	41:2956a0a221e5	3892	case '0':
WiredHome	41:2956a0a221e5	3893	lcd.ClearPerformance();
WiredHome	41:2956a0a221e5	3894	break;
WiredHome	41:2956a0a221e5	3895	case '1':
WiredHome	41:2956a0a221e5	3896	lcd.ReportPerformance(pc);
WiredHome	41:2956a0a221e5	3897	break;
WiredHome	73:f22a18707b5e	3898	#endif
WiredHome	23:a50ded45dbaf	3899	case 'A':
WiredHome	23:a50ded45dbaf	3900	automode = 0;
WiredHome	23:a50ded45dbaf	3901	break;
WiredHome	23:a50ded45dbaf	3902	case 'B':
WiredHome	41:2956a0a221e5	3903	BacklightTest(lcd, pc, 2);
WiredHome	23:a50ded45dbaf	3904	break;
WiredHome	23:a50ded45dbaf	3905	case 'b':
WiredHome	23:a50ded45dbaf	3906	BacklightTest2(lcd, pc);
WiredHome	23:a50ded45dbaf	3907	break;
WiredHome	23:a50ded45dbaf	3908	case 'D':
WiredHome	23:a50ded45dbaf	3909	DOSColorTest(lcd, pc);
WiredHome	23:a50ded45dbaf	3910	break;
WiredHome	75:ca78388cfd77	3911	case 'K':
WiredHome	75:ca78388cfd77	3912	KeyPadTest(lcd, pc);
WiredHome	75:ca78388cfd77	3913	break;
WiredHome	23:a50ded45dbaf	3914	case 'W':
WiredHome	23:a50ded45dbaf	3915	WebColorTest(lcd, pc);
WiredHome	23:a50ded45dbaf	3916	break;
WiredHome	23:a50ded45dbaf	3917	case 't':
WiredHome	23:a50ded45dbaf	3918	TextCursorTest(lcd, pc);
WiredHome	23:a50ded45dbaf	3919	break;
WiredHome	49:c5182231d1b9	3920	case 'w':
WiredHome	49:c5182231d1b9	3921	TextWrapTest(lcd, pc);
WiredHome	49:c5182231d1b9	3922	break;
WiredHome	23:a50ded45dbaf	3923	case 'F':
WiredHome	23:a50ded45dbaf	3924	ExternalFontTest(lcd, pc);
WiredHome	23:a50ded45dbaf	3925	break;
WiredHome	23:a50ded45dbaf	3926	case 'L':
WiredHome	23:a50ded45dbaf	3927	LineTest(lcd, pc);
WiredHome	23:a50ded45dbaf	3928	break;
WiredHome	44:207594dece70	3929	case 'l':
WiredHome	44:207594dece70	3930	LayerTest(lcd, pc);
WiredHome	44:207594dece70	3931	break;
WiredHome	23:a50ded45dbaf	3932	case 'R':
WiredHome	23:a50ded45dbaf	3933	RectangleTest(lcd, pc);
WiredHome	23:a50ded45dbaf	3934	break;
WiredHome	23:a50ded45dbaf	3935	case 'O':
WiredHome	23:a50ded45dbaf	3936	RoundRectTest(lcd, pc);
WiredHome	23:a50ded45dbaf	3937	break;
WiredHome	41:2956a0a221e5	3938	case 'p':
WiredHome	41:2956a0a221e5	3939	PrintScreen(lcd, pc);
WiredHome	41:2956a0a221e5	3940	break;
WiredHome	41:2956a0a221e5	3941	case 'S':
WiredHome	41:2956a0a221e5	3942	SpeedTest(lcd, pc);
WiredHome	41:2956a0a221e5	3943	break;
WiredHome	77:9206c13aa527	3944	case 's':
WiredHome	77:9206c13aa527	3945	TouchPanelTest(lcd, pc);
WiredHome	77:9206c13aa527	3946	break;
WiredHome	23:a50ded45dbaf	3947	case 'T':
WiredHome	23:a50ded45dbaf	3948	TriangleTest(lcd, pc);
WiredHome	23:a50ded45dbaf	3949	break;
WiredHome	37:f19b7e7449dc	3950	case 'P':
WiredHome	37:f19b7e7449dc	3951	PixelTest(lcd, pc);
WiredHome	37:f19b7e7449dc	3952	break;
WiredHome	37:f19b7e7449dc	3953	case 'G':
WiredHome	37:f19b7e7449dc	3954	TestGraphicsBitmap(lcd, pc);
WiredHome	37:f19b7e7449dc	3955	break;
WiredHome	23:a50ded45dbaf	3956	case 'C':
WiredHome	23:a50ded45dbaf	3957	CircleTest(lcd, pc);
WiredHome	23:a50ded45dbaf	3958	break;
WiredHome	23:a50ded45dbaf	3959	case 'E':
WiredHome	23:a50ded45dbaf	3960	EllipseTest(lcd, pc);
WiredHome	23:a50ded45dbaf	3961	break;
WiredHome	23:a50ded45dbaf	3962	case 'r':
WiredHome	23:a50ded45dbaf	3963	pc.printf("Resetting ...\r\n");
WiredHome	197:853d08e2fb53	3964	wait_us(20000);
WiredHome	23:a50ded45dbaf	3965	mbed_reset();
WiredHome	23:a50ded45dbaf	3966	break;
WiredHome	75:ca78388cfd77	3967	case ' ':
WiredHome	75:ca78388cfd77	3968	break;
WiredHome	23:a50ded45dbaf	3969	default:
WiredHome	23:a50ded45dbaf	3970	printf("huh?\n");
WiredHome	23:a50ded45dbaf	3971	break;
WiredHome	23:a50ded45dbaf	3972	}
WiredHome	23:a50ded45dbaf	3973	if (automode >= 0) {
WiredHome	23:a50ded45dbaf	3974	automode++;
WiredHome	23:a50ded45dbaf	3975	if (automode >= sizeof(modelist))
WiredHome	23:a50ded45dbaf	3976	automode = 0;
WiredHome	197:853d08e2fb53	3977	wait_us(2000000);
WiredHome	23:a50ded45dbaf	3978	}
WiredHome	197:853d08e2fb53	3979	wait_us(200000);
WiredHome	23:a50ded45dbaf	3980	}
WiredHome	23:a50ded45dbaf	3981	}
WiredHome	23:a50ded45dbaf	3982
WiredHome	79:544eb4964795	3983	#endif // TESTENABLE

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	12 Jan 2014
Imports:	363
Forks:	7
Commits:	210
Dependents:	20
Dependencies:	0
Followers:	13
Issues:	2

The code in this repository is MIT licensed.

Components

RA8875: 4" to 8" (WQVGA, WVGA, Multi-Touch, Keypad)