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@200:ae29b60d087c, 2020-03-29 (annotated)

Committer:: WiredHome
Date:: Sun Mar 29 14:33:19 2020 +0000
Revision:: 200:ae29b60d087c
Parent:: 198:9b6851107426
Child:: 202:a22cbc04f332

Correct issue with the reset pin control

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