lcdproc/server/drivers/MtxOrb.c

/*
 * Matrix Orbital driver
 *
 * For the Matrix Orbital LCD* LKD* VFD* and VKD* displays
 *
 * September 16, 2001
 *
 * NOTE: GLK displays have a different driver.
 *
 */

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/time.h>
#include <termios.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <syslog.h>

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include "lcd.h"
#include "MtxOrb.h"
#include "drv_base.h"
#include "shared/debug.h"
#include "shared/str.h"

#define DEFAULT_CONTRAST	140
#define DEFAULT_DEVICE		"/dev/lcd"
#define DEFAULT_SPEED		B19200
#define DEFAULT_LINEWRAP	1
#define DEFAULT_AUTOSCROLL	1
#define DEFAULT_CURSORBLINK	0

#define IS_LCD_DISPLAY	(MtxOrb_type == MTXORB_LCD)
#define IS_LKD_DISPLAY	(MtxOrb_type == MTXORB_LKD)
#define IS_VFD_DISPLAY	(MtxOrb_type == MTXORB_VFD)
#define IS_VKD_DISPLAY	(MtxOrb_type == MTXORB_VKD)

#define NotEnoughArgs (i + 1 > argc)

// NOTE: This does not appear to make use of the
//       hbar and vbar functions present in the LKD202-25.
//       Why I do not know.

static int custom = 0;
static enum {MTXORB_LCD, MTXORB_LKD, MTXORB_VFD, MTXORB_VKD} MtxOrb_type;
extern int debug_level;

// TODO: Remove this custom_type if not in use anymore.
typedef enum {
	hbar = 1,
	vbar = 2,
	bign = 4,
	beat = 8
} custom_type;

// TODO: This is my ugglyest piece of code.
typedef enum {
	baru1 = 0,
	baru2 = 1,
	baru3 = 2,
	baru4 = 3,
	baru5 = 4,
	baru6 = 5,
	baru7 = 6,
	bard1 = 7,
	bard2 = 8,
	bard3 = 9,
	bard4 = 10,
	bard5 = 11,
	bard6 = 12,
	bard7 = 13,
	barr1 = 14,
	barr2 = 15,
	barr3 = 16,
	barr4 = 17,
	barl1 = 18,
	barl2 = 19,
	barl3 = 20,
	barl4 = 21,
	barw = 32,
	barb = 255
} bar_type;

static int fd;
static int clear = 1;

static int def[9] = { -1, -1, -1, -1, -1, -1, -1, -1, -1 };
static int use[9] = { 1, 0, 0, 0, 0, 0, 0, 0, 0 };

static void MtxOrb_linewrap (int on);
static void MtxOrb_autoscroll (int on);
static void MtxOrb_cursorblink (int on);
static void MtxOrb_string (int x, int y, char *string);

static int
MtxOrb_set_type (char * str) {
	char c;
	c = str[0];

	if (c == 'l') {
		if (strcmp(str, "lcd") == 0) {
			return MTXORB_LCD;
		} else if (strcmp(str, "lkd") == 0) {
			return MTXORB_LKD;
		} else {
			fprintf (stderr, "MtxOrb_init: unknwon display type %s; must be one of lcd, lkd, vfd, or vkd\n", str);
		}
	} else if (c == 'v') {
		if (strcmp (str, "vfd") == 0) {
			return MTXORB_VFD;
		} else if (strcmp (str, "vkd") == 0) {
			return MTXORB_VKD;
		} else {
			fprintf (stderr, "MtxOrb_init: unknwon display type %s; must be one of lcd, lkd, vfd, or vkd\n", str);
		}
	} else {
		fprintf (stderr, "MtxOrb_init: unknwon display type %s; must be one of lcd, lkd, vfd, or vkd\n", str);
	}
	return (-1);
}

static int
MtxOrb_get_speed (char *arg) {
	int speed;

	switch (atoi(arg)) {
		case 1200: speed = B1200; break;
		case 2400: speed = B2400; break;
		case 9600: speed = B9600; break;
		case 19200: speed = B19200; break;
		default:
			speed = DEFAULT_SPEED;
			fprintf (stderr, "MtxOrb_init: argument must be 1200, 2400, 9600 or 19200. Using default value");
			switch (speed) {
				case B1200: fprintf(stderr, " of 1200 baud.\n"); break;
				case B2400: fprintf(stderr, " of 2400 baud.\n"); break;
				case B9600: fprintf(stderr, " of 9600 baud.\n"); break;
				case B19200: fprintf(stderr, " of 19200 baud.\n"); break;
				default: fprintf(stderr, ".\n"); break;
			}
		}

	return speed;
	}

static void
MtxOrb_usage (void) {
	printf ("LCDproc Matrix-Orbital LCD driver\n"
		"\t-d\t--device\tSelect the output device to use [/dev/lcd]\n"
//		"\t-t\t--type\t\tSelect the LCD type (size) [20x4]\n"
//		"\t-b\t--backlight\tSelect the backlight state [on]\n"
		"\t-c\t--contrast\tSet the initial contrast [140]\n"
		"\t-s\t--speed\t\tSet the communication speed [19200]\n"
		"\t-h\t--help\t\tShow this help information\n"
		"\t-t\t--type\t\tdisplay type: lcd, lkd, vfd, vkd\n");
}

static int
MtxOrb_set_contrast (char * str) {
	int contrast;

	contrast = atoi (str);
	if ((contrast < 0) || (contrast > 255)) {
		fprintf(stderr, "MtxOrb_init: argument must between 0 and 255 (found %s). Using default contrast value of %d.\n", str, DEFAULT_CONTRAST);
		contrast = DEFAULT_CONTRAST;
	}
	return contrast;
}

// TODO:  Get rid of this variable? Probably not...
lcd_logical_driver *MtxOrb;	// set by MtxOrb_init(); doesn't seem to be used anywhere
// TODO:  Get the frame buffers working right

/////////////////////////////////////////////////////////////////
// Opens com port and sets baud correctly...
//
// Called to initialize driver settings
//
int
MtxOrb_init (lcd_logical_driver * driver, char *args)
{
	char *argv[64];		// Notice: 64 arguments - overflows?
	int argc;
	struct termios portset;
	int i;
	int tmp;

	int contrast = DEFAULT_CONTRAST;
	char device[256] = DEFAULT_DEVICE;
	int speed = DEFAULT_SPEED;
	MtxOrb_type = MTXORB_LKD ;  // Assume it's an LCD w/keypad

	MtxOrb = driver;

	//debug("MtxOrb_init: Args(all): %s\n", args);

	argc = get_args (argv, args, 64);

	/*
	   for(i=0; i<argc; i++)
	   {
	   printf("Arg(%i): %s\n", i, argv[i]);
	   }
	 */

	for (i = 0; i < argc; i++) {
		//printf("Arg(%i): %s\n", i, argv[i]);
		if (0 == strcmp (argv[i], "-d") || 0 == strcmp (argv[i], "--device")) {
			if (i + 1 > argc) {
				fprintf (stderr, "MtxOrb_init: %s requires an argument\n", argv[i]);
				return -1;
			}
			strcpy (device, argv[++i]);
		} else if (0 == strcmp (argv[i], "-c") || 0 == strcmp (argv[i], "--contrast")) {
			if (i + 1 > argc) {
				fprintf (stderr, "MtxOrb_init: %s requires an argument\n", argv[i]);
				return -1;
			}
			tmp = atoi (argv[++i]);
			if ((tmp < 0) || (tmp > 255)) {
				fprintf (stderr, "MtxOrb_init: %s argument must between 0 and 255. Ussing default value.\n", argv[i]);
			} else
				contrast = tmp;
		} else if (0 == strcmp (argv[i], "-s") || 0 == strcmp (argv[i], "--speed")) {
			if (i + 1 > argc) {
				fprintf (stderr, "MtxOrb_init: %s requires an argument\n", argv[i]);
				return -1;
			}
			tmp = atoi (argv[++i]);
			if (tmp == 1200)
				speed = B1200;
			else if (tmp == 2400)
				speed = B2400;
			else if (tmp == 9600)
				speed = B9600;
			else if (tmp == 19200)
				speed = B19200;
			else {
				fprintf (stderr, "MtxOrb_init: %s argument must be 1200, 2400, 9600 or 19200. Ussing default value.\n", argv[i]);
			}
		} else if (0 == strcmp (argv[i], "-h") || 0 == strcmp (argv[i], "--help")) {
			printf ("LCDproc Matrix-Orbital LCD driver\n" "\t-d\t--device\tSelect the output device to use [/dev/lcd]\n"
//              "\t-t\t--type\t\tSelect the LCD type (size) [20x4]\n"
					  "\t-c\t--contrast\tSet the initial contrast [140]\n" "\t-s\t--speed\t\tSet the communication speed [19200]\n" "\t-h\t--help\t\tShow this help information\n" "\t-t\t--type\t\tdisplay type: lcd, lkd, vfd, vkd\n");
			return -1;
		} else if (0 == strcmp (argv[i], "-t") || 0 == strcmp (argv[i], "--type")) {
			if (i + 1 > argc) {
				fprintf (stderr, "MtxOrb_init: %s requires an argument\n", argv[i]);
				return -1;
			}
			i++;
			if ( 0 == strcmp (argv[i], "lcd") ) {
				MtxOrb_type = MTXORB_LCD;
			} else if ( 0 == strcmp (argv[i], "lkd") ) {
				MtxOrb_type = MTXORB_LKD;
			} else if ( 0 == strcmp (argv[i], "vfd") ) {
				MtxOrb_type = MTXORB_VFD;
			} else if ( 0 == strcmp (argv[i], "vkd") ) {
				MtxOrb_type = MTXORB_VKD;
			} else {
				fprintf (stderr, "MtxOrb_init: unknwon display type %s\n", argv[i]);
				return(-1);
			}
		} else {
			printf ("Invalid parameter: %s\n", argv[i]);
		}

	}

	// Set up io port correctly, and open it...
	fd = open (device, O_RDWR | O_NOCTTY | O_NDELAY);
	if (fd == -1) {
		switch (errno) {
			case ENOENT: fprintf(stderr, "MtxOrb_init: %s device file missing!\n", device);
				break;
			case EACCES: fprintf(stderr, "MtxOrb_init: %s device could not be opened...\n", device);
				fprintf(stderr, "MtxOrb_init: perhaps you should run LCDd as root?\n");
				break;
			default: fprintf (stderr, "MtxOrb_init: failed (%s)\n", strerror (errno));
				break;
		}
  		return -1;
	} else
		syslog(LOG_INFO, "opened Matrix Orbital display on %s\n", device);

	tcgetattr (fd, &portset);

	// We use RAW mode
#ifdef HAVE_CFMAKERAW
	// The easy way
	cfmakeraw( &portset );
#else
	// The hard way
	portset.c_iflag &= ~( IGNBRK | BRKINT | PARMRK | ISTRIP
	                      | INLCR | IGNCR | ICRNL | IXON );
	portset.c_oflag &= ~OPOST;
	portset.c_lflag &= ~( ECHO | ECHONL | ICANON | ISIG | IEXTEN );
	portset.c_cflag &= ~( CSIZE | PARENB | CRTSCTS );
	portset.c_cflag |= CS8 | CREAD | CLOCAL ;
#endif

	// Set port speed
	cfsetospeed (&portset, speed);
	cfsetispeed (&portset, B0);

	// Do it...
	tcsetattr (fd, TCSANOW, &portset);

	/*
	 * Configure display
	 */

	MtxOrb_linewrap (DEFAULT_LINEWRAP);
	MtxOrb_autoscroll (DEFAULT_AUTOSCROLL);
	MtxOrb_cursorblink (DEFAULT_CURSORBLINK);
	MtxOrb_contrast (contrast);

	if (!driver->framebuf) {
		syslog(LOG_ERR, "no frame buffer! exiting driver init...");
		driver->close ();
		return -1;
	}

	/*
	 * Configure the display functions
	 */

	driver->clear = MtxOrb_clear;
	driver->string = MtxOrb_string;
	driver->chr = MtxOrb_chr;
	driver->vbar = MtxOrb_vbar;
	driver->init_vbar = MtxOrb_init_vbar;
	driver->hbar = MtxOrb_hbar;
	driver->init_hbar = MtxOrb_init_hbar;
	driver->num = MtxOrb_num;
	driver->init_num = MtxOrb_init_num;

	driver->init = MtxOrb_init;
	driver->close = MtxOrb_close;
	driver->flush = MtxOrb_flush;
	driver->flush_box = MtxOrb_flush_box;
	driver->contrast = MtxOrb_contrast;
	driver->backlight = MtxOrb_backlight;
	driver->output = MtxOrb_output;
	driver->set_char = MtxOrb_set_char;
	driver->icon = MtxOrb_icon;
	driver->draw_frame = MtxOrb_draw_frame;

	driver->getkey = MtxOrb_getkey;
	driver->getinfo = MtxOrb_getinfo;

	return fd;
}

#define ValidX(a) { if (x > MtxOrb->wid) { x = MtxOrb->wid; } else x < 1 ? 1 : x; }
#define ValidY(a) { if (y > MtxOrb->hgt) { y = MtxOrb->hgt; } else y < 1 ? 1 : y; }

// TODO: Check this quick hack to detect clear of the screen.
/////////////////////////////////////////////////////////////////
// Clear: catch up when the screen get clear to be able to
//  forget bar caracter not in use anymore and reuse the
//  slot for another bar caracter.
//
static void
MtxOrb_clear ()
{
	if (MtxOrb->framebuf != NULL)
		memset (MtxOrb->framebuf, ' ', (MtxOrb->wid * MtxOrb->hgt));

	write(fd, "\x0FE" "X", 2);  // instant clear...
	clear = 1;
}

/////////////////////////////////////////////////////////////////
// Clean-up
//
static void
MtxOrb_close ()
{
	close (fd);

	if (MtxOrb->framebuf)
		free (MtxOrb->framebuf);

	MtxOrb->framebuf = NULL;
}

static void
MtxOrb_string (int x, int y, char *string)
{
	int offset, siz;

	ValidX(x);
	ValidY(y);

	x--; y--; // Convert 1-based coords to 0-based...
	offset = (y * MtxOrb->wid) + x;
	siz = (MtxOrb->wid * MtxOrb->hgt) - offset - 1;
	siz = siz > strlen(string) ? strlen(string) : siz;

	memcpy(MtxOrb->framebuf + offset, string, siz);
}

static void
MtxOrb_flush ()
{
	MtxOrb_draw_frame (MtxOrb->framebuf);
}

static void
MtxOrb_flush_box (int lft, int top, int rgt, int bot)
{
	int y;
	char out[LCD_MAX_WIDTH];

	for (y = top; y <= bot; y++) {
		snprintf (out, sizeof(out), "\x0FEG%c%c", lft, y);
		write (fd, out, 4);
		write (fd, MtxOrb->framebuf + (y * MtxOrb->wid) + lft, rgt - lft + 1);

	}

}

/////////////////////////////////////////////////////////////////
// Prints a character on the lcd display, at position (x,y).  The
// upper-left is (1,1), and the lower right should be (20,4).
//
static void
MtxOrb_chr (int x, int y, char c)
{
	char out[10], buf[64];
	int offset;

	// Characters may or may NOT be alphabetic; it appears
	// that characters 0..4 (or similar) are graphic fonts

	ValidX(x);
	ValidY(y);

	// write immediately to screen... this code was taken
	// from the LK202-25; should work for others, yes?
	// snprintf(out, sizeof(out), "\x0FEG%c%c%c", x, y, c);
	// write (fd, out, 4);

	// write to frame buffer
	y--; x--; // translate to 0-index
	offset = (y * MtxOrb->wid) + x;
	MtxOrb->framebuf[offset] = c;

	if (debug_level > 2) {
		snprintf(buf, sizeof(buf), "writing character %02X to position (%d,%d)",
			c, x, y);
		syslog(LOG_DEBUG, buf);
	}
}

/////////////////////////////////////////////////////////////////
// Changes screen contrast (0-255; 140 seems good)
// note: works only for LCD displays
// Is it better to use the brightness for VFD/VKD displays ?
//
static int
MtxOrb_contrast (int contrast)
{
	char out[4];

	// validate contrast value
	if (contrast > 255)
		contrast = 255;
	if (contrast < 0)
		contrast = 0;

	if (IS_LCD_DISPLAY || IS_LKD_DISPLAY) {
		snprintf (out, sizeof(out), "\x0FEP%c", contrast);
		write (fd, out, 3);
	}
	return contrast;
}

/////////////////////////////////////////////////////////////////
// Sets the backlight on or off -- can be done quickly for
// an intermediate brightness...
//
// WARNING: off switches vfd/vkd displays off entirely
//	    so maybe it is best to start LCDd with -b on
//
// WARNING: there seems to be a movement afoot to add more
//          functions than just on/off to this..

#define BACKLIGHT_OFF 0
#define BACKLIGHT_ON 1

static void
MtxOrb_backlight (int on)
{
	switch (on) {
		case BACKLIGHT_ON: 
			write (fd, "\x0FE" "F", 2);
			break;
		case BACKLIGHT_OFF: 
			if (IS_VKD_DISPLAY || IS_VFD_DISPLAY)
				; // turns display off entirely (whoops!)
			else
				write (fd, "\x0FE" "B" "\x000", 3);
			break;
		default: // ignored...
			break;
		}
}

/////////////////////////////////////////////////////////////////
// Sets output port on or off
// displays with keypad have 6 outputs but the one without kepad
// have only one output
// NOTE: length of command are different
static void
MtxOrb_output (int on)
{
	char out[5];

	if (IS_LCD_DISPLAY || IS_VFD_DISPLAY) {
		// LCD and VFD displays only have one output port
		(on) ?
			write (fd, "\x0FEW", 2) :
			write (fd, "\x0FEV", 2);
	} else {
		int i;

		// Other displays have six output ports;
		// the value "on" is a binary value determining which
		// ports are turned on (1) and off (0).

		on = on & 077;	// strip to six bits
		for(i = 0; i < 6; i++) {
			(on & (1 << i)) ?
				snprintf (out, sizeof(out), "\x0FEW%c", i + 1) :
				snprintf (out, sizeof(out), "\x0FEV%c", i + 1);
			write (fd, out, 3);
		}
	}
}

/////////////////////////////////////////////////////////////////
// Toggle the built-in linewrapping feature
//
static void
MtxOrb_linewrap (int on)
{
	(on) ? write (fd, "\x0FE" "C", 2) : write (fd, "\x0FE" "D", 2);
}

/////////////////////////////////////////////////////////////////
// Toggle the built-in automatic scrolling feature
//
static void
MtxOrb_autoscroll (int on)
{
	(on) ? write (fd, "\x0FEQ", 2) : write (fd, "\x0FER", 2);
}

// TODO: make sure this doesn't mess up non-VFD displays
/////////////////////////////////////////////////////////////////
// Toggle cursor blink on/off
//
static void
MtxOrb_cursorblink (int on)
{
	(on) ?  write (fd, "\x0FES", 2) : write (fd, "\x0FET", 2);
}

//// TODO: Might not be needed anymore...
/////////////////////////////////////////////////////////////////
// Sets up for vertical bars.  Call before lcd.vbar()
//
static void
MtxOrb_init_vbar ()
{
// Isn't this function supposed to go away?
	MtxOrb_init_all (vbar);
}

// TODO: Might not be needed anymore...
/////////////////////////////////////////////////////////////////
// Inits horizontal bars...
//
static void
MtxOrb_init_hbar ()
{
// Isn't this function supposed to go away?
	MtxOrb_init_all (hbar);
}

/////////////////////////////////////////////////////////////////
// Returns string with general information about the display
//
static char *
MtxOrb_getinfo (void)
{
	char in = 0;
	static char info[255];
	char tmp[255], buf[64];
	int i = 0;
	fd_set rfds;

	struct timeval tv;
	int retval;

	memset(info, '\0', sizeof(info));
	strcpy(info, "Matrix Orbital Driver ");

	/*
	 * Read type of display
	 */

	write(fd, "\x0FE" "7", 2);

	/* Watch fd to see when it has input. */
	FD_ZERO(&rfds);
	FD_SET(fd, &rfds);

	/* Wait the specified amount of time. */
	tv.tv_sec = 0;		// seconds
	tv.tv_usec = 500;	// microseconds

	retval = select(1, &rfds, NULL, NULL, &tv);

	if (retval) {
		if (read (fd, &in, 1) < 0) {
			syslog(LOG_WARNING, "MatrixOrbital driver: unable to read data");
		} else {
			switch (in) {
				case '\x01': strcat(info, "LCD0821 "); break;
				case '\x03': strcat(info, "LCD2021 "); break;
				case '\x04': strcat(info, "LCD1641 "); break;
				case '\x05': strcat(info, "LCD2041 "); break;
				case '\x06': strcat(info, "LCD4021 "); break;
				case '\x07': strcat(info, "LCD4041 "); break;
				case '\x08': strcat(info, "LK202-25 "); break;
				case '\x09': strcat(info, "LK204-25 "); break;
				case '\x0A': strcat(info, "LK404-55 "); break;
				case '\x0B': strcat(info, "VFD2021 "); break;
				case '\x0C': strcat(info, "VFD2041 "); break;
				case '\x0D': strcat(info, "VFD4021 "); break;
				case '\x0E': strcat(info, "VK202-25 "); break;
				case '\x0F': strcat(info, "VK204-25 "); break;
				case '\x10': strcat(info, "GLC12232 "); break;
				case '\x11': strcat(info, "GLC12864 "); break;
				case '\x12': strcat(info, "GLC128128 "); break;
				case '\x13': strcat(info, "GLC24064 "); break;
				case '\x14': strcat(info, "GLK12864-25 "); break;
				case '\x15': strcat(info, "GLK24064-25 "); break;
				case '\x21': strcat(info, "GLK128128-25 "); break;
				case '\x22': strcat(info, "GLK12232-25 "); break;
				case '\x31': strcat(info, "LK404-AT "); break;
				case '\x32': strcat(info, "VFD1621 "); break;
				case '\x33': strcat(info, "LK402-12 "); break;
				case '\x34': strcat(info, "LK162-12 "); break;
				case '\x35': strcat(info, "LK204-25PC "); break;
				default: //snprintf(tmp, sizeof(tmp), "Unknown (%X) ", in); strcat(info, tmp);
					     break;
			}
		}
	} else
		syslog(LOG_WARNING, "MatrixOrbital driver: unable to read device type");

	/*
	 * Read serial number of display
	 */

	memset(tmp, '\0', sizeof(tmp));
	write(fd, "\x0FE" "5", 2);

	/* Wait the specified amount of time. */
	tv.tv_sec = 0;		// seconds
	tv.tv_usec = 500;	// microseconds

	retval = select(1, &rfds, NULL, NULL, &tv);

	if (retval) {
		if (read (fd, &tmp, 2) < 0) {
			syslog(LOG_WARNING, "MatrixOrbital driver: unable to read data");
		} else {
			snprintf(buf, sizeof(buf), "Serial No: %ld ", (long int) tmp);
			strcat(info, buf);
		}
	} else
		syslog(LOG_WARNING, "MatrixOrbital driver: unable to read device serial number");

	/*
	 * Read firmware revision number
	 */

	memset(tmp, '\0', sizeof(tmp));
	write(fd, "\x0FE" "6", 2);

	/* Wait the specified amount of time. */
	tv.tv_sec = 0;		// seconds
	tv.tv_usec = 500;	// microseconds

	retval = select(1, &rfds, NULL, NULL, &tv);

	if (retval) {
		if (read (fd, &tmp, 2) < 0) {
			syslog(LOG_WARNING, "MatrixOrbital driver: unable to read data");
		} else {
			snprintf(buf, sizeof(buf), "Firmware Rev. %ld ", (long int) tmp);
			strcat(info, buf);
		}
	} else
		syslog(LOG_WARNING, "MatrixOrbital driver: unable to read device firmware revision");

	return info;
}

// TODO: Finish the support for bar growing reverse way.
// TODO: Need a "y" as input also !!!
/////////////////////////////////////////////////////////////////
// Draws a vertical bar...
// This is the new version ussing dynamic icon alocation
//
static void
MtxOrb_vbar (int x, int len)
{
	unsigned char mapu[9] = { barw, baru1, baru2, baru3, baru4, baru5, baru6, baru7, barb };
	unsigned char mapd[9] = { barw, bard1, bard2, bard3, bard4, bard5, bard6, bard7, barb };

	int y;

// REMOVE THE NEXT LINE FOR TESTING ONLY...
//  len=-len;
// REMOVE THE PREVIOUS LINE FOR TESTING ONLY...

	if (len > 0) {
		for (y = MtxOrb->hgt; y > 0 && len > 0; y--) {
			if (len >= MtxOrb->cellhgt)
				MtxOrb_chr (x, y, 255);
			else
				MtxOrb_chr (x, y, MtxOrb_ask_bar (mapu[len]));

			len -= MtxOrb->cellhgt;
		}
	} else {
		len = -len;
		for (y = 2; y <= MtxOrb->hgt && len > 0; y++) {
			if (len >= MtxOrb->cellhgt)
				MtxOrb_chr (x, y, 255);
			else
				MtxOrb_chr (x, y, MtxOrb_ask_bar (mapd[len]));

			len -= MtxOrb->cellhgt;
		}
	}

}

// TODO: Finish the support for bar growing reverse way.
/////////////////////////////////////////////////////////////////
// Draws a horizontal bar to the right.
// This is the new version ussing dynamic icon alocation
//
static void
MtxOrb_hbar (int x, int y, int len)
{
	unsigned char mapr[6] = { barw, barr1, barr2, barr3, barr4, barb };
	unsigned char mapl[6] = { barw, barl1, barl2, barl3, barl4, barb };

	ValidX(x);
	ValidY(y);

	if (len > 0) {
		for (; x <= MtxOrb->wid && len > 0; x++) {
			if (len >= MtxOrb->cellwid)
				MtxOrb_chr (x, y, 255);
			else
				MtxOrb_chr (x, y, MtxOrb_ask_bar (mapr[len]));

			len -= MtxOrb->cellwid;

		}
	} else {
		len = -len;
		for (; x > 0 && len > 0; x--) {
			if (len >= MtxOrb->cellwid)
				MtxOrb_chr (x, y, 255);
			else
				MtxOrb_chr (x, y, MtxOrb_ask_bar (mapl[len]));

			len -= MtxOrb->cellwid;

		}
	}

}

// TODO: Might not work, bignum is untested... an untested with dynamic bar.

/////////////////////////////////////////////////////////////////
// Sets up for big numbers.
//
static void
MtxOrb_init_num ()
{
	if (custom != bign) {
		write (fd, "\x0FEn", 2);
		custom = bign;
	}
}

// TODO: Might not work, bignum is untested... an untested with dynamic bar.

/////////////////////////////////////////////////////////////////
// Writes a big number.
//
static void
MtxOrb_num (int x, int num)
{
	char out[5];
	snprintf (out, sizeof(out), "\x0FE#%c%c", x, num);
	write (fd, out, 4);
}

// TODO: This could be higly optimised if data where to be pre-computed.

/////////////////////////////////////////////////////////////////
// Sets a custom character from 0-7...
//
// For input, values > 0 mean "on" and values <= 0 are "off".
//
// The input is just an array of characters...
//
static void
MtxOrb_set_char (int n, char *dat)
{
	char out[4];
	int row, col;
	int letter;

	if (n < 0 || n > 7)
		return;
	if (!dat)
		return;

	snprintf (out, sizeof(out), "\x0FEN%c", n);
	write (fd, out, 3);

	for (row = 0; row < MtxOrb->cellhgt; row++) {
		letter = 0;
		for (col = 0; col < MtxOrb->cellwid; col++) {
			letter <<= 1;
			letter |= (dat[(row * MtxOrb->cellwid) + col] > 0);
		}
		write (fd, &letter, 1);
	}
}

static void
MtxOrb_icon (int which, char dest)
{
	char icons[3][5 * 8] = {
		{
		 1, 1, 1, 1, 1,			  // Empty Heart
		 1, 0, 1, 0, 1,
		 0, 0, 0, 0, 0,
		 0, 0, 0, 0, 0,
		 0, 0, 0, 0, 0,
		 1, 0, 0, 0, 1,
		 1, 1, 0, 1, 1,
		 1, 1, 1, 1, 1,
		 },

		{
		 1, 1, 1, 1, 1,			  // Filled Heart
		 1, 0, 1, 0, 1,
		 0, 1, 0, 1, 0,
		 0, 1, 1, 1, 0,
		 0, 1, 1, 1, 0,
		 1, 0, 1, 0, 1,
		 1, 1, 0, 1, 1,
		 1, 1, 1, 1, 1,
		 },

		{
		 0, 0, 0, 0, 0,			  // Ellipsis
		 0, 0, 0, 0, 0,
		 0, 0, 0, 0, 0,
		 0, 0, 0, 0, 0,
		 0, 0, 0, 0, 0,
		 0, 0, 0, 0, 0,
		 0, 0, 0, 0, 0,
		 1, 0, 1, 0, 1,
		 },

	};

	if (custom == bign)
		custom = beat;
	MtxOrb_set_char (dest, &icons[which][0]);
}

/////////////////////////////////////////////////////////////
// Blasts a single frame onscreen, to the lcd...
//
// Input is a character array, sized lcd.wid*lcd.hgt
//
static void
MtxOrb_draw_frame (char *dat)
{
	char out[LCD_MAX_WIDTH * LCD_MAX_HEIGHT];
	int i;

	if (!dat)
		return;

//        snprintf(out, sizeof(out), "%cG%c%c", 254, 1, 1);
//        write(fd, out, 4);
//        write(fd, dat, lcd.wid*lcd.hgt);

	for (i = 0; i < MtxOrb->hgt; i++) {
		snprintf (out, sizeof(out), "\x0FEG\x001%c", i + 1);
		write (fd, out, 4);
		write (fd, dat + (MtxOrb->wid * i), MtxOrb->wid);
	}
}

/////////////////////////////////////////////////////////////
// returns one character from the keypad...
// (A-Z) on success, 0 on failure...
//
static char
MtxOrb_getkey ()
{
	char in = 0;

	read (fd, &in, 1);
	return in;
}

/////////////////////////////////////////////////////////////////
// Ask for dynamic allocation of a custom caracter to be
//  a well none bar graphic. The function is suppose to
//  return a value between 0 and 7 but 0 is reserver for
//  heart beat.
//  This function manadge a cache of graphical caracter in use.
//  I really hope it is working and bug-less because it is not
//  completely tested, just a quick hack.
//
static int
MtxOrb_ask_bar (int type)
{
	int i;
	int last_not_in_use;
	int pos;							  // 0 is icon, 1 to 7 are free, 8 is not found.
	// TODO: Reuse graphic caracter 0 if heartbeat is not in use.

	// REMOVE: fprintf(stderr, "GLU: MtxOrb_ask_bar(%d).\n", type);
	// Check if the screen was clear.
	if (clear) {					  // If the screen was clear then graphic caracter are not in use.
		//REMOVE: fprintf(stderr, "GLU: MtxOrb_ask_bar| clear was set.\n");
		use[0] = 1;					  // Heartbeat is always in use (not true but it help).
		for (pos = 1; pos < 8; pos++) {
			use[pos] = 0;			  // Other are not in use.
		}
		clear = 0;					  // We made the special treatement.
	} else {
		// Nothing special if some caracter a curently in use (...) ?
	}

	// Search for a match with caracter already defined.
	pos = 8;							  // Not found.
	last_not_in_use = 8;			  // No empty slot to reuse.
	for (i = 1; i < 8; i++) {	  // For all but first (heartbeat).
		if (!use[i])
			last_not_in_use = i;	  // New empty slot.
		if (def[i] == type)
			pos = i;					  // Founded (should break now).
	}

	if (pos == 8) {
		// REMOVE: fprintf(stderr, "GLU: MtxOrb_ask_bar| not found.\n");
		pos = last_not_in_use;
		// TODO: Best match/deep search is no more graphic caracter are available.
	}

	if (pos != 8) {				  // A caracter is found (Best match could solve our problem).
		// REMOVE: fprintf(stderr, "GLU: MtxOrb_ask_bar| found at %d.\n", pos);
		if (def[pos] != type) {
			MtxOrb_set_known_char (pos, type);	// Define a new graphic caracter.
			def[pos] = type;		  // Remember that now the caracter is available.
		}
		if (!use[pos]) {			  // If the caracter is no yet in use (but defined).
			use[pos] = 1;			  // Remember it is in use (so protect it from re-use).
		}
	}

	if (pos == 8)					  // TODO: Choose a character to approximate the graph
	{
		//pos=65; // ("A")?
		switch (type) {
		case baru1:
			pos = '_';
			break;
		case baru2:
			pos = '.';
			break;
		case baru3:
			pos = ',';
			break;
		case baru4:
			pos = 'o';
			break;
		case baru5:
			pos = 'o';
			break;
		case baru6:
			pos = 'O';
			break;
		case baru7:
			pos = '8';
			break;

		case bard1:
			pos = '\'';
			break;
		case bard2:
			pos = '"';
			break;
		case bard3:
			pos = '^';
			break;
		case bard4:
			pos = '^';
			break;
		case bard5:
			pos = '*';
			break;
		case bard6:
			pos = 'O';
			break;
		case bard7:
			pos = '8';
			break;

		case barr1:
			pos = '-';
			break;
		case barr2:
			pos = '-';
			break;
		case barr3:
			pos = '=';
			break;
		case barr4:
			pos = '=';
			break;

		case barl1:
			pos = '-';
			break;
		case barl2:
			pos = '-';
			break;
		case barl3:
			pos = '=';
			break;
		case barl4:
			pos = '=';
			break;

		case barw:
			pos = ' ';
			break;

		case barb:
			pos = 255;
			break;

		default:
			pos = '?';
			break;
		}
	}

	return (pos);
}

/////////////////////////////////////////////////////////////
// Does the heartbeat...
//
static char
MtxOrb_heartbeat (int timer)
{
	MtxOrb_icon (!((timer + 4) & 5), 0);
	MtxOrb_chr (MtxOrb->wid, 1, 0);
	return (char) 0;
}

/////////////////////////////////////////////////////////////////
// Sets up a well known character for use.
//
static void
MtxOrb_set_known_char (int car, int type)
{
	char all_bar[25][5 * 8] = {
		{
		 0, 0, 0, 0, 0,			  //  char u1[] = 
		 0, 0, 0, 0, 0,
		 0, 0, 0, 0, 0,
		 0, 0, 0, 0, 0,
		 0, 0, 0, 0, 0,
		 0, 0, 0, 0, 0,
		 0, 0, 0, 0, 0,
		 1, 1, 1, 1, 1,
		 }, {
			  0, 0, 0, 0, 0,		  //  char u2[] = 
			  0, 0, 0, 0, 0,
			  0, 0, 0, 0, 0,
			  0, 0, 0, 0, 0,
			  0, 0, 0, 0, 0,
			  0, 0, 0, 0, 0,
			  1, 1, 1, 1, 1,
			  1, 1, 1, 1, 1,
			  }, {
					0, 0, 0, 0, 0,	  //  char u3[] = 
					0, 0, 0, 0, 0,
					0, 0, 0, 0, 0,
					0, 0, 0, 0, 0,
					0, 0, 0, 0, 0,
					1, 1, 1, 1, 1,
					1, 1, 1, 1, 1,
					1, 1, 1, 1, 1,
					}, {
						 0, 0, 0, 0, 0,	//  char u4[] = 
						 0, 0, 0, 0, 0,
						 0, 0, 0, 0, 0,
						 0, 0, 0, 0, 0,
						 1, 1, 1, 1, 1,
						 1, 1, 1, 1, 1,
						 1, 1, 1, 1, 1,
						 1, 1, 1, 1, 1,
						 }, {
							  0, 0, 0, 0, 0,	//  char u5[] = 
							  0, 0, 0, 0, 0,
							  0, 0, 0, 0, 0,
							  1, 1, 1, 1, 1,
							  1, 1, 1, 1, 1,
							  1, 1, 1, 1, 1,
							  1, 1, 1, 1, 1,
							  1, 1, 1, 1, 1,
							  }, {
									0, 0, 0, 0, 0,	//  char u6[] = 
									0, 0, 0, 0, 0,
									1, 1, 1, 1, 1,
									1, 1, 1, 1, 1,
									1, 1, 1, 1, 1,
									1, 1, 1, 1, 1,
									1, 1, 1, 1, 1,
									1, 1, 1, 1, 1,
									}, {
										 0, 0, 0, 0, 0,	//  char u7[] = 
										 1, 1, 1, 1, 1,
										 1, 1, 1, 1, 1,
										 1, 1, 1, 1, 1,
										 1, 1, 1, 1, 1,
										 1, 1, 1, 1, 1,
										 1, 1, 1, 1, 1,
										 1, 1, 1, 1, 1,
										 }, {
											  1, 1, 1, 1, 1,	//  char d1[] = 
											  0, 0, 0, 0, 0,
											  0, 0, 0, 0, 0,
											  0, 0, 0, 0, 0,
											  0, 0, 0, 0, 0,
											  0, 0, 0, 0, 0,
											  0, 0, 0, 0, 0,
											  0, 0, 0, 0, 0,
											  }, {
													1, 1, 1, 1, 1,	//  char d2[] = 
													1, 1, 1, 1, 1,
													0, 0, 0, 0, 0,
													0, 0, 0, 0, 0,
													0, 0, 0, 0, 0,
													0, 0, 0, 0, 0,
													0, 0, 0, 0, 0,
													0, 0, 0, 0, 0,
													}, {
														 1, 1, 1, 1, 1,	//  char d3[] = 
														 1, 1, 1, 1, 1,
														 1, 1, 1, 1, 1,
														 0, 0, 0, 0, 0,
														 0, 0, 0, 0, 0,
														 0, 0, 0, 0, 0,
														 0, 0, 0, 0, 0,
														 0, 0, 0, 0, 0,
														 }, {
															  1, 1, 1, 1, 1,	//  char d4[] = 
															  1, 1, 1, 1, 1,
															  1, 1, 1, 1, 1,
															  1, 1, 1, 1, 1,
															  0, 0, 0, 0, 0,
															  0, 0, 0, 0, 0,
															  0, 0, 0, 0, 0,
															  0, 0, 0, 0, 0,
															  }, {
																	1, 1, 1, 1, 1,	//  char d5[] = 
																	1, 1, 1, 1, 1,
																	1, 1, 1, 1, 1,
																	1, 1, 1, 1, 1,
																	1, 1, 1, 1, 1,
																	0, 0, 0, 0, 0,
																	0, 0, 0, 0, 0,
																	0, 0, 0, 0, 0,
																	}, {
																		 1, 1, 1, 1, 1,	//  char d6[] = 
																		 1, 1, 1, 1, 1,
																		 1, 1, 1, 1, 1,
																		 1, 1, 1, 1, 1,
																		 1, 1, 1, 1, 1,
																		 1, 1, 1, 1, 1,
																		 0, 0, 0, 0, 0,
																		 0, 0, 0, 0, 0,
																		 }, {
																			  1, 1, 1, 1, 1,	//  char d7[] = 
																			  1, 1, 1, 1, 1,
																			  1, 1, 1, 1, 1,
																			  1, 1, 1, 1, 1,
																			  1, 1, 1, 1, 1,
																			  1, 1, 1, 1, 1,
																			  1, 1, 1, 1, 1,
																			  0, 0, 0, 0, 0,
																			  }, {
																					1, 0, 0, 0, 0,	//  char r1[] = 
																					1, 0, 0, 0, 0,
																					1, 0, 0, 0, 0,
																					1, 0, 0, 0, 0,
																					1, 0, 0, 0, 0,
																					1, 0, 0, 0, 0,
																					1, 0, 0, 0, 0,
																					1, 0, 0, 0, 0,
																					}, {
																						 1, 1, 0, 0, 0,	//  char r2[] = 
																						 1, 1, 0, 0, 0,
																						 1, 1, 0, 0, 0,
																						 1, 1, 0, 0, 0,
																						 1, 1, 0, 0, 0,
																						 1, 1, 0, 0, 0,
																						 1, 1, 0, 0, 0,
																						 1, 1, 0, 0, 0,
																						 }, {
																							  1, 1, 1, 0, 0,	//  char r3[] = 
																							  1, 1, 1, 0, 0,
																							  1, 1, 1, 0, 0,
																							  1, 1, 1, 0, 0,
																							  1, 1, 1, 0, 0,
																							  1, 1, 1, 0, 0,
																							  1, 1, 1, 0, 0,
																							  1, 1, 1, 0, 0,
																							  }, {
																									1, 1, 1, 1, 0,	//  char r4[] = 
																									1, 1, 1, 1, 0,
																									1, 1, 1, 1, 0,
																									1, 1, 1, 1, 0,
																									1, 1, 1, 1, 0,
																									1, 1, 1, 1, 0,
																									1, 1, 1, 1, 0,
																									1, 1, 1, 1, 0,
																									}, {
																										 0, 0, 0, 0, 1,	//  char l1[] = 
																										 0, 0, 0, 0, 1,
																										 0, 0, 0, 0, 1,
																										 0, 0, 0, 0, 1,
																										 0, 0, 0, 0, 1,
																										 0, 0, 0, 0, 1,
																										 0, 0, 0, 0, 1,
																										 0, 0, 0, 0, 1,
																										 }, {
																											  0, 0, 0, 1, 1,	//  char l2[] = 
																											  0, 0, 0, 1, 1,
																											  0, 0, 0, 1, 1,
																											  0, 0, 0, 1, 1,
																											  0, 0, 0, 1, 1,
																											  0, 0, 0, 1, 1,
																											  0, 0, 0, 1, 1,
																											  0, 0, 0, 1, 1,
																											  }, {
																													0, 0, 1, 1, 1,	//  char l3[] = 
																													0, 0, 1, 1, 1,
																													0, 0, 1, 1, 1,
																													0, 0, 1, 1, 1,
																													0, 0, 1, 1, 1,
																													0, 0, 1, 1, 1,
																													0, 0, 1, 1, 1,
																													0, 0, 1, 1, 1,
																													}, {
																														 0, 1, 1, 1, 1,	//  char l4[] = 
																														 0, 1, 1, 1, 1,
																														 0, 1, 1, 1, 1,
																														 0, 1, 1, 1, 1,
																														 0, 1, 1, 1, 1,
																														 0, 1, 1, 1, 1,
																														 0, 1, 1, 1, 1,
																														 0, 1, 1, 1, 1,
																														 }, {
																															  1, 1, 1, 1, 1,	// Empty Heart
																															  1, 0, 1, 0, 1,
																															  0, 0, 0, 0, 0,
																															  0, 0, 0, 0, 0,
																															  0, 0, 0, 0, 0,
																															  1, 0, 0, 0, 1,
																															  1, 1, 0, 1, 1,
																															  1, 1, 1, 1, 1,
																															  }, {
																																	1, 1, 1, 1, 1,	// Filled Heart
																																	1, 0, 1, 0, 1,
																																	0, 1, 0, 1, 0,
																																	0, 1, 1, 1, 0,
																																	0, 1, 1, 1, 0,
																																	1, 0, 1, 0, 1,
																																	1, 1, 0, 1, 1,
																																	1, 1, 1, 1, 1,
																																	}, {
																																		 0, 0, 0, 0, 0,	// Ellipsis
																																		 0, 0, 0, 0, 0,
																																		 0, 0, 0, 0, 0,
																																		 0, 0, 0, 0, 0,
																																		 0, 0, 0, 0, 0,
																																		 0, 0, 0, 0, 0,
																																		 0, 0, 0, 0, 0,
																																		 1, 0, 1, 0, 1,
																																		 }
	};

	MtxOrb_set_char (car, &all_bar[type][0]);
}

/////////////////STOP READING --- TRASH IS AT THE END////////////////

// TODO: Remove this code wich was use for developpement.
// PS: There might be reference to this code left, so keep it for some time.
//
// MtxOrb_init_hbar and MtxOrb_init_vbar use it; it's prototyped in MtxOrb.h ...
static void
MtxOrb_init_all (int type)
{
}