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@206:83edda283d90, 2020-05-25 (annotated)

Committer:: WiredHome
Date:: Mon May 25 16:08:50 2020 +0000
Revision:: 206:83edda283d90
Parent:: 205:f215dc32736b
Child:: 207:82f336e5c021

Pick up a change in the touch ISR to pick up the final release.

Who changed what in which revision?

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