Add basic debugging stuff from rawdraw.

6 files changed, 1264 insertions, 0 deletions

diff --git a/redist/DrawFunctions.c b/redist/DrawFunctions.c
new file mode 100644
index 0000000..f4f27d2
--- /dev/null
+++ b/redist/DrawFunctions.c
@@ -0,0 +1,277 @@
+/*
+Copyright (c) 2010, 2011 Charles Lohr
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "DrawFunctions.h"
+#include <stdio.h>
+
+int CNFGPenX, CNFGPenY;
+uint32_t CNFGBGColor;
+uint32_t CNFGLastColor;
+uint32_t CNFGDialogColor; //background for boxes
+
+const unsigned short FontCharMap[256] = {
+	65535, 0, 10, 20, 32, 44, 56, 68, 70, 65535, 65535, 80, 92, 65535, 104, 114, 
+	126, 132, 138, 148, 156, 166, 180, 188, 200, 206, 212, 218, 224, 228, 238, 244, 
+	65535, 250, 254, 258, 266, 278, 288, 302, 304, 310, 316, 324, 328, 226, 252, 330, 
+	332, 342, 348, 358, 366, 372, 382, 392, 400, 410, 420, 424, 428, 262, 432, 436, 
+	446, 460, 470, 486, 496, 508, 516, 522, 536, 542, 548, 556, 568, 572, 580, 586, 
+	598, 608, 622, 634, 644, 648, 654, 662, 670, 682, 692, 700, 706, 708, 492, 198, 
+	714, 716, 726, 734, 742, 750, 760, 768, 782, 790, 794, 802, 204, 810, 820, 384, 
+	828, 836, 844, 850, 860, 864, 872, 880, 890, 894, 902, 908, 916, 920, 928, 934, 
+	65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 
+	65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 
+	944, 948, 960, 970, 986, 996, 1000, 1016, 1020, 1026, 1034, 1042, 364, 1046, 1056, 1058, 
+	1066, 1072, 1080, 932, 1092, 1100, 68, 1110, 1114, 1116, 1124, 1132, 1142, 1154, 1170, 1180, 
+	1192, 1204, 1218, 1234, 1248, 1264, 1276, 1290, 1300, 1310, 1322, 1334, 1342, 1350, 1360, 1370, 
+	1384, 1396, 1406, 1416, 1428, 1442, 1454, 1458, 1472, 1480, 1488, 1498, 1508, 1520, 1530, 1544, 
+	1556, 1568, 1582, 1598, 1612, 1628, 1642, 1654, 1666, 1678, 1692, 1706, 1710, 1714, 1720, 1726, 
+	1738, 1752, 1762, 1772, 1784, 1798, 1810, 1816, 1826, 1836, 1846, 1858, 1870, 1880, 1890, 65535, };
+
+const unsigned char FontCharData[1902] = {
+	0x00, 0x01, 0x20, 0x21, 0x03, 0x23, 0x23, 0x14, 0x14, 0x83, 0x00, 0x01, 0x20, 0x21, 0x04, 0x24, 
+	0x24, 0x13, 0x13, 0x84, 0x01, 0x21, 0x21, 0x23, 0x23, 0x14, 0x14, 0x03, 0x03, 0x01, 0x11, 0x92, 
+	0x11, 0x22, 0x22, 0x23, 0x23, 0x14, 0x14, 0x03, 0x03, 0x02, 0x02, 0x91, 0x01, 0x21, 0x21, 0x23, 
+	0x23, 0x01, 0x03, 0x21, 0x03, 0x01, 0x12, 0x94, 0x03, 0x23, 0x13, 0x14, 0x23, 0x22, 0x22, 0x11, 
+	0x11, 0x02, 0x02, 0x83, 0x12, 0x92, 0x12, 0x12, 0x01, 0x21, 0x21, 0x23, 0x23, 0x03, 0x03, 0x81, 
+	0x03, 0x21, 0x21, 0x22, 0x21, 0x11, 0x03, 0x14, 0x14, 0x23, 0x23, 0x92, 0x01, 0x10, 0x10, 0x21, 
+	0x21, 0x12, 0x12, 0x01, 0x12, 0x14, 0x03, 0xa3, 0x02, 0x03, 0x03, 0x13, 0x02, 0x12, 0x13, 0x10, 
+	0x10, 0xa1, 0x01, 0x23, 0x03, 0x21, 0x02, 0x11, 0x11, 0x22, 0x22, 0x13, 0x13, 0x82, 0x00, 0x22, 
+	0x22, 0x04, 0x04, 0x80, 0x20, 0x02, 0x02, 0x24, 0x24, 0xa0, 0x01, 0x10, 0x10, 0x21, 0x10, 0x14, 
+	0x14, 0x03, 0x14, 0xa3, 0x00, 0x03, 0x04, 0x04, 0x20, 0x23, 0x24, 0xa4, 0x00, 0x20, 0x00, 0x02, 
+	0x02, 0x22, 0x10, 0x14, 0x20, 0xa4, 0x01, 0x21, 0x21, 0x23, 0x23, 0x03, 0x03, 0x01, 0x20, 0x10, 
+	0x10, 0x14, 0x14, 0x84, 0x03, 0x23, 0x23, 0x24, 0x24, 0x04, 0x04, 0x83, 0x01, 0x10, 0x10, 0x21, 
+	0x10, 0x14, 0x14, 0x03, 0x14, 0x23, 0x04, 0xa4, 0x01, 0x10, 0x21, 0x10, 0x10, 0x94, 0x03, 0x14, 
+	0x23, 0x14, 0x10, 0x94, 0x02, 0x22, 0x22, 0x11, 0x22, 0x93, 0x02, 0x22, 0x02, 0x11, 0x02, 0x93, 
+	0x01, 0x02, 0x02, 0xa2, 0x02, 0x22, 0x22, 0x11, 0x11, 0x02, 0x02, 0x13, 0x13, 0xa2, 0x11, 0x22, 
+	0x22, 0x02, 0x02, 0x91, 0x02, 0x13, 0x13, 0x22, 0x22, 0x82, 0x10, 0x13, 0x14, 0x94, 0x10, 0x01, 
+	0x20, 0x91, 0x10, 0x14, 0x20, 0x24, 0x01, 0x21, 0x03, 0xa3, 0x21, 0x10, 0x10, 0x01, 0x01, 0x23, 
+	0x23, 0x14, 0x14, 0x03, 0x10, 0x94, 0x00, 0x01, 0x23, 0x24, 0x04, 0x03, 0x03, 0x21, 0x21, 0xa0, 
+	0x21, 0x10, 0x10, 0x01, 0x01, 0x12, 0x12, 0x03, 0x03, 0x14, 0x14, 0x23, 0x02, 0xa4, 0x10, 0x91, 
+	0x10, 0x01, 0x01, 0x03, 0x03, 0x94, 0x10, 0x21, 0x21, 0x23, 0x23, 0x94, 0x01, 0x23, 0x11, 0x13, 
+	0x21, 0x03, 0x02, 0xa2, 0x02, 0x22, 0x11, 0x93, 0x31, 0xc0, 0x03, 0xa1, 0x00, 0x20, 0x20, 0x24, 
+	0x24, 0x04, 0x04, 0x00, 0x12, 0x92, 0x01, 0x10, 0x10, 0x14, 0x04, 0xa4, 0x01, 0x10, 0x10, 0x21, 
+	0x21, 0x22, 0x22, 0x04, 0x04, 0xa4, 0x00, 0x20, 0x20, 0x24, 0x24, 0x04, 0x12, 0xa2, 0x00, 0x02, 
+	0x02, 0x22, 0x20, 0xa4, 0x20, 0x00, 0x00, 0x02, 0x02, 0x22, 0x22, 0x24, 0x24, 0x84, 0x20, 0x02, 
+	0x02, 0x22, 0x22, 0x24, 0x24, 0x04, 0x04, 0x82, 0x00, 0x20, 0x20, 0x21, 0x21, 0x12, 0x12, 0x94, 
+	0x00, 0x04, 0x00, 0x20, 0x20, 0x24, 0x04, 0x24, 0x02, 0xa2, 0x00, 0x02, 0x02, 0x22, 0x22, 0x20, 
+	0x20, 0x00, 0x22, 0x84, 0x11, 0x11, 0x13, 0x93, 0x11, 0x11, 0x13, 0x84, 0x20, 0x02, 0x02, 0xa4, 
+	0x00, 0x22, 0x22, 0x84, 0x01, 0x10, 0x10, 0x21, 0x21, 0x12, 0x12, 0x13, 0x14, 0x94, 0x21, 0x01, 
+	0x01, 0x04, 0x04, 0x24, 0x24, 0x22, 0x22, 0x12, 0x12, 0x13, 0x13, 0xa3, 0x04, 0x01, 0x01, 0x10, 
+	0x10, 0x21, 0x21, 0x24, 0x02, 0xa2, 0x00, 0x04, 0x04, 0x14, 0x14, 0x23, 0x23, 0x12, 0x12, 0x02, 
+	0x12, 0x21, 0x21, 0x10, 0x10, 0x80, 0x23, 0x14, 0x14, 0x03, 0x03, 0x01, 0x01, 0x10, 0x10, 0xa1, 
+	0x00, 0x10, 0x10, 0x21, 0x21, 0x23, 0x23, 0x14, 0x14, 0x04, 0x04, 0x80, 0x00, 0x04, 0x04, 0x24, 
+	0x00, 0x20, 0x02, 0x92, 0x00, 0x04, 0x00, 0x20, 0x02, 0x92, 0x21, 0x10, 0x10, 0x01, 0x01, 0x03, 
+	0x03, 0x14, 0x14, 0x23, 0x23, 0x22, 0x22, 0x92, 0x00, 0x04, 0x20, 0x24, 0x02, 0xa2, 0x00, 0x20, 
+	0x10, 0x14, 0x04, 0xa4, 0x00, 0x20, 0x20, 0x23, 0x23, 0x14, 0x14, 0x83, 0x00, 0x04, 0x02, 0x12, 
+	0x12, 0x21, 0x21, 0x20, 0x12, 0x23, 0x23, 0xa4, 0x00, 0x04, 0x04, 0xa4, 0x04, 0x00, 0x00, 0x11, 
+	0x11, 0x20, 0x20, 0xa4, 0x04, 0x00, 0x00, 0x22, 0x20, 0xa4, 0x01, 0x10, 0x10, 0x21, 0x21, 0x23, 
+	0x23, 0x14, 0x14, 0x03, 0x03, 0x81, 0x00, 0x04, 0x00, 0x10, 0x10, 0x21, 0x21, 0x12, 0x12, 0x82, 
+	0x01, 0x10, 0x10, 0x21, 0x21, 0x23, 0x23, 0x14, 0x14, 0x03, 0x03, 0x01, 0x04, 0x93, 0x00, 0x04, 
+	0x00, 0x10, 0x10, 0x21, 0x21, 0x12, 0x12, 0x02, 0x02, 0xa4, 0x21, 0x10, 0x10, 0x01, 0x01, 0x23, 
+	0x23, 0x14, 0x14, 0x83, 0x00, 0x20, 0x10, 0x94, 0x00, 0x04, 0x04, 0x24, 0x24, 0xa0, 0x00, 0x03, 
+	0x03, 0x14, 0x14, 0x23, 0x23, 0xa0, 0x00, 0x04, 0x04, 0x24, 0x14, 0x13, 0x24, 0xa0, 0x00, 0x01, 
+	0x01, 0x23, 0x23, 0x24, 0x04, 0x03, 0x03, 0x21, 0x21, 0xa0, 0x00, 0x01, 0x01, 0x12, 0x12, 0x14, 
+	0x12, 0x21, 0x21, 0xa0, 0x00, 0x20, 0x20, 0x02, 0x02, 0x04, 0x04, 0xa4, 0x10, 0x00, 0x00, 0x04, 
+	0x04, 0x94, 0x01, 0xa3, 0x10, 0x20, 0x20, 0x24, 0x24, 0x94, 0x00, 0x91, 0x02, 0x04, 0x04, 0x24, 
+	0x24, 0x22, 0x23, 0x12, 0x12, 0x82, 0x00, 0x04, 0x04, 0x24, 0x24, 0x22, 0x22, 0x82, 0x24, 0x04, 
+	0x04, 0x03, 0x03, 0x12, 0x12, 0xa2, 0x20, 0x24, 0x24, 0x04, 0x04, 0x02, 0x02, 0xa2, 0x24, 0x04, 
+	0x04, 0x02, 0x02, 0x22, 0x22, 0x23, 0x23, 0x93, 0x04, 0x01, 0x02, 0x12, 0x01, 0x10, 0x10, 0xa1, 
+	0x23, 0x12, 0x12, 0x03, 0x03, 0x14, 0x14, 0x23, 0x23, 0x24, 0x24, 0x15, 0x15, 0x84, 0x00, 0x04, 
+	0x03, 0x12, 0x12, 0x23, 0x23, 0xa4, 0x11, 0x11, 0x12, 0x94, 0x22, 0x22, 0x23, 0x24, 0x24, 0x15, 
+	0x15, 0x84, 0x00, 0x04, 0x03, 0x13, 0x13, 0x22, 0x13, 0xa4, 0x02, 0x04, 0x02, 0x13, 0x12, 0x14, 
+	0x12, 0x23, 0x23, 0xa4, 0x02, 0x04, 0x03, 0x12, 0x12, 0x23, 0x23, 0xa4, 0x02, 0x05, 0x04, 0x24, 
+	0x24, 0x22, 0x22, 0x82, 0x02, 0x04, 0x04, 0x24, 0x25, 0x22, 0x22, 0x82, 0x02, 0x04, 0x03, 0x12, 
+	0x12, 0xa2, 0x22, 0x02, 0x02, 0x03, 0x03, 0x23, 0x23, 0x24, 0x24, 0x84, 0x11, 0x14, 0x02, 0xa2, 
+	0x02, 0x04, 0x04, 0x14, 0x14, 0x23, 0x24, 0xa2, 0x02, 0x03, 0x03, 0x14, 0x14, 0x23, 0x23, 0xa2, 
+	0x02, 0x03, 0x03, 0x14, 0x14, 0x12, 0x13, 0x24, 0x24, 0xa2, 0x02, 0x24, 0x04, 0xa2, 0x02, 0x03, 
+	0x03, 0x14, 0x22, 0x23, 0x23, 0x85, 0x02, 0x22, 0x22, 0x04, 0x04, 0xa4, 0x20, 0x10, 0x10, 0x14, 
+	0x14, 0x24, 0x12, 0x82, 0x10, 0x11, 0x13, 0x94, 0x00, 0x10, 0x10, 0x14, 0x14, 0x04, 0x12, 0xa2, 
+	0x01, 0x10, 0x10, 0x11, 0x11, 0xa0, 0x03, 0x04, 0x04, 0x24, 0x24, 0x23, 0x23, 0x12, 0x12, 0x83, 
+	0x10, 0x10, 0x11, 0x94, 0x21, 0x10, 0x10, 0x01, 0x01, 0x02, 0x02, 0x13, 0x13, 0x22, 0x10, 0x93, 
+	0x11, 0x00, 0x00, 0x04, 0x04, 0x24, 0x24, 0x23, 0x02, 0x92, 0x01, 0x02, 0x11, 0x21, 0x22, 0x23, 
+	0x03, 0x13, 0x02, 0x11, 0x11, 0x22, 0x22, 0x13, 0x13, 0x82, 0x00, 0x11, 0x11, 0x20, 0x11, 0x14, 
+	0x02, 0x22, 0x03, 0xa3, 0x10, 0x12, 0x13, 0x95, 0x20, 0x00, 0x00, 0x02, 0x02, 0x11, 0x11, 0x22, 
+	0x02, 0x13, 0x13, 0x22, 0x22, 0x24, 0x24, 0x84, 0x00, 0x00, 0x20, 0xa0, 0x20, 0x10, 0x10, 0x11, 
+	0x11, 0xa1, 0x10, 0x21, 0x20, 0x21, 0x21, 0x11, 0x11, 0x90, 0x11, 0x02, 0x02, 0x13, 0x21, 0x12, 
+	0x12, 0xa3, 0x01, 0x21, 0x21, 0xa2, 0x10, 0x20, 0x20, 0x21, 0x21, 0x11, 0x12, 0x10, 0x11, 0xa2, 
+	0x00, 0xa0, 0x01, 0x10, 0x10, 0x21, 0x21, 0x12, 0x12, 0x81, 0x02, 0x22, 0x11, 0x13, 0x03, 0xa3, 
+	0x01, 0x10, 0x10, 0x21, 0x21, 0x03, 0x03, 0xa3, 0x01, 0x10, 0x10, 0x21, 0x21, 0x12, 0x12, 0x02, 
+	0x12, 0x23, 0x23, 0x83, 0x02, 0x05, 0x04, 0x14, 0x14, 0x23, 0x22, 0xa4, 0x14, 0x10, 0x10, 0x01, 
+	0x01, 0x12, 0x10, 0x20, 0x20, 0xa4, 0x14, 0x15, 0x15, 0x85, 0x20, 0xa1, 0x10, 0x20, 0x20, 0x21, 
+	0x21, 0x11, 0x11, 0x90, 0x01, 0x12, 0x12, 0x03, 0x11, 0x22, 0x22, 0x93, 0x00, 0x01, 0x02, 0x20, 
+	0x12, 0x13, 0x13, 0x23, 0x22, 0xa4, 0x00, 0x01, 0x02, 0x20, 0x12, 0x22, 0x22, 0x13, 0x13, 0x14, 
+	0x14, 0xa4, 0x00, 0x10, 0x10, 0x11, 0x11, 0x01, 0x11, 0x02, 0x02, 0x20, 0x12, 0x13, 0x13, 0x23, 
+	0x22, 0xa4, 0x10, 0x10, 0x11, 0x12, 0x12, 0x03, 0x03, 0x14, 0x14, 0xa3, 0x04, 0x02, 0x02, 0x11, 
+	0x11, 0x22, 0x22, 0x24, 0x03, 0x23, 0x10, 0xa1, 0x04, 0x02, 0x02, 0x11, 0x11, 0x22, 0x22, 0x24, 
+	0x03, 0x23, 0x01, 0x90, 0x04, 0x02, 0x02, 0x11, 0x11, 0x22, 0x22, 0x24, 0x03, 0x23, 0x01, 0x10, 
+	0x10, 0xa1, 0x04, 0x02, 0x02, 0x11, 0x11, 0x22, 0x22, 0x24, 0x03, 0x23, 0x01, 0x10, 0x10, 0x11, 
+	0x11, 0xa0, 0x04, 0x02, 0x02, 0x11, 0x11, 0x22, 0x22, 0x24, 0x03, 0x23, 0x00, 0x00, 0x20, 0xa0, 
+	0x04, 0x02, 0x02, 0x11, 0x11, 0x22, 0x22, 0x24, 0x03, 0x23, 0x00, 0x20, 0x20, 0x11, 0x11, 0x80, 
+	0x00, 0x04, 0x02, 0x22, 0x00, 0x11, 0x10, 0x14, 0x10, 0x20, 0x14, 0xa4, 0x23, 0x14, 0x14, 0x03, 
+	0x03, 0x01, 0x01, 0x10, 0x10, 0x21, 0x14, 0x15, 0x15, 0x85, 0x02, 0x22, 0x02, 0x04, 0x04, 0x24, 
+	0x03, 0x13, 0x00, 0x91, 0x02, 0x22, 0x02, 0x04, 0x04, 0x24, 0x03, 0x13, 0x11, 0xa0, 0x02, 0x22, 
+	0x02, 0x04, 0x04, 0x24, 0x03, 0x13, 0x01, 0x10, 0x10, 0xa1, 0x02, 0x22, 0x02, 0x04, 0x04, 0x24, 
+	0x03, 0x13, 0x00, 0x00, 0x20, 0xa0, 0x02, 0x22, 0x12, 0x14, 0x04, 0x24, 0x00, 0x91, 0x02, 0x22, 
+	0x12, 0x14, 0x04, 0x24, 0x11, 0xa0, 0x02, 0x22, 0x12, 0x14, 0x04, 0x24, 0x01, 0x10, 0x10, 0xa1, 
+	0x02, 0x22, 0x12, 0x14, 0x04, 0x24, 0x20, 0x20, 0x00, 0x80, 0x00, 0x10, 0x10, 0x21, 0x21, 0x23, 
+	0x23, 0x14, 0x14, 0x04, 0x04, 0x00, 0x02, 0x92, 0x04, 0x02, 0x02, 0x24, 0x24, 0x22, 0x01, 0x10, 
+	0x10, 0x11, 0x11, 0xa0, 0x02, 0x22, 0x22, 0x24, 0x24, 0x04, 0x04, 0x02, 0x00, 0x91, 0x02, 0x22, 
+	0x22, 0x24, 0x24, 0x04, 0x04, 0x02, 0x11, 0xa0, 0x02, 0x22, 0x22, 0x24, 0x24, 0x04, 0x04, 0x02, 
+	0x11, 0x20, 0x00, 0x91, 0x02, 0x22, 0x22, 0x24, 0x24, 0x04, 0x04, 0x02, 0x01, 0x10, 0x10, 0x11, 
+	0x11, 0xa0, 0x01, 0x21, 0x21, 0x24, 0x24, 0x04, 0x04, 0x01, 0x00, 0x00, 0x20, 0xa0, 0x01, 0x23, 
+	0x03, 0xa1, 0x01, 0x10, 0x10, 0x21, 0x21, 0x23, 0x23, 0x14, 0x14, 0x03, 0x03, 0x01, 0x03, 0xa1, 
+	0x01, 0x04, 0x04, 0x24, 0x24, 0x21, 0x11, 0xa0, 0x01, 0x04, 0x04, 0x24, 0x24, 0x21, 0x00, 0x91, 
+	0x02, 0x04, 0x04, 0x24, 0x24, 0x22, 0x01, 0x10, 0x10, 0xa1, 0x01, 0x04, 0x04, 0x24, 0x24, 0x21, 
+	0x00, 0x00, 0x20, 0xa0, 0x01, 0x02, 0x02, 0x13, 0x13, 0x14, 0x13, 0x22, 0x22, 0x21, 0x11, 0xa0, 
+	0x00, 0x04, 0x01, 0x11, 0x11, 0x22, 0x22, 0x13, 0x13, 0x83, 0x00, 0x05, 0x00, 0x10, 0x10, 0x21, 
+	0x21, 0x12, 0x02, 0x22, 0x22, 0x24, 0x24, 0x84, 0x02, 0x04, 0x04, 0x24, 0x24, 0x22, 0x23, 0x12, 
+	0x12, 0x02, 0x00, 0x91, 0x02, 0x04, 0x04, 0x24, 0x24, 0x22, 0x23, 0x12, 0x12, 0x02, 0x11, 0xa0, 
+	0x02, 0x04, 0x04, 0x24, 0x24, 0x22, 0x23, 0x12, 0x12, 0x02, 0x01, 0x10, 0x10, 0xa1, 0x02, 0x04, 
+	0x04, 0x24, 0x24, 0x22, 0x23, 0x12, 0x12, 0x02, 0x01, 0x10, 0x10, 0x11, 0x11, 0xa0, 0x02, 0x04, 
+	0x04, 0x24, 0x24, 0x22, 0x23, 0x12, 0x12, 0x02, 0x01, 0x01, 0x21, 0xa1, 0x02, 0x04, 0x04, 0x24, 
+	0x24, 0x22, 0x23, 0x12, 0x12, 0x02, 0x01, 0x10, 0x10, 0x21, 0x21, 0x81, 0x02, 0x13, 0x02, 0x04, 
+	0x04, 0x24, 0x12, 0x14, 0x12, 0x22, 0x13, 0x23, 0x22, 0xa3, 0x03, 0x04, 0x04, 0x24, 0x03, 0x12, 
+	0x12, 0x22, 0x14, 0x15, 0x15, 0x85, 0x24, 0x04, 0x04, 0x02, 0x02, 0x22, 0x22, 0x23, 0x23, 0x13, 
+	0x00, 0x91, 0x24, 0x04, 0x04, 0x02, 0x02, 0x22, 0x22, 0x23, 0x23, 0x13, 0x11, 0xa0, 0x24, 0x04, 
+	0x04, 0x02, 0x02, 0x22, 0x22, 0x23, 0x23, 0x13, 0x01, 0x10, 0x10, 0xa1, 0x24, 0x04, 0x04, 0x02, 
+	0x02, 0x22, 0x22, 0x23, 0x23, 0x13, 0x01, 0x01, 0x21, 0xa1, 0x12, 0x14, 0x00, 0x91, 0x12, 0x14, 
+	0x11, 0xa0, 0x12, 0x14, 0x01, 0x10, 0x10, 0xa1, 0x12, 0x14, 0x01, 0x01, 0x21, 0xa1, 0x00, 0x22, 
+	0x11, 0x20, 0x02, 0x22, 0x22, 0x24, 0x24, 0x04, 0x04, 0x82, 0x02, 0x04, 0x03, 0x12, 0x12, 0x23, 
+	0x23, 0x24, 0x01, 0x10, 0x10, 0x11, 0x11, 0xa0, 0x02, 0x04, 0x04, 0x24, 0x24, 0x22, 0x22, 0x02, 
+	0x00, 0x91, 0x02, 0x04, 0x04, 0x24, 0x24, 0x22, 0x22, 0x02, 0x11, 0xa0, 0x02, 0x04, 0x04, 0x24, 
+	0x24, 0x22, 0x22, 0x02, 0x01, 0x10, 0x10, 0xa1, 0x02, 0x04, 0x04, 0x24, 0x24, 0x22, 0x22, 0x02, 
+	0x01, 0x10, 0x10, 0x11, 0x11, 0xa0, 0x02, 0x04, 0x04, 0x24, 0x24, 0x22, 0x22, 0x02, 0x01, 0x01, 
+	0x21, 0xa1, 0x11, 0x11, 0x02, 0x22, 0x13, 0x93, 0x02, 0x04, 0x04, 0x24, 0x24, 0x22, 0x22, 0x02, 
+	0x04, 0xa2, 0x02, 0x04, 0x04, 0x14, 0x14, 0x23, 0x24, 0x22, 0x00, 0x91, 0x02, 0x04, 0x04, 0x14, 
+	0x14, 0x23, 0x24, 0x22, 0x11, 0xa0, 0x02, 0x04, 0x04, 0x14, 0x14, 0x23, 0x24, 0x22, 0x01, 0x10, 
+	0x10, 0xa1, 0x02, 0x04, 0x04, 0x14, 0x14, 0x23, 0x24, 0x22, 0x01, 0x01, 0x21, 0xa1, 0x02, 0x03, 
+	0x03, 0x14, 0x22, 0x23, 0x23, 0x05, 0x11, 0xa0, 0x00, 0x04, 0x02, 0x11, 0x11, 0x22, 0x22, 0x13, 
+	0x13, 0x82, 0x02, 0x03, 0x03, 0x14, 0x22, 0x23, 0x23, 0x05, 0x01, 0x01, 0x21, 0xa1, };
+
+
+
+void CNFGDrawText( const char * text, int scale )
+{
+	const unsigned char * lmap;
+	float iox = (float)CNFGPenX;
+	float ioy = (float)CNFGPenY;
+
+	int place = 0;
+	unsigned short index;
+	int bQuit = 0;
+	while( text[place] )
+	{
+		unsigned char c = text[place];
+
+		switch( c )
+		{
+		case 9:
+			iox += 12 * scale;
+			break;
+		case 10:
+			iox = (float)CNFGPenX;
+			ioy += 6 * scale;
+			break;
+		default:
+			index = FontCharMap[c];
+			if( index == 65535 )
+			{
+				iox += 3 * scale;
+				break;
+			}
+
+			lmap = &FontCharData[index];
+			do
+			{
+				int x1 = (int)((((*lmap) & 0x70)>>4)*scale + iox);
+				int y1 = (int)(((*lmap) & 0x0f)*scale + ioy);
+				int x2 = (int)((((*(lmap+1)) & 0x70)>>4)*scale + iox);
+				int y2 = (int)(((*(lmap+1)) & 0x0f)*scale + ioy);
+				lmap++;
+				if(x1 == x2 && y1 == y2){
+					CNFGTackPixel( x1, y1 );
+				} else {
+					CNFGTackSegment( x1, y1, x2, y2 );
+				}
+				bQuit = *lmap & 0x80;
+				lmap++;
+			} while( !bQuit );
+
+			iox += 3 * scale;
+		}
+		place++;
+	}
+}
+
+
+void CNFGDrawBox( int x1, int y1, int x2, int y2 )
+{
+	unsigned lc = CNFGLastColor;
+	CNFGColor( CNFGDialogColor );
+	CNFGTackRectangle( x1, y1, x2, y2 );
+	CNFGColor( lc );
+	CNFGTackSegment( x1, y1, x2, y1 );
+	CNFGTackSegment( x2, y1, x2, y2 );
+	CNFGTackSegment( x2, y2, x1, y2 );
+	CNFGTackSegment( x1, y2, x1, y1 );
+}
+
+void CNFGGetTextExtents( const char * text, int * w, int * h, int textsize )
+{
+	int charsx = 0;
+	int charsy = 1;
+	int charsline = 0;
+	const char * s;
+
+	for( s = text; *s; s++ )
+	{
+		if( *s == '\n' )
+		{
+			charsline = 0;
+			if( *(s+1) )
+				charsy++;
+		}
+		else
+		{
+			charsline++;
+			if( charsline > charsx )
+				charsx = charsline;
+		}
+	}
+
+	*w = charsx * textsize * 3 + textsize;
+	*h = charsy * textsize * 6;
+}
+
+void CNFGDrawTextbox( int x, int y, const char * text, int textsize )
+{
+	int w;
+	int h;
+
+	CNFGGetTextExtents( text, &w, &h, textsize );
+	
+	CNFGDrawBox( x, y, x + w, y + h );
+	CNFGPenX = x + textsize;
+	CNFGPenY = y + textsize;
+	CNFGDrawText( text, textsize );
+}
diff --git a/redist/DrawFunctions.h b/redist/DrawFunctions.h
new file mode 100644
index 0000000..542fcf9
--- /dev/null
+++ b/redist/DrawFunctions.h
@@ -0,0 +1,55 @@
+//Copyright (c) 2011 <>< Charles Lohr - Under the MIT/x11 or NewBSD License you choose.
+
+#ifndef _DRAWFUCNTIONS_H
+#define _DRAWFUCNTIONS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+typedef struct {
+    short x, y; 
+} RDPoint; 
+
+extern int CNFGPenX, CNFGPenY;
+extern uint32_t CNFGBGColor;
+extern uint32_t CNFGLastColor;
+extern uint32_t CNFGDialogColor; //background for boxes
+
+void CNFGDrawText( const char * text, int scale );
+void CNFGDrawBox(  int x1, int y1, int x2, int y2 );
+void CNFGGetTextExtents( const char * text, int * w, int * h, int textsize  );
+void CNFGDrawTextbox( int x, int y, const char * text, int textsize ); //ignores pen.
+
+//To be provided by driver.
+uint32_t CNFGColor( uint32_t RGB );
+void CNFGUpdateScreenWithBitmap( unsigned long * data, int w, int h );
+void CNFGTackPixel( short x1, short y1 );
+void CNFGTackSegment( short x1, short y1, short x2, short y2 );
+void CNFGTackRectangle( short x1, short y1, short x2, short y2 );
+void CNFGTackPoly( RDPoint * points, int verts );
+void CNFGClearFrame();
+void CNFGSwapBuffers();
+
+void CNFGGetDimensions( short * x, short * y );
+void CNFGTearDown();
+void CNFGSetup( const char * WindowName, int w, int h );
+void CNFGSetupFullscreen( const char * WindowName, int screen_number );
+void CNFGHandleInput();
+
+
+//You must provide:
+void HandleKey( int keycode, int bDown );
+void HandleButton( int x, int y, int button, int bDown );
+void HandleMotion( int x, int y, int mask );
+
+
+#ifdef __cplusplus
+};
+#endif
+
+
+#endif
+
diff --git a/redist/WinDriver.c b/redist/WinDriver.c
new file mode 100644
index 0000000..a6dd1e6
--- /dev/null
+++ b/redist/WinDriver.c
@@ -0,0 +1,231 @@
+//Copyright (c) 2011 <>< Charles Lohr - Under the MIT/x11 or NewBSD License you choose.
+//Portion from: http://en.wikibooks.org/wiki/Windows_Programming/Window_Creation
+
+
+#include "DrawFunctions.h"
+#include <windows.h>
+#include <stdlib.h>
+#include <malloc.h> //for alloca
+
+static HINSTANCE lhInstance;
+static HWND lsHWND;
+static HDC lsHDC;
+static HBITMAP lsBackBitmap;
+static HDC lsWindowHDC;
+static HBRUSH lsHBR;
+static HPEN lsHPEN;
+static HBRUSH lsClearBrush;
+static unsigned int lsLastWidth;
+static unsigned int lsLastHeight;
+
+static void InternalHandleResize()
+{
+	DeleteObject( lsBackBitmap );
+	lsBackBitmap = CreateCompatibleBitmap( lsHDC, lsLastWidth, lsLastHeight );
+	SelectObject( lsHDC, lsBackBitmap );
+
+}
+
+uint32_t CNFGColor( uint32_t RGB )
+{
+	CNFGLastColor = RGB;
+
+	DeleteObject( lsHBR );
+	lsHBR = CreateSolidBrush( RGB );
+	SelectObject( lsHDC, lsHBR );
+
+	DeleteObject( lsHPEN );
+	lsHPEN = CreatePen( PS_SOLID, 0, RGB );
+	SelectObject( lsHDC, lsHPEN );
+
+	return RGB;
+}
+
+void CNFGTackSegment( short x1, short y1, short x2, short y2 )
+{
+	POINT pt[2] = { {x1, y1}, {x2, y2} };
+	Polyline( lsHDC, pt, 2 );
+	SetPixel( lsHDC, x1, y1, CNFGLastColor );
+	SetPixel( lsHDC, x2, y2, CNFGLastColor );
+}
+
+void CNFGTackRectangle( short x1, short y1, short x2, short y2 )
+{
+	RECT r;
+	if( x1 < x2 ) { r.left = x1; r.right = x2; }
+	else          { r.left = x2; r.right = x1; }
+	if( y1 < y2 ) { r.top = y1; r.bottom = y2; }
+	else          { r.top = y2; r.bottom = y1; }
+	FillRect( lsHDC, &r, lsHBR );
+}
+
+void CNFGClearFrame()
+{
+	RECT r = { 0, 0, lsLastWidth, lsLastHeight };
+	DeleteObject( lsClearBrush  );
+	lsClearBrush = CreateSolidBrush( CNFGBGColor );
+	SelectObject( lsHDC, lsClearBrush );
+
+	FillRect( lsHDC, &r, lsClearBrush );
+}
+
+void CNFGSwapBuffers()
+{
+	int thisw, thish;
+	RECT r;
+	BitBlt( lsWindowHDC, 0, 0, lsLastWidth, lsLastHeight, lsHDC, 0, 0, SRCCOPY );
+	UpdateWindow( lsHWND );
+
+	//Check to see if the window is closed.
+	if( !IsWindow( lsHWND ) )
+	{
+		exit( 0 );
+	}
+
+	GetClientRect( lsHWND, &r );
+	thisw = r.right - r.left;
+	thish = r.bottom - r.top;
+	if( thisw != lsLastWidth || thish != lsLastHeight )
+	{
+		lsLastWidth = thisw;
+		lsLastHeight = thish;
+		InternalHandleResize();
+	}
+}
+
+void CNFGTackPoly( RDPoint * points, int verts )
+{
+	int i;
+	POINT * t = (POINT*)alloca( sizeof( POINT ) * verts );
+	for( i = 0; i < verts; i++ )
+	{
+		t[i].x = points[i].x;
+		t[i].y = points[i].y;
+	}
+	Polygon( lsHDC, t, verts );
+}
+
+
+void CNFGTackPixel( short x1, short y1 )
+{
+	SetPixel( lsHDC, x1, y1, CNFGLastColor );
+}
+
+void CNFGGetDimensions( short * x, short * y )
+{
+	*x = lsLastWidth;
+	*y = lsLastHeight;
+}
+
+//This was from the article
+LRESULT CALLBACK MyWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	switch(msg)
+	{
+	case WM_DESTROY:
+		CNFGTearDown();
+		return 0;
+	}
+	return DefWindowProc(hwnd, msg, wParam, lParam);
+}
+
+void CNFGTearDown()
+{
+	PostQuitMessage(0);
+}
+
+//This was from the article, too... well, mostly.
+void CNFGSetup( const char * name_of_window, int width, int height )
+{
+	static LPSTR szClassName = "MyClass";
+	RECT client, window;
+	WNDCLASS wnd;
+	int w, h, wd, hd;
+	HINSTANCE hInstance = GetModuleHandle(NULL);
+
+	lsLastWidth = width;
+	lsLastHeight = height;
+
+	wnd.style = CS_HREDRAW | CS_VREDRAW; //we will explain this later
+	wnd.lpfnWndProc = MyWndProc;
+	wnd.cbClsExtra = 0;
+	wnd.cbWndExtra = 0;
+	wnd.hInstance = hInstance;
+	wnd.hIcon = LoadIcon(NULL, IDI_APPLICATION); //default icon
+	wnd.hCursor = LoadCursor(NULL, IDC_ARROW);   //default arrow mouse cursor
+	wnd.hbrBackground = (HBRUSH)(COLOR_BACKGROUND);
+	wnd.lpszMenuName = NULL;                     //no menu
+	wnd.lpszClassName = szClassName;
+
+	if(!RegisterClass(&wnd))                     //register the WNDCLASS
+	{
+		MessageBox(NULL, "This Program Requires Windows NT", "Error", MB_OK);
+	}
+
+	lsHWND = CreateWindow(szClassName,
+		name_of_window,      //name_of_window,
+		WS_OVERLAPPEDWINDOW, //basic window style
+		CW_USEDEFAULT,
+		CW_USEDEFAULT,       //set starting point to default value
+		lsLastWidth,
+		lsLastHeight,        //set all the dimensions to default value
+		NULL,                //no parent window
+		NULL,                //no menu
+		hInstance,
+		NULL);               //no parameters to pass
+
+
+	lsWindowHDC = GetDC( lsHWND );
+	lsHDC = CreateCompatibleDC( lsWindowHDC );
+	lsBackBitmap = CreateCompatibleBitmap( lsWindowHDC, lsLastWidth, lsLastHeight );
+	SelectObject( lsHDC, lsBackBitmap );
+
+	lsClearBrush = CreateSolidBrush( CNFGBGColor );
+	lsHBR = CreateSolidBrush( 0xFFFFFF );
+	lsHPEN = CreatePen( PS_SOLID, 0, 0xFFFFFF );
+
+	ShowWindow(lsHWND, 1);              //display the window on the screen
+
+	//Once set up... we have to change the window's borders so we get the client size right.
+	GetClientRect( lsHWND, &client );
+	GetWindowRect( lsHWND, &window );
+	w = ( window.right - window.left);
+	h = ( window.bottom - window.top);
+	wd = w - client.right;
+	hd = h - client.bottom;
+	MoveWindow( lsHWND, window.left, window.top, lsLastWidth + wd, lsLastHeight + hd, 1 );
+
+	InternalHandleResize();
+}
+
+void CNFGHandleInput()
+{
+	int ldown = 0;
+
+	MSG msg;
+	while( PeekMessage( &msg, lsHWND, 0, 0xFFFF, 1 ) )
+	{
+		TranslateMessage(&msg);
+
+		switch( msg.message )
+		{
+		case WM_MOUSEMOVE:
+			HandleMotion( (msg.lParam & 0xFFFF), (msg.lParam>>16) & 0xFFFF, ( (msg.wParam & 0x01)?1:0) | ((msg.wParam & 0x02)?2:0) | ((msg.wParam & 0x10)?4:0) );
+			break;
+		case WM_LBUTTONDOWN:	HandleButton( (msg.lParam & 0xFFFF), (msg.lParam>>16) & 0xFFFF, 1, 1 ); break;
+		case WM_RBUTTONDOWN:	HandleButton( (msg.lParam & 0xFFFF), (msg.lParam>>16) & 0xFFFF, 2, 1 ); break;
+		case WM_MBUTTONDOWN:	HandleButton( (msg.lParam & 0xFFFF), (msg.lParam>>16) & 0xFFFF, 3, 1 ); break;
+		case WM_LBUTTONUP:		HandleButton( (msg.lParam & 0xFFFF), (msg.lParam>>16) & 0xFFFF, 1, 0 ); break;
+		case WM_RBUTTONUP:		HandleButton( (msg.lParam & 0xFFFF), (msg.lParam>>16) & 0xFFFF, 2, 0 ); break;
+		case WM_MBUTTONUP:		HandleButton( (msg.lParam & 0xFFFF), (msg.lParam>>16) & 0xFFFF, 3, 0 ); break;
+		case WM_KEYDOWN:
+		case WM_KEYUP:
+			HandleKey( tolower( msg.wParam ), (msg.message==WM_KEYDOWN) );
+			break;
+		default:
+			DispatchMessage(&msg);
+			break;
+		}
+	}
+}
+
diff --git a/redist/XDriver.c b/redist/XDriver.c
new file mode 100644
index 0000000..942fe0f
--- /dev/null
+++ b/redist/XDriver.c
@@ -0,0 +1,290 @@
+//Copyright (c) 2011 <>< Charles Lohr - Under the MIT/x11 or NewBSD License you choose.
+//portions from 
+//http://www.xmission.com/~georgeps/documentation/tutorials/Xlib_Beginner.html
+
+#define HAS_XINERAMA
+
+#include "DrawFunctions.h"
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xos.h>
+#include <X11/Xatom.h>
+#include <X11/keysym.h>
+#ifdef HAS_XINERAMA
+#include <X11/extensions/shape.h>
+#include <X11/extensions/Xinerama.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+
+XWindowAttributes CNFGWinAtt;
+XClassHint *CNFGClassHint;
+Display *CNFGDisplay;
+Window CNFGWindow;
+Pixmap CNFGPixmap;
+GC     CNFGGC;
+GC     CNFGWindowGC;
+int FullScreen = 0;
+
+void CNFGGetDimensions( short * x, short * y )
+{
+	*x = CNFGWinAtt.width;
+	*y = CNFGWinAtt.height;
+}
+
+static void InternalLinkScreenAndGo( const char * WindowName )
+{
+	XGetWindowAttributes( CNFGDisplay, CNFGWindow, &CNFGWinAtt );
+
+	XGetClassHint( CNFGDisplay, CNFGWindow, CNFGClassHint );
+	if (!CNFGClassHint) {
+		CNFGClassHint = XAllocClassHint();
+		if (CNFGClassHint) {
+			CNFGClassHint->res_name = "cnping";
+			CNFGClassHint->res_class = "cnping";
+			XSetClassHint( CNFGDisplay, CNFGWindow, CNFGClassHint );
+		} else {
+			fprintf( stderr, "Failed to allocate XClassHint!\n" );
+		}
+	} else {
+		fprintf( stderr, "Pre-existing XClassHint\n" );
+	}
+
+	XSelectInput (CNFGDisplay, CNFGWindow, KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | ExposureMask | PointerMotionMask );
+	XSetStandardProperties( CNFGDisplay, CNFGWindow, WindowName, WindowName, None, NULL, 0, NULL );
+
+	CNFGWindowGC = XCreateGC(CNFGDisplay, CNFGWindow, 0, 0);
+
+	CNFGPixmap = XCreatePixmap( CNFGDisplay, CNFGWindow, CNFGWinAtt.width, CNFGWinAtt.height, CNFGWinAtt.depth );
+	CNFGGC = XCreateGC(CNFGDisplay, CNFGPixmap, 0, 0);
+}
+
+void CNFGSetupFullscreen( const char * WindowName, int screen_no )
+{
+#ifdef HAS_XINERAMA
+	XineramaScreenInfo *screeninfo = NULL;
+	int screens;
+	int event_basep, error_basep, a, b;
+	CNFGDisplay = XOpenDisplay(NULL);
+	int screen = XDefaultScreen(CNFGDisplay);
+	int xpos, ypos;
+
+	if (!XShapeQueryExtension(CNFGDisplay, &event_basep, &error_basep))
+	{
+    	fprintf( stderr, "X-Server does not support shape extension" );
+		exit( 1 );
+	}
+
+ 	Visual * visual = DefaultVisual(CNFGDisplay, screen);
+	CNFGWinAtt.depth = DefaultDepth(CNFGDisplay, screen);
+
+	if (XineramaQueryExtension(CNFGDisplay, &a, &b ) &&
+		(screeninfo = XineramaQueryScreens(CNFGDisplay, &screens)) &&
+		XineramaIsActive(CNFGDisplay) && screen_no >= 0 &&
+		screen_no < screens ) {
+
+		CNFGWinAtt.width = screeninfo[screen_no].width;
+		CNFGWinAtt.height = screeninfo[screen_no].height;
+		xpos = screeninfo[screen_no].x_org;
+		ypos = screeninfo[screen_no].y_org;
+	} else
+	{
+		CNFGWinAtt.width = XDisplayWidth(CNFGDisplay, screen);
+		CNFGWinAtt.height = XDisplayHeight(CNFGDisplay, screen);
+		xpos = 0;
+		ypos = 0;
+	}
+	if (screeninfo)
+	XFree(screeninfo);
+
+
+	XSetWindowAttributes setwinattr;
+	setwinattr.override_redirect = 1;
+	setwinattr.save_under = 1;
+	setwinattr.event_mask = StructureNotifyMask | SubstructureNotifyMask | ExposureMask | ButtonPressMask | ButtonReleaseMask | ButtonPressMask | PointerMotionMask | ButtonMotionMask | EnterWindowMask | LeaveWindowMask |KeyPressMask |KeyReleaseMask | SubstructureNotifyMask | FocusChangeMask;
+	setwinattr.border_pixel = 0;
+
+	CNFGWindow = XCreateWindow(CNFGDisplay, XRootWindow(CNFGDisplay, screen),
+		xpos, ypos, CNFGWinAtt.width, CNFGWinAtt.height,
+		0, CNFGWinAtt.depth, InputOutput, visual, CWBorderPixel | CWEventMask | CWOverrideRedirect | CWSaveUnder, &setwinattr);
+
+	XMapWindow(CNFGDisplay, CNFGWindow);
+	XSetInputFocus( CNFGDisplay, CNFGWindow,   RevertToParent, CurrentTime );
+	XFlush(CNFGDisplay);
+	FullScreen = 1;
+//printf( "%d %d %d %d\n", xpos, ypos, CNFGWinAtt.width, CNFGWinAtt.height );
+	InternalLinkScreenAndGo( WindowName );
+/*
+	setwinattr.override_redirect = 1;
+	XChangeWindowAttributes(
+		CNFGDisplay, CNFGWindow,
+		CWBorderPixel | CWEventMask | CWOverrideRedirect, &setwinattr);
+*/
+#else
+	CNFGSetup( WindowName, 640, 480 );
+#endif
+}
+
+
+void CNFGTearDown()
+{
+	if ( CNFGClassHint ) XFree( CNFGClassHint );
+	if ( CNFGGC ) XFreeGC( CNFGDisplay, CNFGGC );
+	if ( CNFGWindowGC ) XFreeGC( CNFGDisplay, CNFGWindowGC );
+	if ( CNFGDisplay ) XCloseDisplay( CNFGDisplay );
+	CNFGDisplay = NULL;
+	CNFGWindowGC = CNFGGC = NULL;
+	CNFGClassHint = NULL;
+}
+
+void CNFGSetup( const char * WindowName, int w, int h )
+{
+	CNFGDisplay = XOpenDisplay(NULL);
+	atexit( CNFGTearDown );
+	XGetWindowAttributes( CNFGDisplay, RootWindow(CNFGDisplay, 0), &CNFGWinAtt );
+
+	int depth = CNFGWinAtt.depth;
+	CNFGWindow = XCreateWindow(CNFGDisplay, RootWindow(CNFGDisplay, 0), 1, 1, w, h, 0, depth, InputOutput, CopyFromParent, 0, 0 );
+	XMapWindow(CNFGDisplay, CNFGWindow);
+	XFlush(CNFGDisplay);
+
+	InternalLinkScreenAndGo( WindowName );
+
+	Atom WM_DELETE_WINDOW = XInternAtom( CNFGDisplay, "WM_DELETE_WINDOW", False );
+	XSetWMProtocols( CNFGDisplay, CNFGWindow, &WM_DELETE_WINDOW, 1 );
+	XSelectInput( CNFGDisplay, CNFGWindow, KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | ExposureMask | PointerMotionMask );
+}
+
+void CNFGHandleInput()
+{
+	static int ButtonsDown;
+	XEvent report;
+
+	int bKeyDirection = 1;
+	int r;
+	while( XPending( CNFGDisplay ) )
+	{
+		r=XNextEvent( CNFGDisplay, &report );
+
+		bKeyDirection = 1;
+		switch  (report.type)
+		{
+		case NoExpose:
+			break;
+		case Expose:
+			XGetWindowAttributes( CNFGDisplay, CNFGWindow, &CNFGWinAtt );
+			if( CNFGPixmap ) XFreePixmap( CNFGDisplay, CNFGPixmap );
+			CNFGPixmap = XCreatePixmap( CNFGDisplay, CNFGWindow, CNFGWinAtt.width, CNFGWinAtt.height, CNFGWinAtt.depth );
+			if( CNFGGC ) XFreeGC( CNFGDisplay, CNFGGC );
+			CNFGGC = XCreateGC(CNFGDisplay, CNFGPixmap, 0, 0);
+			break;
+		case KeyRelease:
+			bKeyDirection = 0;
+		case KeyPress:
+			HandleKey( XLookupKeysym(&report.xkey, 0), bKeyDirection );
+			break;
+		case ButtonRelease:
+			bKeyDirection = 0;
+		case ButtonPress:
+			HandleButton( report.xbutton.x, report.xbutton.y, report.xbutton.button, bKeyDirection );
+			ButtonsDown = (ButtonsDown & (~(1<<report.xbutton.button))) | ( bKeyDirection << report.xbutton.button );
+
+			//Intentionall fall through -- we want to send a motion in event of a button as well.
+		case MotionNotify:
+			HandleMotion( report.xmotion.x, report.xmotion.y, ButtonsDown>>1 );
+			break;
+		case ClientMessage:
+			// Only subscribed to WM_DELETE_WINDOW, so just exit
+			exit( 0 );
+			break;
+		default:
+			printf( "Event: %d\n", report.type );
+		}
+	}
+}
+
+
+void CNFGUpdateScreenWithBitmap( unsigned long * data, int w, int h )
+{
+	static XImage *xi;
+	static int depth;
+	static int lw, lh;
+	static unsigned char * lbuffer;
+	int r, ls;
+
+	if( !xi )
+	{
+		int screen = DefaultScreen(CNFGDisplay);
+		Visual * visual = DefaultVisual(CNFGDisplay, screen);
+		depth = DefaultDepth(CNFGDisplay, screen)/8;
+//		xi = XCreateImage(CNFGDisplay, DefaultVisual( CNFGDisplay, DefaultScreen(CNFGDisplay) ), depth*8, ZPixmap, 0, (char*)data, w, h, 32, w*4 );
+//		lw = w;
+//		lh = h;
+	}
+
+	if( lw != w || lh != h )
+	{
+		if( xi ) free( xi );
+		xi = XCreateImage(CNFGDisplay, DefaultVisual( CNFGDisplay, DefaultScreen(CNFGDisplay) ), depth*8, ZPixmap, 0, (char*)data, w, h, 32, w*4 );
+		lw = w;
+		lh = h;
+	}
+
+	ls = lw * lh;
+
+	XPutImage(CNFGDisplay, CNFGWindow, CNFGWindowGC, xi, 0, 0, 0, 0, w, h );
+}
+
+
+#ifndef RASTERIZER
+
+
+uint32_t CNFGColor( uint32_t RGB )
+{
+	unsigned char red = RGB & 0xFF;
+	unsigned char grn = ( RGB >> 8 ) & 0xFF;
+	unsigned char blu = ( RGB >> 16 ) & 0xFF;
+	CNFGLastColor = RGB;
+	unsigned long color = (red<<16)|(grn<<8)|(blu);
+	XSetForeground(CNFGDisplay, CNFGGC, color);
+	return color;
+}
+
+void CNFGClearFrame()
+{
+	XGetWindowAttributes( CNFGDisplay, CNFGWindow, &CNFGWinAtt );
+	XSetForeground(CNFGDisplay, CNFGGC, CNFGColor(CNFGBGColor) );	
+	XFillRectangle(CNFGDisplay, CNFGPixmap, CNFGGC, 0, 0, CNFGWinAtt.width, CNFGWinAtt.height );
+}
+
+void CNFGSwapBuffers()
+{
+	XCopyArea(CNFGDisplay, CNFGPixmap, CNFGWindow, CNFGWindowGC, 0,0,CNFGWinAtt.width,CNFGWinAtt.height,0,0);
+	XFlush(CNFGDisplay);
+	if( FullScreen )
+		XSetInputFocus( CNFGDisplay, CNFGWindow, RevertToParent, CurrentTime );
+}
+
+void CNFGTackSegment( short x1, short y1, short x2, short y2 )
+{
+	XDrawLine( CNFGDisplay, CNFGPixmap, CNFGGC, x1, y1, x2, y2 );
+}
+
+void CNFGTackPixel( short x1, short y1 )
+{
+	XDrawPoint( CNFGDisplay, CNFGPixmap, CNFGGC, x1, y1 );
+}
+
+void CNFGTackRectangle( short x1, short y1, short x2, short y2 )
+{
+	XFillRectangle(CNFGDisplay, CNFGPixmap, CNFGGC, x1, y1, x2-x1, y2-y1 );
+}
+
+void CNFGTackPoly( RDPoint * points, int verts )
+{
+	XFillPolygon(CNFGDisplay, CNFGPixmap, CNFGGC, (XPoint *)points, 3, Convex, CoordModeOrigin );
+}
+
+#endif
+
diff --git a/redist/os_generic.c b/redist/os_generic.c
new file mode 100644
index 0000000..7a5af86
--- /dev/null
+++ b/redist/os_generic.c
@@ -0,0 +1,335 @@
+#include "os_generic.h"
+
+
+#ifdef USE_WINDOWS
+
+#include <windows.h>
+
+void OGSleep( int is )
+{
+	Sleep( is*1000 );
+}
+
+void OGUSleep( int ius )
+{
+	Sleep( ius/1000 );
+}
+
+double OGGetAbsoluteTime()
+{
+	static LARGE_INTEGER lpf;
+	LARGE_INTEGER li;
+
+	if( !lpf.QuadPart )
+	{
+		QueryPerformanceFrequency( &lpf );
+	}
+
+	QueryPerformanceCounter( &li );
+	return (double)li.QuadPart / (double)lpf.QuadPart;
+}
+
+
+double OGGetFileTime( const char * file )
+{
+	FILETIME ft;
+
+	HANDLE h = CreateFile(file, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
+
+	if( h==INVALID_HANDLE_VALUE )
+		return -1;
+
+	GetFileTime( h, 0, 0, &ft );
+
+	CloseHandle( h );
+
+	return ft.dwHighDateTime + ft.dwLowDateTime;
+}
+
+
+og_thread_t OGCreateThread( void * (routine)( void * ), void * parameter )
+{
+	return (og_thread_t)CreateThread( 0, 0, (LPTHREAD_START_ROUTINE)routine, parameter, 0, 0 );
+}
+
+void * OGJoinThread( og_thread_t ot )
+{
+	WaitForSingleObject( ot, INFINITE );
+	CloseHandle( ot );
+}
+
+void OGCancelThread( og_thread_t ot )
+{
+	CloseHandle( ot );	
+}
+
+og_mutex_t OGCreateMutex()
+{
+	return CreateMutex( 0, 0, 0 );
+}
+
+void OGLockMutex( og_mutex_t om )
+{
+	WaitForSingleObject(om, INFINITE);
+}
+
+void OGUnlockMutex( og_mutex_t om )
+{
+	ReleaseMutex(om);
+}
+
+void OGDeleteMutex( og_mutex_t om )
+{
+	CloseHandle( om );
+}
+
+
+
+og_sema_t OGCreateSema()
+{
+	HANDLE sem = CreateSemaphore( 0, 0, 32767, 0 );
+	return (og_sema_t)sem;
+}
+
+int OGGetSema( og_sema_t os )
+{
+	typedef LONG NTSTATUS;
+	HANDLE sem = (HANDLE)os;
+	typedef NTSTATUS (NTAPI *_NtQuerySemaphore)(
+		HANDLE SemaphoreHandle, 
+		DWORD SemaphoreInformationClass, /* Would be SEMAPHORE_INFORMATION_CLASS */
+		PVOID SemaphoreInformation,      /* but this is to much to dump here     */
+		ULONG SemaphoreInformationLength, 
+		PULONG ReturnLength OPTIONAL
+	);
+
+	typedef struct _SEMAPHORE_BASIC_INFORMATION {   
+		ULONG CurrentCount; 
+		ULONG MaximumCount;
+	} SEMAPHORE_BASIC_INFORMATION;
+
+
+	static _NtQuerySemaphore NtQuerySemaphore;
+	SEMAPHORE_BASIC_INFORMATION BasicInfo;
+	NTSTATUS Status;
+
+	if( !NtQuerySemaphore )
+	{	
+	    NtQuerySemaphore = (_NtQuerySemaphore)GetProcAddress (GetModuleHandle ("ntdll.dll"), "NtQuerySemaphore");
+		if( !NtQuerySemaphore )
+		{
+			return -1;
+		}
+	}
+
+	
+    Status = NtQuerySemaphore (sem, 0 /*SemaphoreBasicInformation*/, 
+        &BasicInfo, sizeof (SEMAPHORE_BASIC_INFORMATION), NULL);
+
+    if (Status == ERROR_SUCCESS)
+    {       
+        return BasicInfo.CurrentCount;
+    }
+
+	return -2;
+}
+
+void OGLockSema( og_sema_t os )
+{
+	WaitForSingleObject( (HANDLE)os, INFINITE );
+}
+
+void OGUnlockSema( og_sema_t os )
+{
+	ReleaseSemaphore( (HANDLE)os, 1, 0 );
+}
+
+void OGDeleteSema( og_sema_t os )
+{
+	CloseHandle( os );
+}
+
+#else
+
+#define _GNU_SOURCE
+
+
+#include <sys/stat.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <sys/time.h>
+#include <semaphore.h>
+
+pthread_mutex_t g_RawMutexStart = PTHREAD_MUTEX_INITIALIZER;
+
+void OGSleep( int is )
+{
+	sleep( is );
+}
+
+void OGUSleep( int ius )
+{
+	usleep( ius );
+}
+
+double OGGetAbsoluteTime()
+{
+	struct timeval tv;
+	gettimeofday( &tv, 0 );
+	return ((double)tv.tv_usec)/1000000. + (tv.tv_sec);
+}
+
+double OGGetFileTime( const char * file )
+{
+	struct stat buff; 
+
+	int r = stat( file, &buff );
+
+	if( r < 0 )
+	{
+		return -1;
+	}
+
+	return buff.st_mtime;
+}
+
+
+
+og_thread_t OGCreateThread( void * (routine)( void * ), void * parameter )
+{
+	pthread_t * ret = malloc( sizeof( pthread_t ) );
+	int r = pthread_create( ret, 0, routine, parameter );
+	if( r )
+	{
+		free( ret );
+		return 0;
+	}
+	return (og_thread_t)ret;
+}
+
+void * OGJoinThread( og_thread_t ot )
+{
+	void * retval;
+	if( !ot )
+	{
+		return 0;
+	}
+	pthread_join( *(pthread_t*)ot, &retval );
+	free( ot );
+	return retval;
+}
+
+void OGCancelThread( og_thread_t ot )
+{
+	if( !ot )
+	{
+		return;
+	}
+	pthread_cancel( *(pthread_t*)ot );
+	free( ot );
+}
+
+og_mutex_t OGCreateMutex()
+{
+	pthread_mutexattr_t   mta;
+	og_mutex_t r = malloc( sizeof( pthread_mutex_t ) );
+
+	pthread_mutexattr_init(&mta);
+	pthread_mutexattr_settype(&mta, PTHREAD_MUTEX_RECURSIVE);
+
+	pthread_mutex_init( (pthread_mutex_t *)r, &mta );
+
+	return r;
+}
+
+void OGLockMutex( og_mutex_t om )
+{
+	if( !om )
+	{
+		return;
+	}
+	pthread_mutex_lock( (pthread_mutex_t*)om );
+}
+
+void OGUnlockMutex( og_mutex_t om )
+{
+	if( !om )
+	{
+		return;
+	}
+	pthread_mutex_unlock( (pthread_mutex_t*)om );
+}
+
+void OGDeleteMutex( og_mutex_t om )
+{
+	if( !om )
+	{
+		return;
+	}
+
+	pthread_mutex_destroy( (pthread_mutex_t*)om );
+	free( om );
+}
+
+
+
+
+og_sema_t OGCreateSema()
+{
+	sem_t * sem = malloc( sizeof( sem_t ) );
+	sem_init( sem, 0, 0 );
+	return (og_sema_t)sem;
+}
+
+int OGGetSema( og_sema_t os )
+{
+	int valp;
+	sem_getvalue( os, &valp );
+	return valp;
+}
+
+
+void OGLockSema( og_sema_t os )
+{
+	sem_wait( os );
+}
+
+void OGUnlockSema( og_sema_t os )
+{
+	sem_post( os );
+}
+
+void OGDeleteSema( og_sema_t os )
+{
+	sem_destroy( os );
+	free(os);
+}
+
+
+
+#endif
+
+//Date Stamp: 2012-02-15
+
+/*
+   Copyright (c) 2011-2012 <>< Charles Lohr
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of this file.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+   IN THE SOFTWARE.
+*/
+
diff --git a/redist/os_generic.h b/redist/os_generic.h
new file mode 100644
index 0000000..7ce22f2
--- /dev/null
+++ b/redist/os_generic.h
@@ -0,0 +1,76 @@
+#ifndef _OS_GENERIC_H

+#define _OS_GENERIC_H

+

+#ifdef WIN32

+#define USE_WINDOWS

+#endif

+

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+//Things that shouldn't be macro'd

+double OGGetAbsoluteTime();

+void OGSleep( int is );

+void OGUSleep( int ius );

+double OGGetFileTime( const char * file );

+

+//Threads and Mutices

+typedef void* og_thread_t;

+typedef void* og_mutex_t;

+typedef void* og_sema_t;

+

+og_thread_t OGCreateThread( void * (routine)( void * ), void * parameter );

+void * OGJoinThread( og_thread_t ot );

+void OGCancelThread( og_thread_t ot );

+

+//Always a recrusive mutex.

+og_mutex_t OGCreateMutex();

+void OGLockMutex( og_mutex_t om );

+void OGUnlockMutex( og_mutex_t om );

+void OGDeleteMutex( og_mutex_t om );

+

+//Always a semaphore

+og_sema_t OGCreateSema(); //Create a semaphore, comes locked initially.  NOTE: Max count is 32767

+void OGLockSema( og_sema_t os );

+int OGGetSema( og_sema_t os );  //if <0 there was a failure.

+void OGUnlockSema( og_sema_t os );

+void OGDeleteSema( og_sema_t os );

+

+#ifdef __cplusplus

+};

+#endif

+

+

+

+#endif

+

+

+//Date Stamp: 2012-02-15

+

+/*

+   NOTE: Portions (namely the top section) are part of headers from other

+   sources.

+

+   Copyright (c) 2011-2012 <>< Charles Lohr

+

+   Permission is hereby granted, free of charge, to any person obtaining a

+   copy of this software and associated documentation files (the "Software"),

+   to deal in the Software without restriction, including without limitation

+   the rights to use, copy, modify, merge, publish, distribute, sublicense,

+   and/or sell copies of the Software, and to permit persons to whom the

+   Software is furnished to do so, subject to the following conditions:

+

+   The above copyright notice and this permission notice shall be included in

+   all copies or substantial portions of this file.

+

+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS

+   IN THE SOFTWARE.

+*/

+