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@203:704df2dbd3e6, 2020-05-17 (annotated)

Committer:: WiredHome
Date:: Sun May 17 14:07:46 2020 +0000
Revision:: 203:704df2dbd3e6
Parent:: 202:a22cbc04f332
Child:: 204:48e05a27de25

Fix coordinate translation for touch events.; Minor code cleanup.

Who changed what in which revision?

User	Revision	Line number	New contents of line
WiredHome	152:a013ac0133e4	1	// RA8875 Display Controller Library.
WiredHome	152:a013ac0133e4	2	//
WiredHome	152:a013ac0133e4	3	// This is being created for a Raio RA8875-based display from buydisplay.com,
WiredHome	152:a013ac0133e4	4	// which is either 480 x 272 or 800 x 480, using a 4-wire SPI interface.
WiredHome	152:a013ac0133e4	5	// Support is provided for both a keypad and a resistive touch-screen.
WiredHome	152:a013ac0133e4	6	//
WiredHome	152:a013ac0133e4	7	// See the RA8875.h file for full details.
WiredHome	152:a013ac0133e4	8	//
WiredHome	152:a013ac0133e4	9	// 20161106: Updated the initialization to set the various registers based on
WiredHome	152:a013ac0133e4	10	// the BuyDisplay.com example code. This altered several registers
WiredHome	152:a013ac0133e4	11	// for the 800x480 display driver.
WiredHome	152:a013ac0133e4	12	//
WiredHome	19:3f82c1161fd2	13	#include "RA8875.h"
WiredHome	19:3f82c1161fd2	14
WiredHome	145:5eb2492acdda	15	//#include "Utility.h" // private memory manager
WiredHome	145:5eb2492acdda	16	#ifndef UTILITY_H
WiredHome	145:5eb2492acdda	17	#define swMalloc malloc // use the standard
WiredHome	145:5eb2492acdda	18	#define swFree free
WiredHome	145:5eb2492acdda	19	#endif
WiredHome	145:5eb2492acdda	20
WiredHome	197:853d08e2fb53	21	//#define DEBUG "RAIO"
WiredHome	19:3f82c1161fd2	22	// ...
WiredHome	19:3f82c1161fd2	23	// INFO("Stuff to show %d", var); // new-line is automatically appended
WiredHome	19:3f82c1161fd2	24	//
WiredHome	19:3f82c1161fd2	25	#if (defined(DEBUG) && !defined(TARGET_LPC11U24))
WiredHome	190:3132b7dfad82	26	#define INFO(x, ...) std::printf("[INF %s %4d] " x "\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome	190:3132b7dfad82	27	#define WARN(x, ...) std::printf("[WRN %s %4d] " x "\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome	190:3132b7dfad82	28	#define ERR(x, ...) std::printf("[ERR %s %4d] " x "\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome	98:ecebed9b80b2	29	static void HexDump(const char * title, const uint8_t * p, int count)
WiredHome	73:f22a18707b5e	30	{
WiredHome	73:f22a18707b5e	31	int i;
WiredHome	73:f22a18707b5e	32	char buf[100] = "0000: ";
WiredHome	73:f22a18707b5e	33
WiredHome	73:f22a18707b5e	34	if (*title)
WiredHome	73:f22a18707b5e	35	INFO("%s", title);
WiredHome	73:f22a18707b5e	36	for (i=0; i<count; ) {
WiredHome	73:f22a18707b5e	37	sprintf(buf + strlen(buf), "%02X ", *(p+i));
WiredHome	73:f22a18707b5e	38	if ((++i & 0x0F) == 0x00) {
WiredHome	73:f22a18707b5e	39	INFO("%s", buf);
WiredHome	73:f22a18707b5e	40	if (i < count)
WiredHome	73:f22a18707b5e	41	sprintf(buf, "%04X: ", i);
WiredHome	73:f22a18707b5e	42	else
WiredHome	73:f22a18707b5e	43	buf[0] = '\0';
WiredHome	73:f22a18707b5e	44	}
WiredHome	73:f22a18707b5e	45	}
WiredHome	73:f22a18707b5e	46	if (strlen(buf))
WiredHome	73:f22a18707b5e	47	INFO("%s", buf);
WiredHome	73:f22a18707b5e	48	}
WiredHome	19:3f82c1161fd2	49	#else
WiredHome	19:3f82c1161fd2	50	#define INFO(x, ...)
WiredHome	19:3f82c1161fd2	51	#define WARN(x, ...)
WiredHome	19:3f82c1161fd2	52	#define ERR(x, ...)
WiredHome	73:f22a18707b5e	53	#define HexDump(a, b, c)
WiredHome	19:3f82c1161fd2	54	#endif
WiredHome	19:3f82c1161fd2	55
WiredHome	109:7b94f06f085b	56	// Defaults. Users can override this with the init() method.
WiredHome	19:3f82c1161fd2	57	#define RA8875_DISPLAY_WIDTH 480
WiredHome	19:3f82c1161fd2	58	#define RA8875_DISPLAY_HEIGHT 272
WiredHome	43:3becae133285	59	#define RA8875_COLORDEPTH_BPP 16 /* Not an API */
WiredHome	19:3f82c1161fd2	60
WiredHome	19:3f82c1161fd2	61	#ifdef PERF_METRICS
WiredHome	19:3f82c1161fd2	62	#define PERFORMANCE_RESET performance.reset()
WiredHome	19:3f82c1161fd2	63	#define REGISTERPERFORMANCE(a) RegisterPerformance(a)
WiredHome	68:ab08efabfc88	64	#define COUNTIDLETIME(a) CountIdleTime(a)
WiredHome	73:f22a18707b5e	65	static const char *metricsName[] = {
WiredHome	109:7b94f06f085b	66	"Cls", "Pixel", "Pixel Stream", "Boolean Stream",
WiredHome	41:2956a0a221e5	67	"Read Pixel", "Read Pixel Stream",
WiredHome	73:f22a18707b5e	68	"Line",
WiredHome	73:f22a18707b5e	69	"Rectangle", "Rounded Rectangle",
WiredHome	68:ab08efabfc88	70	"Triangle", "Circle", "Ellipse"
WiredHome	19:3f82c1161fd2	71	};
WiredHome	91:ca5f829e6d27	72	uint16_t commandsUsed[256]; // track which commands are used with simple counter of number of hits.
WiredHome	19:3f82c1161fd2	73	#else
WiredHome	19:3f82c1161fd2	74	#define PERFORMANCE_RESET
WiredHome	19:3f82c1161fd2	75	#define REGISTERPERFORMANCE(a)
WiredHome	68:ab08efabfc88	76	#define COUNTIDLETIME(a)
WiredHome	19:3f82c1161fd2	77	#endif
WiredHome	19:3f82c1161fd2	78
WiredHome	73:f22a18707b5e	79	// When it is going to poll a register for completion, how many
WiredHome	19:3f82c1161fd2	80	// uSec should it wait between each polling activity.
WiredHome	19:3f82c1161fd2	81	#define POLLWAITuSec 10
WiredHome	19:3f82c1161fd2	82
WiredHome	75:ca78388cfd77	83	// Private RawKeyMap for the Keyboard interface
WiredHome	79:544eb4964795	84	static const uint8_t DefaultKeyMap[22] = {
WiredHome	77:9206c13aa527	85	0,
WiredHome	77:9206c13aa527	86	1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
WiredHome	75:ca78388cfd77	87	11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
WiredHome	75:ca78388cfd77	88	255
WiredHome	77:9206c13aa527	89	};
WiredHome	75:ca78388cfd77	90
WiredHome	79:544eb4964795	91	static const char * ErrMessages[] = {
WiredHome	79:544eb4964795	92	"noerror", ///< no errors, command completed successfully
WiredHome	89:04575562c961	93	"bad parameter", ///< one or more parameters are invalid
WiredHome	89:04575562c961	94	"file not found", ///< specified file could not be found
WiredHome	89:04575562c961	95	"not bmp format", ///< file is not a .bmp file
WiredHome	89:04575562c961	96	"not ico format", ///< file is not a .ico file
WiredHome	89:04575562c961	97	"not supported format", ///< file format is not yet supported
WiredHome	89:04575562c961	98	"image too big", ///< image is too large for the screen
WiredHome	89:04575562c961	99	"not enough ram", ///< could not allocate ram for scanline
WiredHome	125:7a0b70f56550	100	"touch cal. timeout", ///< calibration could not complete in time
WiredHome	125:7a0b70f56550	101	"external abort", ///< during an idle callback, the user code initiated an abort
WiredHome	79:544eb4964795	102	};
WiredHome	19:3f82c1161fd2	103
WiredHome	163:17526689a3ed	104	typedef struct {
WiredHome	163:17526689a3ed	105	uint8_t b;
WiredHome	163:17526689a3ed	106	uint8_t g;
WiredHome	163:17526689a3ed	107	uint8_t r;
WiredHome	163:17526689a3ed	108	uint8_t a;
WiredHome	163:17526689a3ed	109	} rgbTrio_t;
WiredHome	163:17526689a3ed	110
WiredHome	197:853d08e2fb53	111	/// This is defined as a "Web-Safe" color palette of 216 colors.
WiredHome	164:76edd7d9cb68	112	///
WiredHome	164:76edd7d9cb68	113	/// It is defined so it can be emitted into a BMP file as the color palette, and it is then used
WiredHome	164:76edd7d9cb68	114	/// for downscaling from higher resolution color depth to an 8-bit format.
WiredHome	164:76edd7d9cb68	115	///
WiredHome	163:17526689a3ed	116	static const rgbTrio_t WebColorPalette[] = {
WiredHome	163:17526689a3ed	117	{0x00,0x00,0x00,0xFF}, {0x00,0x00,0x33,0xFF}, {0x00,0x00,0x66,0xFF}, {0x00,0x00,0x99,0xFF}, {0x00,0x00,0xCC,0xFF}, {0x00,0x00,0xFF,0xFF},
WiredHome	163:17526689a3ed	118	{0x00,0x33,0x00,0xFF}, {0x00,0x33,0x33,0xFF}, {0x00,0x33,0x66,0xFF}, {0x00,0x33,0x99,0xFF}, {0x00,0x33,0xCC,0xFF}, {0x00,0x33,0xFF,0xFF},
WiredHome	163:17526689a3ed	119	{0x00,0x66,0x00,0xFF}, {0x00,0x66,0x33,0xFF}, {0x00,0x66,0x66,0xFF}, {0x00,0x66,0x99,0xFF}, {0x00,0x66,0xCC,0xFF}, {0x00,0x66,0xFF,0xFF},
WiredHome	163:17526689a3ed	120	{0x00,0x99,0x00,0xFF}, {0x00,0x99,0x33,0xFF}, {0x00,0x99,0x66,0xFF}, {0x00,0x99,0x99,0xFF}, {0x00,0x99,0xCC,0xFF}, {0x00,0x99,0xFF,0xFF},
WiredHome	163:17526689a3ed	121	{0x00,0xCC,0x00,0xFF}, {0x00,0xCC,0x33,0xFF}, {0x00,0xCC,0x66,0xFF}, {0x00,0xCC,0x99,0xFF}, {0x00,0xCC,0xCC,0xFF}, {0x00,0xCC,0xFF,0xFF},
WiredHome	163:17526689a3ed	122	{0x00,0xFF,0x00,0xFF}, {0x00,0xFF,0x33,0xFF}, {0x00,0xFF,0x66,0xFF}, {0x00,0xFF,0x99,0xFF}, {0x00,0xFF,0xCC,0xFF}, {0x00,0xFF,0xFF,0xFF},
WiredHome	163:17526689a3ed	123	{0x33,0x00,0x00,0xFF}, {0x33,0x00,0x33,0xFF}, {0x33,0x00,0x66,0xFF}, {0x33,0x00,0x99,0xFF}, {0x33,0x00,0xCC,0xFF}, {0x33,0x00,0xFF,0xFF},
WiredHome	163:17526689a3ed	124	{0x33,0x33,0x00,0xFF}, {0x33,0x33,0x33,0xFF}, {0x33,0x33,0x66,0xFF}, {0x33,0x33,0x99,0xFF}, {0x33,0x33,0xCC,0xFF}, {0x33,0x33,0xFF,0xFF},
WiredHome	163:17526689a3ed	125	{0x33,0x66,0x00,0xFF}, {0x33,0x66,0x33,0xFF}, {0x33,0x66,0x66,0xFF}, {0x33,0x66,0x99,0xFF}, {0x33,0x66,0xCC,0xFF}, {0x33,0x66,0xFF,0xFF},
WiredHome	163:17526689a3ed	126	{0x33,0x99,0x00,0xFF}, {0x33,0x99,0x33,0xFF}, {0x33,0x99,0x66,0xFF}, {0x33,0x99,0x99,0xFF}, {0x33,0x99,0xCC,0xFF}, {0x33,0x99,0xFF,0xFF},
WiredHome	163:17526689a3ed	127	{0x33,0xCC,0x00,0xFF}, {0x33,0xCC,0x33,0xFF}, {0x33,0xCC,0x66,0xFF}, {0x33,0xCC,0x99,0xFF}, {0x33,0xCC,0xCC,0xFF}, {0x33,0xCC,0xFF,0xFF},
WiredHome	163:17526689a3ed	128	{0x33,0xFF,0x00,0xFF}, {0x33,0xFF,0x33,0xFF}, {0x33,0xFF,0x66,0xFF}, {0x33,0xFF,0x99,0xFF}, {0x33,0xFF,0xCC,0xFF}, {0x33,0xFF,0xFF,0xFF},
WiredHome	163:17526689a3ed	129	{0x66,0x00,0x00,0xFF}, {0x66,0x00,0x33,0xFF}, {0x66,0x00,0x66,0xFF}, {0x66,0x00,0x99,0xFF}, {0x66,0x00,0xCC,0xFF}, {0x66,0x00,0xFF,0xFF},
WiredHome	163:17526689a3ed	130	{0x66,0x33,0x00,0xFF}, {0x66,0x33,0x33,0xFF}, {0x66,0x33,0x66,0xFF}, {0x66,0x33,0x99,0xFF}, {0x66,0x33,0xCC,0xFF}, {0x66,0x33,0xFF,0xFF},
WiredHome	163:17526689a3ed	131	{0x66,0x66,0x00,0xFF}, {0x66,0x66,0x33,0xFF}, {0x66,0x66,0x66,0xFF}, {0x66,0x66,0x99,0xFF}, {0x66,0x66,0xCC,0xFF}, {0x66,0x66,0xFF,0xFF},
WiredHome	163:17526689a3ed	132	{0x66,0x99,0x00,0xFF}, {0x66,0x99,0x33,0xFF}, {0x66,0x99,0x66,0xFF}, {0x66,0x99,0x99,0xFF}, {0x66,0x99,0xCC,0xFF}, {0x66,0x99,0xFF,0xFF},
WiredHome	163:17526689a3ed	133	{0x66,0xCC,0x00,0xFF}, {0x66,0xCC,0x33,0xFF}, {0x66,0xCC,0x66,0xFF}, {0x66,0xCC,0x99,0xFF}, {0x66,0xCC,0xCC,0xFF}, {0x66,0xCC,0xFF,0xFF},
WiredHome	163:17526689a3ed	134	{0x66,0xFF,0x00,0xFF}, {0x66,0xFF,0x33,0xFF}, {0x66,0xFF,0x66,0xFF}, {0x66,0xFF,0x99,0xFF}, {0x66,0xFF,0xCC,0xFF}, {0x66,0xFF,0xFF,0xFF},
WiredHome	163:17526689a3ed	135	{0x99,0x00,0x00,0xFF}, {0x99,0x00,0x33,0xFF}, {0x99,0x00,0x66,0xFF}, {0x99,0x00,0x99,0xFF}, {0x99,0x00,0xCC,0xFF}, {0x99,0x00,0xFF,0xFF},
WiredHome	163:17526689a3ed	136	{0x99,0x33,0x00,0xFF}, {0x99,0x33,0x33,0xFF}, {0x99,0x33,0x66,0xFF}, {0x99,0x33,0x99,0xFF}, {0x99,0x33,0xCC,0xFF}, {0x99,0x33,0xFF,0xFF},
WiredHome	163:17526689a3ed	137	{0x99,0x66,0x00,0xFF}, {0x99,0x66,0x33,0xFF}, {0x99,0x66,0x66,0xFF}, {0x99,0x66,0x99,0xFF}, {0x99,0x66,0xCC,0xFF}, {0x99,0x66,0xFF,0xFF},
WiredHome	163:17526689a3ed	138	{0x99,0x99,0x00,0xFF}, {0x99,0x99,0x33,0xFF}, {0x99,0x99,0x66,0xFF}, {0x99,0x99,0x99,0xFF}, {0x99,0x99,0xCC,0xFF}, {0x99,0x99,0xFF,0xFF},
WiredHome	163:17526689a3ed	139	{0x99,0xCC,0x00,0xFF}, {0x99,0xCC,0x33,0xFF}, {0x99,0xCC,0x66,0xFF}, {0x99,0xCC,0x99,0xFF}, {0x99,0xCC,0xCC,0xFF}, {0x99,0xCC,0xFF,0xFF},
WiredHome	163:17526689a3ed	140	{0x99,0xFF,0x00,0xFF}, {0x99,0xFF,0x33,0xFF}, {0x99,0xFF,0x66,0xFF}, {0x99,0xFF,0x99,0xFF}, {0x99,0xFF,0xCC,0xFF}, {0x99,0xFF,0xFF,0xFF},
WiredHome	163:17526689a3ed	141	{0xCC,0x00,0x00,0xFF}, {0xCC,0x00,0x33,0xFF}, {0xCC,0x00,0x66,0xFF}, {0xCC,0x00,0x99,0xFF}, {0xCC,0x00,0xCC,0xFF}, {0xCC,0x00,0xFF,0xFF},
WiredHome	163:17526689a3ed	142	{0xCC,0x33,0x00,0xFF}, {0xCC,0x33,0x33,0xFF}, {0xCC,0x33,0x66,0xFF}, {0xCC,0x33,0x99,0xFF}, {0xCC,0x33,0xCC,0xFF}, {0xCC,0x33,0xFF,0xFF},
WiredHome	163:17526689a3ed	143	{0xCC,0x66,0x00,0xFF}, {0xCC,0x66,0x33,0xFF}, {0xCC,0x66,0x66,0xFF}, {0xCC,0x66,0x99,0xFF}, {0xCC,0x66,0xCC,0xFF}, {0xCC,0x66,0xFF,0xFF},
WiredHome	163:17526689a3ed	144	{0xCC,0x99,0x00,0xFF}, {0xCC,0x99,0x33,0xFF}, {0xCC,0x99,0x66,0xFF}, {0xCC,0x99,0x99,0xFF}, {0xCC,0x99,0xCC,0xFF}, {0xCC,0x99,0xFF,0xFF},
WiredHome	163:17526689a3ed	145	{0xCC,0xCC,0x00,0xFF}, {0xCC,0xCC,0x33,0xFF}, {0xCC,0xCC,0x66,0xFF}, {0xCC,0xCC,0x99,0xFF}, {0xCC,0xCC,0xCC,0xFF}, {0xCC,0xCC,0xFF,0xFF},
WiredHome	163:17526689a3ed	146	{0xCC,0xFF,0x00,0xFF}, {0xCC,0xFF,0x33,0xFF}, {0xCC,0xFF,0x66,0xFF}, {0xCC,0xFF,0x99,0xFF}, {0xCC,0xFF,0xCC,0xFF}, {0xCC,0xFF,0xFF,0xFF},
WiredHome	163:17526689a3ed	147	{0xFF,0x00,0x00,0xFF}, {0xFF,0x00,0x33,0xFF}, {0xFF,0x00,0x66,0xFF}, {0xFF,0x00,0x99,0xFF}, {0xFF,0x00,0xCC,0xFF}, {0xFF,0x00,0xFF,0xFF},
WiredHome	163:17526689a3ed	148	{0xFF,0x33,0x00,0xFF}, {0xFF,0x33,0x33,0xFF}, {0xFF,0x33,0x66,0xFF}, {0xFF,0x33,0x99,0xFF}, {0xFF,0x33,0xCC,0xFF}, {0xFF,0x33,0xFF,0xFF},
WiredHome	163:17526689a3ed	149	{0xFF,0x66,0x00,0xFF}, {0xFF,0x66,0x33,0xFF}, {0xFF,0x66,0x66,0xFF}, {0xFF,0x66,0x99,0xFF}, {0xFF,0x66,0xCC,0xFF}, {0xFF,0x66,0xFF,0xFF},
WiredHome	163:17526689a3ed	150	{0xFF,0x99,0x00,0xFF}, {0xFF,0x99,0x33,0xFF}, {0xFF,0x99,0x66,0xFF}, {0xFF,0x99,0x99,0xFF}, {0xFF,0x99,0xCC,0xFF}, {0xFF,0x99,0xFF,0xFF},
WiredHome	163:17526689a3ed	151	{0xFF,0xCC,0x00,0xFF}, {0xFF,0xCC,0x33,0xFF}, {0xFF,0xCC,0x66,0xFF}, {0xFF,0xCC,0x99,0xFF}, {0xFF,0xCC,0xCC,0xFF}, {0xFF,0xCC,0xFF,0xFF},
WiredHome	163:17526689a3ed	152	{0xFF,0xFF,0x00,0xFF}, {0xFF,0xFF,0x33,0xFF}, {0xFF,0xFF,0x66,0xFF}, {0xFF,0xFF,0x99,0xFF}, {0xFF,0xFF,0xCC,0xFF}, {0xFF,0xFF,0xFF,0xFF},
WiredHome	163:17526689a3ed	153
WiredHome	190:3132b7dfad82	154	{0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF},
WiredHome	190:3132b7dfad82	155	{0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF},
WiredHome	190:3132b7dfad82	156	{0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF},
WiredHome	190:3132b7dfad82	157	{0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF},
WiredHome	190:3132b7dfad82	158	{0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF},
WiredHome	190:3132b7dfad82	159	{0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF},
WiredHome	190:3132b7dfad82	160	{0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF}, {0x00,0x00,0x00,0xFF},
WiredHome	163:17526689a3ed	161	};
WiredHome	163:17526689a3ed	162
WiredHome	164:76edd7d9cb68	163	#define sqr(a) ((a) * (a))
WiredHome	164:76edd7d9cb68	164
WiredHome	164:76edd7d9cb68	165	/// Find the nearest color match in the lookup table.
WiredHome	164:76edd7d9cb68	166	///
WiredHome	164:76edd7d9cb68	167	/// The typical process is to find the difference between a given color and each entry in
WiredHome	164:76edd7d9cb68	168	/// the table. The difference is defined as:
WiredHome	164:76edd7d9cb68	169	/// diff = sqrt(sqr(r - table[i].r) + sqr(g - table[i].g) + sqr(b - table[i].b))
WiredHome	164:76edd7d9cb68	170	/// The square root function is very CPU intensive, especially w/o a floating point unit,
WiredHome	164:76edd7d9cb68	171	/// so that step is omitted to speed it up a bit.
WiredHome	164:76edd7d9cb68	172	///
WiredHome	163:17526689a3ed	173	static int FindNearestWebColor(uint8_t r, uint8_t g, uint8_t b) {
WiredHome	163:17526689a3ed	174	int bestNdx = 0;
WiredHome	164:76edd7d9cb68	175	float bestDiff = (sqr(r - WebColorPalette[0].r) + sqr(g - WebColorPalette[0].g) + sqr(b - WebColorPalette[0].b));
WiredHome	163:17526689a3ed	176	for (int i=1; i<216; i++) {
WiredHome	164:76edd7d9cb68	177	float thisDiff = (sqr(r - WebColorPalette[i].r) + sqr(g - WebColorPalette[i].g) + sqr(b - WebColorPalette[i].b));
WiredHome	163:17526689a3ed	178	if (thisDiff < bestDiff) {
WiredHome	163:17526689a3ed	179	bestDiff = thisDiff;
WiredHome	163:17526689a3ed	180	bestNdx = i;
WiredHome	163:17526689a3ed	181	}
WiredHome	163:17526689a3ed	182	}
WiredHome	163:17526689a3ed	183	return bestNdx;
WiredHome	163:17526689a3ed	184	}
WiredHome	163:17526689a3ed	185
WiredHome	166:53fd4a876dac	186	// Non-Touch, or Resistive Touch when later initialized that way
WiredHome	166:53fd4a876dac	187	//
WiredHome	190:3132b7dfad82	188	RA8875::RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset,
WiredHome	124:1690a7ae871c	189	const char *name)
WiredHome	58:26658a56112a	190	: GraphicsDisplay(name)
WiredHome	58:26658a56112a	191	, spi(mosi, miso, sclk)
WiredHome	19:3f82c1161fd2	192	, cs(csel)
WiredHome	200:ae29b60d087c	193	, res(NULL)
WiredHome	19:3f82c1161fd2	194	{
WiredHome	178:ae472eb22740	195	INFO("RA8875");
WiredHome	200:ae29b60d087c	196	if (reset != NC)
WiredHome	200:ae29b60d087c	197	res = new DigitalOut(reset);
WiredHome	182:8832d03a2a29	198	InitAllMemberVars();
WiredHome	176:4ab96d33a8ec	199	touchInfo = (touchInfo_T )malloc(RESISTIVE_TOUCH_POINTS sizeof(touchInfo_T));
WiredHome	176:4ab96d33a8ec	200	if (touchInfo)
WiredHome	176:4ab96d33a8ec	201	useTouchPanel = TP_RES;
WiredHome	19:3f82c1161fd2	202	}
WiredHome	19:3f82c1161fd2	203
WiredHome	166:53fd4a876dac	204	// Touch, based on FT5206 Controller Chip
WiredHome	166:53fd4a876dac	205	//
WiredHome	190:3132b7dfad82	206	RA8875::RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset,
WiredHome	190:3132b7dfad82	207	PinName sda, PinName scl, PinName irq, const char * name)
WiredHome	124:1690a7ae871c	208	: GraphicsDisplay(name)
WiredHome	124:1690a7ae871c	209	, spi(mosi, miso, sclk)
WiredHome	124:1690a7ae871c	210	, cs(csel)
WiredHome	200:ae29b60d087c	211	, res(NULL)
WiredHome	124:1690a7ae871c	212	{
WiredHome	178:ae472eb22740	213	INFO("RA8875");
WiredHome	200:ae29b60d087c	214	if (reset != NC)
WiredHome	200:ae29b60d087c	215	res = new DigitalOut(reset);
WiredHome	182:8832d03a2a29	216	InitAllMemberVars();
WiredHome	124:1690a7ae871c	217	m_irq = new InterruptIn(irq);
WiredHome	124:1690a7ae871c	218	m_i2c = new I2C(sda, scl);
WiredHome	178:ae472eb22740	219	INFO("m_i2c = %p", m_i2c);
WiredHome	190:3132b7dfad82	220
WiredHome	165:695c24cc5197	221	// Cap touch panel config
WiredHome	166:53fd4a876dac	222	touchInfo = (touchInfo_T )malloc(FT5206_TOUCH_POINTS sizeof(touchInfo_T));
WiredHome	166:53fd4a876dac	223	if (touchInfo)
WiredHome	166:53fd4a876dac	224	useTouchPanel = TP_FT5206;
WiredHome	165:695c24cc5197	225	m_addr = (FT5206_I2C_ADDRESS << 1);
WiredHome	165:695c24cc5197	226	m_i2c->frequency(FT5206_I2C_FREQUENCY);
WiredHome	190:3132b7dfad82	227
WiredHome	124:1690a7ae871c	228	// Interrupt
WiredHome	124:1690a7ae871c	229	m_irq->mode(PullUp);
WiredHome	155:b3f225ae572c	230	#if MBED_VERSION >= MBED_ENCODE_VERSION(5,8,0)
WiredHome	155:b3f225ae572c	231	eventThread.start(callback(&queue, &EventQueue::dispatch_forever));
WiredHome	155:b3f225ae572c	232	m_irq->fall(queue.event(callback(this, &RA8875::TouchPanelISR)));
WiredHome	181:0032d1b8f5d4	233	#elif (MBED_MAJOR_VERSION >= 5) \|\| (MBED_LIBRARY_VERSION > 127)
WiredHome	145:5eb2492acdda	234	m_irq->fall(callback(this, &RA8875::TouchPanelISR));
WiredHome	150:35a4db3081c1	235	#else
WiredHome	150:35a4db3081c1	236	m_irq->fall(this, &RA8875::TouchPanelISR);
WiredHome	150:35a4db3081c1	237	#endif
WiredHome	178:ae472eb22740	238	m_irq->enable_irq();
WiredHome	124:1690a7ae871c	239	TouchPanelInit();
WiredHome	178:ae472eb22740	240	INFO("RA8875 end.");
WiredHome	124:1690a7ae871c	241	}
WiredHome	124:1690a7ae871c	242
WiredHome	166:53fd4a876dac	243
WiredHome	166:53fd4a876dac	244	// Touch, based on GSL1680 Controller Chip
WiredHome	166:53fd4a876dac	245	//
WiredHome	190:3132b7dfad82	246	RA8875::RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset,
WiredHome	190:3132b7dfad82	247	PinName sda, PinName scl, PinName wake, PinName irq, const char * name)
WiredHome	165:695c24cc5197	248	: GraphicsDisplay(name)
WiredHome	165:695c24cc5197	249	, spi(mosi, miso, sclk)
WiredHome	165:695c24cc5197	250	, cs(csel)
WiredHome	200:ae29b60d087c	251	, res(NULL)
WiredHome	165:695c24cc5197	252	{
WiredHome	178:ae472eb22740	253	INFO("RA8875");
WiredHome	200:ae29b60d087c	254	if (reset != NC)
WiredHome	200:ae29b60d087c	255	res = new DigitalOut(reset);
WiredHome	182:8832d03a2a29	256	InitAllMemberVars();
WiredHome	190:3132b7dfad82	257
WiredHome	165:695c24cc5197	258	m_irq = new InterruptIn(irq);
WiredHome	165:695c24cc5197	259	m_i2c = new I2C(sda, scl);
WiredHome	165:695c24cc5197	260
WiredHome	165:695c24cc5197	261	// Cap touch panel config
WiredHome	166:53fd4a876dac	262	touchInfo = (touchInfo_T )malloc(FT5206_TOUCH_POINTS sizeof(touchInfo_T));
WiredHome	166:53fd4a876dac	263	if (touchInfo)
WiredHome	166:53fd4a876dac	264	useTouchPanel = TP_GSL1680;
WiredHome	165:695c24cc5197	265	m_addr = (GSL1680_I2C_ADDRESS << 1);
WiredHome	165:695c24cc5197	266	m_i2c->frequency(GSL1680_I2C_FREQUENCY);
WiredHome	165:695c24cc5197	267	m_wake = new DigitalOut(wake);
WiredHome	165:695c24cc5197	268
WiredHome	165:695c24cc5197	269	// Interrupt
WiredHome	165:695c24cc5197	270	m_irq->mode(PullUp);
WiredHome	165:695c24cc5197	271	m_irq->enable_irq();
WiredHome	165:695c24cc5197	272	#if MBED_VERSION >= MBED_ENCODE_VERSION(5,8,0)
WiredHome	165:695c24cc5197	273	eventThread.start(callback(&queue, &EventQueue::dispatch_forever));
WiredHome	165:695c24cc5197	274	m_irq->fall(queue.event(callback(this, &RA8875::TouchPanelISR)));
WiredHome	181:0032d1b8f5d4	275	#elif (MBED_MAJOR_VERSION >= 5) \|\| (MBED_LIBRARY_VERSION > 127)
WiredHome	165:695c24cc5197	276	m_irq->fall(callback(this, &RA8875::TouchPanelISR));
WiredHome	165:695c24cc5197	277	#else
WiredHome	165:695c24cc5197	278	m_irq->fall(this, &RA8875::TouchPanelISR);
WiredHome	165:695c24cc5197	279	#endif
WiredHome	165:695c24cc5197	280	TouchPanelInit();
WiredHome	165:695c24cc5197	281	}
WiredHome	165:695c24cc5197	282
WiredHome	165:695c24cc5197	283
WiredHome	124:1690a7ae871c	284
WiredHome	19:3f82c1161fd2	285	//RA8875::~RA8875()
WiredHome	19:3f82c1161fd2	286	//{
WiredHome	19:3f82c1161fd2	287	//}
WiredHome	19:3f82c1161fd2	288
WiredHome	182:8832d03a2a29	289	void RA8875::InitAllMemberVars() {
WiredHome	182:8832d03a2a29	290	tpFQFN = NULL;
WiredHome	182:8832d03a2a29	291	tpCalMessage = NULL;
WiredHome	182:8832d03a2a29	292	c_callback = NULL;
WiredHome	182:8832d03a2a29	293	obj_callback = NULL;
WiredHome	182:8832d03a2a29	294	method_callback = NULL;
WiredHome	182:8832d03a2a29	295	idle_callback = NULL;
WiredHome	182:8832d03a2a29	296	fontScaleX = fontScaleY = 1;
WiredHome	182:8832d03a2a29	297	m_addr = 0;
WiredHome	182:8832d03a2a29	298	m_wake = NULL; // not used for FT5206
WiredHome	182:8832d03a2a29	299	m_irq = NULL;
WiredHome	182:8832d03a2a29	300	m_i2c = NULL;
WiredHome	182:8832d03a2a29	301	touchInfo = NULL;
WiredHome	182:8832d03a2a29	302	useTouchPanel = TP_NONE;
WiredHome	182:8832d03a2a29	303	touchState = no_touch;
WiredHome	182:8832d03a2a29	304	numberOfTouchPoints = 0;
WiredHome	182:8832d03a2a29	305	gesture = 0;
WiredHome	198:9b6851107426	306	panelTouched = false;
WiredHome	182:8832d03a2a29	307	touchSample = 0;
WiredHome	182:8832d03a2a29	308	memset(&tpMatrix, 0, sizeof(tpMatrix_t));
WiredHome	182:8832d03a2a29	309	pKeyMap = NULL;
WiredHome	182:8832d03a2a29	310	spiWriteSpeed = false;
WiredHome	182:8832d03a2a29	311	spiwritefreq = 1000000;
WiredHome	182:8832d03a2a29	312	spireadfreq = 1000000;
WiredHome	182:8832d03a2a29	313	screenbpp = 16;
WiredHome	198:9b6851107426	314	virt_screenwidth = 0;
WiredHome	198:9b6851107426	315	virt_screenheight = 0;
WiredHome	182:8832d03a2a29	316	memset(&windowrect, 0, sizeof(rect_t));
WiredHome	182:8832d03a2a29	317	font = NULL;
WiredHome	182:8832d03a2a29	318	extFontHeight = 0;
WiredHome	182:8832d03a2a29	319	extFontWidth = 0;
WiredHome	182:8832d03a2a29	320	cursor_x = 0;
WiredHome	182:8832d03a2a29	321	cursor_y = 0;
WiredHome	182:8832d03a2a29	322	_printFH = NULL;
WiredHome	190:3132b7dfad82	323	roundCap = false;
WiredHome	182:8832d03a2a29	324	screen_orientation = normal;
WiredHome	182:8832d03a2a29	325	#ifdef PERF_METRICS
WiredHome	182:8832d03a2a29	326	ClearPerformance();
WiredHome	182:8832d03a2a29	327	#endif
WiredHome	182:8832d03a2a29	328	}
WiredHome	154:ad2450fc3dc3	329
WiredHome	131:5bd6ba2ee4a1	330	RetCode_t RA8875::init(int width, int height, int color_bpp, uint8_t poweron, bool keypadon, bool touchscreenon)
WiredHome	79:544eb4964795	331	{
WiredHome	178:ae472eb22740	332	INFO("RA8875::init()");
WiredHome	98:ecebed9b80b2	333	font = NULL; // no external font, use internal.
WiredHome	98:ecebed9b80b2	334	pKeyMap = DefaultKeyMap; // set default key map
WiredHome	98:ecebed9b80b2	335	_select(false); // deselect the display
WiredHome	98:ecebed9b80b2	336	frequency(RA8875_DEFAULT_SPI_FREQ); // data rate
WiredHome	79:544eb4964795	337	Reset();
WiredHome	134:f028ed71a0af	338	// Set PLL based on display size from buy-display.com sample code
WiredHome	198:9b6851107426	339	// RAIO Reference display values noted: 800w: 0x0B, 480w: 0x0A
WiredHome	134:f028ed71a0af	340	if (width == 800) {
WiredHome	198:9b6851107426	341	WriteCommand(RA8875_PLLC1, 0x0C); // PLLC1 - Phase Lock Loop registers [RAIO 0B]
WiredHome	134:f028ed71a0af	342	} else {
WiredHome	198:9b6851107426	343	WriteCommand(RA8875_PLLC1, 0x0B); // PLLC1 - Phase Lock Loop registers [RAIO 0A]
WiredHome	134:f028ed71a0af	344	}
WiredHome	197:853d08e2fb53	345	wait_us(1000);
WiredHome	175:7be3a1fb7fc2	346	WriteCommand(RA8875_PLLC2, 0x02);
WiredHome	197:853d08e2fb53	347	wait_us(1000);
WiredHome	79:544eb4964795	348
WiredHome	79:544eb4964795	349	// System Config Register (SYSR)
WiredHome	105:4f116006ba1f	350	screenbpp = color_bpp;
WiredHome	79:544eb4964795	351	if (color_bpp == 16) {
WiredHome	175:7be3a1fb7fc2	352	WriteCommand(RA8875_SYSR, 0x0C); // 16-bpp (65K colors) color depth, 8-bit interface
WiredHome	79:544eb4964795	353	} else { // color_bpp == 8
WiredHome	175:7be3a1fb7fc2	354	WriteCommand(RA8875_SYSR, 0x00); // 8-bpp (256 colors)
WiredHome	79:544eb4964795	355	}
WiredHome	134:f028ed71a0af	356
WiredHome	134:f028ed71a0af	357	// Set Pixel Clock Setting Register (PCSR) based on display size from buy-display.com sample code
WiredHome	134:f028ed71a0af	358	if (width == 800) {
WiredHome	175:7be3a1fb7fc2	359	WriteCommand(RA8875_PCSR, 0x81); // PDAT on PCLK falling edge, PCLK = 4 x System Clock
WiredHome	197:853d08e2fb53	360	wait_us(1000);
WiredHome	134:f028ed71a0af	361
WiredHome	134:f028ed71a0af	362	// Horizontal Settings
WiredHome	198:9b6851107426	363	virt_screenwidth = width;
WiredHome	175:7be3a1fb7fc2	364	WriteCommand(RA8875_HDWR, width/8 - 1); //HDWR//Horizontal Display Width Setting Bit[6:0]
WiredHome	198:9b6851107426	365	WriteCommand(RA8875_HNDFTR, 0x00); //HNDFCR//Horizontal Non-Display Period fine tune Bit[3:0]
WiredHome	198:9b6851107426	366	WriteCommand(RA8875_HNDR, 0x03); //HNDR//Horizontal Non-Display Period Bit[4:0] [RAIO 0x01]
WiredHome	198:9b6851107426	367	WriteCommand(RA8875_HSTR, 0x03); //HSTR//HSYNC Start Position[4:0] [RAIO 0x00]
WiredHome	198:9b6851107426	368	WriteCommand(RA8875_HPWR, 0x0B); //HPWR//HSYNC Polarity ,The period width of HSYNC. [RAIO 0x05]
WiredHome	134:f028ed71a0af	369
WiredHome	134:f028ed71a0af	370	// Vertical Settings
WiredHome	198:9b6851107426	371	virt_screenheight = height;
WiredHome	175:7be3a1fb7fc2	372	WriteCommand(RA8875_VDHR0, (height-1)&0xFF); //VDHR0 //Vertical Display Height Bit [7:0]
WiredHome	175:7be3a1fb7fc2	373	WriteCommand(RA8875_VDHR1, (height-1)>>8); //VDHR1 //Vertical Display Height Bit [8]
WiredHome	198:9b6851107426	374	WriteCommand(RA8875_VNDR0, 0x20); //VNDR0 //Vertical Non-Display Period Bit [7:0] [RAIO 0x02]
WiredHome	175:7be3a1fb7fc2	375	WriteCommand(RA8875_VNDR1, 0x00); //VNDR1 //Vertical Non-Display Period Bit [8]
WiredHome	198:9b6851107426	376	WriteCommand(RA8875_VSTR0, 0x16); //VSTR0 //VSYNC Start Position[7:0] [RAIO 0x07]
WiredHome	175:7be3a1fb7fc2	377	WriteCommand(RA8875_VSTR1, 0x00); //VSTR1 //VSYNC Start Position[8]
WiredHome	198:9b6851107426	378	WriteCommand(RA8875_VPWR, 0x01); //VPWR //VSYNC Polarity ,VSYNC Pulse Width[6:0] [RAIO 0x09]
WiredHome	134:f028ed71a0af	379	} else {
WiredHome	175:7be3a1fb7fc2	380	WriteCommand(RA8875_PCSR, 0x82); // PDAT on PCLK falling edge, PCLK = 4 x System Clock
WiredHome	197:853d08e2fb53	381	wait_us(1000);
WiredHome	134:f028ed71a0af	382
WiredHome	134:f028ed71a0af	383	// Horizontal Settings
WiredHome	198:9b6851107426	384	virt_screenwidth = width;
WiredHome	175:7be3a1fb7fc2	385	WriteCommand(RA8875_HDWR, width/8 - 1); //HDWR//Horizontal Display Width Setting Bit[6:0]
WiredHome	175:7be3a1fb7fc2	386	WriteCommand(RA8875_HNDFTR, 0x02); //HNDFCR//Horizontal Non-Display Period fine tune Bit[3:0]
WiredHome	175:7be3a1fb7fc2	387	WriteCommand(RA8875_HNDR, 0x03); //HNDR//Horizontal Non-Display Period Bit[4:0]
WiredHome	175:7be3a1fb7fc2	388	WriteCommand(RA8875_HSTR, 0x01); //HSTR//HSYNC Start Position[4:0]
WiredHome	175:7be3a1fb7fc2	389	WriteCommand(RA8875_HPWR, 0x03); //HPWR//HSYNC Polarity ,The period width of HSYNC.
WiredHome	134:f028ed71a0af	390
WiredHome	134:f028ed71a0af	391	// Vertical Settings
WiredHome	198:9b6851107426	392	virt_screenheight = height;
WiredHome	175:7be3a1fb7fc2	393	WriteCommand(RA8875_VDHR0, (height-1)&0xFF); //VDHR0 //Vertical Display Height Bit [7:0]
WiredHome	175:7be3a1fb7fc2	394	WriteCommand(RA8875_VDHR1, (height-1)>>8); //VDHR1 //Vertical Display Height Bit [8]
WiredHome	175:7be3a1fb7fc2	395	WriteCommand(RA8875_VNDR0, 0x0F); //VNDR0 //Vertical Non-Display Period Bit [7:0]
WiredHome	175:7be3a1fb7fc2	396	WriteCommand(RA8875_VNDR1, 0x00); //VNDR1 //Vertical Non-Display Period Bit [8]
WiredHome	175:7be3a1fb7fc2	397	WriteCommand(RA8875_VSTR0, 0x0e); //VSTR0 //VSYNC Start Position[7:0]
WiredHome	175:7be3a1fb7fc2	398	WriteCommand(RA8875_VSTR1, 0x06); //VSTR1 //VSYNC Start Position[8]
WiredHome	175:7be3a1fb7fc2	399	WriteCommand(RA8875_VPWR, 0x01); //VPWR //VSYNC Polarity ,VSYNC Pulse Width[6:0]
WiredHome	134:f028ed71a0af	400	}
WiredHome	79:544eb4964795	401
WiredHome	79:544eb4964795	402	if (width >= 800 && height >= 480 && color_bpp > 8) {
WiredHome	175:7be3a1fb7fc2	403	WriteCommand(RA8875_DPCR, 0x00); // DPCR - 1-layer mode when the resolution is too high
WiredHome	79:544eb4964795	404	} else {
WiredHome	175:7be3a1fb7fc2	405	WriteCommand(RA8875_DPCR, 0x80); // DPCR - 2-layer mode
WiredHome	79:544eb4964795	406	}
WiredHome	79:544eb4964795	407
WiredHome	79:544eb4964795	408	// Set display image to Blue on Black as default
WiredHome	198:9b6851107426	409	SetWindow(0,0, width-1, height-1); // Initialize to full screen
WiredHome	79:544eb4964795	410	SetTextCursorControl();
WiredHome	79:544eb4964795	411	foreground(Blue);
WiredHome	79:544eb4964795	412	background(Black);
WiredHome	79:544eb4964795	413	cls(3);
WiredHome	79:544eb4964795	414
WiredHome	79:544eb4964795	415	Power(poweron);
WiredHome	131:5bd6ba2ee4a1	416	Backlight_u8(poweron);
WiredHome	81:01da2e34283d	417	if (keypadon)
WiredHome	81:01da2e34283d	418	KeypadInit();
WiredHome	124:1690a7ae871c	419	if (touchscreenon) {
WiredHome	124:1690a7ae871c	420	if (useTouchPanel == TP_NONE)
WiredHome	124:1690a7ae871c	421	useTouchPanel = TP_RES;
WiredHome	178:ae472eb22740	422	if (useTouchPanel == TP_RES)
WiredHome	178:ae472eb22740	423	TouchPanelInit(); // only init again if resistive (due to HW reset applied above).
WiredHome	124:1690a7ae871c	424	}
WiredHome	79:544eb4964795	425	#ifdef PERF_METRICS
WiredHome	79:544eb4964795	426	performance.start();
WiredHome	79:544eb4964795	427	ClearPerformance();
WiredHome	79:544eb4964795	428	#endif
WiredHome	178:ae472eb22740	429	INFO("RA8875::init() end");
WiredHome	79:544eb4964795	430	return noerror;
WiredHome	79:544eb4964795	431	}
WiredHome	79:544eb4964795	432
WiredHome	79:544eb4964795	433
WiredHome	79:544eb4964795	434	RetCode_t RA8875::Reset(void)
WiredHome	79:544eb4964795	435	{
WiredHome	79:544eb4964795	436	RetCode_t ret;
WiredHome	190:3132b7dfad82	437
WiredHome	198:9b6851107426	438	#if 1
WiredHome	200:ae29b60d087c	439	if (res) {
WiredHome	200:ae29b60d087c	440	res->write(0); // Active low - assert reset
WiredHome	200:ae29b60d087c	441	wait_us(2000); // must be > 1024 clock periods. (@25 MHz, this is 40.96 usec)
WiredHome	200:ae29b60d087c	442	res->write(1); // de-assert reset
WiredHome	94:203729061e48	443	}
WiredHome	94:203729061e48	444	#endif
WiredHome	175:7be3a1fb7fc2	445	ret = WriteCommand(RA8875_PWRR, 0x01); // Apply Display Off, Reset
WiredHome	197:853d08e2fb53	446	wait_us(2000); // no idea if I need to wait, or how long
WiredHome	79:544eb4964795	447	if (ret == noerror) {
WiredHome	175:7be3a1fb7fc2	448	ret = WriteCommand(RA8875_PWRR, 0x00); // Display off, Remove reset
WiredHome	197:853d08e2fb53	449	wait_us(2000); // no idea if I need to wait, or how long
WiredHome	79:544eb4964795	450	}
WiredHome	79:544eb4964795	451	return ret;
WiredHome	79:544eb4964795	452	}
WiredHome	79:544eb4964795	453
WiredHome	79:544eb4964795	454
WiredHome	79:544eb4964795	455	const char * RA8875::GetErrorMessage(RetCode_t code)
WiredHome	79:544eb4964795	456	{
WiredHome	79:544eb4964795	457	if (code >= LastErrCode)
WiredHome	79:544eb4964795	458	code = bad_parameter;
WiredHome	79:544eb4964795	459	return ErrMessages[code];
WiredHome	79:544eb4964795	460	}
WiredHome	79:544eb4964795	461
WiredHome	79:544eb4964795	462
WiredHome	61:8f3153bf0baa	463	uint16_t RA8875::GetDrawingLayer(void)
WiredHome	61:8f3153bf0baa	464	{
WiredHome	61:8f3153bf0baa	465	return (ReadCommand(0x41) & 0x01);
WiredHome	61:8f3153bf0baa	466	}
WiredHome	43:3becae133285	467
WiredHome	79:544eb4964795	468
WiredHome	198:9b6851107426	469	uint16_t RA8875::SelectDrawingLayer(uint16_t layer)
WiredHome	43:3becae133285	470	{
WiredHome	198:9b6851107426	471	uint16_t prevLayer;
WiredHome	142:6e9bff59878a	472	unsigned char mwcr1 = ReadCommand(0x41); // retain all but the currently selected layer
WiredHome	198:9b6851107426	473	prevLayer = (mwcr1 & 1);
WiredHome	142:6e9bff59878a	474	mwcr1 &= ~0x01; // remove the current layer
WiredHome	198:9b6851107426	475	if (virt_screenwidth >= 800 && virt_screenheight >= 480 && screenbpp > 8) {
WiredHome	142:6e9bff59878a	476	layer = 0;
WiredHome	43:3becae133285	477	} else if (layer > 1) {
WiredHome	142:6e9bff59878a	478	layer = 0;
WiredHome	43:3becae133285	479	}
WiredHome	198:9b6851107426	480	WriteCommand(RA8875_MWCR1, mwcr1 \| layer);
WiredHome	198:9b6851107426	481	return prevLayer;
WiredHome	43:3becae133285	482	}
WiredHome	43:3becae133285	483
WiredHome	44:207594dece70	484
WiredHome	82:f7d300f26540	485	RA8875::LayerMode_T RA8875::GetLayerMode(void)
WiredHome	82:f7d300f26540	486	{
WiredHome	82:f7d300f26540	487	return (LayerMode_T)(ReadCommand(0x52) & 0x7);
WiredHome	82:f7d300f26540	488	}
WiredHome	82:f7d300f26540	489
WiredHome	82:f7d300f26540	490
WiredHome	198:9b6851107426	491	RA8875::LayerMode_T RA8875::SetLayerMode(LayerMode_T mode)
WiredHome	44:207594dece70	492	{
WiredHome	198:9b6851107426	493	unsigned char ltpr0 = ReadCommand(0x52); // retain all but the display layer mode
WiredHome	198:9b6851107426	494	LayerMode_T oldLayer = (LayerMode_T)(ltpr0 & 0x07);
WiredHome	53:86d24b9480b9	495	if (mode <= (LayerMode_T)6) {
WiredHome	198:9b6851107426	496	WriteCommand(RA8875_LTPR0, (ltpr0 & ~0x07) \| (mode & 0x07));
WiredHome	53:86d24b9480b9	497	}
WiredHome	198:9b6851107426	498	return oldLayer;
WiredHome	44:207594dece70	499	}
WiredHome	44:207594dece70	500
WiredHome	44:207594dece70	501
WiredHome	44:207594dece70	502	RetCode_t RA8875::SetLayerTransparency(uint8_t layer1, uint8_t layer2)
WiredHome	44:207594dece70	503	{
WiredHome	44:207594dece70	504	if (layer1 > 8)
WiredHome	44:207594dece70	505	layer1 = 8;
WiredHome	44:207594dece70	506	if (layer2 > 8)
WiredHome	44:207594dece70	507	layer2 = 8;
WiredHome	175:7be3a1fb7fc2	508	WriteCommand(RA8875_LTPR1, ((layer2 & 0xF) << 4) \| (layer1 & 0xF));
WiredHome	44:207594dece70	509	return noerror;
WiredHome	44:207594dece70	510	}
WiredHome	44:207594dece70	511
WiredHome	44:207594dece70	512
WiredHome	198:9b6851107426	513	color_t RA8875::SetBackgroundTransparencyColor(color_t color)
WiredHome	53:86d24b9480b9	514	{
WiredHome	198:9b6851107426	515	color_t oldColor = _readColorTrio(0x67);
WiredHome	198:9b6851107426	516	_writeColorTrio(0x67, color);
WiredHome	198:9b6851107426	517	return oldColor;
WiredHome	53:86d24b9480b9	518	}
WiredHome	53:86d24b9480b9	519
WiredHome	79:544eb4964795	520
WiredHome	73:f22a18707b5e	521	color_t RA8875::GetBackgroundTransparencyColor(void)
WiredHome	73:f22a18707b5e	522	{
WiredHome	73:f22a18707b5e	523	RGBQUAD q;
WiredHome	190:3132b7dfad82	524
WiredHome	73:f22a18707b5e	525	q.rgbRed = ReadCommand(0x67);
WiredHome	73:f22a18707b5e	526	q.rgbGreen = ReadCommand(0x68);
WiredHome	73:f22a18707b5e	527	q.rgbBlue = ReadCommand(0x69);
WiredHome	73:f22a18707b5e	528	return RGBQuadToRGB16(&q, 0);
WiredHome	73:f22a18707b5e	529	}
WiredHome	73:f22a18707b5e	530
WiredHome	71:dcac8efd842d	531
WiredHome	77:9206c13aa527	532	RetCode_t RA8875::KeypadInit(bool scanEnable, bool longDetect, uint8_t sampleTime, uint8_t scanFrequency,
WiredHome	77:9206c13aa527	533	uint8_t longTimeAdjustment, bool interruptEnable, bool wakeupEnable)
WiredHome	71:dcac8efd842d	534	{
WiredHome	71:dcac8efd842d	535	uint8_t value = 0;
WiredHome	77:9206c13aa527	536
WiredHome	71:dcac8efd842d	537	if (sampleTime > 3 \|\| scanFrequency > 7 \|\| longTimeAdjustment > 3)
WiredHome	71:dcac8efd842d	538	return bad_parameter;
WiredHome	71:dcac8efd842d	539	value \|= (scanEnable) ? 0x80 : 0x00;
WiredHome	71:dcac8efd842d	540	value \|= (longDetect) ? 0x40 : 0x00;
WiredHome	71:dcac8efd842d	541	value \|= (sampleTime & 0x03) << 4;
WiredHome	71:dcac8efd842d	542	value \|= (scanFrequency & 0x07);
WiredHome	175:7be3a1fb7fc2	543	WriteCommand(RA8875_KSCR1, value); // KSCR1 - Enable Key Scan (and ignore possibility of an error)
WiredHome	77:9206c13aa527	544
WiredHome	71:dcac8efd842d	545	value = 0;
WiredHome	71:dcac8efd842d	546	value \|= (wakeupEnable) ? 0x80 : 0x00;
WiredHome	71:dcac8efd842d	547	value \|= (longTimeAdjustment & 0x03) << 2;
WiredHome	175:7be3a1fb7fc2	548	WriteCommand(RA8875_KSCR2, value); // KSCR2 - (and ignore possibility of an error)
WiredHome	77:9206c13aa527	549
WiredHome	75:ca78388cfd77	550	value = ReadCommand(0xF0); // (and ignore possibility of an error)
WiredHome	71:dcac8efd842d	551	value &= ~0x10;
WiredHome	71:dcac8efd842d	552	value \|= (interruptEnable) ? 0x10 : 0x00;
WiredHome	175:7be3a1fb7fc2	553	return WriteCommand(RA8875_INTC1, value); // INT
WiredHome	71:dcac8efd842d	554	}
WiredHome	71:dcac8efd842d	555
WiredHome	79:544eb4964795	556
WiredHome	75:ca78388cfd77	557	RetCode_t RA8875::SetKeyMap(const uint8_t * CodeList)
WiredHome	75:ca78388cfd77	558	{
WiredHome	75:ca78388cfd77	559	pKeyMap = CodeList;
WiredHome	75:ca78388cfd77	560	return noerror;
WiredHome	75:ca78388cfd77	561	}
WiredHome	75:ca78388cfd77	562
WiredHome	79:544eb4964795	563
WiredHome	75:ca78388cfd77	564	bool RA8875::readable(void)
WiredHome	71:dcac8efd842d	565	{
WiredHome	71:dcac8efd842d	566	return (ReadCommand(0xF1) & 0x10); // check KS status - true if kbhit
WiredHome	71:dcac8efd842d	567	}
WiredHome	71:dcac8efd842d	568
WiredHome	79:544eb4964795	569
WiredHome	75:ca78388cfd77	570	uint8_t RA8875::getc(void)
WiredHome	71:dcac8efd842d	571	{
WiredHome	79:544eb4964795	572	//#define GETC_DEV // for development
WiredHome	77:9206c13aa527	573	#ifdef GETC_DEV
WiredHome	75:ca78388cfd77	574	uint8_t keyCode1, keyCode2;
WiredHome	77:9206c13aa527	575	#endif
WiredHome	75:ca78388cfd77	576	uint8_t keyCode3;
WiredHome	75:ca78388cfd77	577	static uint8_t count = 0;
WiredHome	75:ca78388cfd77	578	uint8_t col, row;
WiredHome	75:ca78388cfd77	579	uint8_t key;
WiredHome	190:3132b7dfad82	580
WiredHome	75:ca78388cfd77	581	while (!readable()) {
WiredHome	71:dcac8efd842d	582	wait_us(POLLWAITuSec);
WiredHome	75:ca78388cfd77	583	// COUNTIDLETIME(POLLWAITuSec); // As it is voluntary to call the getc and pend. Don't tally it.
WiredHome	123:2f45e80fec5f	584	if (idle_callback) {
WiredHome	149:c62c4b2d6a15	585	if (external_abort == (*idle_callback)(getc_wait, 0)) {
WiredHome	123:2f45e80fec5f	586	return 0;
WiredHome	123:2f45e80fec5f	587	}
WiredHome	123:2f45e80fec5f	588	}
WiredHome	71:dcac8efd842d	589	}
WiredHome	71:dcac8efd842d	590	// read the key press number
WiredHome	71:dcac8efd842d	591	uint8_t keyNumReg = ReadCommand(0xC1) & 0x03;
WiredHome	75:ca78388cfd77	592	count++;
WiredHome	75:ca78388cfd77	593	switch (keyNumReg) {
WiredHome	75:ca78388cfd77	594	case 0x01: // one key
WiredHome	75:ca78388cfd77	595	keyCode3 = ReadCommand(0xC2);
WiredHome	77:9206c13aa527	596	#ifdef GETC_DEV
WiredHome	75:ca78388cfd77	597	keyCode2 = 0;
WiredHome	75:ca78388cfd77	598	keyCode1 = 0;
WiredHome	77:9206c13aa527	599	#endif
WiredHome	75:ca78388cfd77	600	break;
WiredHome	75:ca78388cfd77	601	case 0x02: // two keys
WiredHome	75:ca78388cfd77	602	keyCode3 = ReadCommand(0xC3);
WiredHome	77:9206c13aa527	603	#ifdef GETC_DEV
WiredHome	75:ca78388cfd77	604	keyCode2 = ReadCommand(0xC2);
WiredHome	75:ca78388cfd77	605	keyCode1 = 0;
WiredHome	77:9206c13aa527	606	#endif
WiredHome	75:ca78388cfd77	607	break;
WiredHome	75:ca78388cfd77	608	case 0x03: // three keys
WiredHome	75:ca78388cfd77	609	keyCode3 = ReadCommand(0xC4);
WiredHome	77:9206c13aa527	610	#ifdef GETC_DEV
WiredHome	75:ca78388cfd77	611	keyCode2 = ReadCommand(0xC3);
WiredHome	75:ca78388cfd77	612	keyCode1 = ReadCommand(0xC2);
WiredHome	77:9206c13aa527	613	#endif
WiredHome	75:ca78388cfd77	614	break;
WiredHome	75:ca78388cfd77	615	default: // no keys (key released)
WiredHome	75:ca78388cfd77	616	keyCode3 = 0xFF;
WiredHome	77:9206c13aa527	617	#ifdef GETC_DEV
WiredHome	75:ca78388cfd77	618	keyCode2 = 0;
WiredHome	75:ca78388cfd77	619	keyCode1 = 0;
WiredHome	77:9206c13aa527	620	#endif
WiredHome	75:ca78388cfd77	621	break;
WiredHome	75:ca78388cfd77	622	}
WiredHome	75:ca78388cfd77	623	if (keyCode3 == 0xFF)
WiredHome	75:ca78388cfd77	624	key = pKeyMap[0]; // Key value 0
WiredHome	75:ca78388cfd77	625	else {
WiredHome	75:ca78388cfd77	626	row = (keyCode3 >> 4) & 0x03;
WiredHome	75:ca78388cfd77	627	col = (keyCode3 & 7);
WiredHome	75:ca78388cfd77	628	key = row * 5 + col + 1; // Keys value 1 - 20
WiredHome	75:ca78388cfd77	629	if (key > 21) {
WiredHome	75:ca78388cfd77	630	key = 21;
WiredHome	75:ca78388cfd77	631	}
WiredHome	75:ca78388cfd77	632	key = pKeyMap[key];
WiredHome	75:ca78388cfd77	633	key \|= (keyCode3 & 0x80); // combine the key held flag
WiredHome	75:ca78388cfd77	634	}
WiredHome	77:9206c13aa527	635	#if GETC_DEV // for Development only
WiredHome	75:ca78388cfd77	636	SetTextCursor(0, 20);
WiredHome	75:ca78388cfd77	637	printf(" Reg: %02x\r\n", keyNumReg);
WiredHome	75:ca78388cfd77	638	printf(" key1: %02x\r\n", keyCode1);
WiredHome	75:ca78388cfd77	639	printf(" key2: %02x\r\n", keyCode2);
WiredHome	75:ca78388cfd77	640	printf(" key3: %02x\r\n", keyCode3);
WiredHome	75:ca78388cfd77	641	printf(" count: %02X\r\n", count);
WiredHome	75:ca78388cfd77	642	printf(" key: %02X\r\n", key);
WiredHome	77:9206c13aa527	643	#endif
WiredHome	175:7be3a1fb7fc2	644	WriteCommand(RA8875_INTC2, 0x10); // Clear KS status
WiredHome	75:ca78388cfd77	645	return key;
WiredHome	71:dcac8efd842d	646	}
WiredHome	71:dcac8efd842d	647
WiredHome	79:544eb4964795	648
WiredHome	19:3f82c1161fd2	649	#ifdef PERF_METRICS
WiredHome	19:3f82c1161fd2	650	void RA8875::ClearPerformance()
WiredHome	19:3f82c1161fd2	651	{
WiredHome	100:0b084475d5a9	652	int i;
WiredHome	190:3132b7dfad82	653
WiredHome	100:0b084475d5a9	654	for (i=0; i<METRICCOUNT; i++)
WiredHome	19:3f82c1161fd2	655	metrics[i] = 0;
WiredHome	75:ca78388cfd77	656	idletime_usec = 0;
WiredHome	100:0b084475d5a9	657	for (i=0; i<256; i++)
WiredHome	100:0b084475d5a9	658	commandsUsed[i] = 0;
WiredHome	19:3f82c1161fd2	659	}
WiredHome	19:3f82c1161fd2	660
WiredHome	79:544eb4964795	661
WiredHome	19:3f82c1161fd2	662	void RA8875::RegisterPerformance(method_e method)
WiredHome	19:3f82c1161fd2	663	{
WiredHome	19:3f82c1161fd2	664	unsigned long elapsed = performance.read_us();
WiredHome	73:f22a18707b5e	665
WiredHome	19:3f82c1161fd2	666	if (method < METRICCOUNT && elapsed > metrics[method])
WiredHome	19:3f82c1161fd2	667	metrics[method] = elapsed;
WiredHome	19:3f82c1161fd2	668	}
WiredHome	19:3f82c1161fd2	669
WiredHome	79:544eb4964795	670
WiredHome	66:468a11f05580	671	void RA8875::CountIdleTime(uint32_t t)
WiredHome	66:468a11f05580	672	{
WiredHome	75:ca78388cfd77	673	idletime_usec += t;
WiredHome	66:468a11f05580	674	}
WiredHome	44:207594dece70	675
WiredHome	79:544eb4964795	676
WiredHome	41:2956a0a221e5	677	void RA8875::ReportPerformance(Serial & pc)
WiredHome	19:3f82c1161fd2	678	{
WiredHome	100:0b084475d5a9	679	int i;
WiredHome	190:3132b7dfad82	680
WiredHome	41:2956a0a221e5	681	pc.printf("\r\nPerformance Metrics\r\n");
WiredHome	100:0b084475d5a9	682	for (i=0; i<METRICCOUNT; i++) {
WiredHome	41:2956a0a221e5	683	pc.printf("%10d uS %s\r\n", metrics[i], metricsName[i]);
WiredHome	66:468a11f05580	684	}
WiredHome	75:ca78388cfd77	685	pc.printf("%10d uS Idle time polling display for ready.\r\n", idletime_usec);
WiredHome	91:ca5f829e6d27	686	for (i=0; i<256; i++) {
WiredHome	91:ca5f829e6d27	687	if (commandsUsed[i])
WiredHome	100:0b084475d5a9	688	pc.printf("Command %02X used %5d times.\r\n", i, commandsUsed[i]);
WiredHome	91:ca5f829e6d27	689	}
WiredHome	19:3f82c1161fd2	690	}
WiredHome	19:3f82c1161fd2	691	#endif
WiredHome	19:3f82c1161fd2	692
WiredHome	44:207594dece70	693
WiredHome	190:3132b7dfad82	694	rect_t RA8875::AlignRectInRect(rect_t toAlign, rect_t inRect, valign_t v, halign_t h) {
WiredHome	190:3132b7dfad82	695	rect_t newRect; dim_t width; dim_t height;
WiredHome	198:9b6851107426	696	width = toAlign.p2.x - toAlign.p1.x + 1;
WiredHome	198:9b6851107426	697	height = toAlign.p2.y - toAlign.p1.y + 1;
WiredHome	198:9b6851107426	698	INFO("Align(%d,%d)-(%d,%d) in (%d,%d)-(%d,%d) v:%d, h:%d",
WiredHome	198:9b6851107426	699	toAlign.p1.x,toAlign.p1.y,toAlign.p2.x,toAlign.p2.y,
WiredHome	198:9b6851107426	700	inRect.p1.x,inRect.p1.y,inRect.p2.x,inRect.p2.y,
WiredHome	198:9b6851107426	701	v,h
WiredHome	198:9b6851107426	702	);
WiredHome	190:3132b7dfad82	703	switch (h) {
WiredHome	190:3132b7dfad82	704	case left:
WiredHome	190:3132b7dfad82	705	default:
WiredHome	190:3132b7dfad82	706	newRect.p1.x = inRect.p1.x;
WiredHome	198:9b6851107426	707	newRect.p2.x = newRect.p1.x + width - 1;
WiredHome	190:3132b7dfad82	708	break;
WiredHome	190:3132b7dfad82	709	case center:
WiredHome	190:3132b7dfad82	710	newRect.p1.x = (inRect.p1.x + inRect.p2.x + 1) / 2 - width / 2;
WiredHome	198:9b6851107426	711	newRect.p2.x = newRect.p1.x + width - 1;
WiredHome	190:3132b7dfad82	712	break;
WiredHome	190:3132b7dfad82	713	case right:
WiredHome	198:9b6851107426	714	newRect.p1.x = inRect.p2.x - width - 1;
WiredHome	198:9b6851107426	715	newRect.p2.x = newRect.p1.x + width - 1;
WiredHome	190:3132b7dfad82	716	break;
WiredHome	190:3132b7dfad82	717	}
WiredHome	190:3132b7dfad82	718	switch (v) {
WiredHome	190:3132b7dfad82	719	case top:
WiredHome	190:3132b7dfad82	720	default:
WiredHome	190:3132b7dfad82	721	newRect.p1.y = inRect.p1.y;
WiredHome	198:9b6851107426	722	newRect.p2.y = newRect.p1.y + height - 1;
WiredHome	190:3132b7dfad82	723	break;
WiredHome	190:3132b7dfad82	724	case middle:
WiredHome	190:3132b7dfad82	725	newRect.p1.y = (inRect.p1.y + inRect.p2.y + 1) / 2 - height / 2;
WiredHome	198:9b6851107426	726	newRect.p2.y = newRect.p1.y + height - 1;
WiredHome	190:3132b7dfad82	727	break;
WiredHome	190:3132b7dfad82	728	case bottom:
WiredHome	198:9b6851107426	729	newRect.p1.y = inRect.p2.y - height - 1;
WiredHome	198:9b6851107426	730	newRect.p2.y = newRect.p1.y + height - 1;
WiredHome	190:3132b7dfad82	731	break;
WiredHome	190:3132b7dfad82	732	}
WiredHome	190:3132b7dfad82	733	return newRect;
WiredHome	190:3132b7dfad82	734	}
WiredHome	190:3132b7dfad82	735
WiredHome	190:3132b7dfad82	736
WiredHome	82:f7d300f26540	737	bool RA8875::Intersect(rect_t rect, point_t p)
WiredHome	82:f7d300f26540	738	{
WiredHome	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	198:9b6851107426	1714	const 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	198:9b6851107426	1717	//INFO("SetWindow(%d,%d)-(%d,%d)", x1,y1, x2,y2);
WiredHome	198:9b6851107426	1718	// Correct the initial values (0,-1) - (0,-1)
WiredHome	198:9b6851107426	1719	if (x2 == (loc_t)-1) x2 = virt_screenwidth - 1;
WiredHome	198:9b6851107426	1720	if (y2 == (loc_t)-1) y2 = virt_screenheight - 1;
WiredHome	198:9b6851107426	1721	// Sanity check the parameters.
WiredHome	198:9b6851107426	1722	if (x1 < 0 \|\| y1 < 0 \|\| x2 < 0 \|\| y2 < 0
WiredHome	198:9b6851107426	1723	\|\| x1 >= virt_screenwidth \|\| y1 >= virt_screenheight
WiredHome	198:9b6851107426	1724	\|\| x2 >= virt_screenwidth \|\| y2 >= virt_screenheight) {
WiredHome	198:9b6851107426	1725	return nullRect;
WiredHome	198:9b6851107426	1726	}
WiredHome	198:9b6851107426	1727	windowrect.p1.x = x1;
WiredHome	198:9b6851107426	1728	windowrect.p1.y = y1;
WiredHome	198:9b6851107426	1729	windowrect.p2.x = x2;
WiredHome	198:9b6851107426	1730	windowrect.p2.y = y2;
WiredHome	198:9b6851107426	1731	switch (screen_orientation) {
WiredHome	198:9b6851107426	1732	case rotate_0:
WiredHome	198:9b6851107426	1733	case rotate_180:
WiredHome	202:a22cbc04f332	1734	tempWidth = RAmax(virt_screenwidth, virt_screenheight);
WiredHome	202:a22cbc04f332	1735	tempHeight = RAmin(virt_screenwidth, virt_screenheight);
WiredHome	198:9b6851107426	1736	virt_screenwidth = tempWidth;
WiredHome	198:9b6851107426	1737	virt_screenheight = tempHeight;
WiredHome	198:9b6851107426	1738	//GraphicsDisplay::SetWindow(x1, y1, x2, y2);
WiredHome	198:9b6851107426	1739	WriteCommandW(RA8875_HSAW0, x1);
WiredHome	198:9b6851107426	1740	WriteCommandW(RA8875_VSAW0, y1);
WiredHome	198:9b6851107426	1741	WriteCommandW(RA8875_HEAW0, x2);
WiredHome	198:9b6851107426	1742	WriteCommandW(RA8875_VEAW0, y2);
WiredHome	198:9b6851107426	1743	break;
WiredHome	198:9b6851107426	1744	case rotate_90:
WiredHome	198:9b6851107426	1745	case rotate_270:
WiredHome	202:a22cbc04f332	1746	tempWidth = RAmin(virt_screenwidth, virt_screenheight);
WiredHome	202:a22cbc04f332	1747	tempHeight = RAmax(virt_screenwidth, virt_screenheight);
WiredHome	198:9b6851107426	1748	virt_screenwidth = tempWidth;
WiredHome	198:9b6851107426	1749	virt_screenheight = tempHeight;
WiredHome	198:9b6851107426	1750	//GraphicsDisplay::SetWindow(x1, y1, x2, y2);
WiredHome	198:9b6851107426	1751	WriteCommandW(RA8875_HSAW0, y1);
WiredHome	198:9b6851107426	1752	WriteCommandW(RA8875_VSAW0, x1);
WiredHome	198:9b6851107426	1753	WriteCommandW(RA8875_HEAW0, y2);
WiredHome	198:9b6851107426	1754	WriteCommandW(RA8875_VEAW0, x2);
WiredHome	198:9b6851107426	1755	break;
WiredHome	198:9b6851107426	1756	case invalid:
WiredHome	198:9b6851107426	1757	break;
WiredHome	198:9b6851107426	1758	}
WiredHome	198:9b6851107426	1759	return oldWin;
WiredHome	19:3f82c1161fd2	1760	}
WiredHome	19:3f82c1161fd2	1761
WiredHome	61:8f3153bf0baa	1762	RetCode_t RA8875::cls(uint16_t layers)
WiredHome	19:3f82c1161fd2	1763	{
WiredHome	198:9b6851107426	1764	RetCode_t ret = noerror;
WiredHome	198:9b6851107426	1765
WiredHome	198:9b6851107426	1766	INFO("cls(%d)", layers);
WiredHome	19:3f82c1161fd2	1767	PERFORMANCE_RESET;
WiredHome	61:8f3153bf0baa	1768	if (layers == 0) {
WiredHome	61:8f3153bf0baa	1769	ret = clsw(FULLWINDOW);
WiredHome	61:8f3153bf0baa	1770	} else if (layers > 3) {
WiredHome	61:8f3153bf0baa	1771	ret = bad_parameter;
WiredHome	61:8f3153bf0baa	1772	} else {
WiredHome	61:8f3153bf0baa	1773	uint16_t prevLayer = GetDrawingLayer();
WiredHome	61:8f3153bf0baa	1774	if (layers & 1) {
WiredHome	61:8f3153bf0baa	1775	SelectDrawingLayer(0);
WiredHome	61:8f3153bf0baa	1776	clsw(FULLWINDOW);
WiredHome	61:8f3153bf0baa	1777	}
WiredHome	61:8f3153bf0baa	1778	if (layers & 2) {
WiredHome	61:8f3153bf0baa	1779	SelectDrawingLayer(1);
WiredHome	61:8f3153bf0baa	1780	clsw(FULLWINDOW);
WiredHome	61:8f3153bf0baa	1781	}
WiredHome	142:6e9bff59878a	1782	SelectDrawingLayer(prevLayer);
WiredHome	61:8f3153bf0baa	1783	}
WiredHome	198:9b6851107426	1784	SetTextCursor(0,0);
WiredHome	178:ae472eb22740	1785	//ret = locate(0,0);
WiredHome	19:3f82c1161fd2	1786	REGISTERPERFORMANCE(PRF_CLS);
WiredHome	61:8f3153bf0baa	1787	return ret;
WiredHome	19:3f82c1161fd2	1788	}
WiredHome	19:3f82c1161fd2	1789
WiredHome	44:207594dece70	1790
WiredHome	19:3f82c1161fd2	1791	RetCode_t RA8875::clsw(RA8875::Region_t region)
WiredHome	19:3f82c1161fd2	1792	{
WiredHome	195:17e176dbd6eb	1793	INFO("clsw(%d)", region);
WiredHome	19:3f82c1161fd2	1794	PERFORMANCE_RESET;
WiredHome	175:7be3a1fb7fc2	1795	WriteCommand(RA8875_MCLR, (region == ACTIVEWINDOW) ? 0xC0 : 0x80);
WiredHome	198:9b6851107426	1796	if (!_WaitWhileReg(RA8875_MCLR, 0x80)) {
WiredHome	198:9b6851107426	1797	WriteCommand(RA8875_MCLR, 0x00); // Abort clearing on request
WiredHome	131:5bd6ba2ee4a1	1798	REGISTERPERFORMANCE(PRF_CLS);
WiredHome	131:5bd6ba2ee4a1	1799	return external_abort;
WiredHome	131:5bd6ba2ee4a1	1800	}
WiredHome	19:3f82c1161fd2	1801	REGISTERPERFORMANCE(PRF_CLS);
WiredHome	19:3f82c1161fd2	1802	return noerror;
WiredHome	19:3f82c1161fd2	1803	}
WiredHome	19:3f82c1161fd2	1804
WiredHome	44:207594dece70	1805
WiredHome	87:ee2240581aa7	1806	RetCode_t RA8875::pixel(point_t p, color_t color)
WiredHome	87:ee2240581aa7	1807	{
WiredHome	87:ee2240581aa7	1808	return pixel(p.x, p.y, color);
WiredHome	87:ee2240581aa7	1809	}
WiredHome	87:ee2240581aa7	1810
WiredHome	87:ee2240581aa7	1811	RetCode_t RA8875::pixel(point_t p)
WiredHome	87:ee2240581aa7	1812	{
WiredHome	87:ee2240581aa7	1813	return pixel(p.x, p.y);
WiredHome	87:ee2240581aa7	1814	}
WiredHome	87:ee2240581aa7	1815
WiredHome	37:f19b7e7449dc	1816	RetCode_t RA8875::pixel(loc_t x, loc_t y, color_t color)
WiredHome	19:3f82c1161fd2	1817	{
WiredHome	62:ba5d33438fda	1818	RetCode_t ret;
WiredHome	73:f22a18707b5e	1819
WiredHome	62:ba5d33438fda	1820	PERFORMANCE_RESET;
WiredHome	62:ba5d33438fda	1821	ret = pixelStream(&color, 1, x,y);
WiredHome	62:ba5d33438fda	1822	REGISTERPERFORMANCE(PRF_DRAWPIXEL);
WiredHome	62:ba5d33438fda	1823	return ret;
WiredHome	19:3f82c1161fd2	1824	}
WiredHome	19:3f82c1161fd2	1825
WiredHome	44:207594dece70	1826
WiredHome	37:f19b7e7449dc	1827	RetCode_t RA8875::pixel(loc_t x, loc_t y)
WiredHome	19:3f82c1161fd2	1828	{
WiredHome	19:3f82c1161fd2	1829	RetCode_t ret;
WiredHome	73:f22a18707b5e	1830
WiredHome	19:3f82c1161fd2	1831	PERFORMANCE_RESET;
WiredHome	19:3f82c1161fd2	1832	color_t color = GetForeColor();
WiredHome	62:ba5d33438fda	1833	ret = pixelStream(&color, 1, x, y);
WiredHome	41:2956a0a221e5	1834	REGISTERPERFORMANCE(PRF_DRAWPIXEL);
WiredHome	19:3f82c1161fd2	1835	return ret;
WiredHome	19:3f82c1161fd2	1836	}
WiredHome	19:3f82c1161fd2	1837
WiredHome	44:207594dece70	1838
WiredHome	41:2956a0a221e5	1839	RetCode_t RA8875::pixelStream(color_t * p, uint32_t count, loc_t x, loc_t y)
WiredHome	41:2956a0a221e5	1840	{
WiredHome	41:2956a0a221e5	1841	PERFORMANCE_RESET;
WiredHome	41:2956a0a221e5	1842	SetGraphicsCursor(x, y);
WiredHome	109:7b94f06f085b	1843	_StartGraphicsStream();
WiredHome	79:544eb4964795	1844	_select(true);
WiredHome	79:544eb4964795	1845	_spiwrite(0x00); // Cmd: write data
WiredHome	41:2956a0a221e5	1846	while (count--) {
WiredHome	105:4f116006ba1f	1847	if (screenbpp == 16) {
WiredHome	105:4f116006ba1f	1848	_spiwrite(*p >> 8);
WiredHome	105:4f116006ba1f	1849	_spiwrite(*p & 0xFF);
WiredHome	105:4f116006ba1f	1850	} else {
WiredHome	105:4f116006ba1f	1851	_spiwrite(_cvt16to8(*p));
WiredHome	105:4f116006ba1f	1852	}
WiredHome	41:2956a0a221e5	1853	p++;
WiredHome	41:2956a0a221e5	1854	}
WiredHome	79:544eb4964795	1855	_select(false);
WiredHome	109:7b94f06f085b	1856	_EndGraphicsStream();
WiredHome	41:2956a0a221e5	1857	REGISTERPERFORMANCE(PRF_PIXELSTREAM);
WiredHome	41:2956a0a221e5	1858	return(noerror);
WiredHome	41:2956a0a221e5	1859	}
WiredHome	41:2956a0a221e5	1860
WiredHome	153:8a85efb3eb71	1861	// With a font scale X = 1, a pixel stream is "abcdefg..."
WiredHome	153:8a85efb3eb71	1862	// With a font scale X = 2, a pixel stream is "aabbccddeeffgg..."
WiredHome	153:8a85efb3eb71	1863	// With a font scale Y = 2, a pixel stream is "abcdefg..."
WiredHome	153:8a85efb3eb71	1864	// "abcdefg..."
WiredHome	153:8a85efb3eb71	1865	//
WiredHome	190:3132b7dfad82	1866	RetCode_t RA8875::booleanStream(loc_t x, loc_t y, dim_t w, dim_t h, const uint8_t * boolStream)
WiredHome	109:7b94f06f085b	1867	{
WiredHome	109:7b94f06f085b	1868	PERFORMANCE_RESET;
WiredHome	190:3132b7dfad82	1869	const uint8_t * rowStream = boolStream;
WiredHome	198:9b6851107426	1870	rect_t restore = SetWindow(x, y, x + w * fontScaleX - 1, y + h * fontScaleY - 1);
WiredHome	109:7b94f06f085b	1871	SetGraphicsCursor(x, y);
WiredHome	109:7b94f06f085b	1872	_StartGraphicsStream();
WiredHome	109:7b94f06f085b	1873	_select(true);
WiredHome	109:7b94f06f085b	1874	_spiwrite(0x00); // Cmd: write data
WiredHome	109:7b94f06f085b	1875	while (h--) {
WiredHome	153:8a85efb3eb71	1876	for (int dy=0; dy<fontScaleY; dy++) { // Vertical Font Scale Factor
WiredHome	153:8a85efb3eb71	1877	uint8_t pixels = w;
WiredHome	153:8a85efb3eb71	1878	uint8_t bitmask = 0x01;
WiredHome	190:3132b7dfad82	1879	rowStream = boolStream;
WiredHome	153:8a85efb3eb71	1880	while (pixels) {
WiredHome	153:8a85efb3eb71	1881	uint8_t byte = *rowStream;
WiredHome	153:8a85efb3eb71	1882	//INFO("byte, mask: %02X, %02X", byte, bitmask);
WiredHome	153:8a85efb3eb71	1883	color_t c = (byte & bitmask) ? _foreground : _background;
WiredHome	190:3132b7dfad82	1884
WiredHome	153:8a85efb3eb71	1885	for (int dx=0; dx<fontScaleX; dx++) { // Horizontal Font Scale Factor
WiredHome	153:8a85efb3eb71	1886	if (screenbpp == 16) {
WiredHome	153:8a85efb3eb71	1887	_spiwrite(c >> 8);
WiredHome	153:8a85efb3eb71	1888	_spiwrite(c & 0xFF);
WiredHome	153:8a85efb3eb71	1889	} else {
WiredHome	153:8a85efb3eb71	1890	_spiwrite(_cvt16to8(c));
WiredHome	153:8a85efb3eb71	1891	}
WiredHome	109:7b94f06f085b	1892	}
WiredHome	153:8a85efb3eb71	1893	bitmask <<= 1;
WiredHome	153:8a85efb3eb71	1894	if (pixels > 1 && bitmask == 0) {
WiredHome	153:8a85efb3eb71	1895	bitmask = 0x01;
WiredHome	153:8a85efb3eb71	1896	rowStream++;
WiredHome	153:8a85efb3eb71	1897	}
WiredHome	153:8a85efb3eb71	1898	pixels--;
WiredHome	109:7b94f06f085b	1899	}
WiredHome	109:7b94f06f085b	1900	}
WiredHome	153:8a85efb3eb71	1901	boolStream += (rowStream - boolStream + 1);
WiredHome	109:7b94f06f085b	1902	}
WiredHome	109:7b94f06f085b	1903	_select(false);
WiredHome	109:7b94f06f085b	1904	_EndGraphicsStream();
WiredHome	198:9b6851107426	1905	SetWindow(restore);
WiredHome	109:7b94f06f085b	1906	REGISTERPERFORMANCE(PRF_BOOLSTREAM);
WiredHome	109:7b94f06f085b	1907	return(noerror);
WiredHome	109:7b94f06f085b	1908	}
WiredHome	44:207594dece70	1909
WiredHome	41:2956a0a221e5	1910	color_t RA8875::getPixel(loc_t x, loc_t y)
WiredHome	41:2956a0a221e5	1911	{
WiredHome	41:2956a0a221e5	1912	color_t pixel;
WiredHome	194:53c18f0e7922	1913	unsigned char mwcr0;
WiredHome	73:f22a18707b5e	1914
WiredHome	41:2956a0a221e5	1915	PERFORMANCE_RESET;
WiredHome	194:53c18f0e7922	1916	mwcr0 = ReadCommand(RA8875_MWCR0);
WiredHome	194:53c18f0e7922	1917	if (mwcr0 & 0x80)
WiredHome	194:53c18f0e7922	1918	WriteCommand(RA8875_MWCR0, mwcr0 & ~0x80); // Graphics write mode
WiredHome	41:2956a0a221e5	1919	SetGraphicsCursorRead(x, y);
WiredHome	175:7be3a1fb7fc2	1920	WriteCommand(RA8875_MRWC);
WiredHome	79:544eb4964795	1921	_select(true);
WiredHome	79:544eb4964795	1922	_spiwrite(0x40); // Cmd: read data
WiredHome	79:544eb4964795	1923	_spiwrite(0x00); // dummy read
WiredHome	105:4f116006ba1f	1924	if (screenbpp == 16) {
WiredHome	105:4f116006ba1f	1925	pixel = _spiread();
WiredHome	105:4f116006ba1f	1926	pixel \|= (_spiread() << 8);
WiredHome	105:4f116006ba1f	1927	} else {
WiredHome	105:4f116006ba1f	1928	pixel = _cvt8to16(_spiread());
WiredHome	105:4f116006ba1f	1929	}
WiredHome	79:544eb4964795	1930	_select(false);
WiredHome	41:2956a0a221e5	1931	REGISTERPERFORMANCE(PRF_READPIXEL);
WiredHome	41:2956a0a221e5	1932	return pixel;
WiredHome	41:2956a0a221e5	1933	}
WiredHome	41:2956a0a221e5	1934
WiredHome	44:207594dece70	1935
WiredHome	41:2956a0a221e5	1936	RetCode_t RA8875::getPixelStream(color_t * p, uint32_t count, loc_t x, loc_t y)
WiredHome	41:2956a0a221e5	1937	{
WiredHome	41:2956a0a221e5	1938	color_t pixel;
WiredHome	194:53c18f0e7922	1939	unsigned char mwcr0;
WiredHome	86:e86b355940f4	1940	RetCode_t ret = noerror;
WiredHome	73:f22a18707b5e	1941
WiredHome	41:2956a0a221e5	1942	PERFORMANCE_RESET;
WiredHome	194:53c18f0e7922	1943	mwcr0 = ReadCommand(RA8875_MWCR0);
WiredHome	194:53c18f0e7922	1944	if (mwcr0 & 0x80)
WiredHome	194:53c18f0e7922	1945	WriteCommand(RA8875_MWCR0, mwcr0 & ~0x80); // Graphics write mode
WiredHome	86:e86b355940f4	1946	ret = SetGraphicsCursorRead(x, y);
WiredHome	175:7be3a1fb7fc2	1947	ret = WriteCommand(RA8875_MRWC);
WiredHome	79:544eb4964795	1948	_select(true);
WiredHome	79:544eb4964795	1949	_spiwrite(0x40); // Cmd: read data
WiredHome	79:544eb4964795	1950	_spiwrite(0x00); // dummy read
WiredHome	106:c80828f5dea4	1951	if (screenbpp == 16)
WiredHome	106:c80828f5dea4	1952	_spiwrite(0x00); // dummy read is only necessary when in 16-bit mode
WiredHome	41:2956a0a221e5	1953	while (count--) {
WiredHome	105:4f116006ba1f	1954	if (screenbpp == 16) {
WiredHome	105:4f116006ba1f	1955	pixel = _spiread();
WiredHome	105:4f116006ba1f	1956	pixel \|= (_spiread() << 8);
WiredHome	105:4f116006ba1f	1957	} else {
WiredHome	105:4f116006ba1f	1958	pixel = _cvt8to16(_spiread());
WiredHome	105:4f116006ba1f	1959	}
WiredHome	41:2956a0a221e5	1960	*p++ = pixel;
WiredHome	41:2956a0a221e5	1961	}
WiredHome	79:544eb4964795	1962	_select(false);
WiredHome	41:2956a0a221e5	1963	REGISTERPERFORMANCE(PRF_READPIXELSTREAM);
WiredHome	86:e86b355940f4	1964	return ret;
WiredHome	41:2956a0a221e5	1965	}
WiredHome	41:2956a0a221e5	1966
WiredHome	44:207594dece70	1967
WiredHome	83:7bad0068cca0	1968	RetCode_t RA8875::line(point_t p1, point_t p2)
WiredHome	83:7bad0068cca0	1969	{
WiredHome	83:7bad0068cca0	1970	return line(p1.x, p1.y, p2.x, p2.y);
WiredHome	83:7bad0068cca0	1971	}
WiredHome	83:7bad0068cca0	1972
WiredHome	83:7bad0068cca0	1973
WiredHome	83:7bad0068cca0	1974	RetCode_t RA8875::line(point_t p1, point_t p2, color_t color)
WiredHome	83:7bad0068cca0	1975	{
WiredHome	83:7bad0068cca0	1976	return line(p1.x, p1.y, p2.x, p2.y, color);
WiredHome	83:7bad0068cca0	1977	}
WiredHome	83:7bad0068cca0	1978
WiredHome	83:7bad0068cca0	1979
WiredHome	37:f19b7e7449dc	1980	RetCode_t RA8875::line(loc_t x1, loc_t y1, loc_t x2, loc_t y2, color_t color)
WiredHome	19:3f82c1161fd2	1981	{
WiredHome	19:3f82c1161fd2	1982	foreground(color);
WiredHome	19:3f82c1161fd2	1983	return line(x1,y1,x2,y2);
WiredHome	19:3f82c1161fd2	1984	}
WiredHome	19:3f82c1161fd2	1985
WiredHome	44:207594dece70	1986
WiredHome	37:f19b7e7449dc	1987	RetCode_t RA8875::line(loc_t x1, loc_t y1, loc_t x2, loc_t y2)
WiredHome	19:3f82c1161fd2	1988	{
WiredHome	19:3f82c1161fd2	1989	PERFORMANCE_RESET;
WiredHome	62:ba5d33438fda	1990	if (x1 == x2 && y1 == y2) {
WiredHome	198:9b6851107426	1991	switch (screen_orientation) {
WiredHome	198:9b6851107426	1992	case invalid:
WiredHome	198:9b6851107426	1993	return bad_parameter;
WiredHome	198:9b6851107426	1994	//break;
WiredHome	198:9b6851107426	1995	case rotate_0:
WiredHome	198:9b6851107426	1996	case rotate_180:
WiredHome	198:9b6851107426	1997	pixel(x1, y1);
WiredHome	198:9b6851107426	1998	break;
WiredHome	198:9b6851107426	1999	case rotate_90:
WiredHome	198:9b6851107426	2000	case rotate_270:
WiredHome	198:9b6851107426	2001	pixel(y1, x1);
WiredHome	198:9b6851107426	2002	break;
WiredHome	198:9b6851107426	2003	}
WiredHome	62:ba5d33438fda	2004	} else {
WiredHome	198:9b6851107426	2005	switch (screen_orientation) {
WiredHome	198:9b6851107426	2006	case invalid:
WiredHome	198:9b6851107426	2007	return bad_parameter;
WiredHome	198:9b6851107426	2008	//break;
WiredHome	198:9b6851107426	2009	case rotate_0:
WiredHome	198:9b6851107426	2010	case rotate_180:
WiredHome	198:9b6851107426	2011	WriteCommandW(RA8875_DLHSR0, x1);
WiredHome	198:9b6851107426	2012	WriteCommandW(RA8875_DLVSR0, y1);
WiredHome	198:9b6851107426	2013	WriteCommandW(RA8875_DLHER0, x2);
WiredHome	198:9b6851107426	2014	WriteCommandW(RA8875_DLVER0, y2);
WiredHome	198:9b6851107426	2015	break;
WiredHome	198:9b6851107426	2016	case rotate_90:
WiredHome	198:9b6851107426	2017	case rotate_270:
WiredHome	198:9b6851107426	2018	WriteCommandW(RA8875_DLHSR0, y1);
WiredHome	198:9b6851107426	2019	WriteCommandW(RA8875_DLVSR0, x1);
WiredHome	198:9b6851107426	2020	WriteCommandW(RA8875_DLHER0, y2);
WiredHome	198:9b6851107426	2021	WriteCommandW(RA8875_DLVER0, x2);
WiredHome	198:9b6851107426	2022	break;
WiredHome	198:9b6851107426	2023	}
WiredHome	60:2dfd574f63bd	2024	unsigned char drawCmd = 0x00; // Line
WiredHome	175:7be3a1fb7fc2	2025	WriteCommand(RA8875_DCR, drawCmd);
WiredHome	175:7be3a1fb7fc2	2026	WriteCommand(RA8875_DCR, 0x80 + drawCmd); // Start drawing.
WiredHome	131:5bd6ba2ee4a1	2027	if (!_WaitWhileReg(0x90, 0x80)) {
WiredHome	131:5bd6ba2ee4a1	2028	REGISTERPERFORMANCE(PRF_DRAWLINE);
WiredHome	131:5bd6ba2ee4a1	2029	return external_abort;
WiredHome	131:5bd6ba2ee4a1	2030	}
WiredHome	60:2dfd574f63bd	2031	}
WiredHome	19:3f82c1161fd2	2032	REGISTERPERFORMANCE(PRF_DRAWLINE);
WiredHome	19:3f82c1161fd2	2033	return noerror;
WiredHome	19:3f82c1161fd2	2034	}
WiredHome	19:3f82c1161fd2	2035
WiredHome	144:ba002c4b21b3	2036
WiredHome	144:ba002c4b21b3	2037	RetCode_t RA8875::ThickLine(point_t p1, point_t p2, dim_t thickness, color_t color)
WiredHome	144:ba002c4b21b3	2038	{
WiredHome	198:9b6851107426	2039	//INFO("ThickLine()");
WiredHome	144:ba002c4b21b3	2040	if (thickness == 1) {
WiredHome	144:ba002c4b21b3	2041	line(p1,p2, color);
WiredHome	144:ba002c4b21b3	2042	} else {
WiredHome	178:ae472eb22740	2043	if (p1.x == p2.x) {
WiredHome	178:ae472eb22740	2044	// vertical
WiredHome	190:3132b7dfad82	2045	if (roundCap) {
WiredHome	190:3132b7dfad82	2046	fillcircle(p1, thickness / 2, color);
WiredHome	190:3132b7dfad82	2047	fillcircle(p2, thickness / 2, color);
WiredHome	190:3132b7dfad82	2048	}
WiredHome	178:ae472eb22740	2049	fillrect(p1.x-thickness/2,p1.y, p2.x+thickness/2,p2.y, color);
WiredHome	178:ae472eb22740	2050	} else if (p1.y == p2.y) {
WiredHome	178:ae472eb22740	2051	// horizontal
WiredHome	190:3132b7dfad82	2052	if (roundCap) {
WiredHome	190:3132b7dfad82	2053	fillcircle(p1, thickness / 2, color);
WiredHome	190:3132b7dfad82	2054	fillcircle(p2, thickness / 2, color);
WiredHome	190:3132b7dfad82	2055	}
WiredHome	178:ae472eb22740	2056	fillrect(p1.x,p1.y-thickness/2, p2.x,p2.y+thickness/2, color);
WiredHome	178:ae472eb22740	2057	} else {
WiredHome	178:ae472eb22740	2058	// some diagonal, drawn rather slowly with filled circles
WiredHome	178:ae472eb22740	2059	// @todo draw the end-points with circles, then draw the diagonal
WiredHome	197:853d08e2fb53	2060	// with 2 triangles.
WiredHome	178:ae472eb22740	2061	//Round-caps
WiredHome	190:3132b7dfad82	2062	if (roundCap) {
WiredHome	190:3132b7dfad82	2063	fillcircle(p1, thickness / 2, color);
WiredHome	190:3132b7dfad82	2064	fillcircle(p2, thickness / 2, color);
WiredHome	190:3132b7dfad82	2065	}
WiredHome	178:ae472eb22740	2066	// Compute the perpendicular points to draw the triangles
WiredHome	178:ae472eb22740	2067	// + fillTriangle: p1a,p1b,p2a
WiredHome	178:ae472eb22740	2068	// / + p1a p1a,p2a,p2b
WiredHome	178:ae472eb22740	2069	// + +p1+ . . . . .
WiredHome	178:ae472eb22740	2070	// p1b + / . angle
WiredHome	197:853d08e2fb53	2071	// + .
WiredHome	178:ae472eb22740	2072	// .
WiredHome	178:ae472eb22740	2073	//
WiredHome	178:ae472eb22740	2074	// . +
WiredHome	178:ae472eb22740	2075	// / + p2a
WiredHome	178:ae472eb22740	2076	// + +p2+
WiredHome	178:ae472eb22740	2077	// p2b + /
WiredHome	178:ae472eb22740	2078	// +
WiredHome	178:ae472eb22740	2079	point_t pTri[4];
WiredHome	178:ae472eb22740	2080	float slope = (p2.y - p1.y) / (p2.x - p1.x);
WiredHome	178:ae472eb22740	2081	slope = -1/slope;
WiredHome	178:ae472eb22740	2082	//centerline
WiredHome	178:ae472eb22740	2083	//line(p1,p2,color);
WiredHome	190:3132b7dfad82	2084	float dx = (thickness/2 / sqrt(thickness/2 + (slope * slope)));
WiredHome	178:ae472eb22740	2085	float dy = slope * dx;
WiredHome	178:ae472eb22740	2086	pTri[0].x = p1.x + dx;
WiredHome	178:ae472eb22740	2087	pTri[0].y = p1.y + dy;
WiredHome	178:ae472eb22740	2088	pTri[1].x = p1.x - dx;
WiredHome	178:ae472eb22740	2089	pTri[1].y = p1.y - dy;
WiredHome	178:ae472eb22740	2090	pTri[2].x = p2.x + dx;
WiredHome	178:ae472eb22740	2091	pTri[2].y = p2.y + dy;
WiredHome	178:ae472eb22740	2092	pTri[3].x = p2.x - dx;
WiredHome	178:ae472eb22740	2093	pTri[3].y = p2.y - dy;
WiredHome	178:ae472eb22740	2094	filltriangle(pTri[0],pTri[1],pTri[3], color);
WiredHome	178:ae472eb22740	2095	filltriangle(pTri[0],pTri[2],pTri[3], color);
WiredHome	178:ae472eb22740	2096	}
WiredHome	144:ba002c4b21b3	2097	}
WiredHome	144:ba002c4b21b3	2098	return noerror;
WiredHome	144:ba002c4b21b3	2099	}
WiredHome	144:ba002c4b21b3	2100
WiredHome	144:ba002c4b21b3	2101
WiredHome	190:3132b7dfad82	2102	bool RA8875::SetEndCap(bool _roundCap) {
WiredHome	190:3132b7dfad82	2103	bool prevCap = roundCap;
WiredHome	190:3132b7dfad82	2104	roundCap = _roundCap;
WiredHome	190:3132b7dfad82	2105	return prevCap;
WiredHome	190:3132b7dfad82	2106	}
WiredHome	190:3132b7dfad82	2107
WiredHome	190:3132b7dfad82	2108
WiredHome	107:f9ccffcb84f1	2109	//
WiredHome	107:f9ccffcb84f1	2110	// Rectangle functions all mostly helpers to the basic rectangle function
WiredHome	107:f9ccffcb84f1	2111	//
WiredHome	107:f9ccffcb84f1	2112
WiredHome	81:01da2e34283d	2113	RetCode_t RA8875::fillrect(rect_t r, color_t color, fill_t fillit)
WiredHome	81:01da2e34283d	2114	{
WiredHome	81:01da2e34283d	2115	return rect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, color, fillit);
WiredHome	81:01da2e34283d	2116	}
WiredHome	44:207594dece70	2117
WiredHome	73:f22a18707b5e	2118	RetCode_t RA8875::fillrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	2119	color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	2120	{
WiredHome	19:3f82c1161fd2	2121	return rect(x1,y1,x2,y2,color,fillit);
WiredHome	19:3f82c1161fd2	2122	}
WiredHome	19:3f82c1161fd2	2123
WiredHome	81:01da2e34283d	2124	RetCode_t RA8875::rect(rect_t r, color_t color, fill_t fillit)
WiredHome	81:01da2e34283d	2125	{
WiredHome	81:01da2e34283d	2126	return rect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, color, fillit);
WiredHome	81:01da2e34283d	2127	}
WiredHome	44:207594dece70	2128
WiredHome	73:f22a18707b5e	2129	RetCode_t RA8875::rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	2130	color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	2131	{
WiredHome	19:3f82c1161fd2	2132	foreground(color);
WiredHome	19:3f82c1161fd2	2133	return rect(x1,y1,x2,y2,fillit);
WiredHome	19:3f82c1161fd2	2134	}
WiredHome	19:3f82c1161fd2	2135
WiredHome	73:f22a18707b5e	2136	RetCode_t RA8875::rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	2137	fill_t fillit)
WiredHome	19:3f82c1161fd2	2138	{
WiredHome	85:022bba13c5c4	2139	RetCode_t ret = noerror;
WiredHome	19:3f82c1161fd2	2140	PERFORMANCE_RESET;
WiredHome	85:022bba13c5c4	2141	// check for bad_parameter
WiredHome	198:9b6851107426	2142	if (x1 < 0 \|\| x1 >= virt_screenwidth \|\| x2 < 0 \|\| x2 >= virt_screenwidth
WiredHome	198:9b6851107426	2143	\|\| y1 < 0 \|\| y1 >= virt_screenheight \|\| y2 < 0 \|\| y2 >= virt_screenheight) {
WiredHome	85:022bba13c5c4	2144	ret = bad_parameter;
WiredHome	100:0b084475d5a9	2145	} else {
WiredHome	85:022bba13c5c4	2146	if (x1 == x2 && y1 == y2) {
WiredHome	85:022bba13c5c4	2147	pixel(x1, y1);
WiredHome	85:022bba13c5c4	2148	} else if (x1 == x2) {
WiredHome	85:022bba13c5c4	2149	line(x1, y1, x2, y2);
WiredHome	85:022bba13c5c4	2150	} else if (y1 == y2) {
WiredHome	85:022bba13c5c4	2151	line(x1, y1, x2, y2);
WiredHome	85:022bba13c5c4	2152	} else {
WiredHome	198:9b6851107426	2153	switch (screen_orientation) {
WiredHome	198:9b6851107426	2154	case rotate_0:
WiredHome	198:9b6851107426	2155	case rotate_180:
WiredHome	198:9b6851107426	2156	WriteCommandW(RA8875_DLHSR0, x1);
WiredHome	198:9b6851107426	2157	WriteCommandW(RA8875_DLVSR0, y1);
WiredHome	198:9b6851107426	2158	WriteCommandW(RA8875_DLHER0, x2);
WiredHome	198:9b6851107426	2159	WriteCommandW(RA8875_DLVER0, y2);
WiredHome	198:9b6851107426	2160	break;
WiredHome	198:9b6851107426	2161	case rotate_90:
WiredHome	198:9b6851107426	2162	case rotate_270:
WiredHome	198:9b6851107426	2163	WriteCommandW(RA8875_DLHSR0, y1);
WiredHome	198:9b6851107426	2164	WriteCommandW(RA8875_DLVSR0, x1);
WiredHome	198:9b6851107426	2165	WriteCommandW(RA8875_DLHER0, y2);
WiredHome	198:9b6851107426	2166	WriteCommandW(RA8875_DLVER0, x2);
WiredHome	198:9b6851107426	2167	break;
WiredHome	198:9b6851107426	2168	case invalid:
WiredHome	198:9b6851107426	2169	REGISTERPERFORMANCE(PRF_DRAWRECTANGLE);
WiredHome	198:9b6851107426	2170	ret = bad_parameter;
WiredHome	198:9b6851107426	2171	return ret;
WiredHome	198:9b6851107426	2172	//break;
WiredHome	198:9b6851107426	2173	}
WiredHome	85:022bba13c5c4	2174	unsigned char drawCmd = 0x10; // Rectangle
WiredHome	85:022bba13c5c4	2175	if (fillit == FILL)
WiredHome	85:022bba13c5c4	2176	drawCmd \|= 0x20;
WiredHome	175:7be3a1fb7fc2	2177	WriteCommand(RA8875_DCR, drawCmd);
WiredHome	175:7be3a1fb7fc2	2178	ret = WriteCommand(RA8875_DCR, 0x80 + drawCmd); // Start drawing.
WiredHome	131:5bd6ba2ee4a1	2179	if (!_WaitWhileReg(0x90, 0x80)) {
WiredHome	131:5bd6ba2ee4a1	2180	REGISTERPERFORMANCE(PRF_DRAWRECTANGLE);
WiredHome	131:5bd6ba2ee4a1	2181	return external_abort;
WiredHome	131:5bd6ba2ee4a1	2182	}
WiredHome	85:022bba13c5c4	2183	}
WiredHome	19:3f82c1161fd2	2184	}
WiredHome	19:3f82c1161fd2	2185	REGISTERPERFORMANCE(PRF_DRAWRECTANGLE);
WiredHome	85:022bba13c5c4	2186	return ret;
WiredHome	19:3f82c1161fd2	2187	}
WiredHome	19:3f82c1161fd2	2188
WiredHome	44:207594dece70	2189
WiredHome	107:f9ccffcb84f1	2190	//
WiredHome	107:f9ccffcb84f1	2191	// rounded rectangle functions are mostly helpers to the base round rect
WiredHome	107:f9ccffcb84f1	2192	//
WiredHome	107:f9ccffcb84f1	2193
WiredHome	107:f9ccffcb84f1	2194	RetCode_t RA8875::fillroundrect(rect_t r, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome	107:f9ccffcb84f1	2195	{
WiredHome	107:f9ccffcb84f1	2196	return roundrect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, radius1, radius2, color, fillit);
WiredHome	107:f9ccffcb84f1	2197	}
WiredHome	107:f9ccffcb84f1	2198
WiredHome	73:f22a18707b5e	2199	RetCode_t RA8875::fillroundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	2200	dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	2201	{
WiredHome	19:3f82c1161fd2	2202	foreground(color);
WiredHome	19:3f82c1161fd2	2203	return roundrect(x1,y1,x2,y2,radius1,radius2,fillit);
WiredHome	19:3f82c1161fd2	2204	}
WiredHome	19:3f82c1161fd2	2205
WiredHome	107:f9ccffcb84f1	2206	RetCode_t RA8875::roundrect(rect_t r, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome	107:f9ccffcb84f1	2207	{
WiredHome	107:f9ccffcb84f1	2208	return roundrect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, radius1, radius2, color, fillit);
WiredHome	107:f9ccffcb84f1	2209	}
WiredHome	44:207594dece70	2210
WiredHome	73:f22a18707b5e	2211	RetCode_t RA8875::roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	2212	dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	2213	{
WiredHome	19:3f82c1161fd2	2214	foreground(color);
WiredHome	19:3f82c1161fd2	2215	return roundrect(x1,y1,x2,y2,radius1,radius2,fillit);
WiredHome	19:3f82c1161fd2	2216	}
WiredHome	19:3f82c1161fd2	2217
WiredHome	44:207594dece70	2218
WiredHome	73:f22a18707b5e	2219	RetCode_t RA8875::roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	2220	dim_t radius1, dim_t radius2, fill_t fillit)
WiredHome	19:3f82c1161fd2	2221	{
WiredHome	19:3f82c1161fd2	2222	RetCode_t ret = noerror;
WiredHome	73:f22a18707b5e	2223
WiredHome	178:ae472eb22740	2224	INFO("roundrect()");
WiredHome	19:3f82c1161fd2	2225	PERFORMANCE_RESET;
WiredHome	198:9b6851107426	2226	if (x1 < 0 \|\| x1 >= virt_screenwidth \|\| x2 < 0 \|\| x2 >= virt_screenwidth
WiredHome	198:9b6851107426	2227	\|\| y1 < 0 \|\| y1 >= virt_screenheight \|\| y2 < 0 \|\| y2 >= virt_screenheight) {
WiredHome	85:022bba13c5c4	2228	ret = bad_parameter;
WiredHome	85:022bba13c5c4	2229	} else if (x1 > x2 \|\| y1 > y2 \|\| (radius1 > (x2-x1)/2) \|\| (radius2 > (y2-y1)/2) ) {
WiredHome	21:3c1efb192927	2230	ret = bad_parameter;
WiredHome	21:3c1efb192927	2231	} else if (x1 == x2 && y1 == y2) {
WiredHome	19:3f82c1161fd2	2232	pixel(x1, y1);
WiredHome	19:3f82c1161fd2	2233	} else if (x1 == x2) {
WiredHome	19:3f82c1161fd2	2234	line(x1, y1, x2, y2);
WiredHome	19:3f82c1161fd2	2235	} else if (y1 == y2) {
WiredHome	19:3f82c1161fd2	2236	line(x1, y1, x2, y2);
WiredHome	19:3f82c1161fd2	2237	} else {
WiredHome	198:9b6851107426	2238	switch (screen_orientation) {
WiredHome	198:9b6851107426	2239	case rotate_0:
WiredHome	198:9b6851107426	2240	case rotate_180:
WiredHome	198:9b6851107426	2241	WriteCommandW(RA8875_DLHSR0, x1);
WiredHome	198:9b6851107426	2242	WriteCommandW(RA8875_DLVSR0, y1);
WiredHome	198:9b6851107426	2243	WriteCommandW(RA8875_DLHER0, x2);
WiredHome	198:9b6851107426	2244	WriteCommandW(RA8875_DLVER0, y2);
WiredHome	198:9b6851107426	2245	WriteCommandW(RA8875_ELLA0, radius1);
WiredHome	198:9b6851107426	2246	WriteCommandW(RA8875_ELLB0, radius2);
WiredHome	198:9b6851107426	2247	break;
WiredHome	198:9b6851107426	2248	case rotate_90:
WiredHome	198:9b6851107426	2249	case rotate_270:
WiredHome	198:9b6851107426	2250	WriteCommandW(RA8875_DLHSR0, y1);
WiredHome	198:9b6851107426	2251	WriteCommandW(RA8875_DLVSR0, x1);
WiredHome	198:9b6851107426	2252	WriteCommandW(RA8875_DLHER0, y2);
WiredHome	198:9b6851107426	2253	WriteCommandW(RA8875_DLVER0, x2);
WiredHome	198:9b6851107426	2254	WriteCommandW(RA8875_ELLA0, radius2);
WiredHome	198:9b6851107426	2255	WriteCommandW(RA8875_ELLB0, radius1);
WiredHome	198:9b6851107426	2256	break;
WiredHome	198:9b6851107426	2257	case invalid:
WiredHome	198:9b6851107426	2258	REGISTERPERFORMANCE(PRF_DRAWROUNDEDRECTANGLE);
WiredHome	198:9b6851107426	2259	return bad_parameter;
WiredHome	198:9b6851107426	2260	//break;
WiredHome	198:9b6851107426	2261	}
WiredHome	21:3c1efb192927	2262	// Should not need this...
WiredHome	175:7be3a1fb7fc2	2263	WriteCommandW(RA8875_DEHR0, 0);
WiredHome	175:7be3a1fb7fc2	2264	WriteCommandW(RA8875_DEVR0, 0);
WiredHome	19:3f82c1161fd2	2265	unsigned char drawCmd = 0x20; // Rounded Rectangle
WiredHome	19:3f82c1161fd2	2266	if (fillit == FILL)
WiredHome	19:3f82c1161fd2	2267	drawCmd \|= 0x40;
WiredHome	175:7be3a1fb7fc2	2268	WriteCommand(RA8875_ELLIPSE, drawCmd);
WiredHome	175:7be3a1fb7fc2	2269	WriteCommand(RA8875_ELLIPSE, 0x80 + drawCmd); // Start drawing.
WiredHome	131:5bd6ba2ee4a1	2270	if (!_WaitWhileReg(0xA0, 0x80)) {
WiredHome	131:5bd6ba2ee4a1	2271	REGISTERPERFORMANCE(PRF_DRAWROUNDEDRECTANGLE);
WiredHome	131:5bd6ba2ee4a1	2272	return external_abort;
WiredHome	131:5bd6ba2ee4a1	2273	}
WiredHome	19:3f82c1161fd2	2274	}
WiredHome	19:3f82c1161fd2	2275	REGISTERPERFORMANCE(PRF_DRAWROUNDEDRECTANGLE);
WiredHome	19:3f82c1161fd2	2276	return ret;
WiredHome	19:3f82c1161fd2	2277	}
WiredHome	19:3f82c1161fd2	2278
WiredHome	44:207594dece70	2279
WiredHome	107:f9ccffcb84f1	2280	//
WiredHome	107:f9ccffcb84f1	2281	// triangle functions
WiredHome	107:f9ccffcb84f1	2282	//
WiredHome	178:ae472eb22740	2283	RetCode_t RA8875::filltriangle(point_t p1, point_t p2, point_t p3, color_t color, fill_t fillit)
WiredHome	178:ae472eb22740	2284	{
WiredHome	178:ae472eb22740	2285	return filltriangle(p1.x,p1.y, p2.x,p2.y, p3.x,p3.y, color, fillit);
WiredHome	178:ae472eb22740	2286	}
WiredHome	178:ae472eb22740	2287
WiredHome	178:ae472eb22740	2288	RetCode_t RA8875::triangle(point_t p1, point_t p2, point_t p3, color_t color, fill_t fillit)
WiredHome	178:ae472eb22740	2289	{
WiredHome	178:ae472eb22740	2290	return triangle(p1.x,p1.y, p2.x,p2.y, p3.x,p3.y, color, fillit);
WiredHome	178:ae472eb22740	2291	}
WiredHome	107:f9ccffcb84f1	2292
WiredHome	73:f22a18707b5e	2293	RetCode_t RA8875::triangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	2294	loc_t x3, loc_t y3, color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	2295	{
WiredHome	20:6e2e4a8372eb	2296	RetCode_t ret;
WiredHome	20:6e2e4a8372eb	2297
WiredHome	198:9b6851107426	2298	if (x1 < 0 \|\| x1 >= virt_screenwidth \|\| x2 < 0 \|\| x2 >= virt_screenwidth \|\| x3 < 0 \|\| x3 >= virt_screenwidth
WiredHome	198:9b6851107426	2299	\|\| y1 < 0 \|\| y1 >= virt_screenheight \|\| y2 < 0 \|\| y2 >= virt_screenheight \|\| y3 < 0 \|\| y3 >= virt_screenheight)
WiredHome	85:022bba13c5c4	2300	ret = bad_parameter;
WiredHome	19:3f82c1161fd2	2301	foreground(color);
WiredHome	20:6e2e4a8372eb	2302	ret = triangle(x1,y1,x2,y2,x3,y3,fillit);
WiredHome	20:6e2e4a8372eb	2303	return ret;
WiredHome	19:3f82c1161fd2	2304	}
WiredHome	19:3f82c1161fd2	2305
WiredHome	44:207594dece70	2306
WiredHome	73:f22a18707b5e	2307	RetCode_t RA8875::filltriangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	2308	loc_t x3, loc_t y3, color_t color, fill_t fillit)
WiredHome	73:f22a18707b5e	2309	{
WiredHome	73:f22a18707b5e	2310	RetCode_t ret;
WiredHome	73:f22a18707b5e	2311
WiredHome	73:f22a18707b5e	2312	foreground(color);
WiredHome	73:f22a18707b5e	2313	ret = triangle(x1,y1,x2,y2,x3,y3,fillit);
WiredHome	73:f22a18707b5e	2314	return ret;
WiredHome	73:f22a18707b5e	2315	}
WiredHome	73:f22a18707b5e	2316
WiredHome	73:f22a18707b5e	2317
WiredHome	73:f22a18707b5e	2318	RetCode_t RA8875::triangle(loc_t x1, loc_t y1 ,loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	2319	loc_t x3, loc_t y3, fill_t fillit)
WiredHome	19:3f82c1161fd2	2320	{
WiredHome	19:3f82c1161fd2	2321	RetCode_t ret = noerror;
WiredHome	73:f22a18707b5e	2322
WiredHome	178:ae472eb22740	2323	INFO("triangle");
WiredHome	19:3f82c1161fd2	2324	PERFORMANCE_RESET;
WiredHome	19:3f82c1161fd2	2325	if (x1 == x2 && y1 == y2 && x1 == x3 && y1 == y3) {
WiredHome	19:3f82c1161fd2	2326	pixel(x1, y1);
WiredHome	19:3f82c1161fd2	2327	} else {
WiredHome	198:9b6851107426	2328	switch (screen_orientation) {
WiredHome	198:9b6851107426	2329	case rotate_0:
WiredHome	198:9b6851107426	2330	case rotate_180:
WiredHome	198:9b6851107426	2331	WriteCommandW(RA8875_DLHSR0, x1);
WiredHome	198:9b6851107426	2332	WriteCommandW(RA8875_DLVSR0, y1);
WiredHome	198:9b6851107426	2333	WriteCommandW(RA8875_DLHER0, x2);
WiredHome	198:9b6851107426	2334	WriteCommandW(RA8875_DLVER0, y2);
WiredHome	198:9b6851107426	2335	WriteCommandW(RA8875_DTPH0, x3);
WiredHome	198:9b6851107426	2336	WriteCommandW(RA8875_DTPV0, y3);
WiredHome	198:9b6851107426	2337	break;
WiredHome	198:9b6851107426	2338	case rotate_90:
WiredHome	198:9b6851107426	2339	case rotate_270:
WiredHome	198:9b6851107426	2340	WriteCommandW(RA8875_DLHSR0, y1);
WiredHome	198:9b6851107426	2341	WriteCommandW(RA8875_DLVSR0, x1);
WiredHome	198:9b6851107426	2342	WriteCommandW(RA8875_DLHER0, y2);
WiredHome	198:9b6851107426	2343	WriteCommandW(RA8875_DLVER0, x2);
WiredHome	198:9b6851107426	2344	WriteCommandW(RA8875_DTPH0, y3);
WiredHome	198:9b6851107426	2345	WriteCommandW(RA8875_DTPV0, x3);
WiredHome	198:9b6851107426	2346	break;
WiredHome	198:9b6851107426	2347	case invalid:
WiredHome	198:9b6851107426	2348	REGISTERPERFORMANCE(PRF_DRAWTRIANGLE);
WiredHome	198:9b6851107426	2349	return bad_parameter;
WiredHome	198:9b6851107426	2350	//break;
WiredHome	198:9b6851107426	2351	}
WiredHome	19:3f82c1161fd2	2352	unsigned char drawCmd = 0x01; // Triangle
WiredHome	19:3f82c1161fd2	2353	if (fillit == FILL)
WiredHome	19:3f82c1161fd2	2354	drawCmd \|= 0x20;
WiredHome	175:7be3a1fb7fc2	2355	WriteCommand(RA8875_DCR, drawCmd);
WiredHome	175:7be3a1fb7fc2	2356	WriteCommand(RA8875_DCR, 0x80 + drawCmd); // Start drawing.
WiredHome	131:5bd6ba2ee4a1	2357	if (!_WaitWhileReg(0x90, 0x80)) {
WiredHome	131:5bd6ba2ee4a1	2358	REGISTERPERFORMANCE(PRF_DRAWTRIANGLE);
WiredHome	131:5bd6ba2ee4a1	2359	return external_abort;
WiredHome	131:5bd6ba2ee4a1	2360	}
WiredHome	19:3f82c1161fd2	2361	}
WiredHome	19:3f82c1161fd2	2362	REGISTERPERFORMANCE(PRF_DRAWTRIANGLE);
WiredHome	19:3f82c1161fd2	2363	return ret;
WiredHome	19:3f82c1161fd2	2364	}
WiredHome	19:3f82c1161fd2	2365
WiredHome	83:7bad0068cca0	2366
WiredHome	83:7bad0068cca0	2367	RetCode_t RA8875::circle(point_t p, dim_t radius,
WiredHome	83:7bad0068cca0	2368	color_t color, fill_t fillit)
WiredHome	83:7bad0068cca0	2369	{
WiredHome	83:7bad0068cca0	2370	foreground(color);
WiredHome	83:7bad0068cca0	2371	return circle(p.x,p.y,radius,fillit);
WiredHome	83:7bad0068cca0	2372	}
WiredHome	83:7bad0068cca0	2373
WiredHome	83:7bad0068cca0	2374
WiredHome	83:7bad0068cca0	2375	RetCode_t RA8875::fillcircle(point_t p, dim_t radius,
WiredHome	83:7bad0068cca0	2376	color_t color, fill_t fillit)
WiredHome	83:7bad0068cca0	2377	{
WiredHome	83:7bad0068cca0	2378	foreground(color);
WiredHome	83:7bad0068cca0	2379	return circle(p.x,p.y,radius,fillit);
WiredHome	83:7bad0068cca0	2380	}
WiredHome	83:7bad0068cca0	2381
WiredHome	83:7bad0068cca0	2382
WiredHome	83:7bad0068cca0	2383	RetCode_t RA8875::circle(point_t p, dim_t radius, fill_t fillit)
WiredHome	83:7bad0068cca0	2384	{
WiredHome	83:7bad0068cca0	2385	return circle(p.x,p.y,radius,fillit);
WiredHome	83:7bad0068cca0	2386	}
WiredHome	83:7bad0068cca0	2387
WiredHome	83:7bad0068cca0	2388
WiredHome	73:f22a18707b5e	2389	RetCode_t RA8875::circle(loc_t x, loc_t y, dim_t radius,
WiredHome	73:f22a18707b5e	2390	color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	2391	{
WiredHome	19:3f82c1161fd2	2392	foreground(color);
WiredHome	19:3f82c1161fd2	2393	return circle(x,y,radius,fillit);
WiredHome	19:3f82c1161fd2	2394	}
WiredHome	19:3f82c1161fd2	2395
WiredHome	44:207594dece70	2396
WiredHome	73:f22a18707b5e	2397	RetCode_t RA8875::fillcircle(loc_t x, loc_t y, dim_t radius,
WiredHome	73:f22a18707b5e	2398	color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	2399	{
WiredHome	19:3f82c1161fd2	2400	foreground(color);
WiredHome	19:3f82c1161fd2	2401	return circle(x,y,radius,fillit);
WiredHome	19:3f82c1161fd2	2402	}
WiredHome	19:3f82c1161fd2	2403
WiredHome	37:f19b7e7449dc	2404	RetCode_t RA8875::circle(loc_t x, loc_t y, dim_t radius, fill_t fillit)
WiredHome	19:3f82c1161fd2	2405	{
WiredHome	19:3f82c1161fd2	2406	RetCode_t ret = noerror;
WiredHome	190:3132b7dfad82	2407
WiredHome	178:ae472eb22740	2408	INFO("circle");
WiredHome	19:3f82c1161fd2	2409	PERFORMANCE_RESET;
WiredHome	183:808f272e481e	2410	if ((x - radius) < 0 \|\| (x + radius) > width()
WiredHome	181:0032d1b8f5d4	2411	\|\| (y - radius) < 0 \|\| (y + radius) > height()) {
WiredHome	19:3f82c1161fd2	2412	ret = bad_parameter;
WiredHome	19:3f82c1161fd2	2413	} else if (radius == 1) {
WiredHome	19:3f82c1161fd2	2414	pixel(x,y);
WiredHome	19:3f82c1161fd2	2415	} else {
WiredHome	198:9b6851107426	2416	switch (screen_orientation) {
WiredHome	198:9b6851107426	2417	case rotate_0:
WiredHome	198:9b6851107426	2418	case rotate_180:
WiredHome	198:9b6851107426	2419	WriteCommandW(RA8875_DCHR0, x);
WiredHome	198:9b6851107426	2420	WriteCommandW(RA8875_DCVR0, y);
WiredHome	198:9b6851107426	2421	break;
WiredHome	198:9b6851107426	2422	case rotate_90:
WiredHome	198:9b6851107426	2423	case rotate_270:
WiredHome	198:9b6851107426	2424	WriteCommandW(RA8875_DCHR0, y);
WiredHome	198:9b6851107426	2425	WriteCommandW(RA8875_DCVR0, x);
WiredHome	198:9b6851107426	2426	break;
WiredHome	198:9b6851107426	2427	case invalid:
WiredHome	198:9b6851107426	2428	REGISTERPERFORMANCE(PRF_DRAWCIRCLE);
WiredHome	198:9b6851107426	2429	return bad_parameter;
WiredHome	198:9b6851107426	2430	//break;
WiredHome	198:9b6851107426	2431	}
WiredHome	175:7be3a1fb7fc2	2432	WriteCommand(RA8875_DCRR, radius & 0xFF);
WiredHome	19:3f82c1161fd2	2433	unsigned char drawCmd = 0x00; // Circle
WiredHome	19:3f82c1161fd2	2434	if (fillit == FILL)
WiredHome	19:3f82c1161fd2	2435	drawCmd \|= 0x20;
WiredHome	175:7be3a1fb7fc2	2436	WriteCommand(RA8875_DCR, drawCmd);
WiredHome	175:7be3a1fb7fc2	2437	WriteCommand(RA8875_DCR, 0x40 + drawCmd); // Start drawing.
WiredHome	131:5bd6ba2ee4a1	2438	if (!_WaitWhileReg(0x90, 0x40)) {
WiredHome	131:5bd6ba2ee4a1	2439	REGISTERPERFORMANCE(PRF_DRAWCIRCLE);
WiredHome	131:5bd6ba2ee4a1	2440	return external_abort;
WiredHome	131:5bd6ba2ee4a1	2441	}
WiredHome	19:3f82c1161fd2	2442	}
WiredHome	19:3f82c1161fd2	2443	REGISTERPERFORMANCE(PRF_DRAWCIRCLE);
WiredHome	19:3f82c1161fd2	2444	return ret;
WiredHome	19:3f82c1161fd2	2445	}
WiredHome	19:3f82c1161fd2	2446
WiredHome	44:207594dece70	2447
WiredHome	37:f19b7e7449dc	2448	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	2449	{
WiredHome	19:3f82c1161fd2	2450	foreground(color);
WiredHome	25:9556a3a9b7cc	2451	return ellipse(x,y,radius1,radius2,fillit);
WiredHome	19:3f82c1161fd2	2452	}
WiredHome	19:3f82c1161fd2	2453
WiredHome	44:207594dece70	2454
WiredHome	37:f19b7e7449dc	2455	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	2456	{
WiredHome	25:9556a3a9b7cc	2457	foreground(color);
WiredHome	25:9556a3a9b7cc	2458	return ellipse(x,y,radius1,radius2,fillit);
WiredHome	25:9556a3a9b7cc	2459	}
WiredHome	44:207594dece70	2460
WiredHome	73:f22a18707b5e	2461
WiredHome	37:f19b7e7449dc	2462	RetCode_t RA8875::ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, fill_t fillit)
WiredHome	19:3f82c1161fd2	2463	{
WiredHome	19:3f82c1161fd2	2464	RetCode_t ret = noerror;
WiredHome	73:f22a18707b5e	2465
WiredHome	178:ae472eb22740	2466	INFO("ellipse");
WiredHome	19:3f82c1161fd2	2467	PERFORMANCE_RESET;
WiredHome	198:9b6851107426	2468	if ((x - radius1) < 0 \|\| (x + radius1) > virt_screenwidth
WiredHome	198:9b6851107426	2469	\|\| (y - radius2) < 0 \|\| (y + radius2) > virt_screenheight) {
WiredHome	85:022bba13c5c4	2470	ret = bad_parameter;
WiredHome	25:9556a3a9b7cc	2471	} else if (radius1 == 1 && radius2 == 1) {
WiredHome	19:3f82c1161fd2	2472	pixel(x, y);
WiredHome	19:3f82c1161fd2	2473	} else {
WiredHome	198:9b6851107426	2474	switch (screen_orientation) {
WiredHome	198:9b6851107426	2475	case rotate_0:
WiredHome	198:9b6851107426	2476	case rotate_180:
WiredHome	198:9b6851107426	2477	WriteCommandW(RA8875_DEHR0, x);
WiredHome	198:9b6851107426	2478	WriteCommandW(RA8875_DEVR0, y);
WiredHome	198:9b6851107426	2479	break;
WiredHome	198:9b6851107426	2480	case rotate_90:
WiredHome	198:9b6851107426	2481	case rotate_270:
WiredHome	198:9b6851107426	2482	WriteCommandW(RA8875_DEHR0, y);
WiredHome	198:9b6851107426	2483	WriteCommandW(RA8875_DEVR0, x);
WiredHome	198:9b6851107426	2484	break;
WiredHome	198:9b6851107426	2485	case invalid:
WiredHome	198:9b6851107426	2486	REGISTERPERFORMANCE(PRF_DRAWELLIPSE);
WiredHome	198:9b6851107426	2487	return bad_parameter;
WiredHome	198:9b6851107426	2488	//break;
WiredHome	198:9b6851107426	2489	}
WiredHome	175:7be3a1fb7fc2	2490	WriteCommandW(RA8875_ELLA0, radius1);
WiredHome	175:7be3a1fb7fc2	2491	WriteCommandW(RA8875_ELLB0, radius2);
WiredHome	19:3f82c1161fd2	2492	unsigned char drawCmd = 0x00; // Ellipse
WiredHome	19:3f82c1161fd2	2493	if (fillit == FILL)
WiredHome	19:3f82c1161fd2	2494	drawCmd \|= 0x40;
WiredHome	175:7be3a1fb7fc2	2495	WriteCommand(RA8875_ELLIPSE, drawCmd);
WiredHome	175:7be3a1fb7fc2	2496	WriteCommand(RA8875_ELLIPSE, 0x80 + drawCmd); // Start drawing.
WiredHome	131:5bd6ba2ee4a1	2497	if (!_WaitWhileReg(0xA0, 0x80)) {
WiredHome	131:5bd6ba2ee4a1	2498	REGISTERPERFORMANCE(PRF_DRAWELLIPSE);
WiredHome	131:5bd6ba2ee4a1	2499	return external_abort;
WiredHome	131:5bd6ba2ee4a1	2500	}
WiredHome	19:3f82c1161fd2	2501	}
WiredHome	19:3f82c1161fd2	2502	REGISTERPERFORMANCE(PRF_DRAWELLIPSE);
WiredHome	19:3f82c1161fd2	2503	return ret;
WiredHome	19:3f82c1161fd2	2504	}
WiredHome	19:3f82c1161fd2	2505
WiredHome	44:207594dece70	2506
WiredHome	68:ab08efabfc88	2507	RetCode_t RA8875::frequency(unsigned long Hz, unsigned long Hz2)
WiredHome	19:3f82c1161fd2	2508	{
WiredHome	66:468a11f05580	2509	spiwritefreq = Hz;
WiredHome	68:ab08efabfc88	2510	if (Hz2 != 0)
WiredHome	68:ab08efabfc88	2511	spireadfreq = Hz2;
WiredHome	68:ab08efabfc88	2512	else
WiredHome	68:ab08efabfc88	2513	spireadfreq = Hz/2;
WiredHome	68:ab08efabfc88	2514	_setWriteSpeed(true);
WiredHome	19:3f82c1161fd2	2515	// __ ___
WiredHome	19:3f82c1161fd2	2516	// Clock ___A Rising edge latched
WiredHome	19:3f82c1161fd2	2517	// ___ ____
WiredHome	19:3f82c1161fd2	2518	// Data ___X____
WiredHome	19:3f82c1161fd2	2519	spi.format(8, 3); // 8 bits and clock to data phase 0
WiredHome	19:3f82c1161fd2	2520	return noerror;
WiredHome	19:3f82c1161fd2	2521	}
WiredHome	19:3f82c1161fd2	2522
WiredHome	68:ab08efabfc88	2523	void RA8875::_setWriteSpeed(bool writeSpeed)
WiredHome	68:ab08efabfc88	2524	{
WiredHome	68:ab08efabfc88	2525	if (writeSpeed) {
WiredHome	68:ab08efabfc88	2526	spi.frequency(spiwritefreq);
WiredHome	68:ab08efabfc88	2527	spiWriteSpeed = true;
WiredHome	68:ab08efabfc88	2528	} else {
WiredHome	68:ab08efabfc88	2529	spi.frequency(spireadfreq);
WiredHome	68:ab08efabfc88	2530	spiWriteSpeed = false;
WiredHome	68:ab08efabfc88	2531	}
WiredHome	68:ab08efabfc88	2532	}
WiredHome	44:207594dece70	2533
WiredHome	131:5bd6ba2ee4a1	2534
WiredHome	131:5bd6ba2ee4a1	2535
WiredHome	131:5bd6ba2ee4a1	2536	RetCode_t RA8875::BlockMove(uint8_t dstLayer, uint8_t dstDataSelect, point_t dstPoint,
WiredHome	131:5bd6ba2ee4a1	2537	uint8_t srcLayer, uint8_t srcDataSelect, point_t srcPoint,
WiredHome	137:9e09f6081ef1	2538	dim_t bte_width, dim_t bte_height,
WiredHome	131:5bd6ba2ee4a1	2539	uint8_t bte_op_code, uint8_t bte_rop_code)
WiredHome	131:5bd6ba2ee4a1	2540	{
WiredHome	131:5bd6ba2ee4a1	2541	uint8_t cmd;
WiredHome	131:5bd6ba2ee4a1	2542
WiredHome	131:5bd6ba2ee4a1	2543	PERFORMANCE_RESET;
WiredHome	137:9e09f6081ef1	2544	///@todo range check and error return rather than to secretly fix
WiredHome	131:5bd6ba2ee4a1	2545	srcPoint.x &= 0x3FF; // prevent high bits from doing unexpected things
WiredHome	131:5bd6ba2ee4a1	2546	srcPoint.y &= 0x1FF;
WiredHome	131:5bd6ba2ee4a1	2547	dstPoint.x &= 0x3FF;
WiredHome	131:5bd6ba2ee4a1	2548	dstPoint.y &= 0x1FF;
WiredHome	175:7be3a1fb7fc2	2549	WriteCommandW(RA8875_HSBE0, srcPoint.x);
WiredHome	175:7be3a1fb7fc2	2550	WriteCommandW(RA8875_VSBE0, ((dim_t)(srcLayer & 1) << 15) \| srcPoint.y);
WiredHome	175:7be3a1fb7fc2	2551	WriteCommandW(RA8875_HDBE0, dstPoint.x);
WiredHome	175:7be3a1fb7fc2	2552	WriteCommandW(RA8875_VDBE0, ((dim_t)(dstLayer & 1) << 15) \| dstPoint.y);
WiredHome	175:7be3a1fb7fc2	2553	WriteCommandW(RA8875_BEWR0, bte_width);
WiredHome	175:7be3a1fb7fc2	2554	WriteCommandW(RA8875_BEHR0, bte_height);
WiredHome	175:7be3a1fb7fc2	2555	WriteCommand(RA8875_BECR1, ((bte_rop_code & 0x0F) << 4) \| (bte_op_code & 0x0F));
WiredHome	131:5bd6ba2ee4a1	2556	cmd = ((srcDataSelect & 1) << 6) \| ((dstDataSelect & 1) << 5);
WiredHome	175:7be3a1fb7fc2	2557	WriteCommand(RA8875_BECR0, 0x80 \| cmd); // enable the BTE
WiredHome	131:5bd6ba2ee4a1	2558	if (!_WaitWhileBusy(0x40)) {
WiredHome	131:5bd6ba2ee4a1	2559	REGISTERPERFORMANCE(PRF_BLOCKMOVE);
WiredHome	131:5bd6ba2ee4a1	2560	return external_abort;
WiredHome	131:5bd6ba2ee4a1	2561	}
WiredHome	131:5bd6ba2ee4a1	2562	REGISTERPERFORMANCE(PRF_BLOCKMOVE);
WiredHome	131:5bd6ba2ee4a1	2563	return noerror;
WiredHome	131:5bd6ba2ee4a1	2564	}
WiredHome	131:5bd6ba2ee4a1	2565
WiredHome	131:5bd6ba2ee4a1	2566
WiredHome	19:3f82c1161fd2	2567	RetCode_t RA8875::Power(bool on)
WiredHome	19:3f82c1161fd2	2568	{
WiredHome	175:7be3a1fb7fc2	2569	WriteCommand(RA8875_PWRR, (on) ? 0x80 : 0x00);
WiredHome	19:3f82c1161fd2	2570	return noerror;
WiredHome	19:3f82c1161fd2	2571	}
WiredHome	19:3f82c1161fd2	2572
WiredHome	44:207594dece70	2573
WiredHome	131:5bd6ba2ee4a1	2574	RetCode_t RA8875::Backlight_u8(uint8_t brightness)
WiredHome	19:3f82c1161fd2	2575	{
WiredHome	19:3f82c1161fd2	2576	static bool is_enabled = false;
WiredHome	190:3132b7dfad82	2577
WiredHome	19:3f82c1161fd2	2578	if (brightness == 0) {
WiredHome	175:7be3a1fb7fc2	2579	WriteCommand(RA8875_P1CR); // Disable the PWM
WiredHome	19:3f82c1161fd2	2580	WriteData(0x00);
WiredHome	19:3f82c1161fd2	2581	is_enabled = false;
WiredHome	19:3f82c1161fd2	2582	} else if (!is_enabled) {
WiredHome	175:7be3a1fb7fc2	2583	WriteCommand(RA8875_P1CR); // Enable the PWM
WiredHome	19:3f82c1161fd2	2584	WriteData(0x80);
WiredHome	175:7be3a1fb7fc2	2585	WriteCommand(RA8875_P1CR); // Not sure why this is needed, but following the pattern
WiredHome	19:3f82c1161fd2	2586	WriteData(0x81); // open PWM (SYS_CLK / 2 as best I can tell)
WiredHome	19:3f82c1161fd2	2587	is_enabled = true;
WiredHome	19:3f82c1161fd2	2588	}
WiredHome	175:7be3a1fb7fc2	2589	WriteCommand(RA8875_P1DCR, brightness); // Brightness parameter 0xff-0x00
WiredHome	19:3f82c1161fd2	2590	return noerror;
WiredHome	19:3f82c1161fd2	2591	}
WiredHome	19:3f82c1161fd2	2592
WiredHome	86:e86b355940f4	2593	uint8_t RA8875::GetBacklight_u8(void)
WiredHome	86:e86b355940f4	2594	{
WiredHome	86:e86b355940f4	2595	return ReadCommand(0x8b);
WiredHome	86:e86b355940f4	2596	}
WiredHome	44:207594dece70	2597
WiredHome	19:3f82c1161fd2	2598	RetCode_t RA8875::Backlight(float brightness)
WiredHome	19:3f82c1161fd2	2599	{
WiredHome	19:3f82c1161fd2	2600	unsigned char b;
WiredHome	73:f22a18707b5e	2601
WiredHome	29:422616aa04bd	2602	if (brightness >= 1.0)
WiredHome	19:3f82c1161fd2	2603	b = 255;
WiredHome	29:422616aa04bd	2604	else if (brightness <= 0.0)
WiredHome	19:3f82c1161fd2	2605	b = 0;
WiredHome	19:3f82c1161fd2	2606	else
WiredHome	19:3f82c1161fd2	2607	b = (unsigned char)(brightness * 255);
WiredHome	19:3f82c1161fd2	2608	return Backlight_u8(b);
WiredHome	19:3f82c1161fd2	2609	}
WiredHome	19:3f82c1161fd2	2610
WiredHome	86:e86b355940f4	2611	float RA8875::GetBacklight(void)
WiredHome	86:e86b355940f4	2612	{
WiredHome	86:e86b355940f4	2613	return (float)(GetBacklight_u8())/255;
WiredHome	86:e86b355940f4	2614	}
WiredHome	44:207594dece70	2615
WiredHome	98:ecebed9b80b2	2616	RetCode_t RA8875::SelectUserFont(const uint8_t * _font)
WiredHome	98:ecebed9b80b2	2617	{
WiredHome	178:ae472eb22740	2618	INFO("SelectUserFont(%p)", _font);
WiredHome	98:ecebed9b80b2	2619	if (_font) {
WiredHome	98:ecebed9b80b2	2620	HexDump("Font Memory", _font, 16);
WiredHome	98:ecebed9b80b2	2621	extFontHeight = _font[6];
WiredHome	98:ecebed9b80b2	2622	uint32_t totalWidth = 0;
WiredHome	98:ecebed9b80b2	2623	uint16_t firstChar = _font[3] * 256 + _font[2];
WiredHome	98:ecebed9b80b2	2624	uint16_t lastChar = _font[5] * 256 + _font[4];
WiredHome	98:ecebed9b80b2	2625	uint16_t i;
WiredHome	190:3132b7dfad82	2626
WiredHome	98:ecebed9b80b2	2627	for (i=firstChar; i<=lastChar; i++) {
WiredHome	98:ecebed9b80b2	2628	// 8 bytes of preamble to the first level lookup table
WiredHome	98:ecebed9b80b2	2629	uint16_t offsetToCharLookup = 8 + 4 * (i - firstChar); // 4-bytes: width(pixels), 16-bit offset from table start, 0
WiredHome	98:ecebed9b80b2	2630	totalWidth += _font[offsetToCharLookup];
WiredHome	98:ecebed9b80b2	2631	}
WiredHome	98:ecebed9b80b2	2632	extFontWidth = totalWidth / (lastChar - firstChar);
WiredHome	98:ecebed9b80b2	2633	INFO("Font Metrics: Avg W: %2d, H: %2d, First:%d, Last:%d", extFontWidth, extFontHeight, firstChar, lastChar);
WiredHome	98:ecebed9b80b2	2634	}
WiredHome	198:9b6851107426	2635	SetTextCursor(GetTextCursor()); // soft-font cursor -> hw cursor
WiredHome	98:ecebed9b80b2	2636	font = _font;
WiredHome	98:ecebed9b80b2	2637	return GraphicsDisplay::SelectUserFont(_font);
WiredHome	98:ecebed9b80b2	2638	}
WiredHome	44:207594dece70	2639
WiredHome	198:9b6851107426	2640	color_t RA8875::background(color_t color)
WiredHome	19:3f82c1161fd2	2641	{
WiredHome	198:9b6851107426	2642	color_t oldColor = GetBackColor();
WiredHome	37:f19b7e7449dc	2643	GraphicsDisplay::background(color);
WiredHome	198:9b6851107426	2644	_writeColorTrio(0x60, color);
WiredHome	198:9b6851107426	2645	return oldColor;
WiredHome	19:3f82c1161fd2	2646	}
WiredHome	19:3f82c1161fd2	2647
WiredHome	44:207594dece70	2648
WiredHome	198:9b6851107426	2649	color_t RA8875::background(unsigned char r, unsigned char g, unsigned char b)
WiredHome	19:3f82c1161fd2	2650	{
WiredHome	198:9b6851107426	2651	return background(RGB(r,g,b));
WiredHome	19:3f82c1161fd2	2652	}
WiredHome	19:3f82c1161fd2	2653
WiredHome	198:9b6851107426	2654	color_t RA8875::GetBackColor(void)
WiredHome	19:3f82c1161fd2	2655	{
WiredHome	198:9b6851107426	2656	return _readColorTrio(0x60);
WiredHome	19:3f82c1161fd2	2657	}
WiredHome	19:3f82c1161fd2	2658
WiredHome	44:207594dece70	2659
WiredHome	198:9b6851107426	2660	color_t RA8875::foreground(color_t color)
WiredHome	19:3f82c1161fd2	2661	{
WiredHome	198:9b6851107426	2662	color_t oldColor = GetForeColor();
WiredHome	198:9b6851107426	2663	GraphicsDisplay::foreground(color);
WiredHome	198:9b6851107426	2664	_writeColorTrio(0x63, color);
WiredHome	198:9b6851107426	2665	return oldColor;
WiredHome	19:3f82c1161fd2	2666	}
WiredHome	19:3f82c1161fd2	2667
WiredHome	44:207594dece70	2668
WiredHome	198:9b6851107426	2669	color_t RA8875::foreground(unsigned char r, unsigned char g, unsigned char b)
WiredHome	198:9b6851107426	2670	{
WiredHome	198:9b6851107426	2671	return foreground(RGB(r,g,b));
WiredHome	198:9b6851107426	2672	}
WiredHome	198:9b6851107426	2673
WiredHome	37:f19b7e7449dc	2674	color_t RA8875::GetForeColor(void)
WiredHome	19:3f82c1161fd2	2675	{
WiredHome	133:e36dcfc2d756	2676	return _readColorTrio(0x63);
WiredHome	19:3f82c1161fd2	2677	}
WiredHome	19:3f82c1161fd2	2678
WiredHome	44:207594dece70	2679
WiredHome	198:9b6851107426	2680
WiredHome	19:3f82c1161fd2	2681	color_t RA8875::DOSColor(int i)
WiredHome	73:f22a18707b5e	2682	{
WiredHome	73:f22a18707b5e	2683	const color_t colors[16] = {
WiredHome	19:3f82c1161fd2	2684	Black, Blue, Green, Cyan,
WiredHome	19:3f82c1161fd2	2685	Red, Magenta, Brown, Gray,
WiredHome	19:3f82c1161fd2	2686	Charcoal, BrightBlue, BrightGreen, BrightCyan,
WiredHome	19:3f82c1161fd2	2687	Orange, Pink, Yellow, White
WiredHome	73:f22a18707b5e	2688	};
WiredHome	85:022bba13c5c4	2689	if (i >= 0 && i < 16)
WiredHome	19:3f82c1161fd2	2690	return colors[i];
WiredHome	19:3f82c1161fd2	2691	else
WiredHome	19:3f82c1161fd2	2692	return 0;
WiredHome	73:f22a18707b5e	2693	}
WiredHome	19:3f82c1161fd2	2694
WiredHome	44:207594dece70	2695
WiredHome	73:f22a18707b5e	2696	const char * RA8875::DOSColorNames(int i)
WiredHome	73:f22a18707b5e	2697	{
WiredHome	73:f22a18707b5e	2698	const char * names[16] = {
WiredHome	19:3f82c1161fd2	2699	"Black", "Blue", "Green", "Cyan",
WiredHome	19:3f82c1161fd2	2700	"Red", "Magenta", "Brown", "Gray",
WiredHome	19:3f82c1161fd2	2701	"Charcoal", "BrightBlue", "BrightGreen", "BrightCyan",
WiredHome	19:3f82c1161fd2	2702	"Orange", "Pink", "Yellow", "White"
WiredHome	73:f22a18707b5e	2703	};
WiredHome	85:022bba13c5c4	2704	if (i >= 0 && i < 16)
WiredHome	19:3f82c1161fd2	2705	return names[i];
WiredHome	19:3f82c1161fd2	2706	else
WiredHome	19:3f82c1161fd2	2707	return NULL;
WiredHome	73:f22a18707b5e	2708	}
WiredHome	19:3f82c1161fd2	2709
WiredHome	19:3f82c1161fd2	2710
WiredHome	19:3f82c1161fd2	2711	///////////////////////////////////////////////////////////////
WiredHome	19:3f82c1161fd2	2712	// Private functions
WiredHome	19:3f82c1161fd2	2713
WiredHome	79:544eb4964795	2714	unsigned char RA8875::_spiwrite(unsigned char data)
WiredHome	19:3f82c1161fd2	2715	{
WiredHome	19:3f82c1161fd2	2716	unsigned char retval;
WiredHome	73:f22a18707b5e	2717
WiredHome	68:ab08efabfc88	2718	if (!spiWriteSpeed)
WiredHome	68:ab08efabfc88	2719	_setWriteSpeed(true);
WiredHome	19:3f82c1161fd2	2720	retval = spi.write(data);
WiredHome	19:3f82c1161fd2	2721	return retval;
WiredHome	19:3f82c1161fd2	2722	}
WiredHome	19:3f82c1161fd2	2723
WiredHome	44:207594dece70	2724
WiredHome	79:544eb4964795	2725	unsigned char RA8875::_spiread(void)
WiredHome	19:3f82c1161fd2	2726	{
WiredHome	19:3f82c1161fd2	2727	unsigned char retval;
WiredHome	19:3f82c1161fd2	2728	unsigned char data = 0;
WiredHome	73:f22a18707b5e	2729
WiredHome	68:ab08efabfc88	2730	if (spiWriteSpeed)
WiredHome	68:ab08efabfc88	2731	_setWriteSpeed(false);
WiredHome	19:3f82c1161fd2	2732	retval = spi.write(data);
WiredHome	19:3f82c1161fd2	2733	return retval;
WiredHome	19:3f82c1161fd2	2734	}
WiredHome	19:3f82c1161fd2	2735
WiredHome	44:207594dece70	2736
WiredHome	79:544eb4964795	2737	RetCode_t RA8875::_select(bool chipsel)
WiredHome	19:3f82c1161fd2	2738	{
WiredHome	19:3f82c1161fd2	2739	cs = (chipsel == true) ? 0 : 1;
WiredHome	19:3f82c1161fd2	2740	return noerror;
WiredHome	19:3f82c1161fd2	2741	}
WiredHome	19:3f82c1161fd2	2742
WiredHome	44:207594dece70	2743
WiredHome	72:ecffe56af969	2744	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	2745	{
WiredHome	74:686faa218914	2746	(void)layer;
WiredHome	190:3132b7dfad82	2747
WiredHome	96:40b74dd3695b	2748	// AttachPrintHandler(this, RA8875::_printCallback);
WiredHome	96:40b74dd3695b	2749	// return PrintScreen(x,y,w,h);
WiredHome	74:686faa218914	2750	return PrintScreen(x, y, w, h, Name_BMP);
WiredHome	72:ecffe56af969	2751	}
WiredHome	72:ecffe56af969	2752
WiredHome	96:40b74dd3695b	2753	RetCode_t RA8875::_printCallback(RA8875::filecmd_t cmd, uint8_t * buffer, uint16_t size)
WiredHome	96:40b74dd3695b	2754	{
WiredHome	96:40b74dd3695b	2755	HexDump("CB", buffer, size);
WiredHome	96:40b74dd3695b	2756	switch(cmd) {
WiredHome	96:40b74dd3695b	2757	case RA8875::OPEN:
WiredHome	96:40b74dd3695b	2758	//pc.printf("About to write %lu bytes\r\n", (uint32_t )buffer);
WiredHome	96:40b74dd3695b	2759	_printFH = fopen("file.bmp", "w+b");
WiredHome	96:40b74dd3695b	2760	if (_printFH == 0)
WiredHome	96:40b74dd3695b	2761	return file_not_found;
WiredHome	96:40b74dd3695b	2762	break;
WiredHome	96:40b74dd3695b	2763	case RA8875::WRITE:
WiredHome	96:40b74dd3695b	2764	//pc.printf(" Write %4u bytes\r\n", size);
WiredHome	96:40b74dd3695b	2765	fwrite(buffer, 1, size, _printFH);
WiredHome	96:40b74dd3695b	2766	break;
WiredHome	96:40b74dd3695b	2767	case RA8875::CLOSE:
WiredHome	96:40b74dd3695b	2768	//pc.printf(" close\r\n");
WiredHome	96:40b74dd3695b	2769	fclose(_printFH);
WiredHome	96:40b74dd3695b	2770	_printFH = 0;
WiredHome	96:40b74dd3695b	2771	break;
WiredHome	96:40b74dd3695b	2772	default:
WiredHome	96:40b74dd3695b	2773	//pc.printf("Unexpected callback %d\r\n", cmd);
WiredHome	96:40b74dd3695b	2774	return file_not_found;
WiredHome	96:40b74dd3695b	2775	//break;
WiredHome	96:40b74dd3695b	2776	}
WiredHome	96:40b74dd3695b	2777	return noerror;
WiredHome	96:40b74dd3695b	2778	}
WiredHome	96:40b74dd3695b	2779
WiredHome	162:a2d7f1988711	2780	int RA8875::RoundUp(int value, int roundTo)
WiredHome	162:a2d7f1988711	2781	{
WiredHome	190:3132b7dfad82	2782	if (roundTo == 0)
WiredHome	162:a2d7f1988711	2783	return 0;
WiredHome	162:a2d7f1988711	2784	return ((value + roundTo - 1) / roundTo) * roundTo;
WiredHome	162:a2d7f1988711	2785	}
WiredHome	162:a2d7f1988711	2786
WiredHome	164:76edd7d9cb68	2787	RetCode_t RA8875::PrintScreen(loc_t x, loc_t y, dim_t w, dim_t h, uint8_t bitsPerPixel)
WiredHome	96:40b74dd3695b	2788	{
WiredHome	96:40b74dd3695b	2789	BITMAPFILEHEADER BMP_Header;
WiredHome	96:40b74dd3695b	2790	BITMAPINFOHEADER BMP_Info;
WiredHome	96:40b74dd3695b	2791	uint8_t * lineBuffer = NULL;
WiredHome	96:40b74dd3695b	2792	color_t * pixelBuffer = NULL;
WiredHome	96:40b74dd3695b	2793	color_t * pixelBuffer2 = NULL;
WiredHome	190:3132b7dfad82	2794
WiredHome	164:76edd7d9cb68	2795	INFO("(%d,%d)-(%d,%d)x%d", x,y,w,h,bitsPerPixel);
WiredHome	198:9b6851107426	2796	if (x >= 0 && x < virt_screenwidth
WiredHome	198:9b6851107426	2797	&& y >= 0 && y < virt_screenheight
WiredHome	198:9b6851107426	2798	&& w > 0 && x + w <= virt_screenwidth
WiredHome	198:9b6851107426	2799	&& h > 0 && y + h <= virt_screenheight) {
WiredHome	96:40b74dd3695b	2800	BMP_Header.bfType = BF_TYPE;
WiredHome	96:40b74dd3695b	2801	BMP_Header.bfReserved1 = 0;
WiredHome	96:40b74dd3695b	2802	BMP_Header.bfReserved2 = 0;
WiredHome	164:76edd7d9cb68	2803	switch (bitsPerPixel) {
WiredHome	164:76edd7d9cb68	2804	case 24:
WiredHome	164:76edd7d9cb68	2805	BMP_Header.bfOffBits = sizeof(BMP_Header) + sizeof(BMP_Info);
WiredHome	164:76edd7d9cb68	2806	BMP_Header.bfSize = (h * RoundUp(w * sizeof(RGBQUAD),4)) + BMP_Header.bfOffBits;
WiredHome	164:76edd7d9cb68	2807	break;
WiredHome	164:76edd7d9cb68	2808	case 8:
WiredHome	164:76edd7d9cb68	2809	default:
WiredHome	164:76edd7d9cb68	2810	BMP_Header.bfOffBits = sizeof(BMP_Header) + sizeof(BMP_Info) + sizeof(WebColorPalette);
WiredHome	198:9b6851107426	2811	INFO("Initial Offset to Bitstream %lX", BMP_Header.bfOffBits);
WiredHome	164:76edd7d9cb68	2812	//if (BMP_Header.bfOffBits & 0x03) {
WiredHome	164:76edd7d9cb68	2813	// BMP_Header.bfOffBits += (4 - (BMP_Header.bfOffBits & 0x03));
WiredHome	164:76edd7d9cb68	2814	//}
WiredHome	164:76edd7d9cb68	2815	BMP_Header.bfSize = (h * RoundUp(w * 1,4)) + BMP_Header.bfOffBits;
WiredHome	164:76edd7d9cb68	2816	break;
WiredHome	164:76edd7d9cb68	2817	}
WiredHome	198:9b6851107426	2818	INFO("Offset to Bitstream %lX", BMP_Header.bfOffBits);
WiredHome	162:a2d7f1988711	2819
WiredHome	162:a2d7f1988711	2820	// Bytes in the line buffer
WiredHome	164:76edd7d9cb68	2821	int lineBufSize = RoundUp(((bitsPerPixel == 24) ? 3 : 1) * w, 4);
WiredHome	162:a2d7f1988711	2822	INFO("LineBufSize: %d", lineBufSize);
WiredHome	96:40b74dd3695b	2823
WiredHome	96:40b74dd3695b	2824	BMP_Info.biSize = sizeof(BMP_Info);
WiredHome	96:40b74dd3695b	2825	BMP_Info.biWidth = w;
WiredHome	96:40b74dd3695b	2826	BMP_Info.biHeight = h;
WiredHome	96:40b74dd3695b	2827	BMP_Info.biPlanes = 1;
WiredHome	164:76edd7d9cb68	2828	BMP_Info.biBitCount = bitsPerPixel;
WiredHome	96:40b74dd3695b	2829	BMP_Info.biCompression = BI_RGB;
WiredHome	162:a2d7f1988711	2830	BMP_Info.biSizeImage = lineBufSize * h;
WiredHome	96:40b74dd3695b	2831	BMP_Info.biXPelsPerMeter = 0;
WiredHome	96:40b74dd3695b	2832	BMP_Info.biYPelsPerMeter = 0;
WiredHome	164:76edd7d9cb68	2833	// for 24-bit, there is no palette, so these are zero
WiredHome	164:76edd7d9cb68	2834	// for 8-bit, there can be up to 256 RGB values in the palette
WiredHome	190:3132b7dfad82	2835
WiredHome	164:76edd7d9cb68	2836	BMP_Info.biClrUsed = (bitsPerPixel == 24) ? 0 : sizeof(WebColorPalette)/sizeof(WebColorPalette[0]); // for 8b/pixel
WiredHome	164:76edd7d9cb68	2837	BMP_Info.biClrImportant = BMP_Info.biClrUsed;
WiredHome	96:40b74dd3695b	2838
WiredHome	96:40b74dd3695b	2839	// Allocate the memory we need to proceed
WiredHome	145:5eb2492acdda	2840	lineBuffer = (uint8_t *)swMalloc(lineBufSize);
WiredHome	96:40b74dd3695b	2841	if (lineBuffer == NULL) {
WiredHome	96:40b74dd3695b	2842	ERR("Not enough RAM for PrintScreen lineBuffer");
WiredHome	96:40b74dd3695b	2843	return(not_enough_ram);
WiredHome	96:40b74dd3695b	2844	}
WiredHome	162:a2d7f1988711	2845	memset(lineBuffer, 0, lineBufSize); // zero-Fill
WiredHome	96:40b74dd3695b	2846
WiredHome	96:40b74dd3695b	2847	#define DOUBLEBUF /* one larger buffer instead of two */
WiredHome	190:3132b7dfad82	2848
WiredHome	96:40b74dd3695b	2849	#ifdef DOUBLEBUF
WiredHome	197:853d08e2fb53	2850	// In the "#else", pixelBuffer2 malloc returns a value,
WiredHome	197:853d08e2fb53	2851	// but is actually causing a failure later.
WiredHome	96:40b74dd3695b	2852	// This test helps determine if it is truly out of memory,
WiredHome	96:40b74dd3695b	2853	// or if malloc is broken.
WiredHome	145:5eb2492acdda	2854	pixelBuffer = (color_t )swMalloc(2 w * sizeof(color_t));
WiredHome	182:8832d03a2a29	2855	if (pixelBuffer)
WiredHome	182:8832d03a2a29	2856	pixelBuffer2 = pixelBuffer + (w * sizeof(color_t));
WiredHome	182:8832d03a2a29	2857	else
WiredHome	182:8832d03a2a29	2858	pixelBuffer2 = NULL;
WiredHome	96:40b74dd3695b	2859	#else
WiredHome	145:5eb2492acdda	2860	pixelBuffer = (color_t )swMalloc(w sizeof(color_t));
WiredHome	145:5eb2492acdda	2861	pixelBuffer2 = (color_t )swMalloc(w sizeof(color_t));
WiredHome	96:40b74dd3695b	2862	#endif
WiredHome	96:40b74dd3695b	2863	if (pixelBuffer == NULL \|\| pixelBuffer2 == NULL) {
WiredHome	96:40b74dd3695b	2864	ERR("Not enough RAM for pixelBuffer");
WiredHome	96:40b74dd3695b	2865	#ifndef DOUBLEBUF
WiredHome	96:40b74dd3695b	2866	if (pixelBuffer2)
WiredHome	145:5eb2492acdda	2867	swFree(pixelBuffer2);
WiredHome	96:40b74dd3695b	2868	#endif
WiredHome	96:40b74dd3695b	2869	if (pixelBuffer)
WiredHome	145:5eb2492acdda	2870	swFree(pixelBuffer);
WiredHome	145:5eb2492acdda	2871	swFree(lineBuffer);
WiredHome	96:40b74dd3695b	2872	return(not_enough_ram);
WiredHome	96:40b74dd3695b	2873	}
WiredHome	96:40b74dd3695b	2874
WiredHome	96:40b74dd3695b	2875	// Get the file primed...
WiredHome	164:76edd7d9cb68	2876	/// @todo check return value for possibility of a fatal error
WiredHome	96:40b74dd3695b	2877	privateCallback(OPEN, (uint8_t *)&BMP_Header.bfSize, 4);
WiredHome	96:40b74dd3695b	2878
WiredHome	96:40b74dd3695b	2879	// Be optimistic - don't check for errors.
WiredHome	198:9b6851107426	2880	//HexDump("BMP_Header", (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome	96:40b74dd3695b	2881	//fwrite(&BMP_Header, sizeof(char), sizeof(BMP_Header), Image);
WiredHome	96:40b74dd3695b	2882	privateCallback(WRITE, (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome	96:40b74dd3695b	2883
WiredHome	198:9b6851107426	2884	//HexDump("BMP_Info", (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome	96:40b74dd3695b	2885	//fwrite(&BMP_Info, sizeof(char), sizeof(BMP_Info), Image);
WiredHome	96:40b74dd3695b	2886	privateCallback(WRITE, (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome	164:76edd7d9cb68	2887	if (bitsPerPixel != 24) {
WiredHome	198:9b6851107426	2888	//HexDump("Palette", (uint8_t *)&WebColorPalette, sizeof(WebColorPalette));
WiredHome	164:76edd7d9cb68	2889	//fwrite(&WebColorPalette, sizeof(char), sizeof(WebColorPalette), Image);
WiredHome	164:76edd7d9cb68	2890	privateCallback(WRITE, (uint8_t *)&WebColorPalette, sizeof(WebColorPalette));
WiredHome	164:76edd7d9cb68	2891	if (0 && sizeof(WebColorPalette) % 4) {
WiredHome	164:76edd7d9cb68	2892	const uint8_t padd[] = { 0, 0, 0 };
WiredHome	164:76edd7d9cb68	2893	//fwrite(&padd, sizeof(char), (sizeof(BMP_Header) + sizeof(BMP_Info) + sizeof(WebColorPalette)) % 4, Image);
WiredHome	164:76edd7d9cb68	2894	privateCallback(WRITE, (uint8_t *)&padd, (sizeof(BMP_Header) + sizeof(BMP_Info) + sizeof(WebColorPalette)) % 4);
WiredHome	164:76edd7d9cb68	2895	}
WiredHome	164:76edd7d9cb68	2896	}
WiredHome	96:40b74dd3695b	2897	//color_t transparency = GetBackgroundTransparencyColor();
WiredHome	96:40b74dd3695b	2898	LayerMode_T ltpr0 = GetLayerMode();
WiredHome	96:40b74dd3695b	2899	uint16_t prevLayer = GetDrawingLayer();
WiredHome	96:40b74dd3695b	2900	// If only one of the layers is visible, select that layer
WiredHome	96:40b74dd3695b	2901	switch(ltpr0) {
WiredHome	96:40b74dd3695b	2902	case ShowLayer0:
WiredHome	96:40b74dd3695b	2903	SelectDrawingLayer(0);
WiredHome	96:40b74dd3695b	2904	break;
WiredHome	96:40b74dd3695b	2905	case ShowLayer1:
WiredHome	96:40b74dd3695b	2906	SelectDrawingLayer(1);
WiredHome	96:40b74dd3695b	2907	break;
WiredHome	96:40b74dd3695b	2908	default:
WiredHome	96:40b74dd3695b	2909	break;
WiredHome	96:40b74dd3695b	2910	}
WiredHome	96:40b74dd3695b	2911
WiredHome	96:40b74dd3695b	2912	// Read the display from the last line toward the top
WiredHome	96:40b74dd3695b	2913	// so we can write the file in one pass.
WiredHome	96:40b74dd3695b	2914	for (int j = h - 1; j >= 0; j--) {
WiredHome	182:8832d03a2a29	2915	if (idle_callback && h >= 1) {
WiredHome	149:c62c4b2d6a15	2916	(idle_callback)(progress, (h - 1 - j) 100 / (h - 1));
WiredHome	149:c62c4b2d6a15	2917	}
WiredHome	96:40b74dd3695b	2918	if (ltpr0 >= 2) // Need to combine the layers...
WiredHome	96:40b74dd3695b	2919	SelectDrawingLayer(0); // so read layer 0 first
WiredHome	96:40b74dd3695b	2920	// Read one line of pixels to a local buffer
WiredHome	198:9b6851107426	2921	INFO("x,y %d,%d", x, y + j);
WiredHome	96:40b74dd3695b	2922	if (getPixelStream(pixelBuffer, w, x,y+j) != noerror) {
WiredHome	96:40b74dd3695b	2923	ERR("getPixelStream error, and no recovery handler...");
WiredHome	96:40b74dd3695b	2924	}
WiredHome	96:40b74dd3695b	2925	if (ltpr0 >= 2) { // Need to combine the layers...
WiredHome	96:40b74dd3695b	2926	SelectDrawingLayer(1); // so read layer 1 next
WiredHome	96:40b74dd3695b	2927	if (getPixelStream(pixelBuffer2, w, x,y+j) != noerror) {
WiredHome	96:40b74dd3695b	2928	ERR("getPixelStream error, and no recovery handler...");
WiredHome	96:40b74dd3695b	2929	}
WiredHome	96:40b74dd3695b	2930	}
WiredHome	164:76edd7d9cb68	2931	INFO("Line: %3d", j);
WiredHome	164:76edd7d9cb68	2932	//HexDump("Raster", (uint8_t )pixelBuffer, w sizeof(color_t));
WiredHome	96:40b74dd3695b	2933	// Convert the local buffer to RGBQUAD format
WiredHome	96:40b74dd3695b	2934	int lb = 0;
WiredHome	96:40b74dd3695b	2935	for (int i=0; i<w; i++) {
WiredHome	162:a2d7f1988711	2936	color_t tColor = pixelBuffer[x+i];
WiredHome	162:a2d7f1988711	2937	tColor = (tColor >> 8) \| (tColor << 8); // Byte Swap
WiredHome	162:a2d7f1988711	2938	RGBQUAD q0 = RGB16ToRGBQuad(tColor); // Scale to 24-bits
WiredHome	162:a2d7f1988711	2939	tColor = pixelBuffer2[x+i];
WiredHome	162:a2d7f1988711	2940	tColor = (tColor >> 8) \| (tColor << 8); // Byte Swap
WiredHome	162:a2d7f1988711	2941	RGBQUAD q1 = RGB16ToRGBQuad(tColor); // Scale to 24-bits
WiredHome	96:40b74dd3695b	2942	switch (ltpr0) {
WiredHome	96:40b74dd3695b	2943	case 0:
WiredHome	96:40b74dd3695b	2944	case 1:
WiredHome	96:40b74dd3695b	2945	case 2: // lighten-overlay (@TODO Not supported yet)
WiredHome	96:40b74dd3695b	2946	case 6: // Floating Windows (@TODO not sure how to support)
WiredHome	96:40b74dd3695b	2947	default: // Reserved...
WiredHome	164:76edd7d9cb68	2948	//lineBuffer[lb++] = q0.rgbBlue;
WiredHome	164:76edd7d9cb68	2949	//lineBuffer[lb++] = q0.rgbGreen;
WiredHome	164:76edd7d9cb68	2950	//lineBuffer[lb++] = q0.rgbRed;
WiredHome	164:76edd7d9cb68	2951	break;
WiredHome	164:76edd7d9cb68	2952	case 3: // transparent mode (@TODO Read the background color register for transparent)
WiredHome	164:76edd7d9cb68	2953	case 4: // boolean or
WiredHome	164:76edd7d9cb68	2954	q0.rgbBlue = q0.rgbBlue \| q1.rgbBlue;
WiredHome	164:76edd7d9cb68	2955	q0.rgbGreen = q0.rgbGreen \| q1.rgbGreen;
WiredHome	164:76edd7d9cb68	2956	q0.rgbRed = q0.rgbRed \| q1.rgbRed;
WiredHome	164:76edd7d9cb68	2957	break;
WiredHome	164:76edd7d9cb68	2958	case 5: // boolean AND
WiredHome	164:76edd7d9cb68	2959	q0.rgbBlue = q0.rgbBlue & q1.rgbBlue;
WiredHome	164:76edd7d9cb68	2960	q0.rgbGreen = q0.rgbGreen & q1.rgbGreen;
WiredHome	164:76edd7d9cb68	2961	q0.rgbRed = q0.rgbRed & q1.rgbRed;
WiredHome	164:76edd7d9cb68	2962	break;
WiredHome	164:76edd7d9cb68	2963	}
WiredHome	164:76edd7d9cb68	2964	switch (bitsPerPixel) {
WiredHome	164:76edd7d9cb68	2965	case 24:
WiredHome	96:40b74dd3695b	2966	lineBuffer[lb++] = q0.rgbBlue;
WiredHome	96:40b74dd3695b	2967	lineBuffer[lb++] = q0.rgbGreen;
WiredHome	96:40b74dd3695b	2968	lineBuffer[lb++] = q0.rgbRed;
WiredHome	96:40b74dd3695b	2969	break;
WiredHome	164:76edd7d9cb68	2970	case 8:
WiredHome	164:76edd7d9cb68	2971	default:
WiredHome	164:76edd7d9cb68	2972	lineBuffer[lb++] = FindNearestWebColor(q0.rgbRed,q0.rgbGreen,q0.rgbBlue);
WiredHome	96:40b74dd3695b	2973	break;
WiredHome	96:40b74dd3695b	2974	}
WiredHome	96:40b74dd3695b	2975	}
WiredHome	198:9b6851107426	2976	if (j == h - 1) {
WiredHome	198:9b6851107426	2977	HexDump("Line", lineBuffer, lineBufSize);
WiredHome	198:9b6851107426	2978	}
WiredHome	96:40b74dd3695b	2979	// Write to disk
WiredHome	162:a2d7f1988711	2980	privateCallback(WRITE, (uint8_t *)lineBuffer, lineBufSize);
WiredHome	96:40b74dd3695b	2981	}
WiredHome	96:40b74dd3695b	2982	SelectDrawingLayer(prevLayer);
WiredHome	96:40b74dd3695b	2983	privateCallback(CLOSE, NULL, 0);
WiredHome	96:40b74dd3695b	2984	#ifndef DOUBLEBUF
WiredHome	96:40b74dd3695b	2985	if (pixelBuffer2)
WiredHome	145:5eb2492acdda	2986	swFree(pixelBuffer2);
WiredHome	96:40b74dd3695b	2987	#endif
WiredHome	96:40b74dd3695b	2988	if (pixelBuffer)
WiredHome	145:5eb2492acdda	2989	swFree(pixelBuffer);
WiredHome	145:5eb2492acdda	2990	swFree(lineBuffer);
WiredHome	96:40b74dd3695b	2991	INFO("Image closed");
WiredHome	96:40b74dd3695b	2992	return noerror;
WiredHome	96:40b74dd3695b	2993	} else {
WiredHome	96:40b74dd3695b	2994	return bad_parameter;
WiredHome	96:40b74dd3695b	2995	}
WiredHome	96:40b74dd3695b	2996	}
WiredHome	79:544eb4964795	2997
WiredHome	163:17526689a3ed	2998
WiredHome	164:76edd7d9cb68	2999
WiredHome	163:17526689a3ed	3000	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	3001	{
WiredHome	72:ecffe56af969	3002	BITMAPFILEHEADER BMP_Header;
WiredHome	72:ecffe56af969	3003	BITMAPINFOHEADER BMP_Info;
WiredHome	86:e86b355940f4	3004	uint8_t * lineBuffer = NULL;
WiredHome	86:e86b355940f4	3005	color_t * pixelBuffer = NULL;
WiredHome	86:e86b355940f4	3006	color_t * pixelBuffer2 = NULL;
WiredHome	190:3132b7dfad82	3007
WiredHome	198:9b6851107426	3008	//INFO("(%d,%d)-(%d,%d)x%d %s", x,y,w,h,bitsPerPixel,Name_BMP);
WiredHome	198:9b6851107426	3009	if (x >= 0 && x < virt_screenwidth
WiredHome	198:9b6851107426	3010	&& y >= 0 && y < virt_screenheight
WiredHome	198:9b6851107426	3011	&& w > 0 && x + w <= virt_screenwidth
WiredHome	198:9b6851107426	3012	&& h > 0 && y + h <= virt_screenheight) {
WiredHome	72:ecffe56af969	3013	BMP_Header.bfType = BF_TYPE;
WiredHome	72:ecffe56af969	3014	BMP_Header.bfReserved1 = 0;
WiredHome	72:ecffe56af969	3015	BMP_Header.bfReserved2 = 0;
WiredHome	163:17526689a3ed	3016	switch (bitsPerPixel) {
WiredHome	163:17526689a3ed	3017	case 24:
WiredHome	163:17526689a3ed	3018	BMP_Header.bfOffBits = sizeof(BMP_Header) + sizeof(BMP_Info);
WiredHome	163:17526689a3ed	3019	BMP_Header.bfSize = (h * RoundUp(w * sizeof(RGBQUAD),4)) + BMP_Header.bfOffBits;
WiredHome	163:17526689a3ed	3020	break;
WiredHome	163:17526689a3ed	3021	case 8:
WiredHome	163:17526689a3ed	3022	default:
WiredHome	163:17526689a3ed	3023	BMP_Header.bfOffBits = sizeof(BMP_Header) + sizeof(BMP_Info) + sizeof(WebColorPalette);
WiredHome	198:9b6851107426	3024	//INFO("Initial Offset to Bitstream %lX", BMP_Header.bfOffBits);
WiredHome	163:17526689a3ed	3025	//if (BMP_Header.bfOffBits & 0x03) {
WiredHome	163:17526689a3ed	3026	// BMP_Header.bfOffBits += (4 - (BMP_Header.bfOffBits & 0x03));
WiredHome	163:17526689a3ed	3027	//}
WiredHome	163:17526689a3ed	3028	BMP_Header.bfSize = (h * RoundUp(w * 1,4)) + BMP_Header.bfOffBits;
WiredHome	163:17526689a3ed	3029	break;
WiredHome	163:17526689a3ed	3030	}
WiredHome	198:9b6851107426	3031	//INFO("Offset to Bitstream %lX", BMP_Header.bfOffBits);
WiredHome	162:a2d7f1988711	3032
WiredHome	162:a2d7f1988711	3033	// Bytes in the line buffer
WiredHome	163:17526689a3ed	3034	int lineBufSize = RoundUp(((bitsPerPixel == 24) ? 3 : 1) * w, 4);
WiredHome	198:9b6851107426	3035	//INFO("LineBufSize: %d", lineBufSize);
WiredHome	73:f22a18707b5e	3036
WiredHome	72:ecffe56af969	3037	BMP_Info.biSize = sizeof(BMP_Info);
WiredHome	72:ecffe56af969	3038	BMP_Info.biWidth = w;
WiredHome	72:ecffe56af969	3039	BMP_Info.biHeight = h;
WiredHome	72:ecffe56af969	3040	BMP_Info.biPlanes = 1;
WiredHome	163:17526689a3ed	3041	BMP_Info.biBitCount = bitsPerPixel;
WiredHome	72:ecffe56af969	3042	BMP_Info.biCompression = BI_RGB;
WiredHome	162:a2d7f1988711	3043	BMP_Info.biSizeImage = lineBufSize * h;
WiredHome	72:ecffe56af969	3044	BMP_Info.biXPelsPerMeter = 0;
WiredHome	72:ecffe56af969	3045	BMP_Info.biYPelsPerMeter = 0;
WiredHome	163:17526689a3ed	3046	// for 24-bit, there is no palette, so these are zero
WiredHome	163:17526689a3ed	3047	// for 8-bit, there can be up to 256 RGB values in the palette
WiredHome	190:3132b7dfad82	3048
WiredHome	163:17526689a3ed	3049	BMP_Info.biClrUsed = (bitsPerPixel == 24) ? 0 : sizeof(WebColorPalette)/sizeof(WebColorPalette[0]); // for 8b/pixel
WiredHome	163:17526689a3ed	3050	BMP_Info.biClrImportant = BMP_Info.biClrUsed;
WiredHome	72:ecffe56af969	3051
WiredHome	86:e86b355940f4	3052	// Allocate the memory we need to proceed
WiredHome	145:5eb2492acdda	3053	lineBuffer = (uint8_t *)swMalloc(lineBufSize);
WiredHome	86:e86b355940f4	3054	if (lineBuffer == NULL) {
WiredHome	86:e86b355940f4	3055	ERR("Not enough RAM for PrintScreen lineBuffer");
WiredHome	86:e86b355940f4	3056	return(not_enough_ram);
WiredHome	86:e86b355940f4	3057	}
WiredHome	162:a2d7f1988711	3058	memset(lineBuffer, 0, lineBufSize); // zero-Fill
WiredHome	86:e86b355940f4	3059
WiredHome	86:e86b355940f4	3060	#define DOUBLEBUF /* one larger buffer instead of two */
WiredHome	190:3132b7dfad82	3061
WiredHome	86:e86b355940f4	3062	#ifdef DOUBLEBUF
WiredHome	197:853d08e2fb53	3063	// In the "#else", pixelBuffer2 malloc returns a value,
WiredHome	197:853d08e2fb53	3064	// but is actually causing a failure later.
WiredHome	86:e86b355940f4	3065	// This test helps determine if it is truly out of memory,
WiredHome	86:e86b355940f4	3066	// or if malloc is broken.
WiredHome	145:5eb2492acdda	3067	pixelBuffer = (color_t )swMalloc(2 w * sizeof(color_t));
WiredHome	182:8832d03a2a29	3068	if (pixelBuffer)
WiredHome	182:8832d03a2a29	3069	pixelBuffer2 = pixelBuffer + (w * sizeof(color_t));
WiredHome	182:8832d03a2a29	3070	else
WiredHome	182:8832d03a2a29	3071	pixelBuffer2 = NULL;
WiredHome	86:e86b355940f4	3072	#else
WiredHome	145:5eb2492acdda	3073	pixelBuffer = (color_t )swMalloc(w sizeof(color_t));
WiredHome	145:5eb2492acdda	3074	pixelBuffer2 = (color_t )swMalloc(w sizeof(color_t));
WiredHome	86:e86b355940f4	3075	#endif
WiredHome	86:e86b355940f4	3076	if (pixelBuffer == NULL \|\| pixelBuffer2 == NULL) {
WiredHome	86:e86b355940f4	3077	ERR("Not enough RAM for pixelBuffer");
WiredHome	86:e86b355940f4	3078	#ifndef DOUBLEBUF
WiredHome	86:e86b355940f4	3079	if (pixelBuffer2)
WiredHome	145:5eb2492acdda	3080	swFree(pixelBuffer2);
WiredHome	86:e86b355940f4	3081	#endif
WiredHome	86:e86b355940f4	3082	if (pixelBuffer)
WiredHome	145:5eb2492acdda	3083	swFree(pixelBuffer);
WiredHome	145:5eb2492acdda	3084	swFree(lineBuffer);
WiredHome	86:e86b355940f4	3085	return(not_enough_ram);
WiredHome	86:e86b355940f4	3086	}
WiredHome	86:e86b355940f4	3087
WiredHome	72:ecffe56af969	3088	FILE *Image = fopen(Name_BMP, "wb");
WiredHome	72:ecffe56af969	3089	if (!Image) {
WiredHome	86:e86b355940f4	3090	ERR("Can't open file for write");
WiredHome	86:e86b355940f4	3091	#ifndef DOUBLEBUF
WiredHome	86:e86b355940f4	3092	if (pixelBuffer2)
WiredHome	145:5eb2492acdda	3093	swFree(pixelBuffer2);
WiredHome	86:e86b355940f4	3094	#endif
WiredHome	86:e86b355940f4	3095	if (pixelBuffer)
WiredHome	145:5eb2492acdda	3096	swFree(pixelBuffer);
WiredHome	145:5eb2492acdda	3097	swFree(lineBuffer);
WiredHome	72:ecffe56af969	3098	return(file_not_found);
WiredHome	72:ecffe56af969	3099	}
WiredHome	72:ecffe56af969	3100
WiredHome	72:ecffe56af969	3101	// Be optimistic - don't check for errors.
WiredHome	198:9b6851107426	3102	//HexDump("BMP_Header", (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome	95:ef538bd687c0	3103	fwrite(&BMP_Header, sizeof(char), sizeof(BMP_Header), Image);
WiredHome	73:f22a18707b5e	3104
WiredHome	198:9b6851107426	3105	//HexDump("BMP_Info", (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome	95:ef538bd687c0	3106	fwrite(&BMP_Info, sizeof(char), sizeof(BMP_Info), Image);
WiredHome	190:3132b7dfad82	3107
WiredHome	163:17526689a3ed	3108	if (bitsPerPixel != 24) {
WiredHome	198:9b6851107426	3109	//HexDump("Palette", (uint8_t *)&WebColorPalette, sizeof(WebColorPalette));
WiredHome	163:17526689a3ed	3110	fwrite(&WebColorPalette, sizeof(char), sizeof(WebColorPalette), Image);
WiredHome	163:17526689a3ed	3111	if (0 && sizeof(WebColorPalette) % 4) {
WiredHome	163:17526689a3ed	3112	const uint8_t padd[] = { 0, 0, 0 };
WiredHome	190:3132b7dfad82	3113	fwrite(&padd, sizeof(char),
WiredHome	163:17526689a3ed	3114	(sizeof(BMP_Header) + sizeof(BMP_Info) + sizeof(WebColorPalette)) % 4, Image);
WiredHome	163:17526689a3ed	3115	}
WiredHome	163:17526689a3ed	3116	}
WiredHome	95:ef538bd687c0	3117	//color_t transparency = GetBackgroundTransparencyColor();
WiredHome	95:ef538bd687c0	3118	LayerMode_T ltpr0 = GetLayerMode();
WiredHome	73:f22a18707b5e	3119
WiredHome	73:f22a18707b5e	3120	uint16_t prevLayer = GetDrawingLayer();
WiredHome	73:f22a18707b5e	3121	// If only one of the layers is visible, select that layer
WiredHome	73:f22a18707b5e	3122	switch(ltpr0) {
WiredHome	95:ef538bd687c0	3123	case ShowLayer0:
WiredHome	73:f22a18707b5e	3124	SelectDrawingLayer(0);
WiredHome	73:f22a18707b5e	3125	break;
WiredHome	95:ef538bd687c0	3126	case ShowLayer1:
WiredHome	73:f22a18707b5e	3127	SelectDrawingLayer(1);
WiredHome	73:f22a18707b5e	3128	break;
WiredHome	73:f22a18707b5e	3129	default:
WiredHome	73:f22a18707b5e	3130	break;
WiredHome	73:f22a18707b5e	3131	}
WiredHome	73:f22a18707b5e	3132
WiredHome	72:ecffe56af969	3133	// Read the display from the last line toward the top
WiredHome	72:ecffe56af969	3134	// so we can write the file in one pass.
WiredHome	72:ecffe56af969	3135	for (int j = h - 1; j >= 0; j--) {
WiredHome	182:8832d03a2a29	3136	if (idle_callback && h >= 1) {
WiredHome	149:c62c4b2d6a15	3137	(idle_callback)(progress, (h - 1 - j) 100 / (h - 1));
WiredHome	149:c62c4b2d6a15	3138	}
WiredHome	149:c62c4b2d6a15	3139
WiredHome	73:f22a18707b5e	3140	if (ltpr0 >= 2) // Need to combine the layers...
WiredHome	73:f22a18707b5e	3141	SelectDrawingLayer(0); // so read layer 0 first
WiredHome	198:9b6851107426	3142
WiredHome	72:ecffe56af969	3143	// Read one line of pixels to a local buffer
WiredHome	72:ecffe56af969	3144	if (getPixelStream(pixelBuffer, w, x,y+j) != noerror) {
WiredHome	72:ecffe56af969	3145	ERR("getPixelStream error, and no recovery handler...");
WiredHome	72:ecffe56af969	3146	}
WiredHome	73:f22a18707b5e	3147	if (ltpr0 >= 2) { // Need to combine the layers...
WiredHome	86:e86b355940f4	3148	SelectDrawingLayer(1); // so read layer 1 next
WiredHome	73:f22a18707b5e	3149	if (getPixelStream(pixelBuffer2, w, x,y+j) != noerror) {
WiredHome	73:f22a18707b5e	3150	ERR("getPixelStream error, and no recovery handler...");
WiredHome	73:f22a18707b5e	3151	}
WiredHome	73:f22a18707b5e	3152	}
WiredHome	198:9b6851107426	3153	//INFO("Line: %3d", j);
WiredHome	163:17526689a3ed	3154	//HexDump("Raster", (uint8_t )pixelBuffer, w sizeof(color_t));
WiredHome	72:ecffe56af969	3155	// Convert the local buffer to RGBQUAD format
WiredHome	72:ecffe56af969	3156	int lb = 0;
WiredHome	72:ecffe56af969	3157	for (int i=0; i<w; i++) {
WiredHome	162:a2d7f1988711	3158	color_t tColor = pixelBuffer[x+i];
WiredHome	162:a2d7f1988711	3159	tColor = (tColor >> 8) \| (tColor << 8); // Byte Swap
WiredHome	162:a2d7f1988711	3160	RGBQUAD q0 = RGB16ToRGBQuad(tColor); // Scale to 24-bits
WiredHome	162:a2d7f1988711	3161	tColor = pixelBuffer2[x+i];
WiredHome	162:a2d7f1988711	3162	tColor = (tColor >> 8) \| (tColor << 8); // Byte Swap
WiredHome	162:a2d7f1988711	3163	RGBQUAD q1 = RGB16ToRGBQuad(tColor); // Scale to 24-bits
WiredHome	73:f22a18707b5e	3164	switch (ltpr0) {
WiredHome	73:f22a18707b5e	3165	case 0:
WiredHome	73:f22a18707b5e	3166	case 1:
WiredHome	73:f22a18707b5e	3167	case 2: // lighten-overlay (@TODO Not supported yet)
WiredHome	73:f22a18707b5e	3168	case 6: // Floating Windows (@TODO not sure how to support)
WiredHome	73:f22a18707b5e	3169	default: // Reserved...
WiredHome	163:17526689a3ed	3170	//lineBuffer[lb++] = q0.rgbBlue;
WiredHome	163:17526689a3ed	3171	//lineBuffer[lb++] = q0.rgbGreen;
WiredHome	163:17526689a3ed	3172	//lineBuffer[lb++] = q0.rgbRed;
WiredHome	163:17526689a3ed	3173	break;
WiredHome	163:17526689a3ed	3174	case 3: // transparent mode (@TODO Read the background color register for transparent)
WiredHome	163:17526689a3ed	3175	case 4: // boolean or
WiredHome	163:17526689a3ed	3176	q0.rgbBlue = q0.rgbBlue \| q1.rgbBlue;
WiredHome	163:17526689a3ed	3177	q0.rgbGreen = q0.rgbGreen \| q1.rgbGreen;
WiredHome	163:17526689a3ed	3178	q0.rgbRed = q0.rgbRed \| q1.rgbRed;
WiredHome	163:17526689a3ed	3179	break;
WiredHome	163:17526689a3ed	3180	case 5: // boolean AND
WiredHome	163:17526689a3ed	3181	q0.rgbBlue = q0.rgbBlue & q1.rgbBlue;
WiredHome	163:17526689a3ed	3182	q0.rgbGreen = q0.rgbGreen & q1.rgbGreen;
WiredHome	163:17526689a3ed	3183	q0.rgbRed = q0.rgbRed & q1.rgbRed;
WiredHome	163:17526689a3ed	3184	break;
WiredHome	163:17526689a3ed	3185	}
WiredHome	163:17526689a3ed	3186	switch (bitsPerPixel) {
WiredHome	163:17526689a3ed	3187	case 24:
WiredHome	73:f22a18707b5e	3188	lineBuffer[lb++] = q0.rgbBlue;
WiredHome	73:f22a18707b5e	3189	lineBuffer[lb++] = q0.rgbGreen;
WiredHome	73:f22a18707b5e	3190	lineBuffer[lb++] = q0.rgbRed;
WiredHome	73:f22a18707b5e	3191	break;
WiredHome	163:17526689a3ed	3192	case 8:
WiredHome	163:17526689a3ed	3193	default:
WiredHome	163:17526689a3ed	3194	lineBuffer[lb++] = FindNearestWebColor(q0.rgbRed,q0.rgbGreen,q0.rgbBlue);
WiredHome	73:f22a18707b5e	3195	break;
WiredHome	73:f22a18707b5e	3196	}
WiredHome	72:ecffe56af969	3197	}
WiredHome	162:a2d7f1988711	3198	//if (j == h - 1) {
WiredHome	163:17526689a3ed	3199	// HexDump("Line", lineBuffer, lineBufSize);
WiredHome	162:a2d7f1988711	3200	//}
WiredHome	72:ecffe56af969	3201	// Write to disk
WiredHome	162:a2d7f1988711	3202	fwrite(lineBuffer, sizeof(char), lineBufSize, Image);
WiredHome	72:ecffe56af969	3203	}
WiredHome	73:f22a18707b5e	3204	SelectDrawingLayer(prevLayer);
WiredHome	72:ecffe56af969	3205	fclose(Image);
WiredHome	86:e86b355940f4	3206	#ifndef DOUBLEBUF
WiredHome	86:e86b355940f4	3207	if (pixelBuffer2)
WiredHome	145:5eb2492acdda	3208	swFree(pixelBuffer2);
WiredHome	86:e86b355940f4	3209	#endif
WiredHome	86:e86b355940f4	3210	if (pixelBuffer)
WiredHome	145:5eb2492acdda	3211	swFree(pixelBuffer);
WiredHome	145:5eb2492acdda	3212	swFree(lineBuffer);
WiredHome	198:9b6851107426	3213	//INFO("Image closed");
WiredHome	72:ecffe56af969	3214	return noerror;
WiredHome	72:ecffe56af969	3215	} else {
WiredHome	72:ecffe56af969	3216	return bad_parameter;
WiredHome	72:ecffe56af969	3217	}
WiredHome	72:ecffe56af969	3218	}
WiredHome	72:ecffe56af969	3219
WiredHome	72:ecffe56af969	3220
WiredHome	72:ecffe56af969	3221	// ##########################################################################
WiredHome	72:ecffe56af969	3222	// ##########################################################################
WiredHome	72:ecffe56af969	3223	// ##########################################################################
WiredHome	72:ecffe56af969	3224
WiredHome	23:a50ded45dbaf	3225	#ifdef TESTENABLE
WiredHome	23:a50ded45dbaf	3226
WiredHome	98:ecebed9b80b2	3227	#include "BPG_Arial08x08.h"
WiredHome	98:ecebed9b80b2	3228	#include "BPG_Arial20x20.h"
WiredHome	37:f19b7e7449dc	3229
WiredHome	23:a50ded45dbaf	3230	// ______________ ______________ ______________ _______________
WiredHome	23:a50ded45dbaf	3231	// /_____ _____/ / ___________/ / ___________/ /_____ ______/
WiredHome	23:a50ded45dbaf	3232	// / / / / / / / /
WiredHome	23:a50ded45dbaf	3233	// / / / /___ / /__________ / /
WiredHome	23:a50ded45dbaf	3234	// / / / ____/ /__________ / / /
WiredHome	23:a50ded45dbaf	3235	// / / / / / / / /
WiredHome	23:a50ded45dbaf	3236	// / / / /__________ ___________/ / / /
WiredHome	23:a50ded45dbaf	3237	// /__/ /_____________/ /_____________/ /__/
WiredHome	23:a50ded45dbaf	3238	//
WiredHome	23:a50ded45dbaf	3239	// Everything from here down is test code.
WiredHome	75:ca78388cfd77	3240	//
WiredHome	41:2956a0a221e5	3241	bool SuppressSlowStuff = false;
WiredHome	23:a50ded45dbaf	3242
WiredHome	49:c5182231d1b9	3243	void TextWrapTest(RA8875 & display, Serial & pc)
WiredHome	49:c5182231d1b9	3244	{
WiredHome	49:c5182231d1b9	3245	if (!SuppressSlowStuff)
WiredHome	49:c5182231d1b9	3246	pc.printf("Text Wrap Test\r\n");
WiredHome	49:c5182231d1b9	3247	display.background(Black);
WiredHome	49:c5182231d1b9	3248	display.foreground(Blue);
WiredHome	49:c5182231d1b9	3249	display.cls();
WiredHome	49:c5182231d1b9	3250	display.Backlight_u8(255);
WiredHome	100:0b084475d5a9	3251	display.puts("Text Wrap Test.\r\n");
WiredHome	52:e6039a823420	3252	for (int i=1; i<60; i++) {
WiredHome	52:e6039a823420	3253	display.printf("L%2d\n", i % 17);
WiredHome	49:c5182231d1b9	3254	if (!SuppressSlowStuff)
WiredHome	197:853d08e2fb53	3255	wait_us(100000);
WiredHome	49:c5182231d1b9	3256	}
WiredHome	49:c5182231d1b9	3257	if (!SuppressSlowStuff)
WiredHome	197:853d08e2fb53	3258	wait_us(3000000);
WiredHome	49:c5182231d1b9	3259	}
WiredHome	49:c5182231d1b9	3260
WiredHome	75:ca78388cfd77	3261
WiredHome	75:ca78388cfd77	3262	void ShowKey(RA8875 & display, int key)
WiredHome	75:ca78388cfd77	3263	{
WiredHome	75:ca78388cfd77	3264	loc_t col, row;
WiredHome	75:ca78388cfd77	3265	dim_t r1 = 25;
WiredHome	75:ca78388cfd77	3266	color_t color = (key & 0x80) ? Red : Green;
WiredHome	75:ca78388cfd77	3267
WiredHome	75:ca78388cfd77	3268	key &= 0x7F; // remove the long-press flag
WiredHome	75:ca78388cfd77	3269	row = (key - 1) / 5;
WiredHome	75:ca78388cfd77	3270	col = (key - 1) % 5;
WiredHome	75:ca78388cfd77	3271	if (col > 5) col = 5;
WiredHome	75:ca78388cfd77	3272	if (row > 4) row = 4;
WiredHome	75:ca78388cfd77	3273	display.circle(450 - + (2 * r1) * col, 200 - (2 * r1) * row, r1-2, color, FILL);
WiredHome	75:ca78388cfd77	3274	}
WiredHome	75:ca78388cfd77	3275
WiredHome	75:ca78388cfd77	3276	void HideKey(RA8875 & display, int key)
WiredHome	75:ca78388cfd77	3277	{
WiredHome	75:ca78388cfd77	3278	loc_t col, row;
WiredHome	75:ca78388cfd77	3279	dim_t r1 = 25;
WiredHome	75:ca78388cfd77	3280
WiredHome	75:ca78388cfd77	3281	row = (key - 1) / 5;
WiredHome	75:ca78388cfd77	3282	col = (key - 1) % 5;
WiredHome	75:ca78388cfd77	3283	if (col > 5) col = 5;
WiredHome	75:ca78388cfd77	3284	if (row > 4) row = 4;
WiredHome	75:ca78388cfd77	3285	display.background(Black);
WiredHome	75:ca78388cfd77	3286	display.circle(450 - (2 * r1) * col, 200 - (2 * r1) * row, r1-2, Black, FILL);
WiredHome	75:ca78388cfd77	3287	display.circle(450 - (2 * r1) * col, 200 - (2 * r1) * row, r1-2, Blue);
WiredHome	75:ca78388cfd77	3288	}
WiredHome	75:ca78388cfd77	3289
WiredHome	75:ca78388cfd77	3290	void KeyPadTest(RA8875 & display, Serial & pc)
WiredHome	75:ca78388cfd77	3291	{
WiredHome	75:ca78388cfd77	3292	const uint8_t myMap[22] = {
WiredHome	77:9206c13aa527	3293	0,
WiredHome	75:ca78388cfd77	3294	'a', 'b', 'c', 'd', 'e',
WiredHome	75:ca78388cfd77	3295	'f', 'g', 'h', 'i', 'j',
WiredHome	75:ca78388cfd77	3296	'k', 'l', 'm', 'n', 'o',
WiredHome	75:ca78388cfd77	3297	'p', 'q', 'r', 's', 't',
WiredHome	75:ca78388cfd77	3298	'x'
WiredHome	75:ca78388cfd77	3299	};
WiredHome	77:9206c13aa527	3300
WiredHome	75:ca78388cfd77	3301	display.background(Black);
WiredHome	75:ca78388cfd77	3302	display.foreground(Blue);
WiredHome	75:ca78388cfd77	3303	display.cls();
WiredHome	75:ca78388cfd77	3304	display.Backlight_u8(255);
WiredHome	100:0b084475d5a9	3305	display.puts("KeyPad Test. Touch the keypad...");
WiredHome	75:ca78388cfd77	3306	pc.printf("\r\n"
WiredHome	75:ca78388cfd77	3307	"Raw KeyPad Test. Keypad returns the key-number.\r\n"
WiredHome	75:ca78388cfd77	3308	"Press [most] any PC keyboard key to advance to next test.\r\n");
WiredHome	75:ca78388cfd77	3309	RetCode_t ret = display.KeypadInit(true, true, 3, 7, 3);
WiredHome	75:ca78388cfd77	3310	if (ret != noerror)
WiredHome	75:ca78388cfd77	3311	pc.printf("returncode from KeypadInit is %d\r\n", ret);
WiredHome	75:ca78388cfd77	3312	int lastKey = 0;
WiredHome	75:ca78388cfd77	3313	while (!pc.readable()) {
WiredHome	75:ca78388cfd77	3314	if (display.readable()) {
WiredHome	75:ca78388cfd77	3315	int key = display.getc();
WiredHome	75:ca78388cfd77	3316	if (key) {
WiredHome	75:ca78388cfd77	3317	if (((key & 0x7F) != lastKey) && (lastKey != 0))
WiredHome	75:ca78388cfd77	3318	HideKey(display, lastKey);
WiredHome	75:ca78388cfd77	3319	ShowKey(display, key);
WiredHome	75:ca78388cfd77	3320	lastKey = key & 0x7F;
WiredHome	75:ca78388cfd77	3321	} else {
WiredHome	75:ca78388cfd77	3322	// erase the last one
WiredHome	75:ca78388cfd77	3323	if (lastKey)
WiredHome	75:ca78388cfd77	3324	HideKey(display, lastKey);
WiredHome	75:ca78388cfd77	3325	}
WiredHome	75:ca78388cfd77	3326	}
WiredHome	75:ca78388cfd77	3327	}
WiredHome	75:ca78388cfd77	3328	(void)pc.getc();
WiredHome	75:ca78388cfd77	3329	pc.printf("\r\n"
WiredHome	75:ca78388cfd77	3330	"Map KeyPad Test. Keypad returns the remapped key 'a' - 't'.\r\n"
WiredHome	75:ca78388cfd77	3331	"Press [most] any PC keyboard key to advance to exit test.\r\n");
WiredHome	75:ca78388cfd77	3332	display.SetKeyMap(myMap);
WiredHome	75:ca78388cfd77	3333	while (!pc.readable()) {
WiredHome	75:ca78388cfd77	3334	if (display.readable()) {
WiredHome	75:ca78388cfd77	3335	int key = display.getc();
WiredHome	75:ca78388cfd77	3336	bool longPress = key & 0x80;
WiredHome	75:ca78388cfd77	3337	display.SetTextCursor(0, 120);
WiredHome	75:ca78388cfd77	3338	display.printf("Long Press: %d\r\n", longPress);
WiredHome	75:ca78388cfd77	3339	display.printf(" Remapped: %c %02X\r\n", (key) ? key & 0x7F : ' ', key);
WiredHome	75:ca78388cfd77	3340	}
WiredHome	75:ca78388cfd77	3341	}
WiredHome	75:ca78388cfd77	3342	(void)pc.getc();
WiredHome	75:ca78388cfd77	3343	display.SetKeyMap();
WiredHome	75:ca78388cfd77	3344	pc.printf("\r\n");
WiredHome	75:ca78388cfd77	3345	}
WiredHome	75:ca78388cfd77	3346
WiredHome	23:a50ded45dbaf	3347	void TextCursorTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3348	{
WiredHome	75:ca78388cfd77	3349	const char * iCursor = "The I-Beam cursor should be visible for this text.\r\n";
WiredHome	75:ca78388cfd77	3350	const char * uCursor = "The Underscore cursor should be visible for this text.\r\n";
WiredHome	75:ca78388cfd77	3351	const char * bCursor = "The Block cursor should be visible for this text.\r\n";
WiredHome	37:f19b7e7449dc	3352	const char * bbCursor = "The Blinking Block cursor should be visible for this text.\r\n";
WiredHome	23:a50ded45dbaf	3353	const char * p;
WiredHome	100:0b084475d5a9	3354	int delay = 60;
WiredHome	73:f22a18707b5e	3355
WiredHome	41:2956a0a221e5	3356	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3357	pc.printf("Text Cursor Test\r\n");
WiredHome	73:f22a18707b5e	3358	else
WiredHome	41:2956a0a221e5	3359	delay = 0;
WiredHome	23:a50ded45dbaf	3360	display.background(Black);
WiredHome	23:a50ded45dbaf	3361	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3362	display.cls();
WiredHome	25:9556a3a9b7cc	3363	display.Backlight_u8(255);
WiredHome	100:0b084475d5a9	3364	display.puts("Text Cursor Test.");
WiredHome	73:f22a18707b5e	3365
WiredHome	23:a50ded45dbaf	3366	// visible, non-blinking
WiredHome	24:8ca861acf12d	3367	display.SetTextCursor(0,20);
WiredHome	53:86d24b9480b9	3368	display.SetTextCursorControl(RA8875::IBEAM, false);
WiredHome	24:8ca861acf12d	3369	p = iCursor;
WiredHome	23:a50ded45dbaf	3370	while (*p) {
WiredHome	24:8ca861acf12d	3371	display._putc(*p++);
WiredHome	41:2956a0a221e5	3372	wait_ms(delay);
WiredHome	24:8ca861acf12d	3373	}
WiredHome	24:8ca861acf12d	3374
WiredHome	53:86d24b9480b9	3375	display.SetTextCursorControl(RA8875::UNDER, false);
WiredHome	24:8ca861acf12d	3376	p = uCursor;
WiredHome	24:8ca861acf12d	3377	while (*p) {
WiredHome	24:8ca861acf12d	3378	display._putc(*p++);
WiredHome	41:2956a0a221e5	3379	wait_ms(delay);
WiredHome	23:a50ded45dbaf	3380	}
WiredHome	73:f22a18707b5e	3381
WiredHome	53:86d24b9480b9	3382	display.SetTextCursorControl(RA8875::BLOCK, false);
WiredHome	24:8ca861acf12d	3383	p = bCursor;
WiredHome	24:8ca861acf12d	3384	while (*p) {
WiredHome	24:8ca861acf12d	3385	display._putc(*p++);
WiredHome	41:2956a0a221e5	3386	wait_ms(delay);
WiredHome	24:8ca861acf12d	3387	}
WiredHome	24:8ca861acf12d	3388
WiredHome	53:86d24b9480b9	3389	display.SetTextCursorControl(RA8875::BLOCK, true);
WiredHome	24:8ca861acf12d	3390	p = bbCursor;
WiredHome	24:8ca861acf12d	3391	while (*p) {
WiredHome	24:8ca861acf12d	3392	display._putc(*p++);
WiredHome	41:2956a0a221e5	3393	wait_ms(delay);
WiredHome	24:8ca861acf12d	3394	}
WiredHome	41:2956a0a221e5	3395	wait_ms(delay * 20);
WiredHome	53:86d24b9480b9	3396	display.SetTextCursorControl(RA8875::NOCURSOR, false);
WiredHome	23:a50ded45dbaf	3397	}
WiredHome	23:a50ded45dbaf	3398
WiredHome	44:207594dece70	3399
WiredHome	23:a50ded45dbaf	3400	void BacklightTest(RA8875 & display, Serial & pc, float ramptime)
WiredHome	23:a50ded45dbaf	3401	{
WiredHome	29:422616aa04bd	3402	char buf[60];
WiredHome	41:2956a0a221e5	3403	unsigned int w = (ramptime * 1000)/ 256;
WiredHome	41:2956a0a221e5	3404	int delay = 200;
WiredHome	41:2956a0a221e5	3405
WiredHome	41:2956a0a221e5	3406	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3407	pc.printf("Backlight Test - ramp over %f sec.\r\n", ramptime);
WiredHome	41:2956a0a221e5	3408	else {
WiredHome	41:2956a0a221e5	3409	delay = 0;
WiredHome	41:2956a0a221e5	3410	w = 0;
WiredHome	41:2956a0a221e5	3411	}
WiredHome	23:a50ded45dbaf	3412	display.Backlight_u8(0);
WiredHome	29:422616aa04bd	3413	display.background(White);
WiredHome	23:a50ded45dbaf	3414	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3415	display.cls();
WiredHome	100:0b084475d5a9	3416	display.puts("RA8875 Backlight Test - Ramp up.");
WiredHome	41:2956a0a221e5	3417	wait_ms(delay);
WiredHome	38:38d503b4fad6	3418	for (int i=0; i <= 255; i++) {
WiredHome	182:8832d03a2a29	3419	snprintf(buf, sizeof(buf), "%3d, %4u", i, w);
WiredHome	37:f19b7e7449dc	3420	display.puts(100,100,buf);
WiredHome	23:a50ded45dbaf	3421	display.Backlight_u8(i);
WiredHome	29:422616aa04bd	3422	wait_ms(w);
WiredHome	23:a50ded45dbaf	3423	}
WiredHome	23:a50ded45dbaf	3424	}
WiredHome	23:a50ded45dbaf	3425
WiredHome	44:207594dece70	3426
WiredHome	23:a50ded45dbaf	3427	void BacklightTest2(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3428	{
WiredHome	41:2956a0a221e5	3429	int delay = 20;
WiredHome	41:2956a0a221e5	3430
WiredHome	41:2956a0a221e5	3431	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3432	pc.printf("Backlight Test 2\r\n");
WiredHome	41:2956a0a221e5	3433	else
WiredHome	41:2956a0a221e5	3434	delay = 0;
WiredHome	41:2956a0a221e5	3435
WiredHome	23:a50ded45dbaf	3436	// Dim it out at the end of the tests.
WiredHome	37:f19b7e7449dc	3437	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3438	display.puts(0,0, "Ramp Backlight down.");
WiredHome	23:a50ded45dbaf	3439	// Ramp it off
WiredHome	23:a50ded45dbaf	3440	for (int i=255; i != 0; i--) {
WiredHome	23:a50ded45dbaf	3441	display.Backlight_u8(i);
WiredHome	41:2956a0a221e5	3442	wait_ms(delay);
WiredHome	23:a50ded45dbaf	3443	}
WiredHome	23:a50ded45dbaf	3444	display.Backlight_u8(0);
WiredHome	23:a50ded45dbaf	3445	}
WiredHome	23:a50ded45dbaf	3446
WiredHome	44:207594dece70	3447
WiredHome	23:a50ded45dbaf	3448	void ExternalFontTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3449	{
WiredHome	41:2956a0a221e5	3450	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3451	pc.printf("External Font Test\r\n");
WiredHome	23:a50ded45dbaf	3452	display.background(Black);
WiredHome	23:a50ded45dbaf	3453	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3454	display.cls();
WiredHome	100:0b084475d5a9	3455	display.puts("External Font Test.");
WiredHome	23:a50ded45dbaf	3456	display.Backlight(1);
WiredHome	37:f19b7e7449dc	3457
WiredHome	98:ecebed9b80b2	3458	display.SelectUserFont(BPG_Arial08x08);
WiredHome	73:f22a18707b5e	3459	display.puts(0,30, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\r\n");
WiredHome	37:f19b7e7449dc	3460
WiredHome	98:ecebed9b80b2	3461	display.SelectUserFont(BPG_Arial20x20);
WiredHome	37:f19b7e7449dc	3462	display.puts("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\r\n");
WiredHome	190:3132b7dfad82	3463
WiredHome	98:ecebed9b80b2	3464	display.SelectUserFont();
WiredHome	73:f22a18707b5e	3465
WiredHome	37:f19b7e7449dc	3466	display.puts("Normal font again.");
WiredHome	37:f19b7e7449dc	3467	//display.window(0,0, display.width(), display.height());
WiredHome	23:a50ded45dbaf	3468	}
WiredHome	23:a50ded45dbaf	3469
WiredHome	44:207594dece70	3470
WiredHome	23:a50ded45dbaf	3471	void DOSColorTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3472	{
WiredHome	41:2956a0a221e5	3473	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3474	pc.printf("DOS Color Test\r\n");
WiredHome	23:a50ded45dbaf	3475	display.background(Black);
WiredHome	23:a50ded45dbaf	3476	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3477	display.cls();
WiredHome	100:0b084475d5a9	3478	display.puts("DOS Colors - Fore");
WiredHome	23:a50ded45dbaf	3479	display.puts(280,0, "Back");
WiredHome	23:a50ded45dbaf	3480	display.background(Gray);
WiredHome	23:a50ded45dbaf	3481	for (int i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	3482	display.foreground(display.DOSColor(i));
WiredHome	23:a50ded45dbaf	3483	display.puts(160, i*16, display.DOSColorNames(i));
WiredHome	23:a50ded45dbaf	3484	display.background(Black);
WiredHome	23:a50ded45dbaf	3485	}
WiredHome	23:a50ded45dbaf	3486	display.foreground(White);
WiredHome	23:a50ded45dbaf	3487	for (int i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	3488	display.background(display.DOSColor(i));
WiredHome	23:a50ded45dbaf	3489	display.puts(360, i*16, display.DOSColorNames(i));
WiredHome	23:a50ded45dbaf	3490	display.foreground(White);
WiredHome	23:a50ded45dbaf	3491	}
WiredHome	23:a50ded45dbaf	3492	}
WiredHome	23:a50ded45dbaf	3493
WiredHome	44:207594dece70	3494
WiredHome	23:a50ded45dbaf	3495	void WebColorTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3496	{
WiredHome	41:2956a0a221e5	3497	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3498	pc.printf("Web Color Test\r\n");
WiredHome	23:a50ded45dbaf	3499	display.background(Black);
WiredHome	23:a50ded45dbaf	3500	display.foreground(Blue);
WiredHome	32:0e4f2ae512e2	3501	display.window(0,0, display.width(), display.height());
WiredHome	23:a50ded45dbaf	3502	display.cls();
WiredHome	59:fb40aad4efd4	3503	display.SetTextFontSize(1,1);
WiredHome	59:fb40aad4efd4	3504	display.puts(200,0, "Web Color Test");
WiredHome	59:fb40aad4efd4	3505	display.SetTextCursor(0,0);
WiredHome	59:fb40aad4efd4	3506	display.puts(" ");
WiredHome	59:fb40aad4efd4	3507	for (int i=0; i<16; i++)
WiredHome	59:fb40aad4efd4	3508	display.printf("%X", i&0xF);
WiredHome	59:fb40aad4efd4	3509	display.puts("\r\n0 ");
WiredHome	23:a50ded45dbaf	3510	for (int i=0; i<sizeof(WebColors)/sizeof(WebColors[0]); i++) {
WiredHome	23:a50ded45dbaf	3511	display.background(WebColors[i]);
WiredHome	23:a50ded45dbaf	3512	display.puts(" ");
WiredHome	59:fb40aad4efd4	3513	if (i % 16 == 15 && i < 255) {
WiredHome	59:fb40aad4efd4	3514	display.printf("\r\n%X ", ((i+1)/16));
WiredHome	59:fb40aad4efd4	3515	}
WiredHome	23:a50ded45dbaf	3516	}
WiredHome	23:a50ded45dbaf	3517	display.SetTextFontSize(1,1);
WiredHome	23:a50ded45dbaf	3518	}
WiredHome	23:a50ded45dbaf	3519
WiredHome	44:207594dece70	3520
WiredHome	37:f19b7e7449dc	3521	void PixelTest(RA8875 & display, Serial & pc)
WiredHome	37:f19b7e7449dc	3522	{
WiredHome	37:f19b7e7449dc	3523	int i, c, x, y;
WiredHome	37:f19b7e7449dc	3524
WiredHome	41:2956a0a221e5	3525	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3526	pc.printf("Pixel Test\r\n");
WiredHome	37:f19b7e7449dc	3527	display.background(Black);
WiredHome	37:f19b7e7449dc	3528	display.foreground(Blue);
WiredHome	37:f19b7e7449dc	3529	display.cls();
WiredHome	100:0b084475d5a9	3530	display.puts("Pixel Test");
WiredHome	37:f19b7e7449dc	3531	for (i=0; i<1000; i++) {
WiredHome	37:f19b7e7449dc	3532	x = rand() % 480;
WiredHome	37:f19b7e7449dc	3533	y = 16 + rand() % (272-16);
WiredHome	37:f19b7e7449dc	3534	c = rand() % 16;
WiredHome	37:f19b7e7449dc	3535	//pc.printf(" (%d,%d) - %d\r\n", x,y,r1);
WiredHome	37:f19b7e7449dc	3536	display.pixel(x,y, display.DOSColor(c));
WiredHome	37:f19b7e7449dc	3537	}
WiredHome	37:f19b7e7449dc	3538	}
WiredHome	37:f19b7e7449dc	3539
WiredHome	44:207594dece70	3540
WiredHome	23:a50ded45dbaf	3541	void LineTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3542	{
WiredHome	23:a50ded45dbaf	3543	int i, x, y, x2, y2;
WiredHome	23:a50ded45dbaf	3544
WiredHome	41:2956a0a221e5	3545	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3546	pc.printf("Line Test\r\n");
WiredHome	23:a50ded45dbaf	3547	display.background(Black);
WiredHome	23:a50ded45dbaf	3548	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3549	display.cls();
WiredHome	100:0b084475d5a9	3550	display.puts("Line Test");
WiredHome	23:a50ded45dbaf	3551	for (i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	3552	// Lines
WiredHome	23:a50ded45dbaf	3553	x = rand() % 480;
WiredHome	23:a50ded45dbaf	3554	y = rand() % 272;
WiredHome	23:a50ded45dbaf	3555	x2 = rand() % 480;
WiredHome	23:a50ded45dbaf	3556	y2 = rand() % 272;
WiredHome	23:a50ded45dbaf	3557	display.line(x,y, x2,y2, display.DOSColor(i));
WiredHome	23:a50ded45dbaf	3558	}
WiredHome	62:ba5d33438fda	3559	display.foreground(BrightRed);
WiredHome	62:ba5d33438fda	3560	display.foreground(BrightGreen);
WiredHome	62:ba5d33438fda	3561	display.foreground(BrightBlue);
WiredHome	62:ba5d33438fda	3562	display.line(55,50, 79,74, BrightRed);
WiredHome	62:ba5d33438fda	3563	display.line(57,50, 81,74, BrightGreen);
WiredHome	62:ba5d33438fda	3564	display.line(59,50, 83,74, BrightBlue);
WiredHome	62:ba5d33438fda	3565	// horz
WiredHome	62:ba5d33438fda	3566	display.line(30,40, 32,40, BrightRed);
WiredHome	62:ba5d33438fda	3567	display.line(30,42, 32,42, BrightGreen);
WiredHome	62:ba5d33438fda	3568	display.line(30,44, 32,44, BrightBlue);
WiredHome	62:ba5d33438fda	3569	// vert
WiredHome	62:ba5d33438fda	3570	display.line(20,40, 20,42, BrightRed);
WiredHome	62:ba5d33438fda	3571	display.line(22,40, 22,42, BrightGreen);
WiredHome	62:ba5d33438fda	3572	display.line(24,40, 24,42, BrightBlue);
WiredHome	62:ba5d33438fda	3573	// compare point to line-point
WiredHome	62:ba5d33438fda	3574	display.pixel(20,50, BrightRed);
WiredHome	62:ba5d33438fda	3575	display.pixel(22,50, BrightGreen);
WiredHome	62:ba5d33438fda	3576	display.pixel(24,50, BrightBlue);
WiredHome	62:ba5d33438fda	3577	display.line(20,52, 20,52, BrightRed);
WiredHome	62:ba5d33438fda	3578	display.line(22,52, 22,52, BrightGreen);
WiredHome	62:ba5d33438fda	3579	display.line(24,52, 24,52, BrightBlue);
WiredHome	73:f22a18707b5e	3580
WiredHome	62:ba5d33438fda	3581	// point
WiredHome	62:ba5d33438fda	3582	display.line(50,50, 50,50, Red);
WiredHome	62:ba5d33438fda	3583	display.line(52,52, 52,52, Green);
WiredHome	62:ba5d33438fda	3584	display.line(54,54, 54,54, Blue);
WiredHome	62:ba5d33438fda	3585	display.line(60,60, 60,60, BrightRed);
WiredHome	62:ba5d33438fda	3586	display.line(62,62, 62,62, BrightGreen);
WiredHome	62:ba5d33438fda	3587	display.line(64,64, 64,64, BrightBlue);
WiredHome	62:ba5d33438fda	3588	display.line(70,70, 70,70, DarkRed);
WiredHome	62:ba5d33438fda	3589	display.line(72,72, 72,72, DarkGreen);
WiredHome	62:ba5d33438fda	3590	display.line(74,74, 74,74, DarkBlue);
WiredHome	23:a50ded45dbaf	3591	}
WiredHome	23:a50ded45dbaf	3592
WiredHome	44:207594dece70	3593
WiredHome	23:a50ded45dbaf	3594	void RectangleTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3595	{
WiredHome	23:a50ded45dbaf	3596	int i, x1,y1, x2,y2;
WiredHome	23:a50ded45dbaf	3597
WiredHome	41:2956a0a221e5	3598	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3599	pc.printf("Rectangle Test\r\n");
WiredHome	23:a50ded45dbaf	3600	display.background(Black);
WiredHome	23:a50ded45dbaf	3601	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3602	display.cls();
WiredHome	100:0b084475d5a9	3603	display.puts("Rectangle Test");
WiredHome	23:a50ded45dbaf	3604	for (i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	3605	x1 = rand() % 240;
WiredHome	23:a50ded45dbaf	3606	y1 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3607	x2 = rand() % 240;
WiredHome	23:a50ded45dbaf	3608	y2 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3609	display.rect(x1,y1, x2,y2, display.DOSColor(i));
WiredHome	23:a50ded45dbaf	3610
WiredHome	23:a50ded45dbaf	3611	x1 = 240 + rand() % 240;
WiredHome	23:a50ded45dbaf	3612	y1 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3613	x2 = 240 + rand() % 240;
WiredHome	23:a50ded45dbaf	3614	y2 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3615	display.rect(x1,y1, x2,y2, FILL);
WiredHome	23:a50ded45dbaf	3616	}
WiredHome	23:a50ded45dbaf	3617	}
WiredHome	23:a50ded45dbaf	3618
WiredHome	44:207594dece70	3619
WiredHome	44:207594dece70	3620	void LayerTest(RA8875 & display, Serial & pc)
WiredHome	44:207594dece70	3621	{
WiredHome	44:207594dece70	3622	loc_t i, x1,y1, x2,y2, r1,r2;
WiredHome	44:207594dece70	3623
WiredHome	44:207594dece70	3624	if (!SuppressSlowStuff)
WiredHome	44:207594dece70	3625	pc.printf("Layer Test\r\n");
WiredHome	44:207594dece70	3626
WiredHome	50:2c4f474a2453	3627	display.SelectDrawingLayer(0);
WiredHome	44:207594dece70	3628	display.background(Black);
WiredHome	44:207594dece70	3629	display.foreground(Blue);
WiredHome	44:207594dece70	3630	display.cls();
WiredHome	100:0b084475d5a9	3631	display.puts("Layer 0");
WiredHome	44:207594dece70	3632	for (i=0; i<16; i++) {
WiredHome	44:207594dece70	3633	x1 = rand() % 240;
WiredHome	44:207594dece70	3634	y1 = 50 + rand() % 200;
WiredHome	44:207594dece70	3635	x2 = x1 + rand() % 100;
WiredHome	44:207594dece70	3636	y2 = y1 + rand() % 100;
WiredHome	44:207594dece70	3637	r1 = rand() % (x2 - x1)/2;
WiredHome	44:207594dece70	3638	r2 = rand() % (y2 - y1)/2;
WiredHome	44:207594dece70	3639	display.roundrect(x1,y1, x2,y2, r1,r2, display.DOSColor(i));
WiredHome	44:207594dece70	3640	if (!SuppressSlowStuff)
WiredHome	197:853d08e2fb53	3641	wait_us(20000);
WiredHome	44:207594dece70	3642	}
WiredHome	44:207594dece70	3643	if (!SuppressSlowStuff)
WiredHome	197:853d08e2fb53	3644	wait_us(1000000);
WiredHome	44:207594dece70	3645
WiredHome	50:2c4f474a2453	3646	display.SelectDrawingLayer(1);
WiredHome	44:207594dece70	3647	display.background(Black);
WiredHome	44:207594dece70	3648	display.foreground(Yellow);
WiredHome	44:207594dece70	3649	display.cls();
WiredHome	44:207594dece70	3650	display.puts(240,0, "Layer 1");
WiredHome	44:207594dece70	3651	for (i=0; i<16; i++) {
WiredHome	44:207594dece70	3652	x1 = 300 + rand() % 100;
WiredHome	44:207594dece70	3653	y1 = 70 + rand() % 200;
WiredHome	202:a22cbc04f332	3654	r1 = rand() % RAmin(y1 - 20, 100);
WiredHome	44:207594dece70	3655	display.circle(x1,y1,r1, display.DOSColor(i));
WiredHome	44:207594dece70	3656	if (!SuppressSlowStuff)
WiredHome	197:853d08e2fb53	3657	wait_us(20000);
WiredHome	44:207594dece70	3658	}
WiredHome	56:7a85d226ad0d	3659	display.SetLayerMode(RA8875::ShowLayer1); // Show it after the build-up
WiredHome	44:207594dece70	3660	if (!SuppressSlowStuff)
WiredHome	197:853d08e2fb53	3661	wait_us(2000000);
WiredHome	44:207594dece70	3662
WiredHome	50:2c4f474a2453	3663	display.SelectDrawingLayer(0);
WiredHome	56:7a85d226ad0d	3664	display.SetLayerMode(RA8875::ShowLayer0); // Show Layer 0 again
WiredHome	44:207594dece70	3665	if (!SuppressSlowStuff)
WiredHome	197:853d08e2fb53	3666	wait_us(1000000);
WiredHome	53:86d24b9480b9	3667	display.SetLayerMode(RA8875::TransparentMode); // Transparent mode
WiredHome	44:207594dece70	3668	if (!SuppressSlowStuff)
WiredHome	197:853d08e2fb53	3669	wait_us(1000000);
WiredHome	44:207594dece70	3670	for (i=0; i<=8; i++) {
WiredHome	44:207594dece70	3671	display.SetLayerTransparency(i, 8-i);
WiredHome	44:207594dece70	3672	if (!SuppressSlowStuff)
WiredHome	197:853d08e2fb53	3673	wait_us(200000);
WiredHome	44:207594dece70	3674	}
WiredHome	73:f22a18707b5e	3675
WiredHome	44:207594dece70	3676	// Restore before we exit
WiredHome	44:207594dece70	3677	display.SetLayerTransparency(0, 0);
WiredHome	56:7a85d226ad0d	3678	display.SetLayerMode(RA8875::ShowLayer0); // Restore to layer 0
WiredHome	44:207594dece70	3679	}
WiredHome	44:207594dece70	3680
WiredHome	44:207594dece70	3681
WiredHome	23:a50ded45dbaf	3682	void RoundRectTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3683	{
WiredHome	37:f19b7e7449dc	3684	loc_t i, x1,y1, x2,y2, r1,r2;
WiredHome	23:a50ded45dbaf	3685
WiredHome	41:2956a0a221e5	3686	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3687	pc.printf("Round Rectangle Test\r\n");
WiredHome	23:a50ded45dbaf	3688	display.background(Black);
WiredHome	23:a50ded45dbaf	3689	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3690	display.cls();
WiredHome	100:0b084475d5a9	3691	display.puts("Rounded Rectangle Test");
WiredHome	73:f22a18707b5e	3692
WiredHome	23:a50ded45dbaf	3693	for (i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	3694	x1 = rand() % 240;
WiredHome	23:a50ded45dbaf	3695	y1 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3696	x2 = x1 + rand() % 100;
WiredHome	23:a50ded45dbaf	3697	y2 = y1 + rand() % 100;
WiredHome	23:a50ded45dbaf	3698	r1 = rand() % (x2 - x1)/2;
WiredHome	23:a50ded45dbaf	3699	r2 = rand() % (y2 - y1)/2;
WiredHome	23:a50ded45dbaf	3700	display.roundrect(x1,y1, x2,y2, 5,8, display.DOSColor(i));
WiredHome	23:a50ded45dbaf	3701
WiredHome	23:a50ded45dbaf	3702	x1 = 240 + rand() % 240;
WiredHome	23:a50ded45dbaf	3703	y1 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3704	x2 = x1 + rand() % 100;
WiredHome	23:a50ded45dbaf	3705	y2 = y1 + rand() % 100;
WiredHome	23:a50ded45dbaf	3706	r1 = rand() % (x2 - x1)/2;
WiredHome	23:a50ded45dbaf	3707	r2 = rand() % (y2 - y1)/2;
WiredHome	23:a50ded45dbaf	3708	display.roundrect(x1,y1, x2,y2, r1,r2, FILL);
WiredHome	23:a50ded45dbaf	3709	}
WiredHome	23:a50ded45dbaf	3710	}
WiredHome	23:a50ded45dbaf	3711
WiredHome	44:207594dece70	3712
WiredHome	23:a50ded45dbaf	3713	void TriangleTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3714	{
WiredHome	23:a50ded45dbaf	3715	int i, x1, y1, x2, y2, x3, y3;
WiredHome	23:a50ded45dbaf	3716
WiredHome	41:2956a0a221e5	3717	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3718	pc.printf("Triangle Test\r\n");
WiredHome	23:a50ded45dbaf	3719	display.background(Black);
WiredHome	23:a50ded45dbaf	3720	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3721	display.cls();
WiredHome	23:a50ded45dbaf	3722	display.puts(0,0, "Triangle Test");
WiredHome	23:a50ded45dbaf	3723
WiredHome	23:a50ded45dbaf	3724	x1 = 150;
WiredHome	23:a50ded45dbaf	3725	y1 = 2;
WiredHome	23:a50ded45dbaf	3726	x2 = 190;
WiredHome	23:a50ded45dbaf	3727	y2 = 7;
WiredHome	23:a50ded45dbaf	3728	x3 = 170;
WiredHome	23:a50ded45dbaf	3729	y3 = 16;
WiredHome	23:a50ded45dbaf	3730	display.triangle(x1,y1, x2,y2, x3,y3);
WiredHome	23:a50ded45dbaf	3731
WiredHome	23:a50ded45dbaf	3732	x1 = 200;
WiredHome	23:a50ded45dbaf	3733	y1 = 2;
WiredHome	23:a50ded45dbaf	3734	x2 = 240;
WiredHome	23:a50ded45dbaf	3735	y2 = 7;
WiredHome	23:a50ded45dbaf	3736	x3 = 220;
WiredHome	23:a50ded45dbaf	3737	y3 = 16;
WiredHome	23:a50ded45dbaf	3738	display.filltriangle(x1,y1, x2,y2, x3,y3, BrightRed);
WiredHome	23:a50ded45dbaf	3739
WiredHome	23:a50ded45dbaf	3740	x1 = 300;
WiredHome	23:a50ded45dbaf	3741	y1 = 2;
WiredHome	23:a50ded45dbaf	3742	x2 = 340;
WiredHome	23:a50ded45dbaf	3743	y2 = 7;
WiredHome	23:a50ded45dbaf	3744	x3 = 320;
WiredHome	23:a50ded45dbaf	3745	y3 = 16;
WiredHome	23:a50ded45dbaf	3746	display.triangle(x1,y1, x2,y2, x3,y3, NOFILL);
WiredHome	23:a50ded45dbaf	3747
WiredHome	23:a50ded45dbaf	3748	x1 = 400;
WiredHome	23:a50ded45dbaf	3749	y1 = 2;
WiredHome	23:a50ded45dbaf	3750	x2 = 440;
WiredHome	23:a50ded45dbaf	3751	y2 = 7;
WiredHome	23:a50ded45dbaf	3752	x3 = 420;
WiredHome	23:a50ded45dbaf	3753	y3 = 16;
WiredHome	23:a50ded45dbaf	3754	display.triangle(x1,y1, x2,y2, x3,y3, Blue);
WiredHome	23:a50ded45dbaf	3755
WiredHome	23:a50ded45dbaf	3756	for (i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	3757	x1 = rand() % 240;
WiredHome	23:a50ded45dbaf	3758	y1 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3759	x2 = rand() % 240;
WiredHome	23:a50ded45dbaf	3760	y2 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3761	x3 = rand() % 240;
WiredHome	23:a50ded45dbaf	3762	y3 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3763	display.triangle(x1,y1, x2,y2, x3,y3, display.DOSColor(i));
WiredHome	23:a50ded45dbaf	3764	x1 = 240 + rand() % 240;
WiredHome	23:a50ded45dbaf	3765	y1 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3766	x2 = 240 + rand() % 240;
WiredHome	23:a50ded45dbaf	3767	y2 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3768	x3 = 240 + rand() % 240;
WiredHome	23:a50ded45dbaf	3769	y3 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	3770	display.triangle(x1,y1, x2,y2, x3,y3, FILL);
WiredHome	23:a50ded45dbaf	3771	}
WiredHome	23:a50ded45dbaf	3772	}
WiredHome	23:a50ded45dbaf	3773
WiredHome	44:207594dece70	3774
WiredHome	23:a50ded45dbaf	3775	void CircleTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3776	{
WiredHome	23:a50ded45dbaf	3777	int i, x, y, r1;
WiredHome	23:a50ded45dbaf	3778
WiredHome	41:2956a0a221e5	3779	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3780	pc.printf("Circle Test\r\n");
WiredHome	23:a50ded45dbaf	3781	display.background(Black);
WiredHome	23:a50ded45dbaf	3782	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3783	display.cls();
WiredHome	100:0b084475d5a9	3784	display.puts("Circle Test");
WiredHome	23:a50ded45dbaf	3785	for (i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	3786	x = 100 + rand() % 100;
WiredHome	23:a50ded45dbaf	3787	y = 70 + rand() % 200;
WiredHome	202:a22cbc04f332	3788	r1 = rand() % RAmin(y - 20, 100);
WiredHome	23:a50ded45dbaf	3789	//pc.printf(" (%d,%d) - %d\r\n", x,y,r1);
WiredHome	23:a50ded45dbaf	3790	display.circle(x,y,r1, display.DOSColor(i));
WiredHome	23:a50ded45dbaf	3791
WiredHome	23:a50ded45dbaf	3792	x = 300 + rand() % 100;
WiredHome	23:a50ded45dbaf	3793	y = 70 + rand() % 200;
WiredHome	202:a22cbc04f332	3794	r1 = rand() % RAmin(y - 20, 100);
WiredHome	23:a50ded45dbaf	3795	//pc.printf(" (%d,%d) - %d FILL\r\n", x,y,r1);
WiredHome	23:a50ded45dbaf	3796	display.circle(x,y,r1, display.DOSColor(i), FILL);
WiredHome	23:a50ded45dbaf	3797	}
WiredHome	23:a50ded45dbaf	3798	}
WiredHome	23:a50ded45dbaf	3799
WiredHome	44:207594dece70	3800
WiredHome	23:a50ded45dbaf	3801	void EllipseTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	3802	{
WiredHome	23:a50ded45dbaf	3803	int i,x,y,r1,r2;
WiredHome	23:a50ded45dbaf	3804
WiredHome	41:2956a0a221e5	3805	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	3806	pc.printf("Ellipse Test\r\n");
WiredHome	23:a50ded45dbaf	3807	display.background(Black);
WiredHome	23:a50ded45dbaf	3808	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	3809	display.cls();
WiredHome	100:0b084475d5a9	3810	display.puts("Ellipse Test");
WiredHome	23:a50ded45dbaf	3811	for (i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	3812	x = 100 + rand() % 100;
WiredHome	23:a50ded45dbaf	3813	y = 70 + rand() % 200;
WiredHome	202:a22cbc04f332	3814	r1 = rand() % RAmin(y - 20, 100);
WiredHome	202:a22cbc04f332	3815	r2 = rand() % RAmin(y - 20, 100);
WiredHome	23:a50ded45dbaf	3816	display.ellipse(x,y,r1,r2, display.DOSColor(i));
WiredHome	23:a50ded45dbaf	3817
WiredHome	23:a50ded45dbaf	3818	x = 300 + rand() % 100;
WiredHome	23:a50ded45dbaf	3819	y = 70 + rand() % 200;
WiredHome	202:a22cbc04f332	3820	r1 = rand() % RAmin(y - 20, 100);
WiredHome	202:a22cbc04f332	3821	r2 = rand() % RAmin(y - 20, 100);
WiredHome	23:a50ded45dbaf	3822	display.ellipse(x,y,r1,r2, FILL);
WiredHome	23:a50ded45dbaf	3823	}
WiredHome	23:a50ded45dbaf	3824	}
WiredHome	23:a50ded45dbaf	3825
WiredHome	44:207594dece70	3826
WiredHome	37:f19b7e7449dc	3827	void TestGraphicsBitmap(RA8875 & display, Serial & pc)
WiredHome	37:f19b7e7449dc	3828	{
WiredHome	37:f19b7e7449dc	3829	LocalFileSystem local("local");
WiredHome	41:2956a0a221e5	3830	if (!SuppressSlowStuff)
WiredHome	73:f22a18707b5e	3831	pc.printf("Bitmap File Load\r\n");
WiredHome	37:f19b7e7449dc	3832	display.background(Black);
WiredHome	37:f19b7e7449dc	3833	display.foreground(Blue);
WiredHome	37:f19b7e7449dc	3834	display.cls();
WiredHome	100:0b084475d5a9	3835	display.puts("Graphics Test, loading /local/TestPat.bmp");
WiredHome	37:f19b7e7449dc	3836	wait(3);
WiredHome	37:f19b7e7449dc	3837
WiredHome	37:f19b7e7449dc	3838	int r = display.RenderBitmapFile(0,0, "/local/TestPat.bmp");
WiredHome	59:fb40aad4efd4	3839	if (!SuppressSlowStuff)
WiredHome	59:fb40aad4efd4	3840	pc.printf(" returned %d\r\n", r);
WiredHome	37:f19b7e7449dc	3841	}
WiredHome	37:f19b7e7449dc	3842
WiredHome	44:207594dece70	3843
WiredHome	77:9206c13aa527	3844	void TouchPanelTest(RA8875 & display, Serial & pc)
WiredHome	77:9206c13aa527	3845	{
WiredHome	77:9206c13aa527	3846	Timer t;
WiredHome	98:ecebed9b80b2	3847	int x, y;
WiredHome	78:faf49c381591	3848	tpMatrix_t calmatrix;
WiredHome	190:3132b7dfad82	3849
WiredHome	77:9206c13aa527	3850	display.background(Black);
WiredHome	77:9206c13aa527	3851	display.foreground(Blue);
WiredHome	77:9206c13aa527	3852	display.cls();
WiredHome	100:0b084475d5a9	3853	display.puts("Touch Panel Test\r\n");
WiredHome	78:faf49c381591	3854	pc.printf("Touch Panel Test\r\n");
WiredHome	77:9206c13aa527	3855	display.TouchPanelInit();
WiredHome	78:faf49c381591	3856	pc.printf(" TP: c - calibrate, r - restore, t - test\r\n");
WiredHome	78:faf49c381591	3857	int c = pc.getc();
WiredHome	78:faf49c381591	3858	if (c == 'c') {
WiredHome	78:faf49c381591	3859	point_t pTest[3] =
WiredHome	78:faf49c381591	3860	{ { 50, 50 }, {450, 150}, {225,250} };
WiredHome	78:faf49c381591	3861	point_t pSample[3];
WiredHome	78:faf49c381591	3862	for (int i=0; i<3; i++) {
WiredHome	78:faf49c381591	3863	display.foreground(Blue);
WiredHome	78:faf49c381591	3864	display.printf(" (%3d,%3d) => ", pTest[i].x, pTest[i].y);
WiredHome	78:faf49c381591	3865	display.line(pTest[i].x-10, pTest[i].y, pTest[i].x+10, pTest[i].y, White);
WiredHome	78:faf49c381591	3866	display.line(pTest[i].x, pTest[i].y-10, pTest[i].x, pTest[i].y+10, White);
WiredHome	79:544eb4964795	3867	while (!display.TouchPanelA2DFiltered(&x, &y))
WiredHome	197:853d08e2fb53	3868	wait_us(20000);
WiredHome	78:faf49c381591	3869	pSample[i].x = x;
WiredHome	78:faf49c381591	3870	pSample[i].y = y;
WiredHome	78:faf49c381591	3871	display.line(pTest[i].x-10, pTest[i].y, pTest[i].x+10, pTest[i].y, Black);
WiredHome	78:faf49c381591	3872	display.line(pTest[i].x, pTest[i].y-10, pTest[i].x, pTest[i].y+10, Black);
WiredHome	78:faf49c381591	3873	display.foreground(Blue);
WiredHome	78:faf49c381591	3874	display.printf(" (%4d,%4d)\r\n", x,y);
WiredHome	79:544eb4964795	3875	while (display.TouchPanelA2DFiltered(&x, &y))
WiredHome	197:853d08e2fb53	3876	wait_us(20000);
WiredHome	78:faf49c381591	3877	wait(2);
WiredHome	78:faf49c381591	3878	}
WiredHome	81:01da2e34283d	3879	display.TouchPanelComputeCalibration(pTest, pSample, &calmatrix);
WiredHome	78:faf49c381591	3880	display.printf(" Writing calibration to tpcal.cfg\r\n");
WiredHome	78:faf49c381591	3881	FILE * fh = fopen("/local/tpcal.cfg", "wb");
WiredHome	78:faf49c381591	3882	if (fh) {
WiredHome	78:faf49c381591	3883	fwrite(&calmatrix, sizeof(calmatrix), 1, fh);
WiredHome	78:faf49c381591	3884	fclose(fh);
WiredHome	78:faf49c381591	3885	}
WiredHome	78:faf49c381591	3886	display.printf(" Calibration is complete.");
WiredHome	78:faf49c381591	3887	} else if (c == 'r') {
WiredHome	78:faf49c381591	3888	display.printf(" Reading calibration from tpcal.cfg\r\n");
WiredHome	78:faf49c381591	3889	FILE * fh = fopen("/local/tpcal.cfg", "rb");
WiredHome	78:faf49c381591	3890	if (fh) {
WiredHome	78:faf49c381591	3891	fread(&calmatrix, sizeof(calmatrix), 1, fh);
WiredHome	78:faf49c381591	3892	fclose(fh);
WiredHome	78:faf49c381591	3893	}
WiredHome	78:faf49c381591	3894	display.printf(" Calibration is complete.");
WiredHome	78:faf49c381591	3895	display.TouchPanelSetMatrix(&calmatrix);
WiredHome	77:9206c13aa527	3896	}
WiredHome	77:9206c13aa527	3897	t.start();
WiredHome	77:9206c13aa527	3898	do {
WiredHome	77:9206c13aa527	3899	point_t point = {0, 0};
WiredHome	79:544eb4964795	3900	if (display.TouchPanelReadable(&point)) {
WiredHome	77:9206c13aa527	3901	display.pixel(point.x, point.y, Red);
WiredHome	77:9206c13aa527	3902	}
WiredHome	77:9206c13aa527	3903	} while (t.read_ms() < 30000);
WiredHome	77:9206c13aa527	3904	pc.printf(">");
WiredHome	77:9206c13aa527	3905	}
WiredHome	77:9206c13aa527	3906
WiredHome	77:9206c13aa527	3907
WiredHome	41:2956a0a221e5	3908	void SpeedTest(RA8875 & display, Serial & pc)
WiredHome	41:2956a0a221e5	3909	{
WiredHome	41:2956a0a221e5	3910	Timer t;
WiredHome	41:2956a0a221e5	3911	SuppressSlowStuff = true;
WiredHome	41:2956a0a221e5	3912	pc.printf("\r\nSpeedTest disables delays, runs tests, reports overall time.\r\n");
WiredHome	41:2956a0a221e5	3913	t.start();
WiredHome	41:2956a0a221e5	3914	// do stuff fast
WiredHome	41:2956a0a221e5	3915	TextCursorTest(display, pc);
WiredHome	49:c5182231d1b9	3916	TextWrapTest(display, pc);
WiredHome	41:2956a0a221e5	3917	BacklightTest(display, pc, 0);
WiredHome	41:2956a0a221e5	3918	BacklightTest2(display, pc);
WiredHome	41:2956a0a221e5	3919	ExternalFontTest(display, pc);
WiredHome	41:2956a0a221e5	3920	DOSColorTest(display, pc);
WiredHome	41:2956a0a221e5	3921	WebColorTest(display, pc);
WiredHome	41:2956a0a221e5	3922	PixelTest(display, pc);
WiredHome	41:2956a0a221e5	3923	LineTest(display, pc);
WiredHome	41:2956a0a221e5	3924	RectangleTest(display, pc);
WiredHome	41:2956a0a221e5	3925	RoundRectTest(display, pc);
WiredHome	41:2956a0a221e5	3926	TriangleTest(display, pc);
WiredHome	41:2956a0a221e5	3927	CircleTest(display, pc);
WiredHome	41:2956a0a221e5	3928	EllipseTest(display, pc);
WiredHome	44:207594dece70	3929	LayerTest(display, pc);
WiredHome	41:2956a0a221e5	3930	//TestGraphicsBitmap(display, pc);
WiredHome	41:2956a0a221e5	3931	pc.printf("SpeedTest completed in %d msec\r\n", t.read_ms());
WiredHome	73:f22a18707b5e	3932	#ifdef PERF_METRICS
WiredHome	41:2956a0a221e5	3933	display.ReportPerformance(pc);
WiredHome	73:f22a18707b5e	3934	#endif
WiredHome	41:2956a0a221e5	3935	SuppressSlowStuff = false;
WiredHome	41:2956a0a221e5	3936	}
WiredHome	41:2956a0a221e5	3937
WiredHome	44:207594dece70	3938
WiredHome	41:2956a0a221e5	3939	void PrintScreen(RA8875 & display, Serial & pc)
WiredHome	41:2956a0a221e5	3940	{
WiredHome	41:2956a0a221e5	3941	if (!SuppressSlowStuff)
WiredHome	73:f22a18707b5e	3942	pc.printf("PrintScreen\r\n");
WiredHome	41:2956a0a221e5	3943	display.PrintScreen( 0,0, 480,272, "/local/Capture.bmp");
WiredHome	41:2956a0a221e5	3944	}
WiredHome	41:2956a0a221e5	3945
WiredHome	44:207594dece70	3946
WiredHome	23:a50ded45dbaf	3947	void RunTestSet(RA8875 & lcd, Serial & pc)
WiredHome	23:a50ded45dbaf	3948	{
WiredHome	23:a50ded45dbaf	3949	int q = 0;
WiredHome	23:a50ded45dbaf	3950	int automode = 0;
WiredHome	49:c5182231d1b9	3951	const unsigned char modelist[] = "BDWtGLlFROTPCEbw"; // auto-test in this order.
WiredHome	23:a50ded45dbaf	3952
WiredHome	23:a50ded45dbaf	3953	while(1) {
WiredHome	23:a50ded45dbaf	3954	pc.printf("\r\n"
WiredHome	41:2956a0a221e5	3955	"B - Backlight up b - backlight dim\r\n"
WiredHome	41:2956a0a221e5	3956	"D - DOS Colors W - Web Colors\r\n"
WiredHome	41:2956a0a221e5	3957	"t - text cursor G - Graphics Bitmap\r\n"
WiredHome	41:2956a0a221e5	3958	"L - Lines F - external Font\r\n"
WiredHome	41:2956a0a221e5	3959	"R - Rectangles O - rOund rectangles\r\n"
WiredHome	41:2956a0a221e5	3960	"T - Triangles P - Pixels \r\n"
WiredHome	41:2956a0a221e5	3961	"C - Circles E - Ellipses\r\n"
WiredHome	41:2956a0a221e5	3962	"A - Auto Test mode S - Speed Test\r\n"
WiredHome	77:9206c13aa527	3963	"K - Keypad Test s - touch screen test\r\n"
WiredHome	41:2956a0a221e5	3964	"p - print screen r - reset \r\n"
WiredHome	49:c5182231d1b9	3965	"l - layer test w - wrapping text \r\n"
WiredHome	73:f22a18707b5e	3966	#ifdef PERF_METRICS
WiredHome	41:2956a0a221e5	3967	"0 - clear performance 1 - report performance\r\n"
WiredHome	73:f22a18707b5e	3968	#endif
WiredHome	23:a50ded45dbaf	3969	"> ");
WiredHome	23:a50ded45dbaf	3970	if (automode == -1 \|\| pc.readable()) {
WiredHome	23:a50ded45dbaf	3971	automode = -1;
WiredHome	37:f19b7e7449dc	3972	q = pc.getc();
WiredHome	37:f19b7e7449dc	3973	while (pc.readable())
WiredHome	37:f19b7e7449dc	3974	pc.getc();
WiredHome	23:a50ded45dbaf	3975	} else if (automode >= 0) {
WiredHome	23:a50ded45dbaf	3976	q = modelist[automode];
WiredHome	23:a50ded45dbaf	3977	}
WiredHome	23:a50ded45dbaf	3978	switch(q) {
WiredHome	73:f22a18707b5e	3979	#ifdef PERF_METRICS
WiredHome	41:2956a0a221e5	3980	case '0':
WiredHome	41:2956a0a221e5	3981	lcd.ClearPerformance();
WiredHome	41:2956a0a221e5	3982	break;
WiredHome	41:2956a0a221e5	3983	case '1':
WiredHome	41:2956a0a221e5	3984	lcd.ReportPerformance(pc);
WiredHome	41:2956a0a221e5	3985	break;
WiredHome	73:f22a18707b5e	3986	#endif
WiredHome	23:a50ded45dbaf	3987	case 'A':
WiredHome	23:a50ded45dbaf	3988	automode = 0;
WiredHome	23:a50ded45dbaf	3989	break;
WiredHome	23:a50ded45dbaf	3990	case 'B':
WiredHome	41:2956a0a221e5	3991	BacklightTest(lcd, pc, 2);
WiredHome	23:a50ded45dbaf	3992	break;
WiredHome	23:a50ded45dbaf	3993	case 'b':
WiredHome	23:a50ded45dbaf	3994	BacklightTest2(lcd, pc);
WiredHome	23:a50ded45dbaf	3995	break;
WiredHome	23:a50ded45dbaf	3996	case 'D':
WiredHome	23:a50ded45dbaf	3997	DOSColorTest(lcd, pc);
WiredHome	23:a50ded45dbaf	3998	break;
WiredHome	75:ca78388cfd77	3999	case 'K':
WiredHome	75:ca78388cfd77	4000	KeyPadTest(lcd, pc);
WiredHome	75:ca78388cfd77	4001	break;
WiredHome	23:a50ded45dbaf	4002	case 'W':
WiredHome	23:a50ded45dbaf	4003	WebColorTest(lcd, pc);
WiredHome	23:a50ded45dbaf	4004	break;
WiredHome	23:a50ded45dbaf	4005	case 't':
WiredHome	23:a50ded45dbaf	4006	TextCursorTest(lcd, pc);
WiredHome	23:a50ded45dbaf	4007	break;
WiredHome	49:c5182231d1b9	4008	case 'w':
WiredHome	49:c5182231d1b9	4009	TextWrapTest(lcd, pc);
WiredHome	49:c5182231d1b9	4010	break;
WiredHome	23:a50ded45dbaf	4011	case 'F':
WiredHome	23:a50ded45dbaf	4012	ExternalFontTest(lcd, pc);
WiredHome	23:a50ded45dbaf	4013	break;
WiredHome	23:a50ded45dbaf	4014	case 'L':
WiredHome	23:a50ded45dbaf	4015	LineTest(lcd, pc);
WiredHome	23:a50ded45dbaf	4016	break;
WiredHome	44:207594dece70	4017	case 'l':
WiredHome	44:207594dece70	4018	LayerTest(lcd, pc);
WiredHome	44:207594dece70	4019	break;
WiredHome	23:a50ded45dbaf	4020	case 'R':
WiredHome	23:a50ded45dbaf	4021	RectangleTest(lcd, pc);
WiredHome	23:a50ded45dbaf	4022	break;
WiredHome	23:a50ded45dbaf	4023	case 'O':
WiredHome	23:a50ded45dbaf	4024	RoundRectTest(lcd, pc);
WiredHome	23:a50ded45dbaf	4025	break;
WiredHome	41:2956a0a221e5	4026	case 'p':
WiredHome	41:2956a0a221e5	4027	PrintScreen(lcd, pc);
WiredHome	41:2956a0a221e5	4028	break;
WiredHome	41:2956a0a221e5	4029	case 'S':
WiredHome	41:2956a0a221e5	4030	SpeedTest(lcd, pc);
WiredHome	41:2956a0a221e5	4031	break;
WiredHome	77:9206c13aa527	4032	case 's':
WiredHome	77:9206c13aa527	4033	TouchPanelTest(lcd, pc);
WiredHome	77:9206c13aa527	4034	break;
WiredHome	23:a50ded45dbaf	4035	case 'T':
WiredHome	23:a50ded45dbaf	4036	TriangleTest(lcd, pc);
WiredHome	23:a50ded45dbaf	4037	break;
WiredHome	37:f19b7e7449dc	4038	case 'P':
WiredHome	37:f19b7e7449dc	4039	PixelTest(lcd, pc);
WiredHome	37:f19b7e7449dc	4040	break;
WiredHome	37:f19b7e7449dc	4041	case 'G':
WiredHome	37:f19b7e7449dc	4042	TestGraphicsBitmap(lcd, pc);
WiredHome	37:f19b7e7449dc	4043	break;
WiredHome	23:a50ded45dbaf	4044	case 'C':
WiredHome	23:a50ded45dbaf	4045	CircleTest(lcd, pc);
WiredHome	23:a50ded45dbaf	4046	break;
WiredHome	23:a50ded45dbaf	4047	case 'E':
WiredHome	23:a50ded45dbaf	4048	EllipseTest(lcd, pc);
WiredHome	23:a50ded45dbaf	4049	break;
WiredHome	23:a50ded45dbaf	4050	case 'r':
WiredHome	23:a50ded45dbaf	4051	pc.printf("Resetting ...\r\n");
WiredHome	197:853d08e2fb53	4052	wait_us(20000);
WiredHome	23:a50ded45dbaf	4053	mbed_reset();
WiredHome	23:a50ded45dbaf	4054	break;
WiredHome	75:ca78388cfd77	4055	case ' ':
WiredHome	75:ca78388cfd77	4056	break;
WiredHome	23:a50ded45dbaf	4057	default:
WiredHome	23:a50ded45dbaf	4058	printf("huh?\n");
WiredHome	23:a50ded45dbaf	4059	break;
WiredHome	23:a50ded45dbaf	4060	}
WiredHome	23:a50ded45dbaf	4061	if (automode >= 0) {
WiredHome	23:a50ded45dbaf	4062	automode++;
WiredHome	23:a50ded45dbaf	4063	if (automode >= sizeof(modelist))
WiredHome	23:a50ded45dbaf	4064	automode = 0;
WiredHome	197:853d08e2fb53	4065	wait_us(2000000);
WiredHome	23:a50ded45dbaf	4066	}
WiredHome	197:853d08e2fb53	4067	wait_us(200000);
WiredHome	23:a50ded45dbaf	4068	}
WiredHome	23:a50ded45dbaf	4069	}
WiredHome	23:a50ded45dbaf	4070
WiredHome	79:544eb4964795	4071	#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)