cnping

Minimal Graphical Ping Tool
git clone https://git.sinitax.com/cnlohr/cnping
Log | Files | Refs | Submodules | README | LICENSE | sfeed.txt
commit 56639b4cc4c9f10e880624ff6d8ed124672d1113
parent 0f47f4965230592f254dc7408c9999764ca7f9e0
Author: cnlohr <lohr85@gmail.com>
Date:   Tue, 21 Mar 2017 00:04:36 -0400

Update to newest rawdraw

Diffstat:

ACNFGFunctions.c | 272+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


ACNFGFunctions.h | 59+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


ACNFGWinDriver.c | 289++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


ACNFGXDriver.c | 304+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


DDrawFunctions.c | 277-------------------------------------------------------------------------------


DDrawFunctions.h | 55-------------------------------------------------------


MMakefile | 6+++---


DWinDriver.c | 487-------------------------------------------------------------------------------


DXDriver.c | 290-------------------------------------------------------------------------------


Mcnping.c | 3++-


Mcnping.exe | 0


11 files changed, 929 insertions(+), 1113 deletions(-)

diff --git a/CNFGFunctions.c b/CNFGFunctions.c
@@ -0,0 +1,272 @@
+/*
+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 "CNFGFunctions.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, 0x04, 0x93, 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++;
+				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/CNFGFunctions.h b/CNFGFunctions.h
@@ -0,0 +1,59 @@
+//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 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 );
+void HandleDestroy();
+
+
+//Internal function for resizing rasterizer for rasterizer-mode.
+void CNFGInternalResize( short x, short y ); //don't call this.
+
+
+#ifdef __cplusplus
+};
+#endif
+
+
+#endif
+
diff --git a/CNFGWinDriver.c b/CNFGWinDriver.c
@@ -0,0 +1,289 @@
+//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 "CNFGFunctions.h"
+#include <windows.h>
+#include <stdlib.h>
+#include <malloc.h> //for alloca
+
+static HBITMAP lsBitmap;
+static HINSTANCE lhInstance;
+static HWND lsHWND;
+static HDC lsWindowHDC;
+static HDC lsHDC;
+
+
+#ifdef RASTERIZER
+#include "CNFGRasterizer.h"
+
+void InternalHandleResize()
+{
+	if( lsBitmap ) DeleteObject( lsBitmap );
+
+	CNFGInternalResize( bufferx, buffery );
+	lsBitmap = CreateBitmap( bufferx, buffery, 1, 32, buffer );
+	SelectObject( lsHDC, lsBitmap );
+}
+#else
+static int bufferx, buffery;
+static int bufferx, buffery;
+static void InternalHandleResize();
+#endif
+
+
+void CNFGGetDimensions( short * x, short * y )
+{
+	*x = bufferx;
+	*y = buffery;
+}
+
+
+
+void CNFGUpdateScreenWithBitmap( unsigned long * data, int w, int h )
+{
+	RECT r;
+
+	int a = SetBitmapBits(lsBitmap,w*h*4,data);
+	a = BitBlt(lsWindowHDC, 0, 0, w, h, lsHDC, 0, 0, SRCCOPY);
+	UpdateWindow( lsHWND );
+
+	int thisw, thish;
+
+	//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 != bufferx || thish != buffery )
+	{
+		bufferx = thisw;
+		buffery = thish;
+		InternalHandleResize();
+	}
+}
+
+
+void CNFGTearDown()
+{
+	PostQuitMessage(0);
+}
+
+//This was from the article
+LRESULT CALLBACK MyWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	switch(msg)
+	{
+	case WM_DESTROY:
+		HandleDestroy();
+		CNFGTearDown();
+		return 0;
+	}
+	return DefWindowProc(hwnd, msg, wParam, lParam);
+}
+
+//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);
+
+	bufferx = width;
+	buffery = 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
+		bufferx,
+		buffery,        //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 );
+	lsBitmap = CreateCompatibleBitmap( lsWindowHDC, bufferx, buffery );
+	SelectObject( lsHDC, lsBitmap );
+
+	//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, bufferx + wd, buffery + 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;
+		}
+	}
+}
+
+
+#ifndef RASTERIZER
+
+static HBITMAP lsBackBitmap;
+static HDC lsWindowHDC;
+static HBRUSH lsHBR;
+static HPEN lsHPEN;
+static HBRUSH lsClearBrush;
+
+static void InternalHandleResize()
+{
+	DeleteObject( lsBackBitmap );
+	lsBackBitmap = CreateCompatibleBitmap( lsHDC, bufferx, buffery );
+	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, bufferx, buffery };
+	DeleteObject( lsClearBrush  );
+	lsClearBrush = CreateSolidBrush( CNFGBGColor );
+	SelectObject( lsHDC, lsClearBrush );
+
+	FillRect( lsHDC, &r, lsClearBrush );
+}
+
+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 CNFGSwapBuffers()
+{
+	int thisw, thish;
+
+	RECT r;
+	BitBlt( lsWindowHDC, 0, 0, bufferx, buffery, 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 != bufferx || thish != buffery )
+	{
+		bufferx = thisw;
+		buffery = thish;
+		InternalHandleResize();
+	}
+}
+
+void CNFGInternalResize( short bufferx, short  buffery ) { }
+#endif
+
diff --git a/CNFGXDriver.c b/CNFGXDriver.c
@@ -0,0 +1,304 @@
+//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 "CNFGFunctions.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 )
+{
+	static int lastx;
+	static int lasty;
+
+	*x = CNFGWinAtt.width;
+	*y = CNFGWinAtt.height;
+
+	if( lastx != *x || lasty != *y )
+	{
+		lastx = *x;
+		lasty = *y;
+		CNFGInternalResize( lastx, lasty );
+	}
+}
+
+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 );
+}
+
+void CNFGInternalResize( short x, short y ) { }
+
+#else
+#include "CNFGRasterizer.h"
+#endif
+
diff --git a/DrawFunctions.c b/DrawFunctions.c
@@ -1,277 +0,0 @@
-/*
-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/DrawFunctions.h b/DrawFunctions.h
@@ -1,55 +0,0 @@
-//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/Makefile b/Makefile
@@ -7,14 +7,14 @@ LDFLAGS:=-g -L/opt/X11/lib/
 #MINGW32:=/usr/bin/i686-w64-mingw32-
 MINGW32:=i686-w64-mingw32-
 
-cnping.exe : cnping.c DrawFunctions.c WinDriver.c os_generic.c ping.c
+cnping.exe : cnping.c CNFGFunctions.c CNFGWinDriver.c os_generic.c ping.c
 	$(MINGW32)windres resources.rc -o resources.o
 	$(MINGW32)gcc -g -mwindows -m32 $(CFLAGS) resources.o -o $@ $^  -lgdi32 -lws2_32 -s -D_WIN32_WINNT=0x0600 -DWIN32
 
-cnping : cnping.o DrawFunctions.o XDriver.o os_generic.o ping.o
+cnping : cnping.o CNFGFunctions.o CNFGXDriver.o os_generic.o ping.o
 	gcc $(CFLAGS) -o $@ $^ -lX11 -lm -lpthread $(LDFLAGS) 
 
-cnping-mousey : cnping-mousey.o DrawFunctions.o XDriver.o os_generic.o ping.o
+cnping-mousey : cnping-mousey.o CNFGFunctions.o CNFGXDriver.o os_generic.o ping.o
 	gcc $(CFLAGS) -o $@ $^ -lX11 -lm -lpthread $(LDFLAGS) 
 
 searchnet : os_generic.o ping.o searchnet.o
diff --git a/WinDriver.c b/WinDriver.c
@@ -1,487 +0,0 @@
-//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 HBITMAP lsBitmap;
-static HINSTANCE lhInstance;
-static HWND lsHWND;
-static HDC lsWindowHDC;
-static HDC lsHDC;
-static unsigned int bufferx;
-static unsigned int buffery;
-static uint32_t * buffer = 0;
-
-void CNFGClearFrame()
-{
-	uint32_t col = CNFGColor( CNFGBGColor );
-	int i;
-	for( i = bufferx * buffery - 1; i>=0; i-- )
-	{
-		buffer[i] = col;
-	}
-}
-
-void InternalHandleResize()
-{
-	if( lsBitmap ) DeleteObject( lsBitmap );
-
-	if( buffer ) free( buffer );
-	buffer = malloc( bufferx * buffery * 4 );
-
-	lsBitmap = CreateBitmap( bufferx, buffery, 1, 32, buffer );
-	SelectObject( lsHDC, lsBitmap );
-}
-
-void CNFGSwapBuffers()
-{
-	int thisw, thish;
-	RECT r;
-
-	int a = SetBitmapBits(lsBitmap,bufferx*buffery*4,buffer);
-	a = BitBlt(lsWindowHDC, 0, 0, bufferx, buffery, 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 != bufferx || thish != buffery )
-	{
-		bufferx = thisw;
-		buffery = thish;
-		InternalHandleResize();
-	}
-}
-
-
-static uint32_t SWAPS( uint32_t r )
-{
-	uint32_t ret = (r&0xFF)<<16;
-	r>>=8;
-	ret |= (r&0xff)<<8;
-	r>>=8;
-	ret |= r;
-	return ret;
-}
-
-uint32_t CNFGColor( uint32_t RGB )
-{
-	CNFGLastColor = SWAPS(RGB);
-	return CNFGLastColor;
-}
-
-void CNFGTackPixel( short tx, short ty )
-{
-	buffer[ty * bufferx + tx] = CNFGLastColor;
-}
-
-void CNFGTackSegment( short x1, short y1, short x2, short y2 )
-{
-	short tx, ty;
-	float slope, lp;
-
-	short dx = x2 - x1;
-	short dy = y2 - y1;
-
-	if( !buffer ) return;
-
-	if( dx < 0 ) dx = -dx;
-	if( dy < 0 ) dy = -dy;
-
-	if( dx > dy )
-	{
-		short minx = (x1 < x2)?x1:x2;
-		short maxx = (x1 < x2)?x2:x1;
-		short miny = (x1 < x2)?y1:y2;
-		short maxy = (x1 < x2)?y2:y1;
-		float thisy = miny;
-		slope = (float)(maxy-miny) / (float)(maxx-minx);
-
-		for( tx = minx; tx <= maxx; tx++ )
-		{
-			ty = thisy;
-			if( tx < 0 || ty < 0 || ty >= buffery ) continue;
-			if( tx >= bufferx ) break;
-			buffer[ty * bufferx + tx] = CNFGLastColor;
-			thisy += slope;
-		}
-	}
-	else
-	{
-		short minx = (y1 < y2)?x1:x2;
-		short maxx = (y1 < y2)?x2:x1;
-		short miny = (y1 < y2)?y1:y2;
-		short maxy = (y1 < y2)?y2:y1;
-		float thisx = minx;
-		slope = (float)(maxx-minx) / (float)(maxy-miny);
-
-		for( ty = miny; ty <= maxy; ty++ )
-		{
-			tx = thisx;
-			if( ty < 0 || tx < 0 || tx >= bufferx ) continue;
-			if( ty >= buffery ) break;
-			buffer[ty * bufferx + tx] = CNFGLastColor;
-			thisx += slope;
-		}
-	}
-}
-
-void CNFGTackRectangle( short x1, short y1, short x2, short y2 )
-{
-	short minx = (x1<x2)?x1:x2;
-	short miny = (y1<y2)?y1:y2;
-	short maxx = (x1>=x2)?x1:x2;
-	short maxy = (y1>=y2)?y1:y2;
-
-	short x, y;
-
-	if( minx < 0 ) minx = 0;
-	if( miny < 0 ) miny = 0;
-	if( maxx >= bufferx ) maxx = bufferx-1;
-	if( maxy >= buffery ) maxy = buffery-1;
-
-	for( y = miny; y <= maxy; y++ )
-	{
-		uint32_t * bufferstart = &buffer[y * bufferx + minx];
-		for( x = minx; x <= maxx; x++ )
-		{
-			(*bufferstart++) = CNFGLastColor;
-		}
-	}
-}
-
-void CNFGTackPoly( RDPoint * points, int verts )
-{
-	short minx = 10000, miny = 10000;
-	short maxx =-10000, maxy =-10000;
-	short i, x, y;
-
-	//Just in case...
-	if( verts > 32767 ) return;
-
-	for( i = 0; i < verts; i++ )
-	{
-		RDPoint * p = &points[i];
-		if( p->x < minx ) minx = p->x;
-		if( p->y < miny ) miny = p->y;
-		if( p->x > maxx ) maxx = p->x;
-		if( p->y > maxy ) maxy = p->y;
-	}
-
-	if( miny < 0 ) miny = 0;
-	if( maxy >= buffery ) maxy = buffery-1;
-
-	for( y = miny; y <= maxy; y++ )
-	{
-		short startfillx = maxx;
-		short endfillx = minx;
-
-		//Figure out what line segments intersect this line.
-		for( i = 0; i < verts; i++ )
-		{
-			short pl = i + 1;
-			if( pl == verts ) pl = 0;
-
-			RDPoint ptop;
-			RDPoint pbot;
-
-			ptop.x = points[i].x;
-			ptop.y = points[i].y;
-			pbot.x = points[pl].x;
-			pbot.y = points[pl].y;
-//printf( "Poly: %d %d\n", pbot.y, ptop.y );
-
-			if( pbot.y < ptop.y )
-			{
-				RDPoint ptmp;
-				ptmp.x = pbot.x;
-				ptmp.y = pbot.y;
-				pbot.x = ptop.x;
-				pbot.y = ptop.y;
-				ptop.x = ptmp.x;
-				ptop.y = ptmp.y;
-			}
-
-			//Make sure this line segment is within our range.
-//printf( "PT: %d %d %d\n", y, ptop.y, pbot.y );
-			if( ptop.y <= y && pbot.y >= y )
-			{
-				short diffy = pbot.y - ptop.y;
-				uint32_t placey = (uint32_t)(y - ptop.y)<<16;  //Scale by 16 so we can do integer math.
-				short diffx = pbot.x - ptop.x;
-				short isectx;
-
-				if( diffy == 0 )
-				{
-					if( pbot.x < ptop.x )
-					{
-						if( startfillx > pbot.x ) startfillx = pbot.x;
-						if( endfillx < ptop.x ) endfillx = ptop.x;
-					}
-					else
-					{
-						if( startfillx > ptop.x ) startfillx = ptop.x;
-						if( endfillx < pbot.x ) endfillx = pbot.x;
-					}
-				}
-				else
-				{
-					//Inner part is scaled by 65536, outer part must be scaled back.
-					isectx = (( (placey / diffy) * diffx + 32768 )>>16) + ptop.x;
-					if( isectx < startfillx ) startfillx = isectx;
-					if( isectx > endfillx ) endfillx = isectx;
-				}
-//printf( "R: %d %d %d\n", pbot.x, ptop.x, isectx );
-			}
-		}
-
-//printf( "%d %d %d\n", y, startfillx, endfillx );
-
-		if( endfillx >= bufferx ) endfillx = bufferx - 1;
-		if( endfillx >= bufferx ) endfillx = buffery - 1;
-		if( startfillx < 0 ) startfillx = 0;
-		if( startfillx < 0 ) startfillx = 0;
-
-		unsigned int * bufferstart = &buffer[y * bufferx + startfillx];
-		for( x = startfillx; x <= endfillx; x++ )
-		{
-			(*bufferstart++) = CNFGLastColor;
-		}
-	}
-//exit(1);
-}
-
-
-
-void CNFGGetDimensions( short * x, short * y )
-{
-	*x = bufferx;
-	*y = buffery;
-}
-
-//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);
-
-	bufferx = width;
-	buffery = 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
-		bufferx,
-		buffery,        //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, buffery );
-	//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, bufferx + wd, buffery + 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;
-		}
-	}
-}
-
-
-/*
-static HBITMAP lsBackBitmap;
-static HDC lsWindowHDC;
-static HBRUSH lsHBR;
-static HPEN lsHPEN;
-static HBRUSH lsClearBrush;
-
-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 );
-}
-*/
-
diff --git a/XDriver.c b/XDriver.c
@@ -1,290 +0,0 @@
-//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/cnping.c b/cnping.c
@@ -15,7 +15,7 @@
 #include <sys/select.h>
 #include <netdb.h>
 #endif
-#include "DrawFunctions.h"
+#include "CNFGFunctions.h"
 #include "os_generic.h"
 #include "ping.h"
 
@@ -92,6 +92,7 @@ void * PingSend( void * r )
 void HandleKey( int keycode, int bDown ){}
 void HandleButton( int x, int y, int button, int bDown ){}
 void HandleMotion( int x, int y, int mask ){}
+void HandleDestroy() { exit(0); }
 
 double GetGlobMaxPingTime( void )
 {
diff --git a/cnping.exe b/cnping.exe
Binary files differ.