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

Users » WiredHome » Code » RA8875

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

Dependents: FRDM_RA8875_mPaint RA8875_Demo RA8875_KeyPadDemo SignalGenerator ... more

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

Offline Help Manual (Windows chm)

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

RA8875.cpp@209:08fc22dea762, 2021-04-04 (annotated)

Committer:: WiredHome
Date:: Sun Apr 04 20:14:06 2021 +0000
Revision:: 209:08fc22dea762
Parent:: 208:c610b031388d

Fix a long-standing defect in the FT5206 where it reported 'touch' code even for hold and release events.

Who changed what in which revision?

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

Repository toolbox

Export to desktop IDE

Repository details

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

The code in this repository is MIT licensed.

Components

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