RA8875 - This is the David Smart RA8875 Library with mods …

Users » lamell » Code » RA8875

This is the David Smart RA8875 Library with mods for working with FRDM-K64F

RA8875.cpp@196:56820026701b, 2020-02-11 (annotated)

Committer:: WiredHome
Date:: Tue Feb 11 21:26:59 2020 +0000
Revision:: 196:56820026701b
Parent:: 195:17e176dbd6eb
Child:: 197:853d08e2fb53

Added puts w/point_t parameter.

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

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	03 Mar 2020
Imports:	7
Forks:	0
Commits:	202
Dependents:	0
Dependencies:	0
Followers:	1

RA8875.cpp@196:56820026701b, 2020-02-11 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning