Initial import of xtrkcad version 1:4.0.2-2

26 files changed, 12287 insertions, 0 deletions

diff --git a/app/wlib/mswlib/CMakeLists.txt b/app/wlib/mswlib/CMakeLists.txt
new file mode 100644
index 0000000..0c69610
--- /dev/null
+++ b/app/wlib/mswlib/CMakeLists.txt
@@ -0,0 +1,39 @@
+FILE(GLOB HEADERS *.h)
+
+SET(SOURCES
+#	checksum.c
+	getopt.c
+	mswbox.c
+	mswbutt.c
+	mswbitmap.c
+	mswchksm.c
+	mswchoic.c
+	mswcolor.c
+	mswdraw.c
+	mswedit.c
+	mswlines.c
+	mswlist.c
+	mswmenu.c
+	mswmisc.c
+	mswmsg.c
+	mswpref.c
+	mswprint.c
+	mswsplash.c
+	mswtext.c
+	gwin32.c
+	simple-gettext.c
+	)
+
+INCLUDE_DIRECTORIES(${XTrkCAD_BINARY_DIR})
+# INCLUDE_DIRECTORIES(${XTRKCAD_BINARY_DIR})
+
+IF(XTRKCAD_USE_GETTEXT)
+	IF(WIN32)
+		ADD_DEFINITIONS(-DUSE_SIMPLE_GETTEXT )
+	ENDIF(WIN32)
+ENDIF(XTRKCAD_USE_GETTEXT)
+
+ADD_LIBRARY(xtrkcad-wlib ${HEADERS} ${SOURCES})
+
+TARGET_LINK_LIBRARIES(xtrkcad-wlib Htmlhelp msimg32 shlwapi)
+
diff --git a/app/wlib/mswlib/ChangeLog b/app/wlib/mswlib/ChangeLog
new file mode 100644
index 0000000..84c17a7
--- /dev/null
+++ b/app/wlib/mswlib/ChangeLog
@@ -0,0 +1,146 @@
+Apr 28, 2010
+	FIX: Daniel Spagnol
+		mswmisc.c: now, wGetAppLibDir can be called before wWinMainCreate is 
+		called.
+
+Jan 09, 2010
+	ENH: Martin Fischer
+		mswmisc.c: get command line parameter handling correct
+		plus some refactoring 
+		
+Dec 12, 2009
+	FIX: Martin Fischer
+		mswmisc.c: minor refactoring to stay compatible with the 
+		work on gtkwindow.c
+
+Sep 20. 2009
+	ENH: Martin Fischer <m_fischer@users.sourceforge.net>
+		CMakeLists.txt, mswbitmap.c, mswmisc.c, mswint.h:
+		new source file for bitmap functions, added bitmap 
+		control to controls available to the application
+		
+Sep 02, 2009
+	ENH: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswbutt.c, mswint.h, mswlist.c mswmisc.c:
+		improved XPM reading including true transparency
+	
+Aug 16, 2009
+	ENH: Martin Fischer <m_fischer@users.sourceforge.net>
+		gwin32.c mswchoic.c mswint.h simple-gettext.c CMakeLists.txt:
+		add simple gettext support
+		
+Jul 24, 2009
+	ENH: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswmisc.c: correct initialization for argv, add option
+		to select configuration file, remove obsolete Win16 code 
+		
+Jul 10, 2009
+	ENH: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswmisc.c: initialize the argument array properly
+		CMakeLists.txt, getopt.c: add getopt() 
+
+Version 4.0.3a
+==============
+		
+Jun 05, 2009
+	FIX: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswmisc.c: GPF when loading XPM icons fixed
+
+May 28, 2009
+	FIX: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswmisc.c: wrong options for wNotice fixed
+		
+May 15, 2009
+	ENH: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswdraw.c, mswmisc.c, mswpref.c: more message boxes with icon
+
+		May 08, 2009
+	ENH: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswmisc.c, wlib.h: add new message box with icon
+		
+Sep 05, 2008
+	ENH: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswmisc.c: enhance look of tooltip
+		
+Jul 11, 2008
+	ENH: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswchoic.c: i18n support
+		mswmenu.c, mswmisc.c: code cleanup and added comments
+		
+Jul 10, 2008
+	ENH: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswmisc.c: allow user to cancel window close request
+
+Jun 12, 2008
+	FIX: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswmsg.c: redraw problem for large font fixed
+		
+Apr 05, 2008
+	IMPROVEMENT: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswmisc,.c mswint.c: improved XPM support
+		
+Mar 29, 2008
+	IMPROVEMENT: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswbutt.c: new look for toolbar buttons
+		
+Mar 17, 2008
+	FIX: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswchoic.c: Label size was not calculated correctly for radio button
+		options.
+
+Feb 23,2008
+	FIX: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswpref.c: Create the correct full path for shared data directory
+
+Jan 24,2008
+	FIX: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswdraw.c, mswmisc.c: fixed some compiler warnings 
+
+Jan 28, 2008
+	FIX: Mikko Nissinen <mni77@users.sourceforge.net>
+		mswmisc.c: Dynamically allocate and form some global translatable
+		strings.
+
+Jan 24,2008
+	IMPROVEMENT: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswpref.c: increase floting point precision when storing floats in INI
+		file
+
+Jan 22, 2008
+	ENH: Mikko Nissinen <mni77@users.sourceforge.net>
+		mswmisc.c: WinMain(): Free user locale before exit.
+
+Dec 16, 2007
+	IMPROVMENT: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswpref.c: use XTrackCad as directory name for configuration files
+
+Aug 03, 2007
+	IMPROVMENT: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswmisc.c: use HTML Help as the help system
+
+Jul 22, 2007
+	IMPROVMENT: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswdraw.c, mswmisc.c: added support for mouse wheel in
+		the drawing area 
+
+Jun 17, 2007
+	IMPROVMENT: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswpref.c: added wGetUserHomeDir() 
+
+Jun, 16 2007
+	IMPROVEMENT: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswpref.c working directory is in the user profile directory tree now
+
+Feb, 05th 2007
+	BUGFIX: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswmisc.c fixed protection fault when pressing ESC in describe dialog
+
+Feb, 04th 2007	
+	BUGFIX: Martin Fischer <m_fischer@users.sourceforge.net>
+		mswmisc.c fixed protection fault when Tabbing through describe dialog	
+			  See xtrkcad-fork Bug 1651117
+
+Oct, 13 2006 mswmisc.c 
+	BUGFIX Bob Blackwell 
+		Fixed a problem with 'No' and 'Cancel' buttons being mixed up
+
diff --git a/app/wlib/mswlib/checksum.c b/app/wlib/mswlib/checksum.c
new file mode 100644
index 0000000..f19d15b
--- /dev/null
+++ b/app/wlib/mswlib/checksum.c
@@ -0,0 +1,42 @@
+#include "mswchksm.c"
+#include <stdlib.h>
+
+int main( int argc, char *argv[] )
+{
+	int set;
+	FILE * fp;
+	long FileSize;
+	unsigned short sum16computed, sum16stored = 0xb8dd;
+	unsigned long sum32computed, sum32stored = 0xa25ce7ac;
+	long sum32off;
+	if (argc < 2) {
+		fprintf( stderr, "Usage: %s [-s] file.exe\n", argv[0] );
+		exit(1);
+	}
+	if (argc > 2) {
+		set = 1;
+		fp = openfile( argv[2], "r+b", &FileSize );
+	} else {
+		set = 0;
+		fp = openfile( argv[1], "rb", &FileSize );
+	}
+	if (fp == NULL)
+		exit(1);
+	
+	fprintf( stderr, "File Size = %ld (%lx)\n", FileSize, FileSize );
+	sum16computed = mswCheck16( fp, FileSize, &sum16stored );
+	if (!mswCheck32( fp, FileSize, &sum32off, &sum32computed, &sum32stored ))
+		fprintf( stderr, "mswCheck32 error\n" );
+	fprintf( stderr, "sum16: stored = %x, computed = %x, sum = %x, expected FFFF\n", sum16stored, sum16computed, sum16stored+sum16computed );
+	fprintf( stderr, "sum32: stored = %lx, computed = %lx, expected %lx\n", sum32stored, sum32computed, sum32stored );
+	if (set) {
+		fseek( fp, 0x12, SEEK_SET );
+		sum16computed = 0xFFFF - sum16computed;
+		fwrite( &sum16computed, sizeof sum16computed, 1, fp );
+		fseek( fp, sum32off, SEEK_SET );
+		/*fwrite( &sum32computed, sizeof sum32computed, 1, fp );*/
+		fflush( fp );
+	}
+	fclose(fp);
+	exit(0);
+}
diff --git a/app/wlib/mswlib/dynarr.h b/app/wlib/mswlib/dynarr.h
new file mode 100644
index 0000000..5bd7a8e
--- /dev/null
+++ b/app/wlib/mswlib/dynarr.h
@@ -0,0 +1,40 @@
+typedef struct {
+		int cnt;
+		int max;
+		void * ptr;
+		} dynArr_t;
+
+#define DYNARR_APPEND(T,DA,INCR) \
+		{ if ((DA).cnt >= (DA).max) { \
+			(DA).max += INCR; \
+			(DA).ptr = realloc( (DA).ptr, (DA).max * sizeof *(T*)NULL ); \
+			if ( (DA).ptr == NULL ) \
+				abort(); \
+		} \
+		(DA).cnt++; }
+#define DYNARR_ADD(T,DA,INCR) DYNARR_APPEND(T,DA,INCR)
+
+#define DYNARR_LAST(T,DA) \
+		(((T*)(DA).ptr)[(DA).cnt-1])
+#define DYNARR_N(T,DA,N) \
+		(((T*)(DA).ptr)[N])
+#define DYNARR_RESET(T,DA) \
+		(DA).cnt=0
+#define DYNARR_SET(T,DA,N) \
+		{ if ((DA).max < N) { \
+			(DA).max = N; \
+			(DA).ptr = realloc( (DA).ptr, (DA).max * sizeof *(T*)NULL ); \
+			if ( (DA).ptr == NULL ) \
+				abort(); \
+		} \
+		(DA).cnt = 0; }
+
+
+#ifdef WINDOWS
+#ifndef WIN32
+#define FAR _far
+#endif
+#define M_PI 3.14159
+#define strcasecmp _stricmp
+#else
+#endif
diff --git a/app/wlib/mswlib/getopt.c b/app/wlib/mswlib/getopt.c
new file mode 100644
index 0000000..888f5f8
--- /dev/null
+++ b/app/wlib/mswlib/getopt.c
@@ -0,0 +1,87 @@
+/*----------------------------------------------------------------------
+
+    Replacement for Unix "getopt()", for DOS/Windows/etc.
+
+    getopt.c 1.3 2003/09/17 16:17:59
+
+    Copyright (C) 1998, 2003 by David A. Hinds -- All Rights Reserved
+
+    This file is part of ASPEX.
+
+    ASPEX is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    ASPEX is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with ASPEX; if not, write to the Free Software Foundation,
+    Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+----------------------------------------------------------------------*/
+
+#include "string.h"
+#include "stdio.h"
+#include "getopt.h"
+
+#ifdef WINDOWS
+#define OPTCHAR '/'
+#else
+#define OPTCHAR '-'
+#endif
+
+char *optarg;
+int optind = 1, opterr, optopt;
+
+int getopt(int argc, char *argv[], const char *optstring)
+{
+    static int pos = 0;
+    char *str;
+    
+    if (pos == 0) {
+	if ((optind >= argc) || (*argv[optind] != OPTCHAR))
+	    return EOF;
+	pos = 1;
+	if (argv[optind][pos] == '\0')
+	    return EOF;
+    }
+    
+    str = strchr(optstring, argv[optind][pos]);
+    if (str == NULL) {
+	optopt = argv[optind][pos];
+	if (opterr)
+	    fprintf(stderr, "%s: illegal option -- %c\n", argv[0],
+		    optopt);
+	return '?';
+    }
+    
+    if (str[1] == ':') {
+	if (argv[optind][pos+1] != '\0') {
+	    optarg = &argv[optind][pos+1];
+	    return *str;
+	}
+	optind++;
+	if (optind >= argc) {
+	    optopt = *str;
+	    if (opterr)
+		fprintf(stderr, "%s: option requires an argument -- %c\n",
+			argv[0], optopt);
+	    return '?';
+	}
+	optarg = argv[optind];
+	optind++; pos = 0;
+	return *str;
+    }
+    else {
+	pos++;
+	if (argv[optind][pos] == '\0') {
+	    optind++;
+	    pos = 0;
+	}
+	return *str;
+    }
+}
diff --git a/app/wlib/mswlib/gwin32.c b/app/wlib/mswlib/gwin32.c
new file mode 100644
index 0000000..6b0c7f3
--- /dev/null
+++ b/app/wlib/mswlib/gwin32.c
@@ -0,0 +1,146 @@
+/* GLIB - Library of useful routines for C programming
+ * Copyright (C) 1995-1998  Peter Mattis, Spencer Kimball and Josh MacDonald
+ * Copyright (C) 1998-1999  Tor Lillqvist
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
+ * file for a list of people on the GLib Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GLib at ftp://ftp.gtk.org/pub/gtk/. 
+ *
+ * Ported to standard C by Martin Fischer 2009
+ *
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <wchar.h>
+#include <errno.h>
+
+#define STRICT			/* Strict typing, please */
+#include <windows.h>
+#undef STRICT
+#include <errno.h>
+#include <ctype.h>
+#if defined(_MSC_VER) || defined(__DMC__)
+#  include <io.h>
+#endif /* _MSC_VER || __DMC__ */
+
+#ifndef SUBLANG_SERBIAN_LATIN_BA
+#define SUBLANG_SERBIAN_LATIN_BA 0x06
+#endif
+
+#if _MSC_VER > 1300
+	#define stricmp _stricmp
+	#define strnicmp _strnicmp
+	#define strdup _strdup
+#endif
+
+/**
+ * This function gets the current thread locale from Windows - without any 
+ * encoding info - and returns it as a string of the above form for use in forming
+ * file names etc. The setlocale() function in the Microsoft C library uses locale
+ * names of the form "English_United States.1252" etc. We want the
+ * UNIXish standard form "en_US", "zh_TW" etc. The returned string should be 
+ * deallocated with free().
+ *
+ * \return newly-allocated locale name.
+ */
+
+char *
+g_win32_getlocale (void)
+{
+  LCID lcid;
+  LANGID langid;
+  char *ev;
+  char *loc;
+  int primary, sub;
+  char iso639[10];
+  char iso3166[10];
+  const char *script = NULL;
+
+  /* Let the user override the system settings through environment
+   * variables, as on POSIX systems. Note that in GTK+ applications
+   * since GTK+ 2.10.7 setting either LC_ALL or LANG also sets the
+   * Win32 locale and C library locale through code in gtkmain.c.
+   */
+  if (((ev = getenv ("LC_ALL")) != NULL && ev[0] != '\0')
+      || ((ev = getenv ("LC_MESSAGES")) != NULL && ev[0] != '\0')
+      || ((ev = getenv ("LANG")) != NULL && ev[0] != '\0'))
+    return strdup (ev);
+
+  lcid = GetThreadLocale ();
+
+  if (!GetLocaleInfo (lcid, LOCALE_SISO639LANGNAME, iso639, sizeof (iso639)) ||
+      !GetLocaleInfo (lcid, LOCALE_SISO3166CTRYNAME, iso3166, sizeof (iso3166)))
+    return strdup ("C");
+  
+  /* Strip off the sorting rules, keep only the language part.  */
+  langid = LANGIDFROMLCID (lcid);
+
+  /* Split into language and territory part.  */
+  primary = PRIMARYLANGID (langid);
+  sub = SUBLANGID (langid);
+
+  /* Handle special cases */
+  switch (primary)
+    {
+    case LANG_AZERI:
+      switch (sub)
+	{
+	case SUBLANG_AZERI_LATIN:
+	  script = "@Latn";
+	  break;
+	case SUBLANG_AZERI_CYRILLIC:
+	  script = "@Cyrl";
+	  break;
+	}
+      break;
+    case LANG_SERBIAN:		/* LANG_CROATIAN == LANG_SERBIAN */
+      switch (sub)
+	{
+	case SUBLANG_SERBIAN_LATIN:
+	case 0x06: /* Serbian (Latin) - Bosnia and Herzegovina */
+	  script = "@Latn";
+	  break;
+	}
+      break;
+    case LANG_UZBEK:
+      switch (sub)
+	{
+	case SUBLANG_UZBEK_LATIN:
+	  script = "@Latn";
+	  break;
+	case SUBLANG_UZBEK_CYRILLIC:
+	  script = "@Cyrl";
+	  break;
+	}
+      break;
+    }
+  
+  loc = malloc( strlen( iso639 ) + strlen( iso3166 ) + (script ? strlen( script ) : 0) + 2 );
+  strcpy( loc, iso639 );
+  strcat( loc, "_" );
+  strcat( loc, iso3166 );
+  if( script )
+	  strcat( loc, script );
+  return loc;
+}
+
diff --git a/app/wlib/mswlib/mswbitmap.c b/app/wlib/mswlib/mswbitmap.c
new file mode 100644
index 0000000..7371834
--- /dev/null
+++ b/app/wlib/mswlib/mswbitmap.c
@@ -0,0 +1,508 @@
+/** \file mswbitmap.c
+ * Bitmap handling functions
+ *
+ * $Header: /home/dmarkle/xtrkcad-fork-cvs/xtrkcad/app/wlib/mswlib/mswbitmap.c,v 1.1 2009-09-20 14:55:54 m_fischer Exp $
+ */
+/*  XTrkCad - Model Railroad CAD
+ *  Copyright (C) 2009 Martin Fischer
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <windows.h>
+#include <string.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <commdlg.h>
+#include <stdio.h>
+#include <assert.h>
+#include "mswint.h"
+#include "i18n.h"
+
+#if _MSC_VER > 1300
+	#define stricmp _stricmp
+	#define strnicmp _strnicmp
+	#define strdup _strdup
+#endif
+
+struct wBitmap_t {
+		WOBJ_COMMON
+		};
+
+HPALETTE hOldPal;
+
+HBITMAP mswCreateBitMap(
+		COLORREF fgCol1,
+		COLORREF fgCol2,
+		COLORREF bgCol,
+		wPos_t w,
+		wPos_t h,
+		const char * bits )
+{
+	HDC hDc;
+	HDC hButtDc;
+	HBRUSH oldBrush, newBrush;
+	RECT rect;
+	HBITMAP hBitMap;
+	HBITMAP hOldBitMap;
+	const char * byts_p;
+	int byt, i, j;
+
+	hDc = GetDC( mswHWnd );
+	hButtDc = CreateCompatibleDC( hDc );
+	hBitMap = CreateCompatibleBitmap( hDc, w, h );
+	ReleaseDC( mswHWnd, hDc );
+	hOldBitMap = SelectObject( hButtDc, hBitMap );
+	if (mswPalette) {
+		hOldPal = SelectPalette( hButtDc, mswPalette, 0 );
+	}
+	
+	/*PatBlt( hButtDc, 0, 0, w, h, WHITENESS );*/
+	newBrush = CreateSolidBrush( bgCol );
+	oldBrush = SelectObject( hButtDc, newBrush );
+	rect.top = 0;
+	rect.left = 0;
+	rect.bottom = h;
+	rect.right = w;
+	FillRect( hButtDc, &rect, newBrush );
+	DeleteObject( SelectObject( hButtDc, oldBrush ) );
+
+	byts_p = bits;
+	for ( j = 0; j < h; j++ ) {
+		byt = (0xFF & *byts_p++) | 0x100;
+		for ( i = 0; i < w; i++ ) {
+			if (byt == 1)
+				byt = (0xFF & *byts_p++) | 0x100;
+			if ( byt & 0x1 ) {
+				SetPixel( hButtDc, i, j, fgCol1 );
+				SetPixel( hButtDc, i+1, j+1, fgCol2 );
+			}
+			byt >>= 1;
+		}
+	}
+
+	SelectObject( hButtDc, hOldBitMap );
+	DeleteDC( hButtDc );
+	return hBitMap;
+}
+
+dynArr_t bitmap_da;
+#define controlMap(N) DYNARR_N(controlMap_t,controlMap_da,N)
+#define bitmap(N) DYNARR_N(HBITMAP,bitmap_da,N)
+
+void mswRegisterBitMap(
+		HBITMAP hBm )
+{
+	DYNARR_APPEND( HBITMAP, bitmap_da, 10 );
+	bitmap(bitmap_da.cnt-1) = hBm;
+}
+
+void deleteBitmaps( void )
+{
+	int inx;
+	for ( inx=0; inx<bitmap_da.cnt; inx++ )
+		DeleteObject( bitmap(inx) );
+}
+
+/**
+ * Draw a bitmap to the screen.
+ *
+ * \param hDc IN device context 
+ * \param offw IN horizontal offset
+ * \param offh IN vertical offset
+ * \param bm IN icon to draw
+ * \param disabled IN draw in disabled state
+ * \param color1 IN for two color bitmaps: foreground color enabled state
+ * \param color2 IN for two color bitmaps: foreground color disabled state
+ *
+ */
+
+void mswDrawIcon(
+		HDC hDc,
+		int offw,
+		int offh,
+		wIcon_p bm,
+		int disabled,
+		COLORREF color1,
+		COLORREF color2 )
+{
+	int i;
+	int byt;
+	BITMAPINFO *bmiInfo;
+	COLORREF col;
+
+    /* draw the bitmap by dynamically creating a Windows DIB in memory */
+
+    bmiInfo = malloc( sizeof( BITMAPINFO ) + (bm->colorcnt - 1) * sizeof( RGBQUAD ));
+    if( !bmiInfo ) {
+        fprintf( stderr, "could not allocate memory for bmiInfo\n" );
+        abort();
+    }
+
+    /* initialize bitmap header from XPM information */
+    bmiInfo->bmiHeader.biSize = sizeof( bmiInfo->bmiHeader );
+    bmiInfo->bmiHeader.biWidth = bm->w;
+    bmiInfo->bmiHeader.biHeight = bm->h;
+    bmiInfo->bmiHeader.biPlanes = 1;
+    if( bm->type == mswIcon_bitmap )
+        bmiInfo->bmiHeader.biBitCount = 1;
+    else 
+        bmiInfo->bmiHeader.biBitCount = 8;							/* up to 256 colors */
+    bmiInfo->bmiHeader.biCompression = BI_RGB;						/* no compression */
+    bmiInfo->bmiHeader.biSizeImage = 0;
+    bmiInfo->bmiHeader.biXPelsPerMeter = 0;
+    bmiInfo->bmiHeader.biYPelsPerMeter = 0;
+    bmiInfo->bmiHeader.biClrUsed = bm->colorcnt;					/* number of colors used */
+    bmiInfo->bmiHeader.biClrImportant = bm->colorcnt;
+
+	/*
+	 * create a transparency mask and paint to screen
+	 */ 
+	if( bm->type == mswIcon_bitmap ) {
+		memset( &bmiInfo->bmiColors[ 0 ], 0xFF, sizeof( RGBQUAD ));
+		memset( &bmiInfo->bmiColors[ 1 ], 0, sizeof( RGBQUAD ));
+	} else {
+		memset( bmiInfo->bmiColors, 0, bm->colorcnt * sizeof( RGBQUAD ));
+		memset( &bmiInfo->bmiColors[ bm->transparent ], 0xFF, sizeof( RGBQUAD ));
+	}
+	StretchDIBits(hDc, offw, offh,
+        bmiInfo->bmiHeader.biWidth,
+        bmiInfo->bmiHeader.biHeight,
+        0, 0,
+        bmiInfo->bmiHeader.biWidth,
+        bmiInfo->bmiHeader.biHeight,
+        bm->pixels, bmiInfo, 				
+        DIB_RGB_COLORS, SRCAND);
+	
+	/* now paint the bitmap with transparent set to black */
+	if( bm->type == mswIcon_bitmap ) {
+		if( disabled ) {   
+			col = color2;
+		} else {
+			col = color1;
+		}
+		memset( &bmiInfo->bmiColors[ 0 ], 0, sizeof( RGBQUAD ));
+                bmiInfo->bmiColors[ 1 ].rgbRed = GetRValue( col );
+                bmiInfo->bmiColors[ 1 ].rgbGreen = GetGValue( col );
+                bmiInfo->bmiColors[ 1 ].rgbBlue = GetBValue( col );
+    } else {
+		if( disabled ) {
+			/* create a gray scale palette */
+			for( i = 0; i < bm->colorcnt; i ++ ) {
+				byt = ( 30 * bm->colormap[ i ].rgbRed + 
+					    59 * bm->colormap[ i ].rgbGreen + 
+						11 * bm->colormap[ i ].rgbBlue )/100;
+        
+				/* if totally black, use a dark gray */
+				if( byt == 0 )
+					byt = 0x66;
+				
+				bmiInfo->bmiColors[ i ].rgbRed = byt;
+				bmiInfo->bmiColors[ i ].rgbGreen = byt;
+				bmiInfo->bmiColors[ i ].rgbBlue = byt;
+			}
+	    } else {
+            /* copy the palette */
+            memcpy( (void *)bmiInfo->bmiColors, (void *)bm->colormap, bm->colorcnt * sizeof( RGBQUAD ));
+        }
+		memset( &bmiInfo->bmiColors[ bm->transparent ], 0, sizeof( RGBQUAD ));
+    }
+    
+    /* show the bitmap */
+    StretchDIBits(hDc, offw, offh,
+            bmiInfo->bmiHeader.biWidth,
+            bmiInfo->bmiHeader.biHeight,
+            0, 0,
+            bmiInfo->bmiHeader.biWidth,
+            bmiInfo->bmiHeader.biHeight,
+            bm->pixels, bmiInfo, 				
+            DIB_RGB_COLORS, SRCPAINT);
+
+    /* forget the data */
+    free( bmiInfo );
+}
+
+/**
+ * Create a two color bitmap. This creates a two color icon. Pixels set to 1 are painted 
+ * in the specified color, pixels set to 0 are transparent
+ * in order to convert the format, a lot of bit fiddling is necessary. The order of 
+ * scanlines needs to be reversed and the bit order (high order - low order) is reversed 
+ * as well.
+ * \param w IN width in pixels
+ * \param h IN height in pixels
+ * \param bits IN pixel data
+ * \param color IN color for foreground
+ * \return    pointer to icon
+ */
+
+wIcon_p wIconCreateBitMap( wPos_t w, wPos_t h, const char * bits, wDrawColor color )
+{
+	int lineLength;
+	int i, j;
+	unsigned char *dest;
+	static unsigned char revbits[] = { 0, 0x08, 0x04, 0x0C, 0x02, 0x0A, 0x06, 0x0E, 0x01, 0x09, 0x05, 0x0D, 0x03, 0x0B, 0x07, 0x0F };  
+	unsigned long col = wDrawGetRGB( color );
+
+	wIcon_p ip;
+	ip = (wIcon_p)malloc( sizeof *ip );
+	if( !ip ) {
+		fprintf( stderr, "Couldn't allocate memory for bitmap header.\n" );
+		abort();
+	}
+
+	memset( ip, 0, sizeof *ip );
+	ip->type = mswIcon_bitmap;
+	ip->w = w;
+	ip->h = h;
+	ip->colorcnt = 2;
+
+	/* set up our two color palette */
+	ip->colormap = malloc( 2 * sizeof( RGBQUAD ));
+
+	ip->colormap[ 1 ].rgbBlue = col & 0xFF;
+	ip->colormap[ 1 ].rgbRed = (col>>16) & 0xFF;
+	ip->colormap[ 1 ].rgbGreen = (col>>8) & 0xFF;
+	ip->colormap[ 1 ].rgbReserved = 0;	
+
+	color = GetSysColor( COLOR_BTNFACE );
+	ip->colormap[ 0 ].rgbBlue = GetBValue( color );
+	ip->colormap[ 0 ].rgbRed = GetRValue( color );
+	ip->colormap[ 0 ].rgbGreen = GetGValue( color );
+	ip->colormap[ 0 ].rgbReserved = 0;	
+
+	lineLength = (((( ip->w + 7 ) / 8 ) + 3 ) >> 2 ) << 2;
+	ip->pixels = malloc( lineLength * ip->h );
+	if( !ip->pixels ) {
+		fprintf( stderr, "Couldn't allocate memory for pixel data.\n" );
+		abort();
+	}
+
+	/* 
+	 * copy the bits from source to the buffer, at this time the order of
+	 * scanlines is reversed by starting with the last source line.
+	 */
+	for( i = 0; i < ip->h; i++ ) {
+		dest = ip->pixels + i * lineLength;
+		memcpy( dest, bits + ( ip->h - i - 1 ) * (( ip->w + 7) / 8), ( ip->w + 7 ) / 8 );
+
+		/*
+		 * and now, the bit order is changed, this is done via a lookup table
+		 */
+		for( j = 0; j < lineLength; j++ )
+		{
+			unsigned byte = dest[ j ];
+			unsigned low = byte & 0x0F;
+			unsigned high = (byte & 0xF0) >> 4;
+			dest[ j ] = revbits[ low ]<<4 | revbits[ high ];
+		}
+	}
+
+	return ip;
+}
+
+/**
+ * Create a pixmap. This functions interprets a XPM icon contained in a
+ * char array. Supported format are one or two byte per pixel and #rrggbb
+ * or #rrrrggggbbbb color specification. Color 'None' is interpreted as
+ * transparency, other symbolic names are not supported.
+ *
+ * \param pm IN XPM variable
+ * \return    pointer to icon, call free() if not needed anymore. 
+ */
+
+wIcon_p wIconCreatePixMap( char *pm[])
+{
+	wIcon_p ip;
+	int col, r, g, b, len;
+	int width, height;
+	char buff[3];
+	char * cp, * cq, * ptr;
+	int i, j, k;
+	int lineLength;
+	unsigned *keys;
+	unsigned numchars;
+	unsigned pixel;
+
+	ip = (wIcon_p)malloc( sizeof *ip );
+	if( !ip ) {
+		fprintf( stderr, "Couldn't allocate memory for bitmap header.\n" );
+		abort();
+	}
+
+	memset( ip, 0, sizeof *ip );
+	ip->type = mswIcon_pixmap;
+
+	/* extract values */
+	cp = pm[0];
+	width = (int)strtol(cp, &cq, 10 );			/* width of image */
+	height = (int)strtol(cq, &cq, 10 );			/* height of image */
+	col = (int)strtol(cq, &cq, 10 );			/* number of colors used */
+	numchars = (int)strtol(cq, &cq, 10 );		/* get number of chars per pixel */
+	
+	ip->colormap = malloc( col * sizeof( RGBQUAD ));
+	ip->w = width;	
+	ip->h = height;
+	ip->colorcnt = col;								/* number of colors used */
+
+	keys = malloc( sizeof( unsigned ) * col );
+
+	for ( col=0; col<(int)ip->colorcnt; col++ ) {
+		ptr = strdup( pm[col+1] );				/* create duplicate for input string*/
+
+		if( numchars == 1 ) {
+			keys[ col ] = (unsigned)ptr[0];
+		}
+		else if( numchars == 2 ) {
+				keys[ col ] = (unsigned) ( ptr[ 0 ] + ptr[ 1 ] * 256 );
+		}
+		
+		cp = strtok( ptr + numchars, "\t " );	/* cp points to color type */
+		assert( *cp == 'c' );					/* should always be color */
+		
+		cp = strtok( NULL, "\t " );				/* go to next token, the color definition itself */
+
+		if( *cp == '#' ) {						/* is this a hex RGB specification? */
+			len = strlen( cp+1 ) / 3;
+			assert( len == 4 || len == 2 );		/* expecting three 2 char or 4 char values */	
+			buff[2] = 0;						/* if yes, extract the values */
+			memcpy( buff, cp + 1, 2 );
+			r = (int)strtol(buff, &cq, 16);
+			memcpy( buff, cp + 1 + len, 2 );
+			g = (int)strtol(buff, &cq, 16);
+			memcpy( buff, cp + 1 + 2 * len, 2 );
+			b = (int)strtol(buff, &cq, 16);
+
+			ip->colormap[ col ].rgbBlue = b;
+			ip->colormap[ col ].rgbGreen = g;
+			ip->colormap[ col ].rgbRed = r;
+			ip->colormap[ col ].rgbReserved = 0;
+
+		} else {
+			if( !stricmp( cp, "none" )) {			/* special case transparency*/
+				ip->transparent = col;
+			}
+			else 
+				assert( *cp == '#' );				/* if no, abort for the moment */
+		}
+		free( ptr );
+	}
+
+	/* get memory for the pixel data */
+	/* dword align begin of line */
+	lineLength = ((ip->w + 3 ) >> 2 ) << 2;
+	ip->pixels = malloc( lineLength * ip->h );
+	if( !ip->pixels ) {
+		fprintf( stderr, "Couldn't allocate memory for pixel data.\n" );
+		abort();
+	}
+
+	/* 
+	   convert the XPM pixel data to indexes into color table
+	   at the same time the order of rows is reversed 
+	   Win32 should be able to do that but I couldn't find out
+	   how, so this is coded by hand. 
+	*/
+
+	/* for all rows */
+	for( i = 0; i < ip->h; i++ ) {
+		
+		cq = ip->pixels + lineLength * i;
+		/* get the next row */
+		cp = pm[ ip->h - i + ip->colorcnt ];
+		/* for all pixels in row */
+		for( j = 0; j < ip->w; j++ ) {
+			/* get the pixel info */
+			if( numchars == 1 )
+				pixel = ( unsigned )*cp;
+			else
+				pixel = (unsigned) (*cp + *(cp+1)*256);
+			cp += numchars;
+
+			/* look up pixel info in color table */
+			k = 0;
+			while( pixel != keys[ k ] )
+				k++;
+
+			/* save the index into color table */
+			*(cq + j) = k;
+		}
+	}		
+	free( keys );
+		
+	return ip;
+}
+
+void wIconSetColor( wIcon_p ip, wDrawColor color )
+{
+	unsigned long col = wDrawGetRGB( color );
+
+	if( ip->type == mswIcon_bitmap ) {
+		ip->colormap[ 1 ].rgbBlue = col & 0xFF;
+		ip->colormap[ 1 ].rgbRed = (col>>16) & 0xFF;
+		ip->colormap[ 1 ].rgbGreen = (col>>8) & 0xFF;
+	}
+}
+
+/**
+ * Draw icon to screen.
+ *
+ * \param d IN drawing area
+ * \param bm IN bitmap to draw
+ * \param x IN x position 
+ * \param y IN y position
+ */
+
+void
+wIconDraw( wDraw_p d, wIcon_p bm, wPos_t x, wPos_t y )
+{
+	mswDrawIcon( d->hDc, (int)x, (int)y, bm, FALSE, 0, 0 );
+}
+
+/**
+ * Create a static control for displaying a bitmap.
+ *
+ * \param parent IN parent window
+ * \param x, y   IN position in parent window
+ * \param option IN ignored for now
+ * \param iconP  IN icon to use
+ * \return    the control
+ */
+
+wControl_p
+wBitmapCreate( wWin_p parent, wPos_t x, wPos_t y, long option, wIcon_p iconP )
+{
+	wBitmap_p control;
+	int index;
+	DWORD style = SS_OWNERDRAW | WS_VISIBLE | WS_CHILD;
+
+	control = mswAlloc( parent, B_BITMAP, NULL, sizeof( struct wBitmap_t ), NULL, &index );
+	mswComputePos( (wControl_p)control, x, y );
+	control->option = option;
+
+	control->hWnd = CreateWindow( "STATIC", NULL,
+						style, control->x, control->y,
+						iconP->w, iconP->h,
+						((wControl_p)parent)->hWnd, (HMENU)index, mswHInst, NULL );
+
+	if (control->hWnd == NULL) {
+		mswFail("CreateWindow(BITMAP)");
+		return (wControl_p)control;
+	}
+	control->h = iconP->h;
+	control->w = iconP->w;
+	control->data = iconP;
+
+	return (wControl_p)control;
+}
\ No newline at end of file
diff --git a/app/wlib/mswlib/mswbox.c b/app/wlib/mswlib/mswbox.c
new file mode 100644
index 0000000..04b3656
--- /dev/null
+++ b/app/wlib/mswlib/mswbox.c
@@ -0,0 +1,119 @@
+#include <windows.h>
+#include <string.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <commdlg.h>
+#include <math.h>
+#include "mswint.h"
+
+/*
+ *****************************************************************************
+ *
+ * Boxes
+ *
+ *****************************************************************************
+ */
+
+struct wBox_t {
+		WOBJ_COMMON
+		wBoxType_e boxTyp;
+		};
+
+#define B (1)
+#define W (2)
+#define SETCOLOR( S, N ) \
+		if ( lastColor != colors[bb->boxTyp][S][N] ) { \
+			lastColor = colors[bb->boxTyp][S][N]; \
+			SetROP2( hDc, (lastColor==B?R2_BLACK:R2_WHITE) ); \
+		}
+
+
+void wBoxSetSize(
+		wBox_p bb,
+		wPos_t w,
+		wPos_t h )
+{
+	bb->w = w;
+	bb->h = h;
+}
+
+
+static void repaintBox( HWND hWnd, wControl_p b )
+{						  
+	HDC hDc;
+	wBox_p bb = (wBox_p)(b);
+	wPos_t x0, y0, x1, y1;
+	char lastColor;
+	int lastRop;
+	static char colors[8][4][2] = {
+		{ /* ThinB	*/ {B,0}, {B,0}, {B,0}, {B,0} },
+		{ /* ThinW	*/ {W,0}, {W,0}, {W,0}, {W,0} },
+		{ /* AboveW */ {W,0}, {W,0}, {B,0}, {B,0} },
+		{ /* BelowW */ {B,0}, {B,0}, {W,0}, {W,0} },
+		{ /* ThickB */ {B,B}, {B,B}, {B,B}, {B,B} },
+		{ /* ThickW */ {W,W}, {W,W}, {W,W}, {W,W} },
+		{ /* RidgeW */ {W,B}, {W,B}, {B,W}, {B,W} },
+		{ /* TroughW*/ {B,W}, {B,W}, {W,B}, {W,B} } };
+
+	x0 = bb->x;
+	x1 = bb->x+bb->w;
+	y0 = bb->y;
+	y1 = bb->y+bb->h;
+	hDc = GetDC( hWnd );
+	MoveTo( hDc, x0, y1 );
+	/*SETCOLOR( 0, 0 );*/
+	lastColor = colors[bb->boxTyp][0][0];
+	lastRop = SetROP2( hDc, (lastColor==B?R2_BLACK:R2_WHITE) );
+	LineTo( hDc, x0, y0 );
+	SETCOLOR( 1, 0 );
+	LineTo( hDc, x1, y0 );
+	SETCOLOR( 2, 0 );
+	LineTo( hDc, x1, y1 );
+	SETCOLOR( 3, 0 );
+	LineTo( hDc, x0, y1 );
+	if (bb->boxTyp >= wBoxThickB) {
+		x0++; y0++; x1--; y1--;
+		MoveTo( hDc, x0, y1 );
+		SETCOLOR( 0, 1 );
+		LineTo( hDc, x0, y0 );
+		SETCOLOR( 1, 1 );
+		LineTo( hDc, x1, y0 );
+		SETCOLOR( 2, 1 );
+		LineTo( hDc, x1, y1 );
+		SETCOLOR( 3, 1 );
+		LineTo( hDc, x0, y1 );
+	}
+	SetROP2( hDc, lastRop );
+	ReleaseDC( hWnd, hDc );
+}
+
+
+static callBacks_t boxCallBacks = {
+		repaintBox,
+		NULL,
+		NULL };
+
+wBox_p wBoxCreate(
+		wWin_p	parent,
+		wPos_t	origX,
+		wPos_t	origY,
+		const char	* labelStr,
+		wBoxType_e typ,
+		wPos_t	width,
+		wPos_t	height )
+{
+	wBox_p b;
+	int index;
+
+	b = (wBox_p)mswAlloc( parent, B_BOX, labelStr, sizeof *b, NULL, &index );
+	b->boxTyp = typ;
+
+	b->x = origX;
+	b->y = origY;
+	b->w = width;
+	b->h = height;
+	mswAddButton( (wControl_p)b, FALSE, NULL );
+	mswCallBacks[B_BOX] = &boxCallBacks; 
+	repaintBox( ((wControl_p)parent)->hWnd, (wControl_p)b );
+	return b;
+} 
diff --git a/app/wlib/mswlib/mswbutt.c b/app/wlib/mswlib/mswbutt.c
new file mode 100644
index 0000000..b5d7b49
--- /dev/null
+++ b/app/wlib/mswlib/mswbutt.c
@@ -0,0 +1,387 @@
+#include <windows.h>
+#include <string.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <commdlg.h>
+#include <math.h>
+#include "mswint.h"
+int kludge12 = 0;
+
+/*
+ *****************************************************************************
+ *
+ * Simple Buttons
+ *
+ *****************************************************************************
+ */
+
+
+
+static XWNDPROC oldButtProc = NULL;
+static XWNDPROC newButtProc;
+
+
+struct wButton_t {
+		WOBJ_COMMON
+		wButtonCallBack_p action;
+		wBool_t busy;
+		wBool_t selected;
+		wIcon_p icon;
+		};
+
+
+
+void mswButtPush(
+		wControl_p b )
+{
+	if ( ((wButton_p)b)->action )
+		((wButton_p)b)->action( ((wButton_p)b)->data );
+}
+
+/**
+ * Paint function for toolbar buttons
+ * 
+ * \param hButtDc IN valid device context
+ * \param bm IN bitmap to add to button
+ * \param selected IN selected state of button
+ * \param disabled IN disabled state of button
+ */
+
+static void drawButton(
+		HDC hButtDc,
+		wIcon_p bm,
+		BOOL_T selected,
+		BOOL_T disabled )
+{
+	HGDIOBJ oldBrush, newBrush;
+	HPEN oldPen, newPen;
+	RECT rect;
+	COLORREF color1, color2;
+	POS_T offw=5, offh=5;
+	TRIVERTEX        vert[2] ;
+	GRADIENT_RECT    gRect;
+
+	COLORREF colL;
+	COLORREF colD;
+	COLORREF colF;
+
+#define LEFT (0)
+#define RIGHT (bm->w+10)
+#define TOP (0)
+#define BOTTOM (bm->h+10)
+
+	/* get the lightest and the darkest color to use */
+	colL = GetSysColor( COLOR_BTNHIGHLIGHT );
+	colD = GetSysColor( COLOR_BTNSHADOW );
+	colF = GetSysColor( COLOR_BTNFACE );
+
+	/* define the rectangle for the button */
+	rect.top = TOP;
+	rect.left = LEFT;
+	rect.right = RIGHT;
+	rect.bottom = BOTTOM;
+
+	/* fill the button with the face color */
+	newBrush = CreateSolidBrush( colF );
+	oldBrush = SelectObject( hButtDc, newBrush );
+	FillRect( hButtDc, &rect, newBrush );
+	DeleteObject( SelectObject( hButtDc, oldBrush ) );
+
+	/* disabled button remain flat */
+	if( !disabled )
+	{
+		/* select colors for the gradient */
+		if( selected ) {
+			color1 = colD;
+			color2 = colL;
+		} else {
+			color1 = colL;
+			color2 = colD;
+		}
+
+#define GRADIENT_WIDTH 6
+
+		/* 
+			first draw the top gradient 
+			this always ends in the button face color 
+			starting color depends on button state (selected or not) 
+		*/
+		vert [0] .x      = LEFT;
+		vert [0] .y      = TOP;
+		vert [0] .Red    = GetRValue( color1 )* 256;
+		vert [0] .Green  = GetGValue( color1 )* 256;
+		vert [0] .Blue   = GetBValue( color1 )* 256;
+		vert [0] .Alpha  = 0x0000;
+		vert [1] .x      = RIGHT;
+		vert [1] .y      = TOP + GRADIENT_WIDTH; 
+		vert [1] .Red    = GetRValue( colF )* 256;
+		vert [1] .Green  = GetGValue( colF )* 256;
+		vert [1] .Blue   = GetBValue( colF )* 256;
+		vert [1] .Alpha  = 0x0000;
+		
+		gRect.UpperLeft  = 0;
+		gRect.LowerRight = 1;
+		
+		GradientFill(hButtDc, vert, 2, &gRect, 1, GRADIENT_FILL_RECT_V);
+
+		/* 
+			now draw the bottom gradient 
+			this always starts with the button face color 
+			ending color depends on button state (selected or not) 
+		*/
+		vert [0] .x      = LEFT;
+		vert [0] .y      = BOTTOM - GRADIENT_WIDTH;
+		vert [0] .Red    = GetRValue( colF )* 256;
+		vert [0] .Green  = GetGValue( colF )* 256;
+		vert [0] .Blue   = GetBValue( colF )* 256;
+		vert [0] .Alpha  = 0x0000;
+		vert [1] .x      = RIGHT;
+		vert [1] .y      = BOTTOM; 
+		vert [1] .Red    = GetRValue( color2 )* 256;
+		vert [1] .Green  = GetGValue( color2 )* 256;
+		vert [1] .Blue   = GetBValue( color2 )* 256;
+		vert [1] .Alpha  = 0x0000;
+		gRect.UpperLeft  = 0;
+		gRect.LowerRight = 1;
+		GradientFill(hButtDc, vert, 2, &gRect, 1, GRADIENT_FILL_RECT_V);
+
+	}
+
+	/* draw delimiting lines in shadow color */
+	newPen = CreatePen( PS_SOLID, 0, colD );
+	oldPen = SelectObject( hButtDc, newPen );
+
+	MoveTo( hButtDc, LEFT, TOP );
+	LineTo( hButtDc, LEFT, BOTTOM );
+	MoveTo( hButtDc, RIGHT, TOP );
+	LineTo( hButtDc, RIGHT, BOTTOM );
+	
+	DeleteObject( SelectObject( hButtDc, oldPen ) );
+		
+	color2 = GetSysColor( COLOR_BTNSHADOW );
+	color1 = RGB( bm->colormap[ 1 ].rgbRed, bm->colormap[ 1 ].rgbGreen, bm->colormap[ 1 ].rgbBlue );
+
+	if (selected) {
+		offw++; offh++;
+	}
+	mswDrawIcon( hButtDc, offw, offh, bm, disabled, color1, color2 );
+}
+
+
+static void buttDrawIcon(
+		wButton_p b,
+		HDC butt_hDc )
+{
+		wIcon_p bm = b->icon;
+		POS_T offw=5, offh=5;
+
+		if (b->selected || b->busy) {
+			offw++; offh++;
+		} else if ( (b->option & BO_DISABLED) != 0 ) {
+			;
+		} else {
+			;
+		}
+		drawButton( butt_hDc, bm, b->selected || b->busy, (b->option & BO_DISABLED) != 0 );
+}
+
+void wButtonSetBusy(
+		wButton_p b,
+		int value )
+{
+	b->busy = value;
+	if (!value)
+		b->selected = FALSE;
+	/*SendMessage( b->hWnd, BM_SETSTATE, (WPARAM)value, 0L );*/
+	InvalidateRgn( b->hWnd, NULL, FALSE );
+}
+
+
+void wButtonSetLabel(
+		wButton_p b,
+		const char * label )
+{
+	if ((b->option&BO_ICON) == 0) {
+		/*b->labelStr = label;*/
+		SetWindowText( b->hWnd, label );
+	} else {
+		b->icon = (wIcon_p)label;
+	}
+	InvalidateRgn( b->hWnd, NULL, FALSE );
+}
+				   
+
+static LRESULT buttPush( wControl_p b, HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
+{
+	wButton_p bb = (wButton_p)b;
+	DRAWITEMSTRUCT * di = (DRAWITEMSTRUCT *)lParam;
+	wBool_t selected;
+
+	switch (message) {
+	case WM_COMMAND:
+		if (bb->action /*&& !bb->busy*/) {
+			bb->action( bb->data );
+			return 0L;
+		}
+		break;
+
+	case WM_MEASUREITEM: {
+		MEASUREITEMSTRUCT * mi = (MEASUREITEMSTRUCT *)lParam;
+		if (bb->type != B_BUTTON || (bb->option & BO_ICON) == 0)
+			break;
+		mi->CtlType = ODT_BUTTON;
+		mi->CtlID = wParam;
+		mi->itemWidth = bb->w;
+		mi->itemHeight = bb->h;
+		} return 0L;
+
+	case WM_DRAWITEM:
+		if (bb->type == B_BUTTON && (bb->option & BO_ICON) != 0) {
+			selected = ((di->itemState & ODS_SELECTED) != 0);
+			if (bb->selected != selected) {
+				bb->selected = selected;
+				InvalidateRgn( bb->hWnd, NULL, FALSE );
+			}
+			return TRUE;
+		}
+		break;
+
+	}
+	return DefWindowProc( hWnd, message, wParam, lParam );
+}
+
+
+static void buttDone(
+		wControl_p b )
+{
+	free(b);
+}
+
+long FAR PASCAL _export pushButt(
+		HWND hWnd,
+		UINT message,
+		UINT wParam,
+		LONG lParam )
+{
+	/* Catch <Return> and cause focus to leave control */
+#ifdef WIN32
+	long inx = GetWindowLong( hWnd, GWL_ID );
+#else
+	short inx = GetWindowWord( hWnd, GWW_ID );
+#endif
+	wButton_p b = (wButton_p)mswMapIndex( inx );
+	PAINTSTRUCT ps;
+
+	switch (message) {
+	case WM_PAINT:
+		if ( b && b->type == B_BUTTON && (b->option & BO_ICON) != 0 ) {
+			BeginPaint( hWnd, &ps );
+			buttDrawIcon( (wButton_p)b, ps.hdc );
+			EndPaint( hWnd, &ps );
+			return 1L;
+		}
+		break;
+	case WM_CHAR:
+		if ( b != NULL ) {
+			switch( wParam ) {
+			case 0x0D:
+			case 0x1B:
+			case 0x09:
+				/*SetFocus( ((wControl_p)(b->parent))->hWnd );*/
+				SendMessage( ((wControl_p)(b->parent))->hWnd, WM_CHAR,
+						wParam, lParam );
+				/*SendMessage( ((wControl_p)(b->parent))->hWnd, WM_COMMAND,
+						inx, MAKELONG( hWnd, EN_KILLFOCUS ) );*/
+				return 0L;
+			}
+		}
+		break;
+	case WM_KILLFOCUS:
+		if ( b )
+			InvalidateRect( b->hWnd, NULL, TRUE );
+		return 0L;
+		break;
+	case WM_ERASEBKGND:
+		if (kludge12)
+		return 1L;
+	}
+	return CallWindowProc( oldButtProc, hWnd, message, wParam, lParam );
+}
+
+static callBacks_t buttonCallBacks = {
+		mswRepaintLabel,
+		buttDone,
+		buttPush };
+
+wButton_p wButtonCreate(
+		wWin_p	parent,
+		POS_T	x,
+		POS_T	y,
+		const char	* helpStr,
+		const char	* labelStr,
+		long	option,
+		wPos_t	width,
+		wButtonCallBack_p action,
+		void	* data )
+{
+	wButton_p b;
+	RECT rect;
+	int h=20;
+	int index;
+	DWORD style;
+	HDC hDc;
+	wIcon_p bm;
+
+	if (width <= 0)
+		width = 80;
+	if ((option&BO_ICON) == 0) {
+		labelStr = mswStrdup( labelStr );
+	} else {
+		bm = (wIcon_p)labelStr;
+		labelStr = NULL;
+	}
+	b = (wButton_p)mswAlloc( parent, B_BUTTON, NULL, sizeof *b, data, &index );
+	b->option = option;
+	b->busy = 0;
+	b->selected = 0;
+	mswComputePos( (wControl_p)b, x, y );
+	if (b->option&BO_ICON) {
+		width = bm->w+10;
+		h = bm->h+10;
+		b->icon = bm;
+	} else {
+		width = (wPos_t)(width*mswScale);
+	}
+	style = ((b->option&BO_ICON)? BS_OWNERDRAW : BS_PUSHBUTTON) |
+				WS_CHILD | WS_VISIBLE |
+				mswGetBaseStyle(parent);
+	if ((b->option&BB_DEFAULT) != 0)
+		style |= BS_DEFPUSHBUTTON;
+	b->hWnd = CreateWindow( "BUTTON", labelStr, style, b->x, b->y,
+				/*CW_USEDEFAULT, CW_USEDEFAULT,*/ width, h,
+				((wControl_p)parent)->hWnd, (HMENU)index, mswHInst, NULL );
+	if (b->hWnd == NULL) {
+		mswFail("CreateWindow(BUTTON)");
+		return b;
+	}
+	/*SetWindowLong( b->hWnd, 0, (long)b );*/
+	GetWindowRect( b->hWnd, &rect );
+	b->w = rect.right - rect.left;
+	b->h = rect.bottom - rect.top;
+	mswAddButton( (wControl_p)b, TRUE, helpStr );
+	b->action = action;
+	mswCallBacks[B_BUTTON] = &buttonCallBacks;
+	mswChainFocus( (wControl_p)b );
+	newButtProc = MakeProcInstance( (XWNDPROC)pushButt, mswHInst );
+	oldButtProc = (XWNDPROC)GetWindowLong( b->hWnd, GWL_WNDPROC );
+	SetWindowLong( b->hWnd, GWL_WNDPROC, (LONG)newButtProc );
+	if (mswPalette) {
+		hDc = GetDC( b->hWnd );
+		SelectPalette( hDc, mswPalette, 0 );
+		RealizePalette( hDc );
+		ReleaseDC( b->hWnd, hDc );
+	}
+	if ( !mswThickFont )
+		SendMessage( b->hWnd, WM_SETFONT, (WPARAM)mswLabelFont, 0L );
+	return b;
+}
diff --git a/app/wlib/mswlib/mswchksm.c b/app/wlib/mswlib/mswchksm.c
new file mode 100644
index 0000000..602c204
--- /dev/null
+++ b/app/wlib/mswlib/mswchksm.c
@@ -0,0 +1,125 @@
+#include <stdio.h>
+#include <sys/stat.h>
+#include "../include/wlib.h"
+#ifdef WINDOWS
+#include <windows.h>
+#include "mswint.h"
+#endif
+
+#define HEWHDROFFSET	(0x3C)
+
+static FILE * openfile( const char * fn, const char * mode, long * fileSize )
+{
+	unsigned short PageCnt;
+	long FileSize;
+	FILE *fp;
+	struct stat Stat;
+	fp = fopen( fn, mode );
+	if (fp == NULL) {
+		perror( "fopen" );
+		return NULL;
+	}
+	fread( &PageCnt, sizeof(PageCnt), 1, fp ); /* Read past signature */
+	fread( &PageCnt, sizeof(PageCnt), 1, fp ); /* Read past pagesize */
+	FileSize = PageCnt;
+	fread( &PageCnt, sizeof(PageCnt), 1, fp ); /* Read past pagesize */
+	if ( FileSize == 0L )
+		FileSize = PageCnt * 512L;
+	else
+		FileSize += (PageCnt - 1) * 512L;
+	*fileSize = FileSize;
+	stat( fn, &Stat );
+	*fileSize = (long)Stat.st_size;
+	fprintf( stderr, "size1 = %ld, size2 = %ld\n", FileSize, (long)Stat.st_size );
+	return fp;
+}
+
+
+static unsigned short mswCheck16( FILE * fp, long FileSize, unsigned short * sum16stored )
+{
+	unsigned short int sum16, NxtInt;
+	long x;
+	unsigned char NxtChar;
+	sum16 = 0;
+	fseek(fp, 0, SEEK_SET);
+
+	for (x=0L; x<FileSize/2L; x++) {
+		fread( &NxtInt, sizeof NxtInt, 1, fp );
+		if (x == 9)
+			*sum16stored = NxtInt;
+		else
+			sum16 += NxtInt;
+	}
+	if (FileSize%2) {
+		fread( &NxtChar, sizeof NxtChar, 1, fp );
+		sum16 += (unsigned int)NxtChar;
+	}
+	return sum16;
+}
+
+
+static int mswCheck32( FILE * fp, long FileSize, long * sum32off, unsigned long * sum32computed, unsigned long * sum32stored )
+{
+	unsigned long sum32, NxtLong;
+	long x;
+	long NewHdrOffset;
+	unsigned char NxtByte, y;
+
+	fseek( fp, HEWHDROFFSET, SEEK_SET );
+	fread( &NewHdrOffset, sizeof NewHdrOffset, 1, fp );
+	if (NewHdrOffset == 0) {
+		fprintf( stderr, "NewHdrOffset == 0\n" );
+		return 0;
+	}
+	NewHdrOffset = (NewHdrOffset/4)*4;
+	*sum32off = NewHdrOffset + 8;
+	sum32 = 0L;
+	fseek( fp, 0, SEEK_SET );
+	for (x = ( NewHdrOffset + 8 ) / 4; x; x-- ) {
+		fread( &NxtLong, sizeof NxtLong, 1, fp );
+		sum32 += NxtLong;
+	}
+	fread( sum32stored, sizeof sum32stored, 1, fp );
+
+	for (x=0; x<(FileSize-NewHdrOffset - 12)/4; x++) {
+		fread( &NxtLong, sizeof NxtLong, 1, fp );
+		sum32 += NxtLong;
+	}
+	if ( 0L != (x=FileSize%4L) ) {
+		NxtLong = 0L;
+		for (y=0; y<x; y++ ) {
+			fread( &NxtByte, sizeof NxtByte, 1, fp );
+			NxtLong += (unsigned long)NxtByte << (8*y);
+		}
+		sum32 += NxtLong;
+	}
+	*sum32computed = sum32;
+	return 1;
+}
+
+
+#ifdef WINDOWS
+wBool_t wCheckExecutable( void )
+{
+	char fileName[1024];
+	FILE * fp;
+	long FileSize;
+	GetModuleFileName( mswHInst, fileName, sizeof fileName );
+	fp = openfile( fileName, "rb", &FileSize );
+#ifdef LATER
+	{
+		unsigned long int sum32offset, sum32computed, sum32stored;
+		if ( ! mswCheck32( fp, FileSize, &sum32offset, &sum32computed, &sum32stored ) )
+			return FALSE;
+		return sum32computed == sum32stored;
+	}
+#else
+	{
+		unsigned short int sum16computed, sum16stored;
+		sum16computed = mswCheck16( fp, FileSize, &sum16stored );
+		sum16computed += sum16stored;
+		return sum16computed == 0xFFFF;
+	}
+#endif
+}
+#endif
diff --git a/app/wlib/mswlib/mswchoic.c b/app/wlib/mswlib/mswchoic.c
new file mode 100644
index 0000000..2ac391a
--- /dev/null
+++ b/app/wlib/mswlib/mswchoic.c
@@ -0,0 +1,423 @@
+#include <windows.h>
+#include <string.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <commdlg.h>
+#include <math.h>
+#include "i18n.h"
+#include "mswint.h"
+
+/*
+ *****************************************************************************
+ *
+ * Choice Boxes
+ *
+ *****************************************************************************
+ */
+
+int CHOICE_HEIGHT=(17);
+int CHOICE_MIN_WIDTH=25;
+
+static XWNDPROC oldChoiceItemProc = NULL;
+static XWNDPROC newChoiceItemProc;
+
+typedef struct {
+		WOBJ_COMMON
+		wChoice_p owner;
+		} wChoiceItem_t, * wChoiceItem_p;
+
+struct wChoice_t {
+		WOBJ_COMMON
+		const char * * labels;
+		wChoiceItem_p *buttList;
+		long *valueP;
+		long oldVal;
+		wChoiceCallBack_p action;
+		HWND hBorder;
+		};
+
+static FARPROC oldChoiceProc;
+
+void wRadioSetValue(
+		wChoice_p bc,
+		long val )
+{
+	const char ** labels;
+	long cnt;
+	wChoiceItem_p * butts;
+
+	butts = (wChoiceItem_p*)bc->buttList;
+	for (labels = bc->labels, cnt=0; *labels; labels++, cnt++, butts++ )
+		SendMessage( (*butts)->hWnd, BM_SETCHECK,
+				(val==cnt)?1:0, 0L );
+	bc->oldVal = val;
+	if (bc->valueP)
+		*bc->valueP = val;
+}
+
+long wRadioGetValue(
+		wChoice_p bc )
+{
+	return bc->oldVal;
+}
+
+
+
+void wToggleSetValue(
+		wChoice_p bc,
+		long val )
+{
+	const char ** labels;
+	long cnt;
+	wChoiceItem_p * butts;
+
+	butts = (wChoiceItem_p*)bc->buttList;
+	for (labels = bc->labels, cnt=0; *labels; labels++, cnt++, butts++ )
+		SendMessage( (*butts)->hWnd, BM_SETCHECK,
+				(val & (1L<<cnt)) != 0, 0L );
+	bc->oldVal = val;
+	if (bc->valueP)
+		*bc->valueP = val;
+}
+
+
+long wToggleGetValue(
+		wChoice_p bc )
+{
+	return bc->oldVal;
+}
+
+
+static void choiceSetBusy(
+		wControl_p b,
+		BOOL_T busy)
+{
+	wChoiceItem_p * butts;
+	wChoice_p bc = (wChoice_p)b;
+
+	for (butts = (wChoiceItem_p*)bc->buttList; *butts; butts++ )
+		EnableWindow( (*butts)->hWnd, !(BOOL)busy );
+}
+
+static void choiceShow(
+		wControl_p b,
+		BOOL_T show)
+{
+	wChoice_p bc = (wChoice_p)b;
+	wChoiceItem_p * butts;
+
+	if ((bc->option & BC_NOBORDER)==0)
+		ShowWindow( bc->hBorder, show?SW_SHOW:SW_HIDE );
+
+	for (butts = (wChoiceItem_p*)bc->buttList; *butts; butts++ )
+		ShowWindow( (*butts)->hWnd, show?SW_SHOW:SW_HIDE );
+}
+
+static void choiceSetPos(
+		wControl_p b,
+		wPos_t x,
+		wPos_t y )
+{
+	wChoice_p bc = (wChoice_p)b;
+	wChoiceItem_p * butts;
+	wPos_t dx, dy;
+
+	dx = x - bc->x;
+	dy = y - bc->y;
+	if ((bc->option & BC_NOBORDER)==0)
+		SetWindowPos( bc->hBorder, HWND_TOP, x, y, CW_USEDEFAULT, CW_USEDEFAULT,
+				SWP_NOSIZE|SWP_NOZORDER );
+
+	for (butts = (wChoiceItem_p*)bc->buttList; *butts; butts++ ) {
+		SetWindowPos( (*butts)->hWnd, HWND_TOP,
+						(*butts)->x+=dx, (*butts)->y+=dy,
+						CW_USEDEFAULT, CW_USEDEFAULT,
+						SWP_NOSIZE|SWP_NOZORDER );
+	}
+	bc->x = x;
+	bc->y = y;
+}
+
+long FAR PASCAL _export pushChoiceItem(
+		HWND hWnd,
+		UINT message,
+		UINT wParam,
+		LONG lParam )
+{
+	/* Catch <Return> and cause focus to leave control */
+#ifdef WIN32
+	long inx = GetWindowLong( hWnd, GWL_ID );
+#else
+	short inx = GetWindowWord( hWnd, GWW_ID );
+#endif
+
+	wControl_p b = mswMapIndex( inx );
+
+	switch (message) {
+	case WM_CHAR:
+		if ( b != NULL) {
+			switch( wParam ) {
+			case 0x0D:
+			case 0x1B:
+			case 0x09:
+				SetFocus( ((wControl_p)(b->parent))->hWnd ); 
+				SendMessage( ((wControl_p)(b->parent))->hWnd, WM_CHAR,
+						wParam, lParam );
+				/*SendMessage( ((wControl_p)(b->parent))->hWnd, WM_COMMAND,
+						inx, MAKELONG( hWnd, EN_KILLFOCUS ) );*/
+				return 0L;
+			}
+		}
+		break;
+	}
+	return CallWindowProc( oldChoiceItemProc, hWnd, message, wParam, lParam );
+}
+
+LRESULT choiceItemProc(
+		wControl_p b,
+		HWND hWnd,
+		UINT message,
+		WPARAM wParam,
+		LPARAM lParam )
+{			   
+	wChoiceItem_p me = (wChoiceItem_p)b, *rest;
+	wChoice_p bc;
+	int num;
+
+	switch( message ) {
+	
+	case WM_COMMAND:
+		switch (WCMD_PARAM_NOTF) {
+		case BN_CLICKED:
+			bc = me->owner;
+			num = -1;
+			for (rest = (wChoiceItem_p*)bc->buttList; *rest; rest++ ) {
+				switch (bc->type) {
+				case B_TOGGLE:
+					num = rest-(wChoiceItem_p*)bc->buttList;
+					if (*rest == me) {
+						bc->oldVal ^= (1L<<num);
+					}
+					SendMessage( (*rest)->hWnd, BM_SETCHECK,
+						(bc->oldVal & (1L<<num)) != 0, 0L );
+					break;
+	
+				case B_RADIO:
+					if (*rest != me) {
+						SendMessage( (*rest)->hWnd, BM_SETCHECK, 0, 0L );
+					} else {
+						bc->oldVal = rest-(wChoiceItem_p*)bc->buttList;
+						SendMessage( (*rest)->hWnd, BM_SETCHECK, 1, 0L );
+					}
+					break;
+				}
+			}
+			if (bc->valueP)
+				*bc->valueP = bc->oldVal;
+			if (bc->action)
+				bc->action( bc->oldVal, bc->data );
+			break;
+
+		}
+		break;
+	}													  
+	
+	return DefWindowProc( hWnd, message, wParam, lParam );
+}					
+
+
+static callBacks_t choiceCallBacks = {
+		mswRepaintLabel,
+		NULL,
+		NULL,
+		choiceSetBusy,
+		choiceShow,
+		choiceSetPos };
+
+static callBacks_t choiceItemCallBacks = {
+		NULL,
+		NULL,
+		choiceItemProc };
+
+/**
+ * Creates choice buttons. This function is used to create a group of 
+ * radio buttons and checkboxes.
+ *
+ * \param type IN type of button
+ * \param parent IN parent window
+ * \param x, y IN position of group
+ * \param helpStr IN index string to find help
+ * \param labelStr IN label for group
+ * \param option IN ?
+ * \param labels IN labels for individual choices
+ * \param valueP OUT pointer for return value
+ * \param action IN ?
+ * \param data IN ?
+ * \return    created choice button group
+ */
+
+static wChoice_p choiceCreate(
+		wType_e type,
+		wWin_p	parent,
+		POS_T	x,
+		POS_T	y,
+		const char	* helpStr,
+		const char	* labelStr,
+		long	option,
+		const char	**labels,
+		long	*valueP,
+		wChoiceCallBack_p action,
+		void	*data )
+{
+	wChoice_p b;
+	const char ** lp;
+	int cnt;
+	wChoiceItem_p * butts;
+	int ppx, ppy;
+	int bs;
+	HDC hDc;
+	HWND hButt;
+	int lab_l;
+	DWORD dw;
+	int w, maxW;
+	int pw, ph;
+	int index;
+	char * helpStrCopy;
+	HFONT hFont;
+
+	b = mswAlloc( parent, type, mswStrdup(labelStr), sizeof *b, data, &index );
+	mswComputePos( (wControl_p)b, x, y );
+	b->option = option;
+	b->valueP = valueP;
+	b->action = action;
+	b->labels = labels;
+	b->labelY += 6;
+		
+	ppx = b->x;
+	ppy = b->y;
+
+	switch (b->type) {
+	case B_TOGGLE:
+			bs = BS_CHECKBOX;
+			break;
+	case B_RADIO:
+			bs = BS_RADIOBUTTON;
+			break;
+	}
+	for (lp = b->labels,cnt=0; *lp; lp++,cnt++ );
+	butts = (wChoiceItem_p*)malloc( (cnt+1) * sizeof *butts );
+	b->buttList = butts;
+	b->oldVal = (b->valueP?*b->valueP:0);
+	ph = pw = 2;
+	maxW = 0;
+	if (helpStr)
+		helpStrCopy = mswStrdup( helpStr );
+	for (lp = b->labels, cnt=0; *lp; lp++, cnt++, butts++ ) {			
+			*butts = (wChoiceItem_p)mswAlloc( parent, B_CHOICEITEM,
+				mswStrdup(_((char *)*lp)), sizeof( wChoiceItem_t ), data, &index );
+			(*butts)->owner = b;
+			(*butts)->hWnd = hButt = CreateWindow( "BUTTON", (*butts)->labelStr,
+						bs | WS_CHILD | WS_VISIBLE | mswGetBaseStyle(parent), b->x+pw, b->y+ph,
+						80, CHOICE_HEIGHT,
+						((wControl_p)parent)->hWnd, (HMENU)index, mswHInst, NULL );
+			if ( hButt == (HWND)0 ) {
+				mswFail( "choiceCreate button" );
+				return b;
+			}
+			(*butts)->x = b->x+pw;
+			(*butts)->y = b->y+ph;
+			if (b->hWnd == 0)
+				b->hWnd = (*butts)->hWnd;
+			(*butts)->helpStr = helpStrCopy;
+
+			hDc = GetDC( hButt );
+			lab_l = strlen((*butts)->labelStr);
+			
+			if (!mswThickFont) {hFont = SelectObject( hDc, mswLabelFont );}
+			dw = GetTextExtent( hDc, (char *)((*butts)->labelStr), lab_l );
+			if (!mswThickFont) {SelectObject( hDc, hFont );}
+		
+			w = LOWORD(dw) + CHOICE_MIN_WIDTH; 
+
+			if (w > maxW)
+				maxW = w;
+			SetBkMode( hDc, TRANSPARENT );
+			ReleaseDC( hButt, hDc );
+			if (b->option & BC_HORZ) {
+				pw += w;
+			} else {
+				ph += CHOICE_HEIGHT;
+			}
+			if (!SetWindowPos( hButt, HWND_TOP, 0, 0,
+				w, CHOICE_HEIGHT, SWP_NOMOVE|SWP_NOZORDER)) {
+				mswFail("Create CHOICE: SetWindowPos");
+			}
+			mswChainFocus( (wControl_p)*butts );
+			newChoiceItemProc = MakeProcInstance( (XWNDPROC)pushChoiceItem, mswHInst );
+			oldChoiceItemProc = (XWNDPROC)GetWindowLong( (*butts)->hWnd, GWL_WNDPROC );
+			SetWindowLong( (*butts)->hWnd, GWL_WNDPROC, (LONG)newChoiceItemProc );
+			if ( !mswThickFont )
+				SendMessage( (*butts)->hWnd, WM_SETFONT, (WPARAM)mswLabelFont, 0L ); 
+	}
+	*butts = NULL;
+	switch (b->type) {
+	case B_TOGGLE:
+		wToggleSetValue( b, (b->valueP?*b->valueP:0L) );
+		break;
+	case B_RADIO:
+		wRadioSetValue( b, (b->valueP?*b->valueP:0L) );
+		break;
+	}
+	if (b->option & BC_HORZ) {
+		ph = CHOICE_HEIGHT;
+	} else {
+		pw = maxW;
+	}
+	pw += 4; ph += 4;
+	b->w = pw;
+	b->h = ph;								  
+
+#define FRAME_STYLE		SS_ETCHEDFRAME
+
+	if ((b->option & BC_NOBORDER)==0) {
+		b->hBorder = CreateWindow( "STATIC", NULL, WS_CHILD | WS_VISIBLE | FRAME_STYLE,
+			b->x, b->y, pw, ph, ((wControl_p)parent)->hWnd, 0, mswHInst, NULL );
+	}
+	mswAddButton( (wControl_p)b, TRUE, helpStr );
+	mswCallBacks[ B_CHOICEITEM ] = &choiceItemCallBacks;
+	mswCallBacks[ type ] = &choiceCallBacks;
+	return b;
+}
+
+
+wChoice_p wRadioCreate(
+		wWin_p	parent,
+		POS_T	x,
+		POS_T	y,
+		const char	* helpStr,
+		const char	* labelStr,
+		long	option,
+		const char	**labels,
+		long	*valueP,
+		wChoiceCallBack_p action,
+		void	*data )
+{
+	return choiceCreate( B_RADIO, parent, x, y, helpStr, labelStr,
+		option, labels, valueP, action, data );
+}
+
+wChoice_p wToggleCreate(
+		wWin_p	parent,
+		POS_T	x,
+		POS_T	y,
+		const char	* helpStr,
+		const char	* labelStr,
+		long	option,
+		const char	**labels,
+		long	*valueP,
+		wChoiceCallBack_p action,
+		void	*data )
+{
+	return choiceCreate( B_TOGGLE, parent, x, y, helpStr, labelStr,
+		option, labels, valueP, action, data );
+}
diff --git a/app/wlib/mswlib/mswcolor.c b/app/wlib/mswlib/mswcolor.c
new file mode 100644
index 0000000..41bf6a9
--- /dev/null
+++ b/app/wlib/mswlib/mswcolor.c
@@ -0,0 +1,362 @@
+/*
+ * $Header: /home/dmarkle/xtrkcad-fork-cvs/xtrkcad/app/wlib/mswlib/mswcolor.c,v 1.2 2007-01-14 08:43:32 m_fischer Exp $
+ */
+
+#include <windows.h>
+#include <string.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <commdlg.h>
+#include <math.h>
+#include <windows.h>
+
+#include "mswint.h"
+
+#include "square10.bmp"
+
+/*
+ *****************************************************************************
+ *
+ * Color
+ *
+ *****************************************************************************
+ */
+
+#define NUM_GRAYS (16)
+#define NUM_COLORS (256)
+
+wDrawColor wDrawColorWhite = 0;
+wDrawColor wDrawColorBlack = 1;
+
+#define MAX_COLOR_DISTANCE (3)
+
+static void mswGetCustomColors( void );
+
+
+static struct {
+		WORD palVersion;
+		WORD palNumEntries;
+		PALETTEENTRY palPalEntry[NUM_COLORS];
+		} colorPalette = {
+		0x300,
+		2,
+		{
+		{ 255, 255, 255 },		/* White */
+		{	0,	 0,	  0 }		/* Black */
+		} };
+
+COLORREF mappedColors[NUM_COLORS];
+
+
+static long flipRGB( long rgb )
+{
+	rgb = ((rgb>>16)&0xFF) | (rgb&0x00FF00) | ((rgb&0xFF)<<16);
+	return rgb;
+}
+
+
+static void getpalette( void )
+{
+
+	HDC hdc;
+	int inx, cnt;
+	PALETTEENTRY pe[256];
+	FILE * f;
+	hdc = GetDC(mswHWnd);
+	if (!(GetDeviceCaps( hdc, RASTERCAPS) & RC_PALETTE)) {
+		ReleaseDC( mswHWnd, hdc );
+		return;
+	}
+	cnt = GetDeviceCaps(hdc, SIZEPALETTE);
+	GetSystemPaletteEntries( hdc, 0, cnt, pe );
+	f = fopen( "palette.txt", "w" );
+	for (inx=0;inx<cnt;inx++)
+		fprintf(f, "%d [ %d %d %d %d ]\n", inx, pe[inx].peRed, pe[inx].peGreen, pe[inx].peBlue, pe[inx].peFlags );
+	fclose(f);
+	ReleaseDC( mswHWnd, hdc );
+}
+
+
+static int findColor( int r0, int g0, int b0 )
+{
+	int r1, g1, b1;
+	int d0, d1;
+	int c, cc;
+	PALETTEENTRY *pal;
+
+	pal = colorPalette.palPalEntry;
+	cc = (int)wDrawColorBlack;
+	d0 = 256*3;
+
+	for ( c = 0; c < (int)colorPalette.palNumEntries; c++ ) {
+		r1 = pal[c].peRed;
+		b1 = pal[c].peBlue;
+		g1 = pal[c].peGreen;
+		d1 = abs(r0-r1) + abs(g0-g1) + abs(b0-b1);
+		if (d1 == 0)
+			return c;
+		if (d1 < d0) {
+			d0 = d1;
+			cc = c;
+		}
+	}
+	if ( colorPalette.palNumEntries < 128 ) {
+		pal[colorPalette.palNumEntries].peRed = r0;
+		pal[colorPalette.palNumEntries].peGreen = g0;
+		pal[colorPalette.palNumEntries].peBlue = b0;
+		if ( mswPalette ) {
+			ResizePalette( mswPalette, colorPalette.palNumEntries+1 );
+			SetPaletteEntries( mswPalette, colorPalette.palNumEntries, 1, &pal[colorPalette.palNumEntries] );
+		}
+		return colorPalette.palNumEntries++;
+	}
+	return cc;
+}
+
+
+int mswGetPaletteClock( void )
+{
+	return colorPalette.palNumEntries;
+}
+
+
+void mswInitColorPalette( void )
+{
+	static int initted = FALSE;
+	HDC hDc;
+	int cnt;
+	int rc;
+	static struct {
+		WORD palVersion;
+		WORD palNumEntries;
+		PALETTEENTRY palPalEntry[256];
+	} pe;
+
+	if (initted)
+		return;
+
+	initted = TRUE;
+	mswGetCustomColors();
+	mswFontInit();
+	hDc = GetDC(mswHWnd);
+	if (!(GetDeviceCaps( hDc, RASTERCAPS) & RC_PALETTE)) {
+		ReleaseDC( mswHWnd, hDc );
+		return;
+	}
+	cnt = GetDeviceCaps(hDc, SIZEPALETTE);
+	rc = GetSystemPaletteEntries( hDc, 0, cnt, pe.palPalEntry );
+	mswPalette = CreatePalette( (const LOGPALETTE FAR*)&colorPalette );
+	ReleaseDC( mswHWnd, hDc );
+
+}
+
+
+HPALETTE mswCreatePalette( void )
+{
+	return CreatePalette( (const LOGPALETTE FAR*)&colorPalette );
+}
+
+
+int mswGetColorList( RGBQUAD * colors )
+{
+	int i;
+	for (i=0;i<(int)colorPalette.palNumEntries;i++) {
+		colors[i].rgbBlue = colorPalette.palPalEntry[i].peBlue;
+		colors[i].rgbGreen = colorPalette.palPalEntry[i].peGreen;
+		colors[i].rgbRed = colorPalette.palPalEntry[i].peRed;
+		colors[i].rgbReserved = 0;
+	}
+	return NUM_COLORS;
+}
+
+
+COLORREF mswGetColor( wBool_t hasPalette, wDrawColor color )
+{
+	if ( hasPalette )
+		return PALETTEINDEX(color);
+	else
+		return RGB( colorPalette.palPalEntry[color].peRed,	colorPalette.palPalEntry[color].peGreen,  colorPalette.palPalEntry[color].peBlue );
+}
+
+
+wDrawColor wDrawColorGray(
+		int percent )
+{
+	int n;
+	n = (percent * NUM_GRAYS) / 100;
+	if ( n <= 0 )
+		return wDrawColorBlack;
+	else if ( n > NUM_GRAYS )
+		return wDrawColorWhite;
+	else {
+		n = (n*256)/NUM_GRAYS;
+		return wDrawFindColor( wRGB(n,n,n) );
+	}
+}
+
+wDrawColor wDrawFindColor(
+		long rgb0 )
+{
+	static long saved_rgb = wRGB(255,255,255);
+	static wDrawColor saved_color = 0;
+	int r0, g0, b0;
+
+	if (rgb0 == saved_rgb)
+		return saved_color;
+	r0 = (int)(rgb0>>16)&0xFF;
+	g0 = (int)(rgb0>>8)&0xFF;
+	b0 = (int)(rgb0)&0xFF;
+	saved_rgb = rgb0;
+	return saved_color = findColor( r0, g0, b0 );
+}
+
+
+long wDrawGetRGB(
+		wDrawColor color )
+{
+	long rgb;
+	int r, g, b;
+	r = colorPalette.palPalEntry[color].peRed;
+	g = colorPalette.palPalEntry[color].peGreen;
+	b = colorPalette.palPalEntry[color].peBlue;
+	rgb = wRGB(r,g,b);
+	return rgb;
+}
+
+
+static CHOOSECOLOR chooseColor;
+static COLORREF aclrCust[16];
+
+static void mswGetCustomColors( void )
+{
+	int inx;
+	char colorName[10];
+	long rgb;
+
+	strcpy( colorName, "custom-" );
+	for ( inx=0; inx<16; inx++ ) {
+		sprintf( colorName+7, "%d", inx );
+		wPrefGetInteger( "mswcolor", colorName, &rgb, 0 );
+		aclrCust[inx] = flipRGB(rgb);
+	}
+}
+
+
+void mswPutCustomColors( void )
+{
+	int inx;
+	char colorName[10];
+	long rgb;
+
+	strcpy( colorName, "custom-" );
+	for ( inx=0; inx<16; inx++ ) {
+		rgb = flipRGB(aclrCust[inx]);
+		if ( rgb != 0 ) {
+			sprintf( colorName+7, "%d", inx );
+			wPrefSetInteger( "mswcolor", colorName, rgb );
+		}
+	}
+}
+
+
+wBool_t wColorSelect(
+		const char * title,
+		wDrawColor * color )
+{
+	long rgb;
+
+	memset( &chooseColor, 0, sizeof chooseColor );
+	rgb = flipRGB(wDrawGetRGB(*color));
+	chooseColor.lStructSize = sizeof chooseColor;
+	chooseColor.hwndOwner = mswHWnd;
+	chooseColor.hInstance = NULL;
+	chooseColor.rgbResult = rgb;
+	chooseColor.lpCustColors = aclrCust;
+	chooseColor.Flags = CC_RGBINIT;
+	chooseColor.lCustData = 0L;
+	chooseColor.lpfnHook = NULL;
+	chooseColor.lpTemplateName = (LPSTR)NULL;
+	if ( ChooseColor( &chooseColor ) ) {
+		rgb = flipRGB(chooseColor.rgbResult);
+		*color = wDrawFindColor(rgb);
+		return TRUE;
+	}
+	return FALSE;
+}
+
+
+typedef struct {
+		wDrawColor * valueP;
+		wColorSelectButtonCallBack_p action;
+		const char * labelStr;
+		void * data;
+		wDrawColor color;
+		wButton_p button;
+		wIcon_p bm;
+		} colorData_t;
+
+
+static void doColorButton(
+		void * data )
+{
+	colorData_t * cd = (colorData_t*)data;
+	wDrawColor newColor;
+
+	newColor = cd->color;
+	if (wColorSelect( cd->labelStr, &newColor )) {
+		cd->color = newColor;
+		wColorSelectButtonSetColor( cd->button, newColor );
+		if (cd->valueP)
+			*cd->valueP = newColor;
+		if (cd->action)
+			cd->action( cd->data, newColor );
+	}
+}
+
+
+wButton_p wColorSelectButtonCreate(
+		wWin_p win,
+		wPos_t x,
+		wPos_t y,
+		const char * helpStr,
+		const char * labelStr,
+		long option,
+		wPos_t width,
+		wDrawColor * color,
+		wColorSelectButtonCallBack_p action,
+		void * data )
+{
+	wButton_p bb;
+	wIcon_p bm;
+	colorData_t * cd;
+	bm = wIconCreateBitMap( square10_width, square10_height, square10_bits, (color?*color:0) );
+	cd = malloc( sizeof *cd );
+	cd->valueP = color;
+	cd->action = action;
+	cd->data = data;
+	cd->labelStr = labelStr;
+	cd->color = (color?*color:0);
+	cd->bm = bm;
+	bb = wButtonCreate( win, x, y, helpStr, (char*)bm, option|BO_ICON, width, doColorButton, cd );
+	cd->button = bb;
+	if ( labelStr )
+				wControlSetLabel( (wControl_p)bb, labelStr );
+	return bb;
+}
+
+
+void wColorSelectButtonSetColor(
+		wButton_p bb,
+		wDrawColor color )
+{
+	((colorData_t*)((wControl_p)bb)->data)->color = color;
+	wIconSetColor( ((colorData_t*)((wControl_p)bb)->data)->bm, color );
+	InvalidateRect( ((wControl_p)bb)->hWnd, NULL, TRUE );
+}
+
+
+wDrawColor wColorSelectButtonGetColor(
+		wButton_p bb )
+{
+	return ((colorData_t*)((wControl_p)bb)->data)->color;
+}
diff --git a/app/wlib/mswlib/mswdraw.c b/app/wlib/mswlib/mswdraw.c
new file mode 100644
index 0000000..498b49e
--- /dev/null
+++ b/app/wlib/mswlib/mswdraw.c
@@ -0,0 +1,1783 @@
+/*
+ * $Header: /home/dmarkle/xtrkcad-fork-cvs/xtrkcad/app/wlib/mswlib/mswdraw.c,v 1.6 2009-05-15 18:16:16 m_fischer Exp $
+ */
+
+#define _WIN32_WINNT 0x0500		/* for wheel mouse supposrt */
+#include <windows.h>
+#include <string.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <commdlg.h>
+#include <math.h>
+#include <winuser.h>
+
+#ifdef WIN32
+#define wFont_t tagLOGFONTA
+#else
+#define wFont_t tagLOGFONT
+#endif
+#include "mswint.h"
+
+/*
+ *****************************************************************************
+ *
+ * Draw
+ *
+ *****************************************************************************
+ */
+
+static wBool_t initted = FALSE;
+
+long wDebugFont;
+
+static FARPROC oldDrawProc;
+
+
+static long tmpOp = 0x990066;
+static long setOp = 0x8800c6;
+static long clrOp = 0xbb0226;
+
+#define CENTERMARK_LENGTH 6
+
+#ifdef SLOW
+static wPos_t XPIX2INCH( wDraw_p d, int ix )
+{
+	return (wPos_t)ix;
+}
+
+static wPos_t YPIX2INCH( wDraw_p d, int iy )
+{
+	wPos_t y;
+	y = (wPos_t)(d->h-2-iy);
+	return y;
+}
+
+static int XINCH2PIX( wDraw_p d, wPos_t xx )
+{
+	int ix;
+	ix = (int)(xx);
+	return ix;
+}
+
+static int YINCH2PIX( wDraw_p d, wPos_t y )
+{
+	int iy;
+	iy = d->h-2 - (int)(y);
+	return iy;
+}
+
+
+static wPos_t XPIXELSTOINCH( wDraw_p d, int ix )
+{
+	return (wPos_t)ix;
+}
+
+
+static wPos_t YPIXELSTOINCH( wDraw_p d, int iy )
+{
+	return (wPos_t)iy;
+}
+#else
+#define XPIX2INCH( d, ix ) \
+	((wPos_t)ix)
+
+#define YPIX2INCH( d, iy ) \
+	((wPos_t)(d->h-2-iy))
+
+#define XINCH2PIX( d, xx ) \
+	((int)(xx))
+
+#define YINCH2PIX( d, y ) \
+	(d->h-2 - (int)(y))
+
+
+#define XPIXELSTOINCH( d, ix ) \
+	((wPos_t)ix)
+
+
+#define YPIXELSTOINCH( d, iy ) \
+	((wPos_t)iy)
+
+#endif
+
+/*
+ *****************************************************************************
+ *
+ * Basic Line Draw
+ *
+ *****************************************************************************
+ */
+
+
+
+static long noNegDrawArgs = -1;
+static long noFlatEndCaps = 0;
+
+void wDrawDelayUpdate(
+		wDraw_p d,
+		wBool_t delay )
+{
+}
+
+/**
+ * Sets the proper pen and composition for the next drawing operation
+ * 
+ *
+ * \param hDc IN device context
+ * \param d IN ???
+ * \param dw IN line width
+ * \param lt IN line type (dashed, solid, ...)
+ * \param dc IN color
+ * \param dopt IN ????
+ */
+
+static void setDrawMode(
+		HDC hDc,
+		wDraw_p d,
+		wDrawWidth dw,
+		wDrawLineType_e lt,
+		wDrawColor dc,
+		wDrawOpts dopt )
+{
+	int mode;
+	HPEN hOldPen;
+	static wDraw_p d0;
+	static wDrawWidth dw0 = -1;
+	static wDrawLineType_e lt0 = (wDrawLineType_e)-1;
+	static wDrawColor dc0 = -1;
+	static int mode0 = -1;
+	static LOGBRUSH logBrush = { 0, 0, 0 };
+	DWORD penStyle;
+
+	if ( d->hasPalette ) {
+		int winPaletteClock = mswGetPaletteClock();
+		if ( d->paletteClock < winPaletteClock ) {
+			RealizePalette( hDc );
+			d->paletteClock = winPaletteClock;
+		}
+	}
+
+	if (dopt & wDrawOptTemp) {
+		mode = R2_NOTXORPEN;
+	} else {
+		mode = R2_COPYPEN;
+	}
+	SetROP2( hDc, mode );
+	if ( d == d0 && mode == mode0 && dw0 == dw && lt == lt0 && dc == dc0 )
+		return;
+
+	// make sure that the line width is at least 1!
+	if( !dw ) 
+		dw++;
+
+	d0 = d; mode0 = mode; dw0 = dw; lt0 = lt; dc0 = dc;
+
+	logBrush.lbColor = mswGetColor(d->hasPalette,dc);
+	if ( lt==wDrawLineSolid ) {
+		penStyle = PS_GEOMETRIC | PS_SOLID;
+		if ( noFlatEndCaps == FALSE )
+			penStyle |= PS_ENDCAP_FLAT;
+		d->hPen = ExtCreatePen( penStyle,
+				dw,
+				&logBrush,
+				0,
+				NULL );
+				/*colorPalette.palPalEntry[dc] );*/
+	} else {
+		d->hPen = CreatePen( PS_DOT, 0, mswGetColor( d->hasPalette, dc ) );
+	}
+	hOldPen = SelectObject( hDc, d->hPen );
+	DeleteObject( hOldPen );
+}
+
+static void setDrawBrush(
+		HDC hDc,
+		wDraw_p d,
+		wDrawColor dc,
+		wDrawOpts dopt )
+{
+	HBRUSH hOldBrush;
+	static wDraw_p d0;
+	static wDrawColor dc0 = -1;
+
+	setDrawMode( hDc, d, 0, wDrawLineSolid, dc, dopt );
+	if ( d == d0 && dc == dc0 )
+		return;
+
+	d0 = d; dc0 = dc;
+
+	d->hBrush = CreateSolidBrush( 
+				mswGetColor(d->hasPalette,dc) );
+	hOldBrush = SelectObject( hDc, d->hBrush );
+	DeleteObject( hOldBrush );
+}
+
+
+static void myInvalidateRect(
+		wDraw_p d,
+		RECT * prect )
+{
+	if ( prect->top < 0 ) prect->top = 0;
+	if ( prect->left < 0 ) prect->left = 0;
+	if ( prect->bottom > d->h ) prect->bottom = d->h;
+	if ( prect->right > d->w ) prect->right = d->w;
+	InvalidateRect( d->hWnd, prect, FALSE );
+}
+
+
+static int clip0( POINT * p0, POINT * p1, wDraw_p d )
+{
+	long int x0=p0->x, y0=p0->y, x1=p1->x, y1=p1->y;
+	long int dx, dy;
+	if ( x0<0 && x1<0 ) return 0;
+	if ( y0<0 && y1<0 ) return 0;
+	dx=x1-x0;
+	dy=y1-y0;
+	if ( x0 < 0 ) {
+		y0 -= x0*dy/dx;
+		x0 = 0;
+	}
+	if ( y0 < 0 ) {
+		if ( (x0 -= y0*dx/dy) < 0 ) return 0;
+		y0 = 0;
+	}
+	if ( x1 < 0 ) {
+		y1 -= x1*dy/dx;
+		x1 = 0;
+	}
+	if ( y1 < 0 ) {
+		if ( (x1 -= y1*dx/dy) < 0 ) return 0;
+		y1 = 0;
+	}
+	p0->x = (int)x0;
+	p0->y = (int)y0;
+	p1->x = (int)x1;
+	p1->y = (int)y1;
+	return 1;
+}
+
+
+void wDrawLine(
+		wDraw_p d,
+		wPos_t p0x,
+		wPos_t p0y,
+		wPos_t p1x,
+		wPos_t p1y,
+		wDrawWidth dw,
+		wDrawLineType_e lt,
+		wDrawColor dc,
+		wDrawOpts dopt )
+{
+	POINT p0, p1;
+	RECT rect;
+	setDrawMode( d->hDc, d, dw, lt, dc, dopt );
+	p0.x = XINCH2PIX(d,p0x);
+	p0.y = YINCH2PIX(d,p0y);
+	p1.x = XINCH2PIX(d,p1x);
+	p1.y = YINCH2PIX(d,p1y);
+	if ( noNegDrawArgs>0 && !clip0( &p0, &p1, d ) )
+		return;
+	MoveTo( d->hDc, p0.x, p0.y );
+	LineTo( d->hDc, p1.x, p1.y );
+	if (d->hWnd) {
+		if (dw==0)
+			dw = 1;
+		dw++;
+	if (p0.y<p1.y) {
+		rect.top = p0.y-dw;
+		rect.bottom = p1.y+dw;
+	} else {
+		rect.top = p1.y-dw;
+		rect.bottom = p0.y+dw;
+	}
+	if (p0.x<p1.x) {
+		rect.left = p0.x-dw;
+		rect.right = p1.x+dw;
+	} else {
+		rect.left = p1.x-dw;
+		rect.right = p0.x+dw;
+	}
+	myInvalidateRect( d, &rect );
+	}
+}
+
+static double mswsin( double angle )
+{
+	while (angle < 0.0) angle += 360.0;
+	while (angle >= 360.0) angle -= 360.0;
+	angle *= (M_PI*2.0)/360.0;
+	return sin( angle );
+}
+
+static double mswcos( double angle )
+{
+	while (angle < 0.0) angle += 360.0;
+	while (angle >= 360.0) angle -= 360.0;
+	angle *= (M_PI*2.0)/360.0;
+	return cos( angle );
+}
+
+static double mswasin( double x, double h )
+{
+	double angle;
+	angle = asin( x/h );
+	angle /= (M_PI*2.0)/360.0;
+	return angle;
+}
+
+/**
+ * Draw an arc around a specified center
+ *
+ * \param d IN ?
+ * \param px, py IN  center of arc
+ * \param r IN radius
+ * \param a0, a1 IN start and end angle
+ * \param drawCenter draw marking for center
+ * \param dw line width
+ * \param lt line type
+ * \param dc color
+ * \param dopt ?
+ */
+
+
+void wDrawArc(
+		wDraw_p d,
+		wPos_t px,
+		wPos_t py,
+		wPos_t r,
+		double a0,
+		double a1,
+		int drawCenter,
+		wDrawWidth dw,
+		wDrawLineType_e lt,
+		wDrawColor dc,
+		wDrawOpts dopt )
+{
+	int i, cnt;
+	POINT p0, p1, ps, pe, pp0, pp1, pp2, pc;
+	double psx, psy, pex, pey, len, aa;
+	RECT rect;
+	int needMoveTo;
+	wBool_t fakeArc = FALSE;
+
+	len = a1/360.0 * (2 * M_PI) * r;
+	if (len < 3)
+		return;
+
+	p0.x = XINCH2PIX(d,px-r);
+	p0.y = YINCH2PIX(d,py+r)+1;
+	p1.x = XINCH2PIX(d,px+r);
+	p1.y = YINCH2PIX(d,py-r)+1;
+
+	pex = px + r * mswsin(a0);
+	pey = py + r * mswcos(a0);
+	psx = px + r * mswsin(a0+a1);
+	psy = py + r * mswcos(a0+a1);
+
+	/*pointOnCircle( &pe, p, r, a0 );
+	pointOnCircle( &ps, p, r, a0+a1 );*/
+	ps.x = XINCH2PIX(d,(wPos_t)psx);
+	ps.y = YINCH2PIX(d,(wPos_t)psy);
+	pe.x = XINCH2PIX(d,(wPos_t)pex);
+	pe.y = YINCH2PIX(d,(wPos_t)pey);
+
+	setDrawMode( d->hDc, d, dw, lt, dc, dopt );
+
+	if (dw == 0)
+		dw = 1;
+
+	if (r>4096) {
+		/* The book says 32K but experience says otherwise */
+		fakeArc = TRUE;
+	}
+	if ( noNegDrawArgs > 0 ) {
+		if ( p0.x < 0 || p0.y < 0 || p1.x < 0 || p1.y < 0 )
+			fakeArc = TRUE;
+	}
+	if ( fakeArc ) {
+		cnt = (int)a1;
+		if ( cnt <= 0 ) cnt = 1;
+		if ( cnt > 360 ) cnt = 360;
+		aa = a1 / cnt;
+		psx = px + r * mswsin(a0);
+		psy = py + r * mswcos(a0);
+		pp0.x = XINCH2PIX( d, (wPos_t)psx );
+		pp0.y = YINCH2PIX( d, (wPos_t)psy );
+		needMoveTo = TRUE;
+		for ( i=0; i<cnt; i++ ) {
+			a0 += aa;
+			psx = px + r * mswsin(a0);
+			psy = py + r * mswcos(a0);
+			pp2.x = pp1.x = XINCH2PIX( d, (wPos_t)psx );
+			pp2.y = pp1.y = YINCH2PIX( d, (wPos_t)psy );
+			if ( clip0( &pp0, &pp1, d ) ) {
+				if (needMoveTo) {
+					MoveTo( d->hDc, pp0.x, pp0.y );
+					needMoveTo = FALSE;
+				}
+				LineTo( d->hDc, pp1.x, pp1.y );
+			} else {
+				needMoveTo = TRUE;
+			}
+			pp0.x = pp2.x; pp0.y = pp2.y;
+		}
+	} else {
+		if ( a0 == 0.0 && a1 == 360.0 ) {
+			Arc( d->hDc, p0.x, p1.y, p1.x, p0.y, ps.x, p0.y-1, pe.x, p1.y-1 );
+			Arc( d->hDc, p0.x, p1.y, p1.x, p0.y, ps.x, p1.y-1, pe.x, p0.y-1 );
+		} else {
+			Arc( d->hDc, p0.x, p1.y, p1.x, p0.y, ps.x, ps.y, pe.x, pe.y );
+		}
+	}
+
+	// should the center of the arc be drawn?
+	if( drawCenter ) {
+			
+			// calculate the center coordinates
+			pc.x = XINCH2PIX( d, px );
+			pc.y = YINCH2PIX( d, py );
+			// now draw the crosshair
+			MoveTo( d->hDc, pc.x - CENTERMARK_LENGTH/2, pc.y );
+			LineTo( d->hDc, pc.x + CENTERMARK_LENGTH/2, pc.y );
+			MoveTo( d->hDc, pc.x, pc.y - CENTERMARK_LENGTH/2 );
+			LineTo( d->hDc, pc.x, pc.y + CENTERMARK_LENGTH/2 );
+			
+			// invalidate the area of the crosshair
+			rect.top  = pc.y - CENTERMARK_LENGTH / 2 - 1;
+			rect.bottom  = pc.y + CENTERMARK_LENGTH / 2 + 1;
+			rect.left = pc.x - CENTERMARK_LENGTH / 2 - 1;
+			rect.right = pc.x + CENTERMARK_LENGTH / 2 + 1;
+			myInvalidateRect( d, &rect );
+	}
+
+	if (d->hWnd) {
+		dw++;
+		a1 += a0;
+		if (a1>360.0)
+			rect.top = p0.y;
+		else
+			rect.top = min(pe.y,ps.y);
+		if (a1>(a0>180?360.0:0.0)+180)
+			rect.bottom = p1.y;
+		else
+			rect.bottom = max(pe.y,ps.y);
+		if (a1>(a0>270?360.0:0.0)+270)
+			rect.left = p0.x;
+		else
+			rect.left = min(pe.x,ps.x);
+		if (a1>(a0>90?360.0:0.0)+90)
+			rect.right = p1.x;
+		else
+			rect.right = max(pe.x,ps.x);
+		rect.top -= dw;
+		rect.bottom += dw;
+		rect.left -= dw;
+		rect.right += dw;
+		myInvalidateRect( d, &rect );
+
+	}
+}
+
+void wDrawPoint(
+		wDraw_p d,
+		wPos_t px,
+		wPos_t py,
+		wDrawColor dc,
+		wDrawOpts dopt )
+{
+	POINT p0;
+	RECT rect;
+
+	p0.x = XINCH2PIX(d,px);
+	p0.y = YINCH2PIX(d,py);
+
+	if ( p0.x < 0 || p0.y < 0 )
+		return;
+	if ( p0.x >= d->w || p0.y >= d->h )
+		return;
+	setDrawMode( d->hDc, d, 0, wDrawLineSolid, dc, dopt );
+
+	SetPixel( d->hDc, p0.x, p0.y, mswGetColor(d->hasPalette,dc) /*colorPalette.palPalEntry[dc]*/ );
+	if (d->hWnd) {
+		rect.top = p0.y-1;
+		rect.bottom = p0.y+1;
+		rect.left = p0.x-1;
+		rect.right = p0.x+1;
+		myInvalidateRect( d, &rect );
+	}
+}
+
+/*
+ *****************************************************************************
+ *
+ * Fonts
+ *
+ *****************************************************************************
+ */
+
+
+static LOGFONT logFont = {
+		/* Initial default values */
+		-24, 0, /* H, W */
+		0,		/* A */
+		0,
+		FW_REGULAR,
+		0, 0, 0,/* I, U, SO */
+		ANSI_CHARSET,
+		0,		/* OP */
+		0,		/* CP */
+		0,		/* Q */
+		0,		/* P&F */
+		"Arial" };
+
+static LOGFONT timesFont[2][2] = {
+		{ {
+		/* Initial default values */
+		0, 0,	/* H, W */
+		0,		/* A */
+		0,
+		FW_REGULAR,
+		0, 0, 0,/* I, U, SO */
+		ANSI_CHARSET,
+		0,		/* OP */
+		0,		/* CP */
+		0,		/* Q */
+		0,		/* P&F */
+		"Times" },
+		{
+		/* Initial default values */
+		0, 0,	/* H, W */
+		0,		/* A */
+		0,
+		FW_REGULAR,
+		1, 0, 0,/* I, U, SO */
+		ANSI_CHARSET,
+		0,		/* OP */
+		0,		/* CP */
+		0,		/* Q */
+		0,		/* P&F */
+		"Times" } },
+		{ {
+		/* Initial default values */
+		0, 0,	/* H, W */
+		0,		/* A */
+		0,
+		FW_BOLD,
+		0, 0, 0,/* I, U, SO */
+		ANSI_CHARSET,
+		0,		/* OP */
+		0,		/* CP */
+		0,		/* Q */
+		0,		/* P&F */
+		"Times" },
+		{
+		/* Initial default values */
+		0, 0,	/* H, W */
+		0,		/* A */
+		0,
+		FW_BOLD,
+		1, 0, 0,/* I, U, SO */
+		ANSI_CHARSET,
+		0,		/* OP */
+		0,		/* CP */
+		0,		/* Q */
+		0,		/* P&F */
+		"Times" } } };
+
+static LOGFONT helvFont[2][2] = {
+		{ {
+		/* Initial default values */
+		0, 0,	/* H, W */
+		0,		/* A */
+		0,
+		FW_REGULAR,
+		0, 0, 0,/* I, U, SO */
+		ANSI_CHARSET,
+		0,		/* OP */
+		0,		/* CP */
+		0,		/* Q */
+		0,		/* P&F */
+		"Arial" },
+		{
+		/* Initial default values */
+		0, 0,	/* H, W */
+		0,		/* A */
+		0,
+		FW_REGULAR,
+		1, 0, 0,/* I, U, SO */
+		ANSI_CHARSET,
+		0,		/* OP */
+		0,		/* CP */
+		0,		/* Q */
+		0,		/* P&F */
+		"Arial" } },
+		{ {
+		/* Initial default values */
+		0, 0,	/* H, W */
+		0,		/* A */
+		0,
+		FW_BOLD,
+		0, 0, 0,/* I, U, SO */
+		ANSI_CHARSET,
+		0,		/* OP */
+		0,		/* CP */
+		0,		/* Q */
+		0,		/* P&F */
+		"Arial" },
+		{
+		/* Initial default values */
+		0, 0,	/* H, W */
+		0,		/* A */
+		0,
+		FW_BOLD,
+		1, 0, 0,/* I, U, SO */
+		ANSI_CHARSET,
+		0,		/* OP */
+		0,		/* CP */
+		0,		/* Q */
+		0,		/* P&F */
+		"Hevletica" } } };
+
+
+void mswFontInit( void )
+{
+	const char * face;
+	long size;
+	face = wPrefGetString( "msw window font", "face" );
+	wPrefGetInteger( "msw window font", "size", &size, -24 );
+	if (face) {
+		strncpy( logFont.lfFaceName, face, LF_FACESIZE );
+	}
+	logFont.lfHeight = (int)size;
+}
+
+
+static CHOOSEFONT chooseFont;
+static wFontSize_t fontSize = 18;
+static double fontFactor = 1.0;
+
+static void doChooseFont( void )
+{
+	int rc;
+	memset( &chooseFont, 0, sizeof chooseFont );
+	chooseFont.lStructSize = sizeof chooseFont;
+	chooseFont.hwndOwner = mswHWnd;
+	chooseFont.lpLogFont = &logFont;
+	chooseFont.Flags = CF_SCREENFONTS|CF_SCALABLEONLY|CF_INITTOLOGFONTSTRUCT;
+	chooseFont.nFontType = SCREEN_FONTTYPE;
+	rc = ChooseFont( &chooseFont );
+	if (rc) {
+		fontSize = (wFontSize_t)(-logFont.lfHeight * 72) / 96.0 / fontFactor;
+		if (fontSize < 1)
+			fontSize = 1;
+		wPrefSetString( "msw window font", "face", logFont.lfFaceName );
+		wPrefSetInteger( "msw window font", "size", logFont.lfHeight );
+	}
+}
+
+static int computeFontSize( wDraw_p d, double siz )
+{
+	int ret;
+	siz = (siz * d->DPI) / 72.0;
+	ret = (int)(siz * fontFactor);
+	if (ret < 1)
+		ret = 1;
+	return -ret;
+}
+
+void wDrawGetTextSize(
+		wPos_t *w,
+		wPos_t *h,
+		wPos_t *d,
+		wDraw_p bd,
+		const char * text,
+		wFont_p fp,
+		double siz )
+{
+	int x, y;
+	HFONT newFont, prevFont;
+	DWORD extent;
+	int oldLfHeight;
+	if (fp == NULL)
+		fp = &logFont;
+	fp->lfEscapement = 0;
+	oldLfHeight = fp->lfHeight;
+	fp->lfHeight = computeFontSize( bd, siz );
+	fp->lfWidth = 0;
+	newFont = CreateFontIndirect( fp );
+	prevFont = SelectObject( bd->hDc, newFont );
+	extent = GetTextExtent( bd->hDc, CAST_AWAY_CONST text, strlen(text) );
+	x = LOWORD(extent);
+	y = HIWORD(extent);
+	*w = XPIXELSTOINCH( bd, x );
+	*h = YPIXELSTOINCH( bd, y );
+	*d = 0;
+	SelectObject( bd->hDc, prevFont );
+	DeleteObject( newFont );
+	fp->lfHeight = oldLfHeight;
+}
+
+void wDrawString(
+		wDraw_p d,
+		wPos_t px,
+		wPos_t py,
+		double angle,
+		const char * text,
+		wFont_p fp,
+		double siz,
+		wDrawColor dc,
+		wDrawOpts dopts )
+{
+	int x, y;
+	HFONT newFont, prevFont;
+	HDC newDc;
+	HBITMAP oldBm, newBm;
+	DWORD extent;
+	int w, h;
+	RECT rect;
+	int oldLfHeight;
+
+	if (fp == NULL)
+		fp = &logFont;
+	oldLfHeight = fp->lfHeight;
+	fp->lfEscapement = (int)(angle*10.0);
+	fp->lfHeight = computeFontSize( d, siz );
+	fp->lfWidth = 0;
+	newFont = CreateFontIndirect( fp );
+	x = XINCH2PIX(d,px) + (int)(mswsin(angle)*fp->lfHeight-0.5);
+	y = YINCH2PIX(d,py) + (int)(mswcos(angle)*fp->lfHeight-0.5);
+	if ( noNegDrawArgs > 0 && ( x < 0 || y < 0 ) )
+		return;
+	if (dopts & wDrawOptTemp) {
+		setDrawMode( d->hDc, d, 0, wDrawLineSolid, dc, dopts );
+		newDc = CreateCompatibleDC( d->hDc );
+		prevFont = SelectObject( newDc, newFont );
+		extent = GetTextExtent( newDc, CAST_AWAY_CONST text, strlen(text) );
+		w = LOWORD(extent);
+		h = HIWORD(extent);
+		if ( h > w ) w = h;
+		newBm = CreateCompatibleBitmap( d->hDc, w*2, w*2 );
+		oldBm = SelectObject( newDc, newBm ); 
+		rect.top = rect.left = 0;
+		rect.bottom = rect.right = w*2;
+		FillRect( newDc, &rect, GetStockObject(WHITE_BRUSH) );
+		TextOut( newDc, w, w, text, strlen(text) );
+		BitBlt( d->hDc, x-w, y-w, w*2, w*2, newDc, 0, 0, tmpOp );
+		SelectObject( newDc, oldBm );
+		DeleteObject( newBm );
+		SelectObject( newDc, prevFont );
+		DeleteDC( newDc );
+		if (d->hWnd) {
+		rect.top = y-(w+1);
+		rect.bottom = y+(w+1);
+		rect.left = x-(w+1);
+		rect.right = x+(w+1);
+		myInvalidateRect( d, &rect );
+		}
+#ifdef LATER
+		/* KLUDGE: Can't Invert text, so we just draw a bow - a pox on windows*/
+		MoveTo( d->hDc, x, y );
+		LineTo( d->hDc, x+w, y );
+		LineTo( d->hDc, x+w, y+h );
+		LineTo( d->hDc, x, y+h );
+		LineTo( d->hDc, x, y );
+#endif
+	} else {
+		prevFont = SelectObject( d->hDc, newFont );
+		SetBkMode( d->hDc, TRANSPARENT );
+		if (dc != wDrawColorBlack) {
+			COLORREF old;
+			old = SetTextColor( d->hDc, mswGetColor(d->hasPalette,dc)/*colorPalette.palPalEntry[dc]*/ );
+			TextOut( d->hDc, x, y, text, strlen(text) );
+			SetTextColor( d->hDc, old );
+		} else
+			TextOut( d->hDc, x, y, text, strlen(text) );
+		extent = GetTextExtent( d->hDc, CAST_AWAY_CONST text, strlen(text) );
+		SelectObject( d->hDc, prevFont );
+		w = LOWORD(extent);
+		h = HIWORD(extent);
+		if (d->hWnd) {
+		rect.top = y-(w+h+1);
+		rect.bottom = y+(w+h+1);
+		rect.left = x-(w+h+1);
+		rect.right = x+(w+h+1);
+		myInvalidateRect( d, &rect );
+		}
+	}
+	DeleteObject( newFont );
+	fp->lfHeight = oldLfHeight;
+}
+
+static const char * wCurFont( void )
+{
+	return logFont.lfFaceName;
+}
+
+void wInitializeFonts()
+{
+}
+
+wFont_p wStandardFont( int family, wBool_t bold, wBool_t italic )
+{
+	if (family == F_TIMES)
+		return &timesFont[bold][italic];
+	else if (family == F_HELV)
+		return &helvFont[bold][italic];
+	else
+		return NULL;
+}
+
+void wSelectFont( const char * title )
+{
+	doChooseFont();
+}
+
+
+wFontSize_t wSelectedFontSize( void )
+{
+	return fontSize;
+}
+
+void wSetSelectedFontSize(int size)
+{
+	fontSize = (wFontSize_t)size;
+}
+
+/*
+ *****************************************************************************
+ *
+ * Misc
+ *
+ *****************************************************************************
+ */
+
+
+
+void wDrawFilledRectangle(
+		wDraw_p d,
+		wPos_t px,
+		wPos_t py,
+		wPos_t sx,
+		wPos_t sy,
+		wDrawColor color,
+		wDrawOpts opts )
+{
+	RECT rect;
+	if (d == NULL)
+		return;
+	setDrawBrush( d->hDc, d, color, opts );
+	rect.left = XINCH2PIX(d,px);
+	rect.right = XINCH2PIX(d,px+sx);
+	rect.top = YINCH2PIX(d,py+sy);
+	rect.bottom = YINCH2PIX(d,py);
+	if ( rect.right < 0 ||
+		 rect.bottom < 0 )
+		return;
+	if ( rect.left < 0 )
+		rect.left = 0;
+	if ( rect.top < 0 )
+		rect.top = 0;
+	if ( rect.left > d->w ||
+		 rect.top > d->h )
+		return;
+	if ( rect.right > d->w )
+		rect.right = d->w;
+	if ( rect.bottom > d->h )
+		rect.bottom = d->h;
+	Rectangle( d->hDc, rect.left, rect.top, rect.right, rect.bottom );
+	if (d->hWnd) {
+		rect.top--;
+		rect.left--;
+		rect.bottom++;
+		rect.right++;
+		myInvalidateRect( d, &rect );
+	}
+}
+
+#ifdef DRAWFILLPOLYLOG
+static FILE * logF;
+#endif
+static int wFillPointsMax = 0;
+static POINT * wFillPoints;
+
+static void addPoint(
+		int * pk,
+		POINT * pp,
+		RECT * pr )
+{
+#ifdef DRAWFILLPOLYLOG
+fprintf( logF, "	q[%d] = {%d,%d}\n", *pk, pp->x, pp->y );
+#endif
+	if ( *pk > 0 &&
+		 wFillPoints[(*pk)-1].x == pp->x && wFillPoints[(*pk)-1].y == pp->y )
+		return;
+	wFillPoints[ (*pk)++ ] = *pp;
+	if (pp->x<pr->left)
+		pr->left = pp->x;
+	if (pp->x>pr->right)
+		pr->right = pp->x;
+	if (pp->y<pr->top)
+		pr->top = pp->y;
+	if (pp->y>pr->bottom)
+		pr->bottom = pp->y;
+}
+
+void wDrawFilledPolygon(
+		wDraw_p d,
+		wPos_t p[][2],
+		int cnt,
+		wDrawColor color,
+		wDrawOpts opts )
+{				 
+	RECT rect;
+	int i, k;
+	POINT p0, p1, q0, q1;
+	static POINT zero = { 0, 0 };
+	wBool_t p1Clipped;
+
+	if (d == NULL)
+		return;
+		if (cnt*2 > wFillPointsMax) {
+				wFillPoints = realloc( wFillPoints, cnt * 2 * sizeof *(POINT*)NULL );
+				wFillPointsMax = cnt*2;
+		}
+	setDrawBrush( d->hDc, d, color, opts );
+	p1.x = rect.left = rect.right = XINCH2PIX(d,p[cnt-1][0]-1);
+	p1.y = rect.top = rect.bottom = YINCH2PIX(d,p[cnt-1][1]+1);
+#ifdef DRAWFILLPOLYLOG
+logF = fopen( "log.txt", "a" );
+fprintf( logF, "\np[%d] = {%d,%d}\n", cnt-1, p1.x, p1.y );
+#endif
+	p1Clipped = FALSE;
+	for ( i=k=0; i<cnt; i++ ) {
+		p0 = p1;
+		p1.x = XINCH2PIX(d,p[i][0]-1);
+		p1.y = YINCH2PIX(d,p[i][1]+1);
+#ifdef DRAWFILLPOLYLOG
+fprintf( logF, "p[%d] = {%d,%d}\n", i, p1.x, p1.y );
+#endif
+		q0 = p0;
+		q1 = p1;
+		if ( clip0( &q0, &q1, NULL ) ) {
+#ifdef DRAWFILLPOLYLOG
+fprintf( logF, "  clip( {%d,%d} {%d,%d} )  = {%d,%d} {%d,%d}\n", p0.x, p0.y, p1.x, p1.y, q0.x, q0.y, q1.x, q1.y );
+#endif
+			if ( q0.x != p0.x || q0.y != p0.y ) {
+				if ( k > 0 && ( q0.x > q0.y ) != ( wFillPoints[k-1].x > wFillPoints[k-1].y ) )
+					 addPoint( &k, &zero, &rect );
+				addPoint( &k, &q0, &rect );
+			}
+			addPoint( &k, &q1, &rect );
+			p1Clipped = ( q1.x != p1.x || q1.y != p1.y );
+		}
+	}
+	if ( p1Clipped &&
+		 ( wFillPoints[k-1].x > wFillPoints[k-1].y ) != ( wFillPoints[0].x > wFillPoints[0].y ) )
+		addPoint( &k, &zero, &rect );
+#ifdef DRAWFILLPOLYLOG
+fflush( logF );
+fclose( logF );
+#endif
+	if ( k <= 2 )
+		return;
+	Polygon( d->hDc, wFillPoints, k );
+	if (d->hWnd) {
+		rect.top--;
+		rect.left--;
+		rect.bottom++;
+		rect.right++;
+		myInvalidateRect( d, &rect );
+	}
+}
+
+#define MAX_FILLCIRCLE_POINTS	(30)
+void wDrawFilledCircle(
+		wDraw_p d,
+		wPos_t x,
+		wPos_t y,
+		wPos_t r,
+		wDrawColor color,
+		wDrawOpts opts )
+{
+	POINT p0, p1;
+	RECT rect;
+	static wPos_t circlePts[MAX_FILLCIRCLE_POINTS][2];
+	int inx, cnt;
+	double dang;
+
+	p0.x = XINCH2PIX(d,x-r);
+	p0.y = YINCH2PIX(d,y+r)+1;
+	p1.x = XINCH2PIX(d,x+r);
+	p1.y = YINCH2PIX(d,y-r)+1;
+						   
+	setDrawBrush( d->hDc, d, color, opts );						  
+	if ( noNegDrawArgs > 0 && ( p0.x < 0 || p0.y < 0 ) ) {
+		if ( r > MAX_FILLCIRCLE_POINTS )
+			cnt = MAX_FILLCIRCLE_POINTS;
+		else if ( r > 8 )
+			cnt = r;
+		else
+			cnt = 8;
+		dang = 360.0/cnt;
+		for ( inx=0; inx<cnt; inx++ ) {
+			circlePts[inx][0] = x + (int)(r * mswcos( inx*dang ) + 0.5 );
+			circlePts[inx][1] = y + (int)(r * mswsin( inx*dang ) + 0.5 );
+		}
+		wDrawFilledPolygon( d, circlePts, cnt, color, opts );
+	} else {
+		Ellipse( d->hDc, p0.x, p0.y, p1.x, p1.y );
+		if (d->hWnd) {
+			rect.top = p0.y;
+			rect.bottom = p1.y;
+			rect.left = p0.x;
+			rect.right = p1.x;
+			myInvalidateRect( d, &rect );
+		}
+	}
+}
+
+/*
+ *****************************************************************************
+ *
+ * Misc
+ *
+ *****************************************************************************
+ */
+
+
+void wDrawSaveImage(
+		wDraw_p bd )
+{
+	if ( bd->hBmBackup ) {			
+		SelectObject( bd->hDcBackup, bd->hBmBackupOld );
+		DeleteObject( bd->hBmBackup );
+		bd->hBmBackup = (HBITMAP)0;
+	}
+	if ( bd->hDcBackup == (HDC)0 )
+		bd->hDcBackup = CreateCompatibleDC( bd->hDc ); 
+	bd->hBmBackup = CreateCompatibleBitmap( bd->hDc, bd->w, bd->h );
+	bd->hBmBackupOld = SelectObject( bd->hDcBackup, bd->hBmBackup );
+	BitBlt( bd->hDcBackup, 0, 0, bd->w, bd->h, bd->hDc, 0, 0, SRCCOPY );
+}
+
+void wDrawRestoreImage(
+		wDraw_p bd )
+{
+	if ( bd->hBmBackup == (HBITMAP)0 ) {
+		mswFail( "wDrawRestoreImage: hBmBackup == 0" );
+		return;
+	}
+	BitBlt( bd->hDc, 0, 0, bd->w, bd->h, bd->hDcBackup, 0, 0, SRCCOPY );
+	InvalidateRect( bd->hWnd, NULL, FALSE );
+}
+
+
+void wDrawClear( wDraw_p d )
+{
+	RECT rect;
+	SetROP2( d->hDc, R2_WHITE );
+	Rectangle( d->hDc, 0, 0, d->w, d->h );
+	if (d->hWnd) {
+	rect.top = 0;
+	rect.bottom = d->h;
+	rect.left = 0;
+	rect.right = d->w;
+	InvalidateRect( d->hWnd, &rect, FALSE );
+	}
+}
+
+
+void wDrawSetSize(
+		wDraw_p d,
+		wPos_t width,
+		wPos_t height )
+{
+	d->w = width;
+	d->h = height;
+	if (!SetWindowPos( d->hWnd, HWND_TOP, 0, 0,
+		d->w, d->h, SWP_NOMOVE|SWP_NOZORDER)) {
+		mswFail("wDrawSetSize: SetWindowPos");
+	}
+	/*wRedraw( d );*/
+}
+
+
+void wDrawGetSize(
+		wDraw_p d,
+		wPos_t * width,
+		wPos_t * height )
+{
+	*width = d->w-2;
+	*height = d->h-2;
+}
+
+
+void * wDrawGetContext( wDraw_p d )
+{
+	return d->data;
+}
+
+
+double wDrawGetDPI( wDraw_p d )
+{
+	return d->DPI;
+}
+
+double wDrawGetMaxRadius( wDraw_p d )
+{
+	return 4096.0;
+}
+
+void wDrawClip(
+		wDraw_p d,
+		wPos_t x,
+		wPos_t y,
+		wPos_t w,
+		wPos_t h )
+{
+	int ix0, iy0, ix1, iy1;
+	HRGN hRgnClip;
+	ix0 = XINCH2PIX(d,x);
+	iy0 = YINCH2PIX(d,y);
+	ix1 = XINCH2PIX(d,x+w);
+	iy1 = YINCH2PIX(d,y+h);
+	/* Note: Ydim is upside down so iy1<iy0 */
+	hRgnClip = CreateRectRgn( ix0, iy1, ix1, iy0 );
+	SelectClipRgn( d->hDc, hRgnClip );
+	DeleteObject( hRgnClip );
+}
+
+
+void wRedraw( wDraw_p d )
+{
+	wDrawClear( d );
+	if (d->drawRepaint)
+		d->drawRepaint( d, d->data, 0, 0 );
+}
+
+/*
+ *****************************************************************************
+ *
+ * BitMap
+ *
+ *****************************************************************************
+ */
+
+struct wDrawBitMap_t {
+		wDrawBitMap_p next;
+		wPos_t x;
+		wPos_t y;
+		wPos_t w;
+		wPos_t h;
+		char * bmx;
+		wDrawColor color;
+		HBITMAP bm;
+		};
+wDrawBitMap_p bmRoot = NULL;
+
+
+void wDrawBitMap(
+		wDraw_p d,
+		wDrawBitMap_p bm,
+		wPos_t px,
+		wPos_t py,
+		wDrawColor dc,
+		wDrawOpts dopt )
+{
+	HDC bmDc, hDc;
+	HBITMAP oldBm;
+	DWORD mode;
+	int x0, y0;
+	RECT rect;
+
+	x0 = XINCH2PIX(d,px-bm->x);
+	y0 = YINCH2PIX(d,py-bm->y+bm->h);
+#ifdef LATER
+	if ( noNegDrawArgs > 0 && ( x0 < 0 || y0 < 0 ) )
+		return;
+#endif
+	if (dopt & wDrawOptTemp) {
+		mode = tmpOp;
+	} else if (dc == wDrawColorWhite) {
+		mode = clrOp;
+		dc = wDrawColorBlack;
+	} else {
+		mode = setOp;
+	}
+
+	if ( bm->color != dc ) {
+		if ( bm->bm )
+			DeleteObject( bm->bm );
+		bm->bm = mswCreateBitMap( mswGetColor(d->hasPalette,dc) /*colorPalette.palPalEntry[dc]*/, RGB( 255, 255, 255 ),
+				RGB( 255, 255, 255 ), bm->w, bm->h, bm->bmx );
+		bm->color = dc;
+	}
+	if ( (dopt & wDrawOptNoClip) != 0 &&
+		 ( px < 0 || px >= d->w || py < 0 || py >= d->h ) ) {
+		x0 += d->x;
+		y0 += d->y;
+		hDc = GetDC( ((wControl_p)(d->parent))->hWnd );
+		bmDc = CreateCompatibleDC( hDc );
+		oldBm = SelectObject( bmDc, bm->bm );
+		BitBlt( hDc, x0, y0, bm->w, bm->h, bmDc, 0, 0, tmpOp );
+		SelectObject( bmDc, oldBm );
+		DeleteDC( bmDc );
+		ReleaseDC( ((wControl_p)(d->parent))->hWnd, hDc );
+		return;
+	}
+
+	bmDc = CreateCompatibleDC( d->hDc );
+	setDrawMode( d->hDc, d, 0, wDrawLineSolid, dc, dopt );
+	oldBm = SelectObject( bmDc, bm->bm );
+	BitBlt( d->hDc, x0, y0, bm->w, bm->h, bmDc, 0, 0, mode );
+	SelectObject( bmDc, oldBm );
+	DeleteDC( bmDc );
+	if (d->hWnd) {
+	rect.top = y0-1;
+	rect.bottom = rect.top+bm->h+1;
+	rect.left = x0-1;
+	rect.right = rect.left+bm->w+1;
+	myInvalidateRect( d, &rect );
+	}
+}
+
+
+wDrawBitMap_p wDrawBitMapCreate(
+		wDraw_p d,
+		int w,
+		int h,
+		int x,
+		int y,
+		const char * bits )
+{
+	wDrawBitMap_p bm;
+	int bmSize = ((w+7)/8) * h;
+	bm = (wDrawBitMap_p)malloc( sizeof *bm );
+	if (bmRoot == NULL) {
+		bmRoot = bm;
+		bm->next = NULL;
+	} else {
+		bm->next = bmRoot;
+		bmRoot = bm;
+	}
+	bm->x = x;
+	bm->y = y;
+	bm->w = w;
+	bm->h = h;
+	bm->bmx = malloc( bmSize );
+	bm->bm = (HBITMAP)0;
+	bm->color = -1;
+	memcpy( bm->bmx, bits, bmSize );
+	/*bm->bm = mswCreateBitMap( GetSysColor(COLOR_BTNTEXT), RGB( 255, 255, 255 ), w, h, bits );*/
+	return bm;
+}
+
+/*
+ *****************************************************************************
+ *
+ * Create
+ *
+ *****************************************************************************
+ */
+
+int doSetFocus = 1;
+
+long FAR PASCAL XEXPORT mswDrawPush(
+		HWND hWnd,
+		UINT message,
+		UINT wParam,
+		LONG lParam )
+{
+#ifdef WIN32
+	long inx = GetWindowLong( hWnd, GWL_ID );
+#else
+	short inx = GetWindowWord( hWnd, GWW_ID );
+#endif
+	wDraw_p b;
+	short int ix, iy;
+	wPos_t x, y;
+	HDC hDc;
+	PAINTSTRUCT ps;
+	wAction_t action;
+	RECT rect;
+	HWND activeWnd;
+	HWND focusWnd;
+	wAccelKey_e extChar;
+
+	switch( message ) {
+	case WM_CREATE:
+		b = (wDraw_p)mswMapIndex( inx );
+		hDc = GetDC(hWnd);
+		if ( b->option & BD_DIRECT ) {
+			b->hDc = hDc;
+			b->hBm = 0;
+			b->hBmOld = 0;
+		} else {
+			b->hDc = CreateCompatibleDC( hDc ); 
+			b->hBm = CreateCompatibleBitmap( hDc, b->w, b->h );
+			b->hBmOld = SelectObject( b->hDc, b->hBm );
+		}
+		if (mswPalette) {
+			SelectPalette( b->hDc, mswPalette, 0 );
+			RealizePalette( b->hDc );
+		}
+		b->wFactor = (double)GetDeviceCaps( b->hDc, LOGPIXELSX );
+		b->hFactor = (double)GetDeviceCaps( b->hDc, LOGPIXELSY );
+		b->DPI = 96.0; /*min( b->wFactor, b->hFactor );*/
+		b->hWnd = hWnd;
+		SetROP2( b->hDc, R2_WHITE );
+		Rectangle( b->hDc, 0, 0, b->w, b->h );
+		if ( (b->option & BD_DIRECT) == 0 ) {
+			SetROP2( hDc, R2_WHITE );
+			Rectangle( hDc, 0, 0, b->w, b->h );
+			ReleaseDC( hWnd, hDc );
+		}
+		break;
+	case WM_SIZE:
+		b = (wDraw_p)mswMapIndex( inx );
+		ix = LOWORD( lParam );
+		iy = HIWORD( lParam );
+		b->w = ix+2;
+		b->h = iy+2;
+		if (b->hWnd) {
+			if ( b->option & BD_DIRECT ) {
+			} else {
+			hDc = GetDC( b->hWnd );
+			b->hBm = CreateCompatibleBitmap( hDc, b->w, b->h );
+			DeleteObject(SelectObject( b->hDc, b->hBm ));
+			ReleaseDC( b->hWnd, hDc );
+			SetROP2( b->hDc, R2_WHITE );
+			Rectangle( b->hDc, 0, 0, b->w, b->h );
+			}
+		}
+		/*if (b->drawResize)
+			b->drawResize( b, b->size );*/
+		if (b->drawRepaint)
+			b->drawRepaint( b, b->data, 0, 0 );
+		return 0;
+	case WM_MOUSEMOVE:
+		activeWnd = GetActiveWindow();
+		focusWnd = GetFocus();
+		if (focusWnd != hWnd) {
+			b = (wDraw_p)mswMapIndex( inx );
+			if (!b)
+				break;
+			if ( !((wControl_p)b->parent) )
+				break;
+			if ( ((wControl_p)b->parent)->hWnd != activeWnd )
+				break;
+		}
+	case WM_LBUTTONDOWN:
+	case WM_LBUTTONUP:
+	case WM_RBUTTONDOWN:
+	case WM_RBUTTONUP:
+		if (message == WM_LBUTTONDOWN)
+			action = wActionLDown;
+		else if (message == WM_RBUTTONDOWN)
+			action = wActionRDown;
+		else if (message == WM_LBUTTONUP)
+			action = wActionLUp;
+		else if (message == WM_RBUTTONUP)
+			action = wActionRUp;
+		else {
+			if ( (wParam & MK_LBUTTON) != 0)
+				action = wActionLDrag;
+			else if ( (wParam & MK_RBUTTON) != 0)
+				action = wActionRDrag;
+			else
+				action = wActionMove;
+		}
+		b = (wDraw_p)mswMapIndex( inx );
+		if (!b)
+			break;
+		if (doSetFocus && message != WM_MOUSEMOVE)
+			SetFocus( ((wControl_p)b->parent)->hWnd );
+		if ( (b->option&BD_NOCAPTURE) == 0 ) {
+			if (message == WM_LBUTTONDOWN || message == WM_RBUTTONDOWN)
+				SetCapture( b->hWnd );
+			else if (message == WM_LBUTTONUP || message == WM_RBUTTONUP)
+				ReleaseCapture();
+		}
+		ix = LOWORD( lParam );
+		iy = HIWORD( lParam );
+		x = XPIX2INCH( b, ix );
+		y = YPIX2INCH( b, iy );
+		if (b->action)
+			b->action( b, b->data, action, x, y );
+		if (b->hWnd)
+			UpdateWindow(b->hWnd);
+		return 0;
+	case WM_CHAR:
+		b = (wDraw_p)mswMapIndex( inx );
+		extChar = wAccelKey_None;
+		if (lParam & 0x01000000L)
+		switch( wParam ) {
+		case VK_DELETE: extChar = wAccelKey_Del; break;
+		case VK_INSERT: extChar = wAccelKey_Ins; break;
+		case VK_HOME:	extChar = wAccelKey_Home; break;
+		case VK_END:	extChar = wAccelKey_End; break;
+		case VK_PRIOR:	extChar = wAccelKey_Pgup; break;
+		case VK_NEXT:	extChar = wAccelKey_Pgdn; break;
+		case VK_UP:		extChar = wAccelKey_Up; break;
+		case VK_DOWN:	extChar = wAccelKey_Down; break;
+		case VK_RIGHT:	extChar = wAccelKey_Right; break;				
+		case VK_LEFT:	extChar = wAccelKey_Left; break;
+		case VK_BACK:	extChar = wAccelKey_Back; break;
+		/*case VK_F1:	extChar = wAccelKey_F1; break;*/
+		case VK_F2:		extChar = wAccelKey_F2; break;
+		case VK_F3:		extChar = wAccelKey_F3; break;
+		case VK_F4:		extChar = wAccelKey_F4; break;
+		case VK_F5:		extChar = wAccelKey_F5; break;
+		case VK_F6:		extChar = wAccelKey_F6; break;
+		case VK_F7:		extChar = wAccelKey_F7; break;
+		case VK_F8:		extChar = wAccelKey_F8; break;
+		case VK_F9:		extChar = wAccelKey_F9; break;
+		case VK_F10:	extChar = wAccelKey_F10; break;
+		case VK_F11:	extChar = wAccelKey_F11; break;
+		case VK_F12:	extChar = wAccelKey_F12; break;
+		}
+		if (b && b->action) {
+			if (extChar != wAccelKey_None)
+				b->action( b, b->data, wActionExtKey + ( (int)extChar << 8 ), 0, 0 );
+			else
+				b->action( b, b->data, wActionText + ( wParam << 8 ), 0, 0 );
+		}
+		return 0;
+
+	case WM_PAINT:
+		b = (wDraw_p)mswMapIndex( inx );
+		if (b && b->type == B_DRAW) {
+			if (GetUpdateRect( b->hWnd, &rect, FALSE )) {
+				hDc = BeginPaint( hWnd, &ps );
+				if ( b->hasPalette ) {
+					int winPaletteClock = mswGetPaletteClock();
+					if ( b->paletteClock < winPaletteClock ) {
+						RealizePalette( hDc );
+						b->paletteClock = winPaletteClock;
+					}
+				}
+				BitBlt( hDc, rect.left, rect.top,
+						rect.right-rect.left, rect.bottom-rect.top,
+						b->hDc, rect.left, rect.top,
+						SRCCOPY );
+				EndPaint( hWnd, &ps );
+			}
+		}
+		break;
+	case WM_DESTROY:
+		b = (wDraw_p)mswMapIndex( inx );
+		if (b && b->type == B_DRAW) {
+			if (b->hDc) {
+				DeleteDC( b->hDc );
+				b->hDc = (HDC)0;
+			}
+			if (b->hDcBackup) {
+				DeleteDC( b->hDcBackup );
+				b->hDcBackup = (HDC)0;
+			}
+		}
+		break;
+	default:
+		break;
+	}
+	return DefWindowProc( hWnd, message, wParam, lParam );
+}
+
+
+static LRESULT drawMsgProc( wDraw_p b, HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
+{
+	wAction_t action;
+
+	switch( message ) {
+	case WM_MOUSEWHEEL:
+		/* handle mouse wheel events */
+		/* fwKeys = GET_KEYSTATE_WPARAM(wParam); modifier keys are currently ignored */
+		if ( GET_WHEEL_DELTA_WPARAM(wParam) > 0 ) {
+			action = wActionWheelUp;
+		} else {
+			action = wActionWheelDown;
+		}
+		if (b->action)
+			b->action( b, b->data, action, 0, 0 );
+		return 0;
+	}
+
+	return DefWindowProc( hWnd, message, wParam, lParam );
+}
+
+
+static void drawDoneProc( wControl_p b )
+{
+	wDraw_p d = (wDraw_p)b;
+	if (d->hBm) {
+		SelectObject( d->hDc, d->hBmOld );
+		DeleteObject( d->hBm );
+		d->hBm = (HBITMAP)0;
+	}
+	if (d->hPen) {
+		SelectObject( d->hDc, GetStockObject( BLACK_PEN ) );
+		DeleteObject( d->hPen );
+		d->hPen = (HPEN)0;
+	}
+	if (d->hBrush) {
+		SelectObject( d->hDc, GetStockObject( BLACK_BRUSH) );
+		DeleteObject( d->hBrush );
+		d->hBrush = (HBRUSH)0;
+	}
+	if (d->hDc) {
+		DeleteDC( d->hDc );
+		d->hDc = (HDC)0;
+	}
+	if ( d->hDcBackup ) {
+		DeleteDC( d->hDcBackup );
+		d->hDcBackup = (HDC)0;
+	}
+	while (bmRoot) {
+		if (bmRoot->bm)
+			DeleteObject( bmRoot->bm );
+		bmRoot = bmRoot->next;
+	}
+}
+
+
+static callBacks_t drawCallBacks = {
+		NULL,
+		drawDoneProc,
+		(messageCallback_p)drawMsgProc };
+
+wDraw_p drawList = NULL;
+
+
+void mswRedrawAll( void )
+{
+	wDraw_p p;
+	for ( p=drawList; p; p=p->drawNext ) {
+		if (p->drawRepaint)
+			p->drawRepaint( p, p->data, 0, 0 );
+	}
+}
+
+
+void mswRepaintAll( void )
+{
+	wDraw_p b;
+	HDC hDc;
+	RECT rect;
+	PAINTSTRUCT ps;
+
+	for ( b=drawList; b; b=b->drawNext ) {
+		if (GetUpdateRect( b->hWnd, &rect, FALSE )) {
+			hDc = BeginPaint( b->hWnd, &ps );
+			BitBlt( hDc, rect.left, rect.top,
+						rect.right-rect.left, rect.bottom-rect.top,
+						b->hDc, rect.left, rect.top,
+						SRCCOPY );
+			EndPaint( b->hWnd, &ps );
+		}
+	}
+}
+
+
+wDraw_p wDrawCreate(
+		wWin_p parent,
+		wPos_t x,
+		wPos_t y,
+		const char * helpStr,
+		long option,
+		wPos_t w,
+		wPos_t h,
+		void * data,
+		wDrawRedrawCallBack_p redrawProc,
+		wDrawActionCallBack_p action )
+{
+	wDraw_p d;
+	RECT rect;
+	int index;
+	HDC hDc;
+
+	if ( noNegDrawArgs < 0 ) {
+		wPrefGetInteger( "msw tweak", "NoNegDrawArgs", &noNegDrawArgs, 0 );
+		wPrefGetInteger( "msw tweak", "NoFlatEndCaps", &noFlatEndCaps, 0 );
+	}
+
+	d = mswAlloc( parent, B_DRAW, NULL, sizeof *d, data, &index );
+	mswComputePos( (wControl_p)d, x, y );
+	d->w = w;
+	d->h = h;
+	d->drawRepaint = NULL;
+	d->action = action;
+	d->option = option;
+
+	d->hWnd = CreateWindow( mswDrawWindowClassName, NULL,
+				WS_CHILDWINDOW|WS_VISIBLE|WS_BORDER,
+				d->x, d->y, w, h,
+				((wControl_p)parent)->hWnd, (HMENU)index, mswHInst, NULL );
+
+	if (d->hWnd == (HWND)0) {
+		mswFail( "CreateWindow(DRAW)" );
+		return d;
+	}
+
+	GetWindowRect( d->hWnd, &rect );
+
+	d->w = rect.right - rect.left;
+	d->h = rect.bottom - rect.top;
+	d->drawRepaint = redrawProc;
+	/*if (d->drawRepaint)
+		d->drawRepaint( d, d->data, 0.0, 0.0 );*/
+
+	mswAddButton( (wControl_p)d, FALSE, helpStr );
+	mswCallBacks[B_DRAW] = &drawCallBacks;
+	d->drawNext = drawList;
+	drawList = d;
+	if (mswPalette) {
+		hDc = GetDC( d->hWnd );
+		d->hasPalette = TRUE;
+		SelectPalette( hDc, mswPalette, 0 );
+		ReleaseDC( d->hWnd, hDc );
+	}
+	return d;
+}
+
+/*
+ *****************************************************************************
+ *
+ * Bitmaps
+ *
+ *****************************************************************************
+ */
+
+wDraw_p wBitMapCreate( wPos_t w, wPos_t h, int planes )
+{
+	wDraw_p d;
+	HDC hDc;
+
+	d = (wDraw_p)calloc(1,sizeof *d);
+	d->type = B_DRAW;
+	d->shown = TRUE;
+	d->x = 0;
+	d->y = 0;
+	d->w = w;
+	d->h = h;
+	d->drawRepaint = NULL;
+	d->action = NULL;
+	d->option = 0;
+
+	hDc = GetDC(mswHWnd);
+	d->hDc = CreateCompatibleDC( hDc ); 
+	if ( d->hDc == (HDC)0 ) {
+		wNoticeEx( NT_ERROR, "CreateBitMap: CreateDC fails", "Ok", NULL );
+		return FALSE;
+	}
+	d->hBm = CreateCompatibleBitmap( hDc, d->w, d->h );
+	if ( d->hBm == (HBITMAP)0 ) {
+		wNoticeEx( NT_ERROR, "CreateBitMap: CreateBM fails", "Ok", NULL );
+		return FALSE;
+	}
+	d->hasPalette = (GetDeviceCaps(hDc,RASTERCAPS ) & RC_PALETTE) != 0;
+	ReleaseDC( mswHWnd, hDc );
+	d->hBmOld = SelectObject( d->hDc, d->hBm );
+	if (mswPalette) {
+		SelectPalette( d->hDc, mswPalette, 0 );
+		RealizePalette( d->hDc );
+	}
+	d->wFactor = (double)GetDeviceCaps( d->hDc, LOGPIXELSX );
+	d->hFactor = (double)GetDeviceCaps( d->hDc, LOGPIXELSY );
+	d->DPI = 96.0; /*min( d->wFactor, d->hFactor );*/
+	d->hWnd = 0;
+	SetROP2( d->hDc, R2_WHITE );
+	Rectangle( d->hDc, 0, 0, d->w, d->h );
+	return d;
+}
+
+wBool_t wBitMapDelete( wDraw_p d )
+{
+	if (d->hPen) {
+		SelectObject( d->hDc, GetStockObject( BLACK_PEN ) );
+		DeleteObject( d->hPen );
+		d->hPen = (HPEN)0;
+	}
+	if (d->hBm) {
+		SelectObject( d->hDc, d->hBmOld );
+		DeleteObject( d->hBm );
+		d->hBm = (HBITMAP)0;
+	}
+	if (d->hDc) {
+		DeleteDC( d->hDc );
+		d->hDc = (HDC)0;
+	}
+	free(d);
+	return TRUE;
+}
+
+wBool_t wBitMapWriteFile( wDraw_p d, const char * fileName )
+{
+	char *pixels;
+	int j, ww, chunk;
+	FILE * f;
+	BITMAPFILEHEADER bmfh;
+	struct {
+		BITMAPINFOHEADER bmih;
+		RGBQUAD colors[256];
+	} bmi;
+	int rc;
+	
+	if ( d->hBm == 0)
+		return FALSE;
+	f = wFileOpen( fileName, "wb" );
+	if (!f) {
+		wNoticeEx( NT_ERROR, fileName, "Ok", NULL );
+		return FALSE;
+	}
+	ww = ((d->w +3) / 4) * 4;
+	bmfh.bfType = 'B'+('M'<<8);
+	bmfh.bfSize = (long)(sizeof bmfh) + (long)(sizeof bmi.bmih) + (long)(sizeof bmi.colors) + (long)ww * (long)(d->h);
+	bmfh.bfReserved1 = 0;
+	bmfh.bfReserved2 = 0;
+	bmfh.bfOffBits = sizeof bmfh + sizeof bmi.bmih + sizeof bmi.colors;
+	fwrite( &bmfh, 1, sizeof bmfh, f );
+	bmi.bmih.biSize = sizeof bmi.bmih;
+	bmi.bmih.biWidth = d->w;
+	bmi.bmih.biHeight = d->h;
+	bmi.bmih.biPlanes = 1;
+	bmi.bmih.biBitCount = 8;
+	bmi.bmih.biCompression = BI_RGB;
+	bmi.bmih.biSizeImage = 0;
+	bmi.bmih.biXPelsPerMeter = 75*(10000/254);
+	bmi.bmih.biYPelsPerMeter = 75*(10000/254);
+	bmi.bmih.biClrUsed = bmi.bmih.biClrImportant = mswGetColorList( bmi.colors );
+	SelectObject( d->hDc, d->hBmOld );
+	rc = GetDIBits( d->hDc, d->hBm, 0, 1, NULL, (BITMAPINFO*)&bmi, DIB_RGB_COLORS );
+	if ( rc == 0 ) {
+		wNoticeEx( NT_ERROR, "WriteBitMap: Can't get bitmapinfo from Bitmap", "Ok", NULL );
+		return FALSE;
+	}
+	bmi.bmih.biClrUsed = 256;
+	fwrite( &bmi.bmih, 1, sizeof bmi.bmih, f );
+	fwrite( bmi.colors, 1, sizeof bmi.colors, f );
+	chunk = 32000/ww;
+	pixels = (char*)malloc( ww*chunk );
+	if ( pixels == NULL ) {
+		wNoticeEx( NT_ERROR, "WriteBitMap: no memory", "OK", NULL );
+		return FALSE;
+	}
+	for (j=0;j<d->h;j+=chunk) {
+		if (j+chunk>d->h)
+			chunk = d->h-j;
+		rc = GetDIBits( d->hDc, d->hBm, j, chunk, pixels, (BITMAPINFO*)&bmi, DIB_RGB_COLORS );
+		if ( rc == 0 ) 
+		if ( rc == 0 ) {
+			wNoticeEx( NT_ERROR, "WriteBitMap: Can't get bits from Bitmap", "Ok", NULL );
+			return FALSE;
+		}
+		rc = fwrite( pixels, 1, ww*chunk, f );
+		if (rc != ww*chunk) {
+			wNoticeEx( NT_ERROR, "WriteBitMap: Bad fwrite", "Ok", NULL);
+		}
+	}
+	free( pixels );
+	SelectObject( d->hDc, d->hBm );
+	fclose( f );
+	return TRUE;
+}
+
diff --git a/app/wlib/mswlib/mswedit.c b/app/wlib/mswlib/mswedit.c
new file mode 100644
index 0000000..5bb26ec
--- /dev/null
+++ b/app/wlib/mswlib/mswedit.c
@@ -0,0 +1,726 @@
+#include <windows.h>
+#include <string.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <commdlg.h>
+#include <math.h>
+#include "mswint.h"
+
+
+struct wString_t {
+		WOBJ_COMMON
+		char * valueP;
+		wIndex_t valueL;
+		wStringCallBack_p action;
+		};
+
+struct wInteger_t {
+		WOBJ_COMMON
+		long low, high;
+		long * valueP;
+		long oldValue;
+		wIntegerCallBack_p action;
+		};
+
+struct wFloat_t {
+		WOBJ_COMMON
+		double low, high;
+		double * valueP;
+		double oldValue;
+		wFloatCallBack_p action;
+		};
+
+
+static XWNDPROC oldEditProc = NULL;
+static XWNDPROC newEditProc;
+static void triggerString( wControl_p b );
+#ifdef LATER
+static void triggerInteger( wControl_p b );
+static void triggerFloat( wControl_p b );
+#endif
+
+
+long FAR PASCAL _export pushEdit(
+		HWND hWnd,
+		UINT message,
+		UINT wParam,
+		LONG lParam )
+{
+	/* Catch <Return> and cause focus to leave control */
+#ifdef WIN32
+	long inx = GetWindowLong( hWnd, GWL_ID );
+#else
+	short inx = GetWindowWord( hWnd, GWW_ID );
+#endif
+	wControl_p b = mswMapIndex( inx );
+
+	switch (message) {
+	case WM_CHAR:
+		if ( b != NULL) {
+			switch( wParam ) {
+			case 0x0D:
+			case 0x1B:
+			case 0x09:
+				SetFocus( ((wControl_p)(b->parent))->hWnd ); 
+				SendMessage( ((wControl_p)(b->parent))->hWnd, WM_CHAR,
+						wParam, lParam );
+				/*SendMessage( ((wControl_p)(b->parent))->hWnd, WM_COMMAND,
+						inx, MAKELONG( hWnd, EN_KILLFOCUS ) );*/
+				return 0L;
+			}
+		}
+		break;
+
+	case WM_KEYUP:
+		if ( b != NULL)
+			switch (b->type) {
+			case B_STRING:
+				if (((wString_p)b)->action)
+					mswSetTrigger( (wControl_p)b, triggerString );
+				break;
+#ifdef LATER
+			case B_INTEGER:
+				if (((wInteger_p)b)->action)
+					mswSetTrigger( (wControl_p)b, triggerInteger );
+				break;
+			case B_FLOAT:
+				if (((wFloat_p)b)->action)
+					mswSetTrigger( (wControl_p)b, triggerFloat );
+				break;
+#endif
+			}
+		break;
+
+	}
+	return CallWindowProc( oldEditProc, hWnd, message, wParam, lParam );
+}
+
+/*
+ *****************************************************************************
+ *
+ * String Boxes
+ *
+ *****************************************************************************
+ */
+
+
+void wStringSetValue(
+		wString_p b,
+		const char * arg )
+{
+	WORD len = strlen( arg );
+	SendMessage( b->hWnd, WM_SETTEXT, 0, (DWORD)arg );
+#ifdef WIN32
+	SendMessage( b->hWnd, EM_SETSEL, len, len );
+	SendMessage( b->hWnd, EM_SCROLLCARET, 0, 0L );
+#else
+	SendMessage( b->hWnd, EM_SETSEL, 0, MAKELPARAM(len,len) );
+#endif
+	SendMessage( b->hWnd, EM_SETMODIFY, FALSE, 0L );
+}
+
+
+void wStringSetWidth(
+		wString_p b,
+		wPos_t w )
+{
+	int rc;
+	b->w = w;
+	rc = SetWindowPos( b->hWnd, HWND_TOP, 0, 0,
+				b->w, b->h, SWP_NOMOVE|SWP_NOZORDER );
+}
+
+
+const char * wStringGetValue(
+		wString_p b )
+{
+	static char buff[256];
+	SendMessage( b->hWnd, WM_GETTEXT, sizeof buff, (DWORD)buff );
+	return buff;
+}
+
+
+static void triggerString(
+		wControl_p b )
+{
+	wString_p bs = (wString_p)b;
+	int cnt;
+
+	if (bs->action) {
+		*(WPARAM*)&mswTmpBuff[0] = 78;
+		cnt = (int)SendMessage( bs->hWnd, (UINT)EM_GETLINE, 0, (DWORD)(LPSTR)mswTmpBuff );
+		mswTmpBuff[cnt] = '\0';
+		if (bs->valueP)
+			strcpy( bs->valueP, mswTmpBuff );
+		bs->action( mswTmpBuff, bs->data );
+		mswSetTrigger( NULL, NULL );
+	}
+}
+
+
+LRESULT stringProc(
+		wControl_p b,
+		HWND hWnd,
+		UINT message,
+		WPARAM wParam,
+		LPARAM lParam )
+{
+	wString_p bs = (wString_p)b;
+	int cnt;
+	int modified;
+
+	switch( message ) {
+
+	case WM_COMMAND:
+		switch (WCMD_PARAM_NOTF) {
+		case EN_KILLFOCUS:
+			modified = (int)SendMessage( bs->hWnd, (UINT)EM_GETMODIFY, 0, 0L );
+			if (!modified)
+				break;
+			*(WPARAM*)&mswTmpBuff[0] = 78;
+			cnt = (int)SendMessage( bs->hWnd, (UINT)EM_GETLINE, 0, (DWORD)(LPSTR)mswTmpBuff );
+			mswTmpBuff[cnt] = '\0';
+			if (bs->valueP)
+				strncpy( bs->valueP, mswTmpBuff, bs->valueL );
+			if (bs->action) {
+				bs->action( mswTmpBuff, bs->data );
+				mswSetTrigger( NULL, NULL );
+			}
+			break;
+			SendMessage( bs->hWnd, (UINT)EM_SETMODIFY, FALSE, 0L );
+		}
+		break;
+	}
+
+	return DefWindowProc( hWnd, message, wParam, lParam );
+}
+
+
+static callBacks_t stringCallBacks = {
+		mswRepaintLabel,
+		NULL,
+		stringProc };
+
+
+wString_p wStringCreate(
+		wWin_p	parent,
+		POS_T	x,
+		POS_T	y,
+		const char	* helpStr,
+		const char	* labelStr,
+		long	option,
+		POS_T	width,
+		char	*valueP,
+		wIndex_t valueL,
+		wStringCallBack_p action,
+		void	*data )
+{
+	wString_p b;
+	RECT rect;
+	int index;
+	DWORD style = 0;
+
+	b = (wString_p)mswAlloc( parent, B_STRING, mswStrdup(labelStr), sizeof *b, data, &index );
+	mswComputePos( (wControl_p)b, x, y );
+	b->option = option;
+	b->valueP =	 valueP;
+	b->valueL = valueL;
+	b->labelY += 2;
+	b->action = action;
+	if (option & BO_READONLY)
+		style |= ES_READONLY;
+
+#ifdef WIN32
+	b->hWnd = CreateWindowEx( WS_EX_CLIENTEDGE, "EDIT", NULL,
+						ES_LEFT | ES_AUTOHSCROLL | WS_CHILD | WS_VISIBLE | WS_BORDER | style,
+						b->x, b->y,
+						width, mswEditHeight,
+						((wControl_p)parent)->hWnd, (HMENU)index, mswHInst, NULL );
+#else
+	b->hWnd = CreateWindow( "EDIT", NULL,
+						ES_LEFT | ES_AUTOHSCROLL | WS_CHILD | WS_VISIBLE | WS_BORDER | style,
+						b->x, b->y,
+						width, mswEditHeight,
+						((wControl_p)parent)->hWnd, (HMENU)index, mswHInst, NULL );
+#endif
+	if (b->hWnd == NULL) {
+		mswFail("CreateWindow(STRING)");
+		return b;
+	}
+
+#ifdef CONTROL3D
+	Ctl3dSubclassCtl( b->hWnd);
+#endif
+
+	newEditProc = MakeProcInstance( (XWNDPROC)pushEdit, mswHInst );
+	oldEditProc = (XWNDPROC)GetWindowLong(b->hWnd, GWL_WNDPROC );
+	SetWindowLong( b->hWnd, GWL_WNDPROC, (LONG)newEditProc );
+
+	if (b->valueP) {
+		SendMessage( b->hWnd, WM_SETTEXT, 0, (DWORD)b->valueP );
+	}
+	SendMessage( b->hWnd, EM_SETMODIFY, FALSE, 0L );
+	if ( !mswThickFont )
+		SendMessage( b->hWnd, WM_SETFONT, (WPARAM)mswLabelFont, 0L );
+	GetWindowRect( b->hWnd, &rect );
+	b->w = rect.right - rect.left;
+	b->h = rect.bottom - rect.top;
+
+	mswAddButton( (wControl_p)b, TRUE, helpStr );
+	mswCallBacks[B_STRING] = &stringCallBacks;
+	mswChainFocus( (wControl_p)b );
+	return b;
+}
+#ifdef LATER
+
+/*
+ *****************************************************************************
+ *
+ * Integer Value Boxes
+ *
+ *****************************************************************************
+ */
+
+
+#define MININT	((long)0x80000000)
+#define MAXINT	((long)0x7FFFFFFF)
+
+
+void wIntegerSetValue(
+		wInteger_p b,
+		long arg )
+{
+	b->oldValue = arg;
+	wsprintf( mswTmpBuff, "%ld", arg );
+	SendMessage( b->hWnd, WM_SETTEXT, 0, (DWORD)(LPSTR)mswTmpBuff );
+	SendMessage( b->hWnd, EM_SETMODIFY, FALSE, 0L );
+}
+
+
+long wIntegerGetValue(
+		wInteger_p b )
+{
+	return b->oldValue;
+}
+
+
+static void triggerInteger(
+		wControl_p b )
+{
+	wInteger_p bi = (wInteger_p)b;
+	int cnt;
+	long value;
+	char * cp;
+
+	if (bi->action) {
+		*(WPARAM*)&mswTmpBuff[0] = 78;
+		cnt = (int)SendMessage( bi->hWnd, (UINT)EM_GETLINE, 0, (DWORD)(LPSTR)mswTmpBuff );
+		mswTmpBuff[cnt] = '\0';
+		if (strcmp( mswTmpBuff, "-" )==0 )
+			return;
+		value = strtol( mswTmpBuff, &cp, 10 );
+		if (*cp != '\0' || value < bi->low || value > bi->high )
+			return;
+		if (bi->oldValue == value)
+			return;
+		if (bi->valueP)
+			*bi->valueP = value;
+		bi->oldValue = value;
+		bi->action( value, bi->data );
+	}
+}
+
+
+LRESULT integerProc(
+		wControl_p b,
+		HWND hWnd,
+		UINT message,
+		WPARAM wParam,
+		LPARAM lParam )
+{			   
+	wInteger_p bi = (wInteger_p)b;
+	int inx;
+	int cnt;
+	long value;
+	char * cp;				
+	wBool_t ok;
+	int modified;
+		
+	switch( message ) {
+	
+	case WM_COMMAND:
+		switch (WCMD_PARAM_NOTF) {
+		case EN_KILLFOCUS:
+			ok = TRUE;
+			modified = (int)SendMessage( bi->hWnd, (UINT)EM_GETMODIFY, 0, 0L );
+			if (!modified)
+				break;
+			*(WPARAM*)&mswTmpBuff[0] = 78;
+			cnt = (int)SendMessage( bi->hWnd, (UINT)EM_GETLINE, 0, (DWORD)(LPSTR)mswTmpBuff );
+			mswTmpBuff[cnt] = '\0';
+			if (strcmp( mswTmpBuff, "-" )==0 && 0 >= bi->low && 0 <= bi->high ) {
+				value = 0;
+			} else {
+				value = strtol( mswTmpBuff, &cp, 10 );
+				if (*cp != '\0' || value < bi->low || value > bi->high ) {
+					inx = GetWindowWord( bi->hWnd, GWW_ID );
+					if (wWinIsVisible(bi->parent)) {
+						PostMessage( ((wControl_p)(bi->parent))->hWnd, 
+							WM_NOTVALID, inx, 0L );
+						return TRUE;
+					} else {
+						if (value < bi->low)
+							value = bi->low;
+						else
+							value = bi->high;
+						sprintf( mswTmpBuff, "%ld", value );
+						SendMessage( bi->hWnd, (UINT)WM_SETTEXT, 0,
+									(DWORD)(LPSTR)mswTmpBuff );
+					}
+				}
+			}
+			bi->oldValue = value;
+			if (bi->valueP)
+				*bi->valueP = value;
+			if (bi->action) {
+				bi->action( value, bi->data );
+				mswSetTrigger( NULL, NULL );
+			}
+			SendMessage( bi->hWnd, (UINT)EM_SETMODIFY, FALSE, 0L );
+		}
+		break;
+
+	case WM_NOTVALID:
+		wsprintf( mswTmpBuff, "Please enter a value between %ld and %ld",
+						bi->low, bi->high );
+		if (bi->low > MININT && bi->high < MAXINT)
+			sprintf( mswTmpBuff,
+					 "Please enter an integer value between %ld and %ld",
+					 bi->low, bi->high );
+		else if (bi->low > MININT)
+			sprintf( mswTmpBuff,
+					 "Please enter an integer value greater or equal to %ld",
+					 bi->low );
+		else if (bi->high < MAXINT)
+			sprintf( mswTmpBuff,
+					 "Please enter an integer value less or equal to %ld",
+					 bi->high );
+		else
+			strcpy( mswTmpBuff, "Please enter an integer value" );
+		MessageBox( bi->hWnd, mswTmpBuff, "Invalid entry", MB_OK );
+		SetFocus( bi->hWnd );
+#ifdef WIN32
+		SendMessage( bi->hWnd, EM_SETSEL, 0, 0x7fff );
+		SendMessage( bi->hWnd, EM_SCROLLCARET, 0, 0L );
+#else
+		SendMessage( bi->hWnd, EM_SETSEL, 0, MAKELONG(0,0x7fff) );
+#endif
+		return TRUE;
+
+	}													  
+ 
+	return DefWindowProc( hWnd, message, wParam, lParam );
+}					
+
+
+static callBacks_t integerCallBacks = {
+		mswRepaintLabel,
+		NULL,
+		integerProc };
+
+
+wInteger_p wIntegerCreate(
+		wWin_p	parent,
+		POS_T	x,
+		POS_T	y,
+		const char	* helpStr,
+		const char	* labelStr,
+		long	option,
+		POS_T	width,
+		long	low,
+		long	high,
+		long	*valueP,
+		wIntegerCallBack_p action,
+		void	*data )
+{
+	wInteger_p b;
+	RECT rect;
+	int index;
+	DWORD style = 0;
+
+	b = mswAlloc( parent, B_INTEGER, mswStrdup(labelStr), sizeof *b, data, &index );
+	mswComputePos( (wControl_p)b, x, y );
+	b->option = option;
+	b->low = low;
+	b->high = high;
+	b->valueP = valueP;
+	b->labelY += 2;
+	b->action = action;
+	if (option & BO_READONLY)
+		style |= ES_READONLY;
+
+	b->hWnd = CreateWindow( "EDIT", NULL,
+						ES_LEFT | ES_AUTOHSCROLL | WS_CHILD | WS_VISIBLE | WS_BORDER | style,
+						b->x, b->y,
+						width, mswEditHeight,
+						((wControl_p)parent)->hWnd, (HMENU)index, mswHInst, NULL );
+	if (b->hWnd == NULL) {
+		mswFail("CreateWindow(INTEGER)");
+		return b;
+	}
+
+#ifdef CONTROL3D
+	Ctl3dSubclassCtl( b->hWnd);
+#endif
+		  
+	newEditProc = MakeProcInstance( (XWNDPROC)pushEdit, mswHInst );
+	oldEditProc = (XWNDPROC)GetWindowLong(b->hWnd, GWL_WNDPROC );
+	SetWindowLong( b->hWnd, GWL_WNDPROC, (LONG)newEditProc );
+
+	if ( !mswThickFont )
+		SendMessage( b->hWnd, WM_SETFONT, (WPARAM)mswLabelFont, 0L );
+	if (b->valueP) {
+		wsprintf( mswTmpBuff, "%ld", *b->valueP );
+		SendMessage( b->hWnd, WM_SETTEXT, 0, (DWORD)(LPSTR)mswTmpBuff );
+		b->oldValue = *b->valueP;
+	} else
+		b->oldValue = 0;
+	SendMessage( b->hWnd, EM_SETMODIFY, FALSE, 0L );
+
+	GetWindowRect( b->hWnd, &rect );
+	b->w = rect.right - rect.left;
+	b->h = rect.bottom - rect.top;
+
+	mswAddButton( (wControl_p)b, TRUE, helpStr );
+	mswCallBacks[ B_INTEGER ] = &integerCallBacks;
+	mswChainFocus( (wControl_p)b );
+	return b;
+}
+
+/*
+ *****************************************************************************
+ *
+ * Floating Point Value Boxes
+ *
+ *****************************************************************************
+ */
+
+
+#define MINFLT	(-1000000)
+#define MAXFLT	(1000000)
+
+
+
+void wFloatSetValue(
+		wFloat_p b,
+		double arg )
+{
+	b->oldValue = arg;
+	sprintf( mswTmpBuff, "%0.3f", arg );
+	SendMessage( b->hWnd, WM_SETTEXT, 0, (DWORD)(LPSTR)mswTmpBuff );
+	SendMessage( b->hWnd, EM_SETMODIFY, FALSE, 0L );
+}
+
+
+double wFloatGetValue(
+		wFloat_p b )
+{
+	return b->oldValue;
+}
+
+
+static void triggerFloat(
+		wControl_p b )
+{
+	wFloat_p bf = (wFloat_p)b;
+	int cnt;
+	double value;
+	char * cp;				
+
+	if (bf->action) {
+		*(WPARAM*)&mswTmpBuff[0] = 78;
+		cnt = (int)SendMessage( bf->hWnd, (UINT)EM_GETLINE, 0,
+									(DWORD)(LPSTR)mswTmpBuff );
+		mswTmpBuff[cnt] = '\0';
+		if (strcmp( mswTmpBuff, "-" )==0)
+			return;
+		value = strtod( mswTmpBuff, &cp );
+		if (*cp != '\0' || value < bf->low || value > bf->high )
+			return;
+		if (bf->oldValue == value)
+			return;
+		bf->oldValue = value;
+		if (bf->valueP)
+		   *bf->valueP = value;
+		bf->action( wFloatGetValue(bf), bf->data );
+	}
+}
+
+
+LRESULT floatProc(
+		wControl_p b,
+		HWND hWnd,
+		UINT message,
+		WPARAM wParam,
+		LPARAM lParam )
+{			   
+	wFloat_p bf = (wFloat_p)b;
+	int inx;
+	int cnt;
+	double value;
+	char * cp;				
+	wBool_t ok;
+	int modified;
+
+	switch( message ) {
+	
+	case WM_COMMAND:
+		switch (HIWORD(lParam)) {
+		case EN_KILLFOCUS:
+			ok = TRUE;
+			modified = (int)SendMessage( bf->hWnd, (UINT)EM_GETMODIFY, 0, 0L );
+			if (!modified)
+				break;
+			*(WPARAM*)&mswTmpBuff[0] = 78;
+			cnt = (int)SendMessage( bf->hWnd, (UINT)EM_GETLINE, 0,
+									(DWORD)(LPSTR)mswTmpBuff );
+			mswTmpBuff[cnt] = '\0';
+			if (strcmp( mswTmpBuff, "-" )==0 && 0 >= bf->low && 0 <= bf->high ) {
+				value = 0;
+			} else {
+				value = strtod( mswTmpBuff, &cp );
+				if (*cp != '\0' || value < bf->low || value > bf->high ) {
+					inx = GetWindowWord( bf->hWnd, GWW_ID );
+					if (wWinIsVisible(bf->parent)) {
+						PostMessage( ((wControl_p)(bf->parent))->hWnd, 
+							WM_NOTVALID, inx, 0L );
+						return TRUE;
+					} else {
+						if (value < bf->low)
+							value = bf->low;
+						else
+							value = bf->high;
+						sprintf( mswTmpBuff, "%0.3f", value );
+						SendMessage( bf->hWnd, (UINT)WM_SETTEXT, 0,
+									(DWORD)(LPSTR)mswTmpBuff );
+					}
+				}
+			}
+			bf->oldValue = value;
+			if (bf->valueP)
+				*bf->valueP = value;
+			if (bf->action) {
+				bf->action( value, bf->data );
+				mswSetTrigger( NULL, NULL );
+			}
+			SendMessage( bf->hWnd, (UINT)EM_SETMODIFY, FALSE, 0L );
+		}
+		break;
+
+	case WM_NOTVALID:
+		if (bf->low > MINFLT && bf->high < MAXFLT)
+			sprintf( mswTmpBuff,
+					 "Please enter an float value between %0.3f and %0.3f",
+					 bf->low, bf->high );
+		else if (bf->low > MINFLT)
+			sprintf( mswTmpBuff,
+					 "Please enter an float value greater or equal to %0.3f",
+					 bf->low );
+		else if (bf->high < MAXFLT)
+			sprintf( mswTmpBuff,
+					 "Please enter an float value less or equal to %0.3f",
+					 bf->high );
+		else
+			strcpy( mswTmpBuff, "Please enter an float value" );
+		MessageBox( bf->hWnd, mswTmpBuff, "Invalid entry", MB_OK );
+		SetFocus( bf->hWnd );
+#ifdef WIN32
+		SendMessage( bi->hWnd, EM_SETSEL, 0, 0x7fff );
+		SendMessage( bi->hWnd, EM_SCROLLCARET, 0, 0L );
+#else
+		SendMessage( bi->hWnd, EM_SETSEL, 0, MAKELONG(0,0x7fff) );
+#endif
+		return TRUE;
+
+	}													  
+	return DefWindowProc( hWnd, message, wParam, lParam );
+}					
+
+
+static callBacks_t floatCallBacks = {
+		mswRepaintLabel,
+		NULL,
+		floatProc };
+
+
+wFloat_p wFloatCreate(
+		wWin_p	parent,
+		POS_T	x,
+		POS_T	y,
+		const char	* helpStr,
+		const char	* labelStr,
+		long	option,
+		POS_T	width,
+		double	low,
+		double	high,
+		double	*valueP,
+		wFloatCallBack_p action,
+		void	*data )
+{
+	wFloat_p b;
+	RECT rect;
+	int index;
+	DWORD style = 0;
+
+	b = mswAlloc( parent, B_FLOAT, mswStrdup(labelStr), sizeof *b, data, &index );
+	mswComputePos( (wControl_p)b, x, y );
+	b->option = option;
+	b->low = low;
+	b->high = high;
+	b->valueP = valueP;
+	b->labelY += 2;
+	b->action = action;
+	if (option & BO_READONLY)
+		style |= ES_READONLY;
+
+	b->hWnd = CreateWindow( "EDIT", NULL,
+						ES_LEFT | ES_AUTOHSCROLL | WS_CHILD | WS_VISIBLE | WS_BORDER | style,
+						b->x, b->y,
+						width, mswEditHeight,
+						((wControl_p)parent)->hWnd, (HMENU)index, mswHInst, NULL );
+	if (b->hWnd == NULL) {
+		mswFail("CreateWindow(FLOAT)");
+		return b;
+	}
+
+#ifdef CONTROL3D
+	Ctl3dSubclassCtl( b->hWnd);
+#endif
+	
+	newEditProc = MakeProcInstance( (XWNDPROC)pushEdit, mswHInst );
+	oldEditProc = (XWNDPROC)GetWindowLong(b->hWnd, GWL_WNDPROC );
+	SetWindowLong( b->hWnd, GWL_WNDPROC, (LONG)newEditProc );
+
+	if (b->valueP) {
+			b->oldValue = *b->valueP;
+	} else
+			b->oldValue = 0.0;
+	if (b->valueP)
+			sprintf( mswTmpBuff, "%0.3f", *b->valueP );
+	else
+			strcpy( mswTmpBuff, "0.000" );
+	if ( !mswThickFont )
+		SendMessage( b->hWnd, WM_SETFONT, (WPARAM)mswLabelFont, 0L );
+	SendMessage( b->hWnd, WM_SETTEXT, 0, (DWORD)(LPSTR)mswTmpBuff );
+	SendMessage( b->hWnd, EM_SETMODIFY, FALSE, 0L );
+
+	GetWindowRect( b->hWnd, &rect );
+	b->w = rect.right - rect.left;
+	b->h = rect.bottom - rect.top;
+	mswAddButton( (wControl_p)b, TRUE, helpStr );
+	mswCallBacks[ B_FLOAT ] = &floatCallBacks;
+	mswChainFocus( (wControl_p)b );
+	return b;
+}
+#endif
diff --git a/app/wlib/mswlib/mswint.h b/app/wlib/mswlib/mswint.h
new file mode 100644
index 0000000..2311415
--- /dev/null
+++ b/app/wlib/mswlib/mswint.h
@@ -0,0 +1,193 @@
+#include "wlib.h"
+#include "mswlib.h"
+#include "dynarr.h"
+#ifndef WIN32
+/*#define CONTROL3D*/
+#endif
+#include "stdio.h"
+
+#ifdef CONTROL3D
+#include "ctl3d.h"
+#endif
+
+#ifdef WIN32
+#ifdef FAR
+#undef FAR
+#endif
+#define FAR
+#define _export
+#define MoveTo(HDC,X,Y) MoveToEx(HDC,X,Y,NULL)
+#define READ	(0)
+#define WRITE	(1)
+#define XEXPORT
+#define XWNDPROC		WNDPROC
+#define WCMD_PARAM_HWND	lParam
+#define WCMD_PARAM_NOTF	HIWORD(wParam)
+#define WCMD_PARAM_ID	LOWORD(wParam)
+#define WSCROLL_PARAM_CODE	LOWORD(wParam)
+#define WSCROLL_PARAM_NPOS	HIWORD(wParam)
+#define WSCROLL_PARAM_HWND	lParam
+#else
+#define XEXPORT			_export
+#define XWNDPROC		FARPROC
+#define WCMD_PARAM_HWND	LOWORD(lParam)
+#define WCMD_PARAM_NOTF	HIWORD(lParam)
+#define WCMD_PARAM_ID	wParam
+#define WSCROLL_PARAM_CODE	wParam
+#define WSCROLL_PARAM_NPOS	LOWORD(lParam)
+#define WSCROLL_PARAM_HWND	HIWORD(lParam)
+#endif
+
+#define CAST_AWAY_CONST (char *)
+
+#define BOOL_T wBool_t
+#define POS_T wPos_t
+#define INDEX_T wIndex_t
+#define INTEGER_T wInteger_t
+
+typedef enum {
+		W_MAIN, W_POPUP,
+		B_BUTTON, B_STRING, B_INTEGER, B_FLOAT,
+		B_LIST, B_DROPLIST, B_COMBOLIST,
+		B_RADIO, B_TOGGLE,
+		B_DRAW, B_TEXT, B_MESSAGE, B_LINES,
+		B_MENUITEM, B_CHOICEITEM, B_BOX, 
+		B_BITMAP } wType_e;
+
+typedef void (*repaintProcCallback_p)( HWND, wControl_p );
+typedef void (*doneProcCallback_p)( wControl_p b );
+typedef LRESULT (*messageCallback_p)( wControl_p, HWND, UINT, WPARAM, LPARAM );
+typedef void (*setTriggerCallback_p)( wControl_p b );
+typedef void (*setBusyCallback_p)( wControl_p, BOOL_T );
+typedef void (*showCallback_p)( wControl_p, BOOL_T );
+typedef void (*setPosCallback_p)( wControl_p, wPos_t, wPos_t );
+
+typedef struct {
+		repaintProcCallback_p	repaintProc;
+		doneProcCallback_p		doneProc;
+		messageCallback_p		messageProc;
+		setBusyCallback_p		setBusyProc;
+		showCallback_p			showProc;
+		setPosCallback_p		setPosProc;
+		} callBacks_t;
+
+#define CALLBACK_CNT (B_BOX+1)
+extern callBacks_t *mswCallBacks[CALLBACK_CNT];
+
+
+#define WOBJ_COMMON \
+		wType_e type; \
+		wControl_p next; \
+		wControl_p synonym; \
+		wWin_p parent; \
+		POS_T x, y; \
+		POS_T w, h; \
+		long option; \
+		POS_T labelX, labelY; \
+		const char * labelStr; \
+		const char * helpStr; \
+		const char * tipStr; \
+		HWND hWnd; \
+		void * data;\
+		wControl_p focusChainNext; \
+		wBool_t shown;
+
+struct wControl_t {
+		WOBJ_COMMON
+		};
+
+typedef struct {
+		unsigned key;
+		wDrawColor color;
+		} wIconColorMap_t;
+#define mswIcon_bitmap (1)
+#define mswIcon_pixmap (2)
+
+struct wIcon_t {
+		int type;
+		wPos_t w;				/**< width */
+		wPos_t h;				/**< height */
+		wDrawColor color;
+		int colorcnt;			/**< number of colors */
+		RGBQUAD *colormap;
+		char *pixels;			/**< pointer to pixel information */
+		int transparent;		/**< index of transparent color */
+		};
+
+struct wDraw_t {
+		WOBJ_COMMON
+		HDC hDc;
+		double wFactor;
+		double hFactor;
+		double DPI;
+		wDrawRedrawCallBack_p drawRepaint;
+		wDrawActionCallBack_p action;
+		HBITMAP hBm;
+		HPEN hPen;
+		HBRUSH hBrush;
+		wDraw_p drawNext;
+		HBITMAP hBmOld;
+		wBool_t hasPalette;
+		int paletteClock;
+		HBITMAP hBmBackup;
+		HDC hDcBackup;
+		HBITMAP hBmBackupOld;
+		};
+
+extern HINSTANCE mswHInst;
+extern char mswTmpBuff[1024];
+extern HWND mswHWnd;
+extern const char *mswDrawWindowClassName;
+char *mswProfileFile;
+extern int mswEditHeight;
+extern int mswAllowBalloonHelp;
+extern HFONT mswOldTextFont;
+extern HFONT mswLabelFont;
+extern wDrawColor wDrawColorWhite;
+extern wDrawColor wDrawColorBlack;
+extern long mswThickFont;
+extern double mswScale;
+
+DWORD mswGetBaseStyle( wWin_p );
+char * mswStrdup( const char * );
+HBITMAP mswCreateBitMap( COLORREF, COLORREF, COLORREF, int, int, const char * );
+void mswFail( const char * );
+void mswResize( wWin_p );
+wControl_p mswMapIndex( INDEX_T );
+void mswButtPush( wControl_p );
+void * mswAlloc( wWin_p, wType_e, const char *, int, void *, int * );
+void mswComputePos( wControl_p, wPos_t, wPos_t );
+void mswAddButton( wControl_p, BOOL_T, const char * );
+void mswRepaintLabel( HWND, wControl_p );
+int mswRegister( wControl_p );
+void mswUnregister( int );
+void mswChainFocus( wControl_p );
+void mswSetFocus( wControl_p );
+void mswSetTrigger( wControl_p, setTriggerCallback_p );
+void mswMenuPush( wControl_p );
+void mswCreateCheckBitmaps( void );
+long FAR PASCAL XEXPORT mswDrawPush( HWND, UINT, UINT, LONG );
+#ifdef WIN32
+DWORD GetTextExtent( HDC, CHAR *, UINT );
+#endif
+void mswRedrawAll( void );
+void mswRepaintAll( void );
+HDC mswGetPrinterDC( void );
+int mswMenuAccelerator( wWin_p, long );
+void mswMenuMove( wMenu_p, wPos_t, wPos_t );
+void mswRegisterBitMap( HBITMAP );
+void mswFontInit( void );
+void mswInitColorPalette( void );
+void mswPutCustomColors( void );
+COLORREF mswGetColor( wBool_t, wDrawColor );
+int mswGetColorList( RGBQUAD * );
+int mswGetPaletteClock( void );
+HPALETTE mswPalette;
+HPALETTE mswCreatePalette( void );
+
+/* mswbitmaps.c */
+void deleteBitmaps( void );
+void mswDrawIcon( HDC, int, int, wIcon_p, int, COLORREF, COLORREF );
+
+/* gwin32.c*/
+char *g_win32_getlocale (void);
\ No newline at end of file
diff --git a/app/wlib/mswlib/mswlines.c b/app/wlib/mswlib/mswlines.c
new file mode 100644
index 0000000..be1330d
--- /dev/null
+++ b/app/wlib/mswlib/mswlines.c
@@ -0,0 +1,98 @@
+#include <windows.h>
+#include <string.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <commdlg.h>
+#include <math.h>
+#include "mswint.h"
+
+/*
+ *****************************************************************************
+ *
+ * Lines
+ *
+ *****************************************************************************
+ */
+
+struct wLine_t {
+		WOBJ_COMMON
+		int count;
+		wLines_t * lines;
+		};
+
+static void repaintLines( HWND hWnd, wControl_p b )
+{
+	int lastWidth;
+	HDC hDc;
+	wLine_p bl = (wLine_p)(b);
+	wLines_p lp;
+	HPEN oldPen, newPen;
+
+	lastWidth = -1;
+	hDc = GetDC( hWnd );
+	for (lp=bl->lines; lp<&bl->lines[bl->count]; lp++) {
+		if (lastWidth != lp->width) {
+			lastWidth = lp->width;
+			newPen = CreatePen( PS_SOLID, lastWidth, RGB(0,0,0) );
+			oldPen = SelectObject( hDc, newPen );
+			DeleteObject( oldPen );
+		}
+		MoveTo( hDc, lp->x0, lp->y0 );
+		LineTo( hDc, lp->x1, lp->y1 );
+	}
+	ReleaseDC( hWnd, hDc );
+}
+
+
+static callBacks_t linesCallBacks = {
+		repaintLines,
+		NULL,
+		NULL };
+
+
+wLine_p wLineCreate(
+		wWin_p	parent,
+		const char	* labelStr,
+		int		count,
+		wLines_t * lines )
+{
+	wLine_p b;
+	wLines_p lp;
+	POS_T minX, maxX, minY, maxY;
+	int index;
+
+	if (count <= 0)
+		return NULL;
+	b = (wLine_p)mswAlloc( parent, B_LINES, labelStr, sizeof *b, NULL, &index );
+	b->count = count;
+	b->lines = lines;
+
+	lp = lines;
+	minX = maxX = lp->x0;
+	minY = maxY = lp->y0;
+	for (lp=lines; lp<&b->lines[count]; lp++) {
+		if (minX > lp->x0)
+			minX = lp->x0;
+		if (maxX < lp->x0)
+			maxX = lp->x0;
+		if (minY > lp->y0)
+			minY = lp->y0;
+		if (maxY < lp->y0)
+			maxY = lp->y0;
+		if (minX > lp->x1)
+			minX = lp->x1;
+		if (maxX < lp->x1)
+			maxX = lp->x1;
+		if (minY > lp->y1)
+			minY = lp->y1;
+		if (maxY < lp->y1)
+			maxY = lp->y1;
+	}
+	b->x = minX;
+	b->y = minY;
+	b->w = maxX-minX;
+	b->h = maxY-minY;
+	mswAddButton( (wControl_p)b, FALSE, NULL );
+	mswCallBacks[B_LINES] = &linesCallBacks;
+	return b;
+}
diff --git a/app/wlib/mswlib/mswlist.c b/app/wlib/mswlib/mswlist.c
new file mode 100644
index 0000000..968624a
--- /dev/null
+++ b/app/wlib/mswlib/mswlist.c
@@ -0,0 +1,1173 @@
+#include <windows.h>
+#include <string.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <commdlg.h>
+#include <math.h>
+#include "mswint.h"
+
+/*
+ *****************************************************************************
+ *
+ * List Boxes
+ *
+ *****************************************************************************
+ */
+
+static XWNDPROC oldListProc = NULL;
+static XWNDPROC newListProc;
+static XWNDPROC oldComboProc = NULL;
+static XWNDPROC newComboProc;
+
+struct wList_t {
+		WOBJ_COMMON
+		int count;
+		int last;
+		long * valueP;
+		wListCallBack_p action;
+		wBool_t editable;
+		int colCnt;
+		wPos_t * colWidths;
+		wBool_t * colRightJust;
+		const char * * colTitles;
+		wPos_t maxWidth;
+		wPos_t scrollPos;
+		HWND hScrollWnd;
+		wPos_t scrollH;
+		wPos_t dragPos;
+		int dragCol;
+		wPos_t dragColWidth;
+		};
+
+
+typedef struct {
+		void * itemContext;
+		wIcon_p bm;
+		wBool_t selected;
+		} listData;
+
+static int LIST_HEIGHT = 19;
+static int listTitleHeight = 16;
+
+
+void wListClear(
+		wList_p b )
+{
+	UINT msg;
+	if (b->type==B_LIST)
+		msg = LB_RESETCONTENT;
+	else
+		msg = CB_RESETCONTENT;
+	SendMessage( b->hWnd, msg, 0, 0 );
+	b->last = -1;
+	b->count = 0;
+}
+
+
+
+void wListSetSize( wList_p bl, wPos_t w, wPos_t h )
+{
+	int rc;
+	RECT rect;
+	wPos_t y;
+
+	bl->w = w;
+	bl->h = h;
+	y = bl->y;	  
+	if ( bl->hScrollWnd && bl->maxWidth > bl->w )
+		h -= bl->scrollH;
+	if ( bl->colTitles ) {
+		h -= listTitleHeight;
+		y += listTitleHeight;
+	}
+	rc = SetWindowPos( bl->hWnd, HWND_TOP, 0, 0,
+		w, h, SWP_NOMOVE|SWP_NOZORDER);
+	if ( bl->hScrollWnd ) {
+		if ( bl->maxWidth > bl->w ) {
+			GetClientRect( bl->hWnd, &rect );
+			rc = SetWindowPos( bl->hScrollWnd, HWND_TOP, bl->x, y+rect.bottom+2,
+				bl->w, bl->scrollH, SWP_NOZORDER);
+			ShowWindow( bl->hScrollWnd, SW_SHOW );
+		} else {
+			ShowWindow( bl->hScrollWnd, SW_HIDE );
+		}
+	}
+
+}
+
+
+void wListSetIndex(
+		wList_p bl,
+		int index )
+{
+	listData * ldp;
+
+	wListGetCount(bl);
+	if ( index >= bl->count )
+		index = bl->count-1;
+	if ( bl->last == index && index == -1 )
+		return;
+	if ( bl->type==B_LIST && (bl->option&BL_MANY) != 0 ) {
+		if ( bl->last != -1 )
+			SendMessage( bl->hWnd, LB_SETSEL, 0, MAKELPARAM(bl->last,0) );
+		if ( index >= 0 )
+			SendMessage( bl->hWnd, LB_SETSEL, 1, MAKELPARAM(index, 0) );
+	} else {
+		SendMessage( bl->hWnd,
+				bl->type==B_LIST?LB_SETCURSEL:CB_SETCURSEL, index, 0 );
+	}
+	if ( bl->last >= 0 ) {
+		ldp = (listData*)SendMessage( bl->hWnd,
+				(bl->type==B_LIST?LB_GETITEMDATA:CB_GETITEMDATA),
+				bl->last, 0L );
+		if ( ldp && ldp!=(void*)LB_ERR )
+			ldp->selected = FALSE;
+	}
+	if ( index >= 0 ) {
+		ldp = (listData*)SendMessage( bl->hWnd,
+				(bl->type==B_LIST?LB_GETITEMDATA:CB_GETITEMDATA),
+				index, 0L );
+		if ( ldp && ldp!=(void*)LB_ERR )
+			ldp->selected = TRUE;
+	}
+	/*if (b->option&BL_ICON)*/
+		InvalidateRect( bl->hWnd, NULL, FALSE );
+	bl->last = index;
+}
+
+
+wIndex_t wListGetIndex(
+		wList_p b )
+{
+	return b->last;
+}
+
+
+void wListSetActive(
+		wList_p b,
+		int inx,
+		wBool_t active )
+{
+}
+
+
+void wListSetEditable(
+		wList_p b,
+		wBool_t editable )
+{
+	b->editable = editable;
+}
+
+
+void wListSetValue(
+		wList_p bl,
+		const char * val )
+{
+	if ( bl->type == B_DROPLIST ) {
+		SendMessage( bl->hWnd, WM_SETTEXT, 0, (DWORD)(LPSTR)val );
+		bl->last = -1;
+	}
+}
+
+
+wIndex_t wListFindValue(
+		wList_p bl,
+		const char * val )
+{
+	wIndex_t inx;
+	WORD cnt;
+	wListGetCount(bl);
+	for ( inx = 0; inx < bl->count ; inx++ ) {
+		cnt = (int)SendMessage( bl->hWnd,
+				(bl->type==B_LIST?LB_GETTEXT:CB_GETLBTEXT), inx,
+				(DWORD)(LPSTR)mswTmpBuff );
+		mswTmpBuff[cnt] = '\0';
+		if ( strcmp( val, mswTmpBuff ) == 0 )
+			return inx;
+	}
+	return -1;
+}
+
+
+wIndex_t wListGetValues(
+		wList_p bl,
+		char * s,
+		int siz,
+		void * * listContextRef,
+		void * * itemContextRef )
+{
+	WORD cnt;
+	WORD msg;
+	WORD inx = bl->last;
+	listData *ldp = NULL;
+	if ( bl->type==B_DROPLIST && bl->last < 0 ) {
+		msg = WM_GETTEXT;
+		inx = sizeof mswTmpBuff;
+	} else {
+		if ( bl->last < 0 )
+			goto EMPTY;
+		if ( bl->type==B_LIST ) {
+			msg = LB_GETTEXT;
+		} else {
+			msg = CB_GETLBTEXT;
+		}
+	}
+	cnt = (int)SendMessage( bl->hWnd, msg, inx, (DWORD)(LPSTR)mswTmpBuff );
+	mswTmpBuff[cnt] = '\0';
+	if (s)
+		strncpy( s, mswTmpBuff, siz );
+	if (bl->last >= 0) {
+		ldp = (listData*)SendMessage( bl->hWnd,
+				(bl->type==B_LIST?LB_GETITEMDATA:CB_GETITEMDATA),
+				bl->last, 0L );
+		if ( ldp==(listData*)LB_ERR )
+			ldp = NULL;
+	} else {
+		ldp = NULL;
+	}
+EMPTY:
+	if (itemContextRef)
+		*itemContextRef = (ldp?ldp->itemContext:NULL);
+	if (listContextRef)
+		*listContextRef = bl->data;
+	return bl->last;
+}
+
+wBool_t wListSetValues(
+		wList_p b,
+		wIndex_t inx,
+		const char * labelStr,
+		wIcon_p bm,
+		void * itemData )
+{
+	listData * ldp;		
+	WORD curSel;
+	ldp = (listData*)malloc( sizeof *ldp );
+	ldp->itemContext = itemData;
+	ldp->bm = bm;
+	ldp->selected = FALSE;
+	if ( (b->option&BL_MANY) == 0 )
+		curSel = (WORD)SendMessage( b->hWnd,
+				(UINT)b->type==B_LIST?LB_GETCURSEL:CB_GETCURSEL,
+				(WPARAM)0,
+				(DWORD)0L );
+	SendMessage( b->hWnd,
+				(UINT)b->type==B_LIST?LB_DELETESTRING:CB_DELETESTRING,
+				(WPARAM)inx,
+				(DWORD)0L );
+	inx = (wIndex_t)SendMessage( b->hWnd,
+				(UINT)b->type==B_LIST?LB_INSERTSTRING:CB_INSERTSTRING,
+				(WPARAM)inx,
+				(DWORD)(LPSTR)labelStr );
+	SendMessage( b->hWnd,
+				(UINT)b->type==B_LIST?LB_SETITEMDATA:CB_SETITEMDATA,
+				(WPARAM)inx,
+				(DWORD)ldp );
+	if ( (b->option&BL_MANY) == 0 && curSel == (WORD)inx)
+			SendMessage( b->hWnd,
+					(UINT)b->type==B_LIST?LB_SETCURSEL:CB_SETCURSEL,
+					(WPARAM)inx,
+					(DWORD)0L );
+	/*if (b->option&BL_ICON)*/
+		InvalidateRect( b->hWnd, NULL, FALSE );
+	return TRUE;
+}
+
+
+void wListDelete(
+		wList_p b,
+		wIndex_t inx )
+{
+	SendMessage( b->hWnd,
+				(UINT)b->type==B_LIST?LB_DELETESTRING:CB_DELETESTRING,
+				(WPARAM)inx,
+				(DWORD)0L );
+}
+
+
+wIndex_t wListGetCount(
+		wList_p bl )
+{			  
+	bl->count = (int)SendMessage( bl->hWnd, (UINT)bl->type==B_LIST?LB_GETCOUNT:CB_GETCOUNT, 0, 0L );
+	return bl->count;
+}
+
+
+void * wListGetItemContext(
+		wList_p bl,
+		wIndex_t inx )
+{
+	listData * ldp;
+	wListGetCount(bl);
+	if ( inx < 0 || inx >= bl->count ) return NULL;
+	ldp = (listData*)SendMessage( bl->hWnd,
+				(bl->type==B_LIST?LB_GETITEMDATA:CB_GETITEMDATA),
+				inx, 0L );
+	return ((ldp&&ldp!=(void*)LB_ERR)?ldp->itemContext:NULL);
+}
+
+
+wBool_t wListGetItemSelected(
+		wList_p bl,
+		wIndex_t inx )
+{
+	listData * ldp;
+	wListGetCount(bl);
+	if ( inx < 0 || inx >= bl->count ) return FALSE;
+	ldp = (listData*)SendMessage( bl->hWnd,
+				(bl->type==B_LIST?LB_GETITEMDATA:CB_GETITEMDATA),
+				inx, 0L );
+	return ((ldp&&ldp!=(void*)LB_ERR)?ldp->selected:FALSE);
+}
+
+
+wIndex_t wListGetSelectedCount(
+		wList_p bl )
+{
+	wIndex_t selcnt, inx;
+	wListGetCount(bl);
+	for ( selcnt=inx=0; inx<bl->count; inx++ )
+		if ( wListGetItemSelected( bl, inx ) )
+			selcnt++;
+	return selcnt;
+}
+
+
+wIndex_t wListAddValue(
+		wList_p b,
+		const char * value,
+		wIcon_p bm,
+		void * itemContext )
+{
+	int nindex;
+	listData * ldp;
+	ldp = (listData*)malloc( sizeof *ldp );
+	ldp->itemContext = itemContext;
+	ldp->bm = bm;
+	ldp->selected = FALSE;
+	if ( value == NULL )
+		value = "";
+	b->count++;
+	nindex = (int)SendMessage(
+				b->hWnd,
+				(UINT)b->type==B_LIST?LB_ADDSTRING:CB_ADDSTRING,
+				(WPARAM)0,
+				(DWORD)value );
+	if (nindex == 0) {
+		SendMessage( b->hWnd,
+				(UINT)b->type==B_LIST?LB_SETCURSEL:CB_SETCURSEL,
+				(WPARAM)nindex,
+				(DWORD)0 );
+		b->last = 0;
+	}
+	SendMessage( b->hWnd,
+				(UINT)b->type==B_LIST?LB_SETITEMDATA:CB_SETITEMDATA,
+				(WPARAM)nindex,
+				(DWORD)ldp );
+	return nindex;
+}
+
+
+int wListGetColumnWidths(
+		wList_p bl,
+		int colCnt,
+		wPos_t * colWidths )
+{
+	wIndex_t inx;
+
+	if ( bl->type != B_LIST )
+		return 0;
+	if ( bl->colWidths == NULL )
+		return 0;
+	for ( inx=0; inx<colCnt; inx++ ) {
+		if ( inx < bl->colCnt )
+			colWidths[inx] = bl->colWidths[inx];
+		else
+			colWidths[inx] = 0;
+	}
+	return bl->colCnt;
+}
+
+
+static void listSetBusy(
+		wControl_p b,
+		BOOL_T busy)
+{
+	wList_p bl = (wList_p)b;
+
+	EnableWindow( bl->hWnd, !(BOOL)busy );
+	if ( bl->hScrollWnd )
+		EnableWindow( bl->hScrollWnd, !(BOOL)busy );
+}
+
+static void listShow(
+		wControl_p b,
+		BOOL_T show)
+{
+	wList_p bl = (wList_p)b;
+
+	ShowWindow( bl->hWnd, show?SW_SHOW:SW_HIDE );
+	if ( bl->hScrollWnd && bl->maxWidth > bl->w )
+		ShowWindow( bl->hScrollWnd, show?SW_SHOW:SW_HIDE );
+#ifdef SHOW_DOES_SETFOCUS
+	if ( show && (bl->option&BO_READONLY)==0 )
+		hWnd = SetFocus( bl->hWnd );
+#endif
+}
+
+static void listSetPos(
+		wControl_p b,
+		wPos_t x,
+		wPos_t y )
+{
+	wList_p bl = (wList_p)b;
+	wPos_t x1, y1;
+	RECT rect;
+	
+	bl->x = x1 = x;
+	bl->y = y1 = y;
+	if ( bl->colTitles )
+		y1 += listTitleHeight;
+	if (!SetWindowPos( b->hWnd, HWND_TOP, x1, y1,
+				CW_USEDEFAULT, CW_USEDEFAULT,
+				SWP_NOSIZE|SWP_NOZORDER))
+				mswFail("listSetPos");
+	if ( bl->hScrollWnd && bl->maxWidth > bl->w ) {
+		GetClientRect( bl->hWnd, &rect );
+		if (!SetWindowPos( bl->hScrollWnd, HWND_TOP, x1, y1+rect.bottom+2,
+				CW_USEDEFAULT, CW_USEDEFAULT,
+				SWP_NOSIZE|SWP_NOZORDER))
+				mswFail("listSetPos2");
+	}
+}
+
+
+static void listRepaintLabel(
+		HWND hWnd,
+		wControl_p b )
+{
+	wList_p bl = (wList_p)b;
+	HDC hDc;
+	RECT rc;
+	HFONT hFont;
+	HPEN hPen0, hPen1, hPen2, hPen3;
+	HBRUSH hBrush;
+	const char * * title;
+	int inx;
+	int start;
+	wPos_t colWidth;
+
+	mswRepaintLabel( hWnd, b );
+	if ( bl->colTitles == NULL )
+		return;
+	hDc = GetDC( hWnd );
+	start = bl->x-bl->scrollPos+2;
+	rc.top = bl->y;
+	rc.bottom = bl->y+listTitleHeight;
+	rc.left = bl->x-1;
+	rc.right = bl->x+bl->w;
+	hBrush = CreateSolidBrush( GetSysColor( COLOR_BTNFACE ) );
+	FillRect( hDc, &rc, hBrush );
+	SetBkColor( hDc, GetSysColor( COLOR_BTNFACE ) );
+	
+	hFont = SelectObject( hDc, mswLabelFont );
+	hPen1 = CreatePen( PS_SOLID, 0, GetSysColor( COLOR_BTNTEXT ) );
+	hPen2 = CreatePen( PS_SOLID, 0, GetSysColor( COLOR_BTNHIGHLIGHT ) );
+	hPen3 = CreatePen( PS_SOLID, 0, GetSysColor( COLOR_BTNSHADOW ) );
+	hPen0 = SelectObject( hDc, hPen1 );
+	MoveTo( hDc, rc.left, rc.top );
+	LineTo( hDc, rc.right, rc.top );
+	LineTo( hDc, rc.right, rc.bottom );
+	LineTo( hDc, rc.left, rc.bottom );
+	LineTo( hDc, rc.left, rc.top );
+	SelectObject( hDc, hPen2 );
+	MoveTo( hDc, rc.left+1, rc.bottom-1 );
+	LineTo( hDc, rc.left+1, rc.top+1 );
+	LineTo( hDc, rc.right-1, rc.top+1 );
+	SelectObject( hDc, hPen3 );
+	MoveTo( hDc, rc.left+2, rc.bottom-1 );
+	LineTo( hDc, rc.right-1, rc.bottom-1 );
+	LineTo( hDc, rc.right-1, rc.top+1 );
+	rc.top += 2;
+	rc.bottom -= 1;
+	for ( inx=0,title=bl->colTitles; inx<bl->colCnt&&*title&&start<bl->x+bl->w; inx++ ) {
+		colWidth = bl->colWidths[inx];
+		if ( start+colWidth >= 3 ) {
+			rc.left = start;
+			if ( rc.left < bl->x+2 )
+				rc.left = bl->x+2;
+			rc.right = start+colWidth;
+			if ( rc.right > bl->x+bl->w-1 )
+				rc.right = bl->x+bl->w-1;
+			ExtTextOut( hDc, start+1, rc.top+0,
+				ETO_CLIPPED|ETO_OPAQUE, &rc,
+				*title, strlen(*title), NULL );
+			if ( start-bl->x >= 3 ) {
+			SelectObject( hDc, hPen1 );
+			MoveTo( hDc, start-1, rc.top-1 );
+			LineTo( hDc, start-1, rc.bottom+3 );
+			SelectObject( hDc, hPen2 );
+			MoveTo( hDc, start, rc.top );
+			LineTo( hDc, start, rc.bottom+1 );
+			SelectObject( hDc, hPen3 );
+			MoveTo( hDc, start-2, rc.top );
+			LineTo( hDc, start-2, rc.bottom+1 );
+			}
+		}
+		title++;
+		start += colWidth;
+	}
+	SelectObject( hDc, hPen0 );
+	SelectObject( hDc, hFont );
+	DeleteObject( hBrush );
+	DeleteObject( hPen1 );
+	DeleteObject( hPen2 );
+	DeleteObject( hPen3 );
+}
+
+
+#ifdef LATER
+static void listHandleSelectionState( LPDRAWITEMSTRUCT lpdis, LPRECT rc )
+{
+	int oldROP;
+	oldROP = SetROP2( lpdis->hDC, R2_NOT );
+	Rectangle( lpdis->hDC, rc->left, rc->top, rc->right, rc->bottom );
+	SetROP2( lpdis->hDC, oldROP );
+	/*InvertRect( lpdis->hDC, rc );*/
+}
+#endif
+
+static void listHandleFocusState( LPDRAWITEMSTRUCT lpdis, LPRECT rc )
+{
+	DrawFocusRect( lpdis->hDC, rc );
+}
+
+
+LRESULT listProc(
+		wControl_p b,
+		HWND hWnd,
+		UINT message,
+		WPARAM wParam,
+		LPARAM lParam )
+{						
+	wList_p bl = (wList_p)b;
+	int cnt, inx, selected;
+	long len;
+	listData * ldp;
+	HDC hDc;
+	LPMEASUREITEMSTRUCT lpmis;
+	TEXTMETRIC tm;
+	LPDRAWITEMSTRUCT lpdis;
+	RECT rc, rc1;
+	char * cp0, * cp1;
+	wPos_t colWidth, x;
+	int nPos;
+	HFONT hFont;
+	HPEN hPen;
+	HBRUSH hBrush;
+	WPARAM notification;
+	COLORREF col;
+
+	if (bl) switch( message ) {
+	
+	case WM_COMMAND:
+		notification = WCMD_PARAM_NOTF;
+		switch (bl->type) {
+		case B_LIST:
+			switch (notification) {
+			case LBN_SELCHANGE:
+			case LBN_DBLCLK:
+				if ( (bl->option&BL_DBLCLICK)!=0 ?
+						notification!=LBN_DBLCLK :
+						notification==LBN_DBLCLK )
+					break;
+				if ( (bl->option&BL_MANY) ) {
+					wListGetCount(bl);
+					for ( inx=0; inx<bl->count; inx++ ) {
+					ldp = (listData*)SendMessage( bl->hWnd, LB_GETITEMDATA, inx, 0L );
+					if ( ldp != NULL && ldp != (void*)LB_ERR ) {
+						selected = ((long)SendMessage( bl->hWnd, LB_GETSEL, inx, 0L ) != 0L );
+						if ( selected != ldp->selected ) {
+							ldp->selected = selected;
+							if ( selected ) {
+								bl->last = inx;
+								cnt = (int)SendMessage( bl->hWnd, LB_GETTEXT, bl->last, (DWORD)(LPSTR)mswTmpBuff );
+								mswTmpBuff[cnt] = '\0';
+							} else {
+								mswTmpBuff[0] = '\0';
+							}
+							if ( bl->action )
+								bl->action( inx, mswTmpBuff, selected?1:2, bl->data, ldp->itemContext );
+							if ( selected && bl->valueP )
+								*bl->valueP = bl->last;
+						}
+					}
+					}
+				} else {
+					bl->last = (int)SendMessage( bl->hWnd, LB_GETCURSEL, 0, 0L );
+					cnt = (int)SendMessage( bl->hWnd, LB_GETTEXT, bl->last,
+										(DWORD)(LPSTR)mswTmpBuff );
+					mswTmpBuff[cnt] = '\0';
+					if (bl->action) {
+						ldp = (listData*)SendMessage( bl->hWnd, LB_GETITEMDATA,
+										bl->last, 0L );
+						bl->action( bl->last, mswTmpBuff, 1, bl->data,
+							((bl->last>=0&&ldp&&ldp!=(void*)LB_ERR)?ldp->itemContext:NULL) );
+					}
+					if (bl->valueP) {
+						*bl->valueP = bl->last;
+					}
+				}
+				break;
+
+			case LBN_KILLFOCUS:
+				if ( ( bl->option&BL_MANY ) == 0 &&
+					 bl->last != (int)SendMessage( bl->hWnd, LB_GETCURSEL, 0, 0L ) )
+					(void)SendMessage( bl->hWnd, LB_SETCURSEL, bl->last, 0L );
+				break;
+			}
+			break;
+
+		case B_DROPLIST:
+		case B_COMBOLIST:
+			switch (notification) {
+			case CBN_SELCHANGE:
+			case CBN_DBLCLK:
+				if ( (bl->type == B_DROPLIST) ||
+					 ( (bl->option&BL_DBLCLICK)!=0 ?
+						notification!=CBN_DBLCLK :
+						notification==CBN_DBLCLK) )
+					break;
+
+			case CBN_CLOSEUP:
+				bl->last = (int)SendMessage( bl->hWnd, CB_GETCURSEL, 0, 0L );
+				if (bl->last < 0)
+					break;
+				if (bl->action) {
+					cnt = (int)SendMessage( bl->hWnd, CB_GETLBTEXT, bl->last,
+										(DWORD)(LPSTR)mswTmpBuff );
+					ldp = (listData*)SendMessage( bl->hWnd, CB_GETITEMDATA,
+										bl->last, 0L );
+					mswTmpBuff[cnt] = '\0';
+					bl->action( bl->last, mswTmpBuff, 1, bl->data,
+						((bl->last>=0&&ldp&&ldp!=(void*)LB_ERR)?ldp->itemContext:NULL) );
+				}
+				if (bl->valueP) {
+					*bl->valueP = bl->last;
+				}
+				mswAllowBalloonHelp = TRUE;
+				/*SendMessage( bl->bWnd, CB_SETCURSEL, bl->last, 0L );*/
+				break;
+
+			case CBN_KILLFOCUS:
+				inx = (int)SendMessage( bl->hWnd, CB_GETCURSEL, 0, 0L );
+				if ( bl->last != inx )
+					(void)SendMessage( bl->hWnd, CB_SETCURSEL, bl->last, 0L );
+				break;
+
+			case CBN_DROPDOWN:
+				mswAllowBalloonHelp = FALSE;
+				break;
+
+			case CBN_EDITCHANGE:
+				bl->last = -1;
+				if (bl->action) {
+					cnt = (int)SendMessage( bl->hWnd, WM_GETTEXT, sizeof mswTmpBuff,
+										(DWORD)(LPSTR)mswTmpBuff );
+					mswTmpBuff[cnt] = '\0';
+					bl->action( -1, mswTmpBuff, 1, bl->data, NULL );
+				}
+				break;
+			}
+			break;
+		}
+		break;
+
+	case WM_MEASUREITEM:
+		lpmis = (LPMEASUREITEMSTRUCT)lParam;
+		hDc = GetDC( hWnd );
+		if ( bl->type == B_LIST )
+			hFont = SelectObject( hDc, mswLabelFont );
+		GetTextMetrics( hDc, &tm );
+		lpmis->itemHeight = tm.tmHeight;			  
+		if ( bl->type == B_LIST )
+			SelectObject( hDc, hFont );
+		ReleaseDC( hWnd, hDc );
+		break;
+
+	case WM_DRAWITEM:
+		lpdis = (LPDRAWITEMSTRUCT)lParam;
+		if (lpdis->itemID == -1) {
+			listHandleFocusState(lpdis, &lpdis->rcItem);
+			return TRUE;
+		}
+		ldp = (listData*)SendMessage( bl->hWnd,
+						(bl->type==B_LIST?LB_GETITEMDATA:CB_GETITEMDATA),
+						lpdis->itemID, 0L );
+		rc = lpdis->rcItem;
+		if (lpdis->itemAction & (ODA_DRAWENTIRE|ODA_SELECT|ODA_FOCUS)) {
+			if( bl->type == B_LIST )
+				hFont = SelectObject( lpdis->hDC, mswLabelFont );
+			cnt = (int)SendMessage( lpdis->hwndItem, 
+				(bl->type==B_LIST?LB_GETTEXT:CB_GETLBTEXT),
+				lpdis->itemID, (LONG)(LPSTR)mswTmpBuff );
+			mswTmpBuff[cnt] = '\0';
+			if ( lpdis->itemState & ODS_SELECTED ) {
+				SetTextColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHTTEXT ) );
+				SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
+			} else {
+				SetTextColor( lpdis->hDC, GetSysColor( COLOR_WINDOWTEXT ) );
+				SetBkColor( lpdis->hDC, GetSysColor( COLOR_WINDOW ) );
+			}
+			rc1 = rc;
+			rc1.left -= bl->scrollPos;
+			for ( inx=0,cp0=mswTmpBuff; inx<bl->colCnt&&cp0&&rc1.left<rc.right; inx++ ) {
+				if ( inx>=bl->colCnt-1 || (cp1=strchr(cp0,'\t')) == NULL ) {
+					len = strlen( cp0 );
+					cp1=cp0 + len; // JBB, to avoid an MSC error below where cp1 has not been defined.
+				} else {
+					len = cp1-cp0;
+					cp1 ++;
+				}
+				if ( bl->colWidths ) {
+					colWidth = bl->colWidths[inx];
+				} else {
+					colWidth = rc.right;
+				}
+				if ( inx == 0 && ldp && ldp!=(void*)LB_ERR && ldp->bm ) {
+					if (mswPalette) {
+						SelectPalette( lpdis->hDC, mswPalette, 0 );
+						cnt = RealizePalette( lpdis->hDC );
+					}
+					hPen = SelectObject( lpdis->hDC, CreatePen( PS_SOLID, 0, GetSysColor( COLOR_WINDOW ) ) );
+					hBrush = SelectObject( lpdis->hDC, CreateSolidBrush( GetSysColor( COLOR_WINDOW ) ) );
+					Rectangle( lpdis->hDC, rc1.left, rc1.top, rc1.right, rc1.bottom );
+					DeleteObject( SelectObject( lpdis->hDC, hPen ) );
+					DeleteObject( SelectObject( lpdis->hDC, hBrush ) );
+
+					col = RGB(	(ldp->bm->colormap[ 1 ]).rgbRed, 
+								(ldp->bm->colormap[ 1 ]).rgbGreen,
+								(ldp->bm->colormap[ 1 ]).rgbBlue );
+					mswDrawIcon( lpdis->hDC, rc1.left+2, rc.top+0, ldp->bm, 0, col, col);
+
+					rc1.left += ldp->bm->w+6;
+					colWidth -= ldp->bm->w+6;
+				}
+				if ( inx>=bl->colCnt-1 || (rc1.right = rc1.left + colWidth) > rc.right )
+					 rc1.right = rc.right;
+				if ( rc1.right > 0 && rc1.left+3 < rc.right ) {
+					ExtTextOut( lpdis->hDC, rc1.left+3, rc1.top+1,
+						ETO_CLIPPED | ETO_OPAQUE, &rc1,
+						(LPSTR)cp0, (int)len, NULL );
+				}
+				rc1.left = rc1.right;
+				cp0 = cp1;
+			}
+			if ( lpdis->itemState & ODS_SELECTED ) {
+				SetTextColor( lpdis->hDC, GetSysColor( COLOR_WINDOWTEXT ) );
+				SetBkColor( lpdis->hDC, GetSysColor( COLOR_WINDOW ) );
+			}
+			if (lpdis->itemState & ODS_FOCUS) {
+				DrawFocusRect( lpdis->hDC, &rc );
+			}
+			if ( bl->type == B_LIST)
+				SelectObject( lpdis->hDC, hFont );
+			return TRUE;
+		}
+		
+		break;
+
+	case WM_HSCROLL:
+		len = ((long)bl->maxWidth)-((long)bl->w);
+		if ( len <= 0 )
+			return 0;
+		switch ( WSCROLL_PARAM_CODE ) {
+		case SB_LEFT:
+			if ( bl->scrollPos == 0 )
+				return 0;
+			bl->scrollPos = 0;
+			break;
+		case SB_LINELEFT:
+		case SB_PAGELEFT:
+			if ( bl->scrollPos == 0 )
+				return 0;
+			for ( inx=colWidth=0; inx<bl->colCnt; inx++ ) {
+				if ( colWidth+bl->colWidths[inx] >= bl->scrollPos ) {
+					bl->scrollPos = colWidth; 
+					break;
+				}
+				colWidth += bl->colWidths[inx];
+			}
+			break;
+		case SB_LINERIGHT:
+		case SB_PAGERIGHT:
+			if ( bl->scrollPos >= len )
+				return 0;
+			for ( inx=colWidth=0; inx<bl->colCnt; inx++ ) {
+				if ( colWidth >= bl->scrollPos ) {
+					bl->scrollPos = colWidth+bl->colWidths[inx];
+					break;
+				}
+				colWidth += bl->colWidths[inx];
+			}
+			break;
+		case SB_RIGHT:
+			if ( bl->scrollPos >= len )
+				return 0;
+			bl->scrollPos = (int)len;
+			break;
+		case SB_THUMBTRACK:	  
+			return 0;
+		case SB_THUMBPOSITION:
+			nPos = (int)WSCROLL_PARAM_NPOS;
+			bl->scrollPos = (int)(len*nPos/100);
+			break;
+		case SB_ENDSCROLL:
+			return 0;
+		}
+		if ( bl->scrollPos > len ) bl->scrollPos = (int)len;
+		if ( bl->scrollPos < 0 ) bl->scrollPos = 0;
+		nPos = (int)(((long)bl->scrollPos)*100L/len+0.5);
+		SetScrollPos( bl->hScrollWnd, SB_CTL, nPos, TRUE );
+		InvalidateRect( bl->hWnd, NULL, FALSE );
+		listRepaintLabel( ((wControl_p)(bl->parent))->hWnd, (wControl_p)bl );
+		return 0;
+
+	case WM_LBUTTONDOWN:
+		if ( bl->type != B_LIST )
+			break;
+		if ( bl->colCnt <= 1 )
+			break;
+		x = bl->dragPos = LOWORD(lParam)+bl->scrollPos-4;
+		bl->dragCol = -1;
+		for ( inx=0; inx<bl->colCnt; inx++ ) {
+			x -= bl->colWidths[inx];
+			if ( x < -5 ) break;
+			if ( x <= 0 ) { bl->dragCol = inx; break; }
+			if ( x > bl->colWidths[inx+1] ) continue;
+			if ( x <= 10 ) { bl->dragCol = inx; break; }
+		}
+		if ( bl->dragCol >= 0 )
+			bl->dragColWidth = bl->colWidths[inx];
+		return 0L;
+
+#ifdef LATER
+	case WM_MOUSEMOVE:
+		if ( (wParam&MK_LBUTTON) == 0 )
+			break;
+		if ( bl->type != B_LIST )
+			break;
+		if ( bl->colCnt <= 1 )
+			break;
+		x = LOWORD(lParam)+bl->scrolPos;
+		for ( inx=0; inx<bl->colCnt; inx++ ) {
+			x -= bl->colWidths[inx];
+			if ( x <= 0 )
+				break;
+		}
+		return 0L;
+#endif
+
+	case WM_MOUSEMOVE:
+		if ( (wParam&MK_LBUTTON) == 0 )
+			break;
+	case WM_LBUTTONUP:
+		if ( bl->type != B_LIST )
+			break;
+		if ( bl->colCnt <= 1 )
+			break;
+		if ( bl->dragCol < 0 )
+			break;
+		x = LOWORD(lParam)+bl->scrollPos-4-bl->dragPos;			/* WIN32??? */
+		bl->colWidths[bl->dragCol] = bl->dragColWidth+x;
+		if ( bl->colWidths[bl->dragCol] < 0 )
+			bl->colWidths[bl->dragCol] = 0;
+		for ( bl->maxWidth=inx=0; inx<bl->colCnt; inx++ )
+			bl->maxWidth += bl->colWidths[inx];
+		if ( bl->maxWidth <= bl->w ) {
+			x = bl->w - bl->maxWidth;
+			bl->colWidths[bl->colCnt-1] += x;
+			bl->maxWidth = bl->w;
+			bl->scrollPos = 0;
+		} else {
+			if ( bl->scrollPos+bl->w > bl->maxWidth ) {
+				bl->scrollPos = bl->maxWidth - bl->w;
+			}
+		}
+		InvalidateRect( bl->hWnd, NULL, FALSE );
+		listRepaintLabel( ((wControl_p)(bl->parent))->hWnd, (wControl_p)bl );
+		return 0L;
+
+	}													  
+	
+	return DefWindowProc( hWnd, message, wParam, lParam );
+}					
+
+long FAR PASCAL _export pushList(
+		HWND hWnd,
+		UINT message,
+		UINT wParam,
+		LONG lParam )
+{
+	/* Catch <Return> and cause focus to leave control */
+#ifdef WIN32
+	long inx = GetWindowLong( hWnd, GWL_ID );
+#else
+	short inx = GetWindowWord( hWnd, GWW_ID );
+#endif
+	wControl_p b = mswMapIndex( inx );
+
+	switch (message) {
+	case WM_CHAR:
+		if ( b != NULL) {
+			switch( WCMD_PARAM_ID ) {
+			case 0x0D:
+			case 0x1B:
+			case 0x09:
+				SetFocus( ((wControl_p)(b->parent))->hWnd ); 
+				SendMessage( ((wControl_p)(b->parent))->hWnd, WM_CHAR,
+						wParam, lParam );
+				/*SendMessage( ((wControl_p)(b->parent))->hWnd, WM_COMMAND,
+						inx, MAKELONG( hWnd, EN_KILLFOCUS ) );*/
+				return 0L;
+			}
+		}
+		break;
+	}
+	return CallWindowProc( oldListProc, hWnd, message, wParam, lParam );
+}
+
+long FAR PASCAL _export pushCombo(
+		HWND hWnd,
+		UINT message,
+		UINT wParam,
+		LONG lParam )
+{
+	/* Catch <Return> and cause focus to leave control */
+#ifdef WIN32
+	long inx = GetWindowLong( hWnd, GWL_ID );
+#else
+	short inx = GetWindowWord( hWnd, GWW_ID );
+#endif
+	wControl_p b = mswMapIndex( inx );
+
+	switch (message) {
+	case WM_CHAR:
+		if ( b != NULL) {
+			switch( WCMD_PARAM_ID ) {
+			case 0x0D:
+			case 0x1B:
+			case 0x09:
+				SetFocus( ((wControl_p)(b->parent))->hWnd ); 
+				SendMessage( ((wControl_p)(b->parent))->hWnd, WM_CHAR,
+						wParam, lParam );
+				/*SendMessage( ((wControl_p)(b->parent))->hWnd, WM_COMMAND,
+						inx, MAKELONG( hWnd, EN_KILLFOCUS ) );*/
+				return 0L;
+			}
+		}
+		break;
+	}
+	return CallWindowProc( oldComboProc, hWnd, message, wParam, lParam );
+}
+
+static callBacks_t listCallBacks = {
+		listRepaintLabel,
+		NULL,
+		listProc,
+		listSetBusy,
+		listShow,
+		listSetPos };
+
+
+static wList_p listCreate(
+		int		typ,
+		const char	*className,
+		long	style,
+		wWin_p	parent,
+		POS_T	x,
+		POS_T	y,
+		const char	* helpStr,
+		const char	* labelStr,
+		long	option,
+		long	number,
+		POS_T	width,
+		long	*valueP,
+		wListCallBack_p action,
+		void	*data,
+		wBool_t addFocus,
+		int		*indexR )
+{ 
+	wList_p b;
+	RECT rect;	
+	int index;
+
+	b = (wList_p)mswAlloc( parent, typ, mswStrdup(labelStr), sizeof *b, data, &index );
+	mswComputePos( (wControl_p)b, x, y );
+	b->option = option;
+	b->count = 0;
+	b->last = -1;
+	b->valueP = valueP;
+	b->labelY += 4;
+	b->action = action;
+	b->maxWidth = 0;
+	b->scrollPos = 0;
+	b->scrollH = 0;
+	b->dragPos = 0;
+	b->dragCol = -1;
+
+	b->hWnd = CreateWindow( className, NULL,
+				style | WS_CHILD | WS_VISIBLE | mswGetBaseStyle(parent), b->x, b->y,
+				width, LIST_HEIGHT*(int)number,
+				((wControl_p)parent)->hWnd, (HMENU)index, mswHInst, NULL );
+	if (b->hWnd == NULL) {
+		mswFail("CreateWindow(LIST)");
+		return b;
+	}
+
+#ifdef CONTROL3D
+	Ctl3dSubclassCtl( b->hWnd );
+#endif
+
+	GetWindowRect( b->hWnd, &rect );
+	b->w = rect.right - rect.left;
+	b->h = rect.bottom - rect.top;
+	b->colCnt = 1;
+	b->colWidths = NULL;
+	b->colTitles = NULL;
+
+	mswAddButton( (wControl_p)b, TRUE, helpStr );
+	mswCallBacks[typ] = &listCallBacks;
+	if (addFocus) {
+		mswChainFocus( (wControl_p)b );
+		if (b->type == B_LIST) {
+			newListProc = MakeProcInstance( (XWNDPROC)pushList, mswHInst );
+			oldListProc = (XWNDPROC)GetWindowLong( b->hWnd, GWL_WNDPROC );
+			SetWindowLong( b->hWnd, GWL_WNDPROC, (LONG)newListProc );
+		} else {
+			newComboProc = MakeProcInstance( (XWNDPROC)pushCombo, mswHInst );
+			oldComboProc = (XWNDPROC)GetWindowLong( b->hWnd, GWL_WNDPROC );
+			SetWindowLong( b->hWnd, GWL_WNDPROC, (LONG)newComboProc );
+		}
+	}
+	if ( indexR )
+		*indexR = index;
+	if ( !mswThickFont )
+		SendMessage( b->hWnd, WM_SETFONT, (WPARAM)mswLabelFont, 0L );
+	return b;
+}
+
+
+wList_p wListCreate(
+		wWin_p	parent,
+		POS_T	x,
+		POS_T	y,
+		const char	* helpStr,
+		const char	* labelStr,
+		long	option,
+		long	number,
+		POS_T	width,
+		int		colCnt,
+		wPos_t	* colWidths,
+		wBool_t * colRightJust,
+		const char	* * colTitles,
+		long	*valueP,
+		wListCallBack_p action,
+		void	*data )
+{ 
+	long bs;
+	wList_p bl;
+	static int dbu = 0;
+	RECT rect;
+	int index;
+	int i;
+
+	bs = LBS_NOTIFY | WS_VSCROLL | WS_BORDER | LBS_OWNERDRAWFIXED | LBS_HASSTRINGS;
+	if (option & BL_MANY)
+		bs |= LBS_MULTIPLESEL|LBS_EXTENDEDSEL;
+	if (option & BL_SORT)
+		bs |= LBS_SORT;
+	if ( colCnt > 1 )
+		bs |= WS_HSCROLL;
+	if ( colTitles ) {
+		y += listTitleHeight;
+		number -= 1;
+	}
+	bl = listCreate( B_LIST, "LISTBOX", bs, parent, x, y, helpStr,
+						labelStr, option, number, width, valueP, action, data, TRUE, &index );
+	if ( colTitles ) {
+		bl->y -= listTitleHeight;
+		bl->h += listTitleHeight;
+	}	 
+	if ( colCnt > 1 ) {
+		bl->colCnt = colCnt;
+		bl->colWidths = (int*)malloc( colCnt * sizeof *bl->colWidths );
+		bl->colRightJust = (wBool_t*)malloc( colCnt * sizeof *bl->colRightJust );
+		bl->colTitles = colTitles;
+		bl->maxWidth = 0;
+		memcpy( bl->colWidths, colWidths, colCnt * sizeof *bl->colWidths );
+		for ( i=0; i<colCnt; i++ ) {
+			bl->colWidths[i] = colWidths[i];
+			bl->maxWidth += bl->colWidths[i];
+		}
+		bl->hScrollWnd = CreateWindow( "ScrollBar", NULL,
+				SBS_HORZ | SBS_BOTTOMALIGN | WS_CHILD | WS_VISIBLE | mswGetBaseStyle(parent), bl->x, bl->y,
+				width, CW_USEDEFAULT,
+				((wControl_p)parent)->hWnd, (HMENU)index, mswHInst, NULL );
+		if (bl->hScrollWnd == NULL)
+			mswFail("CreateWindow(LISTSCROLL)");
+		SetScrollRange( bl->hScrollWnd, SB_CTL, 0, 100, TRUE );
+		GetWindowRect( bl->hScrollWnd, &rect );
+		bl->scrollH = rect.bottom - rect.top+2;
+	}
+	return bl;
+}
+
+
+wList_p wDropListCreate(
+		wWin_p	parent,
+		POS_T	x,
+		POS_T	y,
+		const char	* helpStr,
+		const char	* labelStr,
+		long	option,
+		long	number,
+		POS_T	width,
+		long	*valueP,
+		wListCallBack_p action,
+		void	*data )
+{
+	long bs;
+
+	if ( (option&BL_EDITABLE) != 0 )
+		bs = CBS_DROPDOWN;
+	else
+		bs = CBS_DROPDOWNLIST;
+	bs |= WS_VSCROLL | CBS_OWNERDRAWFIXED | CBS_HASSTRINGS;
+	if (option & BL_SORT)
+		bs |= CBS_SORT;
+	return listCreate( B_DROPLIST, "COMBOBOX", bs, parent, x, y, helpStr,
+						labelStr, option, number, width, valueP, action, data, TRUE, NULL );
+}
+
+wList_p wComboListCreate(
+		wWin_p	parent,
+		POS_T	x,
+		POS_T	y,
+		const char	* helpStr,
+		const char	* labelStr,
+		long	option,
+		long	number,
+		POS_T	width,
+		long	*valueP,
+		wListCallBack_p action,
+		void	*data )
+{
+	long bs;
+
+	bs = CBS_SIMPLE | WS_VSCROLL | CBS_OWNERDRAWFIXED | CBS_HASSTRINGS;
+	if (option & BL_SORT)
+		bs |= CBS_SORT;
+	return listCreate( B_COMBOLIST, "COMBOBOX", bs, parent, x, y, helpStr,
+						labelStr, option, number, width, valueP, action, data, FALSE, NULL );
+}
diff --git a/app/wlib/mswlib/mswmenu.c b/app/wlib/mswlib/mswmenu.c
new file mode 100644
index 0000000..15053a2
--- /dev/null
+++ b/app/wlib/mswlib/mswmenu.c
@@ -0,0 +1,1062 @@
+#define OEMRESOURCE
+
+#include <windows.h>
+#include <string.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <commdlg.h>
+#include <math.h>
+#include <ctype.h>
+#include <assert.h>
+#include "mswint.h"
+
+/*
+ *****************************************************************************
+ *
+ * Menus
+ *
+ *****************************************************************************
+ */
+
+typedef enum { M_MENU, M_SEPARATOR, M_PUSH, M_LIST, M_LISTITEM, M_TOGGLE, M_RADIO } mtype_e;
+typedef enum { MM_BUTT, MM_MENU, MM_BAR, MM_POPUP } mmtype_e;
+
+typedef struct wMenuItem_t * wMenuItem_p;
+
+struct radioButtonGroup {
+		int firstButton;	/* id of first button in group */
+		int lastButton;		/* id of last button in group */	
+};
+
+/* NOTE: first field must be the same as WOBJ_COMMON */
+#define MOBJ_COMMON \
+		WOBJ_COMMON \
+		int index; \
+		mtype_e mtype; \
+		wMenu_p parentMenu; \
+		wMenuItem_p mnext;
+
+struct wMenuItem_t {
+		MOBJ_COMMON
+		};
+
+struct wMenu_t {
+		MOBJ_COMMON
+		mmtype_e mmtype;
+		wMenuItem_p first, last;
+		struct radioButtonGroup *radioGroup;
+		HMENU menu;
+		wButton_p button;
+		wMenuTraceCallBack_p traceFunc;
+		void * traceData;
+		};
+
+struct wMenuPush_t {
+		MOBJ_COMMON
+		wMenu_p mparent;
+		wMenuCallBack_p action;
+		long acclKey;
+		wBool_t enabled;
+		};
+
+struct wMenuRadio_t {
+		MOBJ_COMMON
+		wMenu_p mparent;
+		wMenuCallBack_p action;
+		long acclKey;
+		wBool_t enabled;
+		};
+struct wMenuToggle_t {
+		MOBJ_COMMON
+		wMenu_p mparent;
+		wMenuToggleCallBack_p action;
+		long acclKey;
+		wBool_t enabled;
+		};
+
+typedef struct wMenuListItem_t * wMenuListItem_p;
+struct wMenuList_t {
+		MOBJ_COMMON
+		wMenuListItem_p left, right;
+		wMenu_p mlparent;
+		int max;
+		int count;
+		wMenuListCallBack_p action;
+		};
+
+struct wMenuListItem_t {
+		MOBJ_COMMON
+		wMenuListItem_p left, right;
+		wMenuListCallBack_p action;
+		};
+
+#define UNCHECK (0)
+#define CHECK	(1)
+#define RADIOCHECK (2)
+#define RADIOUNCHECK (3)
+
+static 	HBITMAP checked;
+static	HBITMAP unchecked;
+static  HBITMAP checkedRadio;
+static 	HBITMAP uncheckedRadio;
+
+
+/*
+ *****************************************************************************
+ *
+ * Internal Functions
+ *
+ *****************************************************************************
+ */
+
+char * mswStrdup( const char * str )
+{
+	char * ret;
+	if (str) {
+		ret = (char*)malloc( strlen(str)+1 );
+		strcpy( ret, str );
+	} else
+		ret = NULL;
+	return ret;
+}
+
+static LRESULT menuPush(
+		wControl_p b,
+		HWND hWnd,
+		UINT message,
+		WPARAM wParam,
+		LPARAM lParam )
+{
+	wMenuItem_p m = (wMenuItem_p)b;
+	wBool_t set;
+
+	mswAllowBalloonHelp = TRUE;
+
+	switch( message ) {
+
+	case WM_COMMAND:
+
+		switch (m->mtype) {
+		default:
+			mswFail( "pushMenu" );
+			break;
+		case M_PUSH:
+			if (((wMenuPush_p)m)->action)
+				((wMenuPush_p)m)->action(((wMenuPush_p)m)->data);
+			break;
+		case M_TOGGLE:
+			set = wMenuToggleGet((wMenuToggle_p)m);
+			set = !set;
+			wMenuToggleSet((wMenuToggle_p)m,set);
+			if (((wMenuToggle_p)m)->action)
+				((wMenuToggle_p)m)->action(set, ((wMenuPush_p)m)->data);
+			break;
+		case M_LISTITEM:
+			if (((wMenuListItem_p)m)->action)
+				((wMenuListItem_p)m)->action(0, "", ((wMenuListItem_p)m)->data);
+			break;
+		case M_RADIO:
+			if (((wMenuRadio_p)m)->action)
+				((wMenuRadio_p)m)->action(((wMenuRadio_p)m)->data);
+			break;
+		}
+		return 0L;
+	}
+	if ( (m->parentMenu)->traceFunc ) {
+		(m->parentMenu)->traceFunc( m->parentMenu, m->labelStr, ((wMenu_p)m->parentMenu)->traceData );
+	}
+	return DefWindowProc( hWnd, message, wParam, lParam );
+}
+
+static void menuDone( wControl_p b )
+{
+	wMenuItem_p m = (wMenuItem_p)b;
+	switch ( m->mtype ) {
+	case M_MENU:
+		if ( ((wMenu_p)m)->mmtype == MM_BUTT ||
+			 ((wMenu_p)m)->mmtype == MM_POPUP )
+			DestroyMenu( ((wMenu_p)m)->menu );
+		break;
+	}
+}
+
+static callBacks_t menuItemCallBacks = {
+		NULL,
+		menuDone,
+		menuPush };
+
+
+static wMenuItem_p createMenuItem(
+		wMenu_p m,
+		mtype_e mtype,
+		const char * helpStr,
+		const char * labelStr,
+		int size )
+{
+	wMenuItem_p mi;
+
+	mi = (wMenuItem_p)calloc( 1, size );
+	mi->type = B_MENUITEM;
+	/*mi->messageProc = menuPush;*/
+	mi->index = mswRegister( (wControl_p)mi );
+	mi->mtype = mtype;
+	if (m) {
+		if (m->last != NULL) {
+			m->last->mnext = mi;
+		} else {
+			m->first = m->last = mi;
+		}
+		m->last = mi;
+	}
+	mi->mnext = NULL;
+	mi->labelStr = mswStrdup( labelStr );
+//	if (helpStr != NULL) {
+//		char *string;
+//		string = malloc( strlen(helpStr) + 1 );
+//		strcpy( string, helpStr );
+//		/*xv_set(mi->menu_item, XV_HELP_DATA, string, 0 );*/
+//	}
+	mswCallBacks[B_MENUITEM] = &menuItemCallBacks;
+	return mi;
+}
+
+/*
+ *****************************************************************************
+ *
+ * Accelerators
+ *
+ *****************************************************************************
+ */
+
+
+typedef struct {
+		long acclKey;
+		wMenuPush_p mp;
+		wAccelKeyCallBack_p action;
+		wAccelKey_e key;
+		void * data;
+		} acclTable_t, *acclTable_p;
+dynArr_t acclTable_da;
+#define acclTable(N) DYNARR_N( acclTable_t, acclTable_da, N )
+
+
+int mswMenuAccelerator(
+		wWin_p win,
+		long acclKey )
+{
+	acclTable_p at;
+	if ( ((wControl_p)win)->type != W_MAIN &&
+		 ((wControl_p)win)->type != W_POPUP )
+		return 0;
+	for ( at = &acclTable(0); at<&acclTable(acclTable_da.cnt); at++ ) {
+		if (at->acclKey == acclKey) {
+			if (at->mp) {
+				if (at->mp->enabled && at->mp->action)
+					at->mp->action(at->mp->data);
+				return 1;
+			} else if (at->action) {
+				at->action( at->key, at->data );
+				return 1;
+			} else {
+				return 0;
+			}
+		}
+	}
+	return 0;
+}
+
+
+
+static long acclKeyMap[] = {
+			0,					/* wAccelKey_None, */
+			VK_DELETE,			/* wAccelKey_Del, */
+			VK_INSERT,			/* wAccelKey_Ins, */
+			VK_HOME,			/* wAccelKey_Home, */
+			VK_END,				/* wAccelKey_End, */
+			VK_PRIOR,			/* wAccelKey_Pgup, */
+			VK_NEXT,			/* wAccelKey_Pgdn, */
+			VK_UP,				/* wAccelKey_Up, */
+			VK_DOWN,			/* wAccelKey_Down, */
+			VK_RIGHT,			/* wAccelKey_Right, */
+			VK_LEFT,			/* wAccelKey_Left, */
+			VK_BACK,			/* wAccelKey_Back, */
+			VK_F1,				/* wAccelKey_F1, */
+			VK_F2,				/* wAccelKey_F2, */
+			VK_F3,				/* wAccelKey_F3, */
+			VK_F4,				/* wAccelKey_F4, */
+			VK_F5,				/* wAccelKey_F5, */
+			VK_F6,				/* wAccelKey_F6, */
+			VK_F7,				/* wAccelKey_F7, */
+			VK_F8,				/* wAccelKey_F8, */
+			VK_F9,				/* wAccelKey_F9, */
+			VK_F10,				/* wAccelKey_F10, */
+			VK_F11,				/* wAccelKey_F11, */
+			VK_F12				/* wAccelKey_F12, */
+		};
+
+
+void wAttachAccelKey(
+		wAccelKey_e key,
+		int modifier,
+		wAccelKeyCallBack_p action,
+		void * data )
+{
+	acclTable_t * ad;
+	if ( key < 1 || key > wAccelKey_F12 ) {
+		mswFail( "wAttachAccelKey: key out of range" );
+		return;
+	}
+	DYNARR_APPEND( acclTable_t, acclTable_da, 10 );
+	ad = &acclTable(acclTable_da.cnt-1);
+	ad->acclKey = acclKeyMap[key] | (modifier<<8);
+	ad->key = key;
+	ad->action = action;
+	ad->data = data;
+	ad->mp = NULL;
+}
+
+/*
+ *****************************************************************************
+ *
+ * Menu Item Create
+ *
+ *****************************************************************************
+ */
+
+HBITMAP GetMyCheckBitmaps(UINT fuCheck) 
+{ 
+    COLORREF crBackground;  /* background color */                 
+    HBRUSH hbrBackground;   /* background brush */                 
+    HBRUSH hbrTargetOld;    /* original background brush */
+    HDC hdcSource;          /* source device context */       
+    HDC hdcTarget;          /* target device context */          
+    HBITMAP hbmpCheckboxes; /* handle to check-box bitmap */
+    BITMAP bmCheckbox;      /* structure for bitmap data */      
+    HBITMAP hbmpSourceOld;  /* handle to original source bitmap */
+    HBITMAP hbmpTargetOld;  /* handle to original target bitmap */
+    HBITMAP hbmpCheck;      /* handle to check-mark bitmap */
+    RECT rc;                /* rectangle for check-box bitmap */    
+    WORD wBitmapX;          /* width of check-mark bitmap */       
+    WORD wBitmapY;          /* height of check-mark bitmap */      
+ 
+    /* Get the menu background color and create a solid brush 
+       with that color. */
+ 
+    crBackground = GetSysColor(COLOR_MENU); 
+    hbrBackground = CreateSolidBrush(crBackground); 
+ 
+    /* Create memory device contexts for the source and 
+       destination bitmaps. */
+ 
+    hdcSource = CreateCompatibleDC((HDC) NULL); 
+    hdcTarget = CreateCompatibleDC(hdcSource); 
+ 
+    /* Get the size of the system default check-mark bitmap and 
+       create a compatible bitmap of the same size. */
+ 
+    wBitmapX = GetSystemMetrics(SM_CXMENUCHECK); 
+    wBitmapY = GetSystemMetrics(SM_CYMENUCHECK); 
+ 
+    hbmpCheck = CreateCompatibleBitmap(hdcSource, wBitmapX, 
+        wBitmapY); 
+ 
+    /* Select the background brush and bitmap into the target DC. */
+ 
+    hbrTargetOld = SelectObject(hdcTarget, hbrBackground); 
+    hbmpTargetOld = SelectObject(hdcTarget, hbmpCheck); 
+ 
+    /* Use the selected brush to initialize the background color 
+       of the bitmap in the target device context. */
+ 
+    PatBlt(hdcTarget, 0, 0, wBitmapX, wBitmapY, PATCOPY); 
+ 
+    /* Load the predefined check box bitmaps and select it 
+       into the source DC. */
+ 
+    hbmpCheckboxes = LoadBitmap((HINSTANCE) NULL, 
+        (LPTSTR) OBM_CHECKBOXES); 
+ 
+    hbmpSourceOld = SelectObject(hdcSource, hbmpCheckboxes); 
+ 
+    /* Fill a BITMAP structure with information about the 
+       check box bitmaps, and then find the upper-left corner of 
+       the unchecked check box or the checked check box. */
+ 
+    GetObject(hbmpCheckboxes, sizeof(BITMAP), &bmCheckbox); 
+ 
+	switch( fuCheck ) {
+		
+	case UNCHECK:
+        rc.left = 0; 
+        rc.right = (bmCheckbox.bmWidth / 4); 
+		rc.top = 0; 
+		rc.bottom = (bmCheckbox.bmHeight / 3); 
+		break;  
+	case CHECK:  
+        rc.left = (bmCheckbox.bmWidth / 4); 
+        rc.right = (bmCheckbox.bmWidth / 4) * 2; 
+	    rc.top = 0; 
+	    rc.bottom = (bmCheckbox.bmHeight / 3); 
+		break;
+	case RADIOCHECK:
+        rc.left = (bmCheckbox.bmWidth / 4); 
+        rc.right = (bmCheckbox.bmWidth / 4) * 2; 
+		rc.top = (bmCheckbox.bmHeight / 3) + 1;
+	    rc.bottom = (bmCheckbox.bmHeight / 3) * 2; 
+		break;
+	case RADIOUNCHECK:
+		rc.top = (bmCheckbox.bmHeight / 3) + 1;
+	    rc.bottom = (bmCheckbox.bmHeight / 3) * 2; 
+        rc.left = 0; 
+        rc.right = (bmCheckbox.bmWidth / 4); 
+
+		break;
+	}
+    
+    /* Copy the appropriate bitmap into the target DC. If the 
+       check-box bitmap is larger than the default check-mark 
+       bitmap, use StretchBlt to make it fit; otherwise, just 
+       copy it. */
+ 
+    if (((rc.right - rc.left) > (int) wBitmapX) || 
+            ((rc.bottom - rc.top) > (int) wBitmapY)) 
+    {
+        StretchBlt(hdcTarget, 0, 0, wBitmapX, wBitmapY, 
+            hdcSource, rc.left, rc.top, rc.right - rc.left, 
+            rc.bottom - rc.top, SRCCOPY); 
+    }
+ 
+    else 
+    {
+        BitBlt(hdcTarget, 0, 0, rc.right - rc.left, 
+            rc.bottom - rc.top, 
+            hdcSource, rc.left, rc.top, SRCCOPY); 
+    }
+ 
+    /* Select the old source and destination bitmaps into the 
+       source and destination DCs, and then delete the DCs and 
+       the background brush. */
+ 
+    SelectObject(hdcSource, hbmpSourceOld); 
+    SelectObject(hdcTarget, hbrTargetOld); 
+    hbmpCheck = SelectObject(hdcTarget, hbmpTargetOld); 
+ 
+    DeleteObject(hbrBackground); 
+    DeleteObject(hdcSource); 
+    DeleteObject(hdcTarget); 
+ 
+    /* Return a handle to the new check-mark bitmap. */
+ 
+    return hbmpCheck; 
+} 
+
+void mswCreateCheckBitmaps()
+{
+	checked = GetMyCheckBitmaps( CHECK );
+	unchecked = GetMyCheckBitmaps( UNCHECK );
+	checkedRadio = GetMyCheckBitmaps( RADIOCHECK );
+	uncheckedRadio = GetMyCheckBitmaps( RADIOUNCHECK );
+
+}
+
+wMenuRadio_p wMenuRadioCreate(
+		wMenu_p m, 
+		const char * helpStr,
+		const char * labelStr,
+		long acclKey,
+		wMenuCallBack_p action,
+		void	*data )
+{
+	wMenuRadio_p mi;
+	int rc;
+	char label[80];
+	char *cp;
+	char ac;
+	UINT vk;
+	long modifier;
+
+	mi = (wMenuRadio_p)createMenuItem( m, M_RADIO, helpStr, labelStr, sizeof *mi );
+	mi->action = action;
+	mi->data = data;
+	mi->mparent = m;
+	mi->acclKey = acclKey;
+	mi->enabled = TRUE;
+	strcpy( label, mi->labelStr );
+	modifier = 0;
+	if ( acclKey != 0 ) {
+		DYNARR_APPEND( acclTable_t, acclTable_da, 10 );
+		cp = label + strlen( label );
+		*cp++ = '\t';
+		if (acclKey & WCTL ) {
+			strcpy( cp, "Ctrl+" );
+			cp += 5;
+			modifier |= WKEY_CTRL;
+		}
+		if (acclKey & WALT ) {
+			strcpy( cp, "Alt+" );
+			cp += 4;
+			modifier |= WKEY_ALT;
+		}
+		if (acclKey & WSHIFT ) {
+			strcpy( cp, "Shift+" );
+			cp += 6;
+			modifier |= WKEY_SHIFT;
+		}
+		*cp++ = toupper( (char)(acclKey & 0xFF) );
+		*cp++ = '\0';
+		ac = (char)(acclKey & 0xFF);
+		if (isalpha(ac)) {
+			ac = tolower( ac );
+		}
+		vk = VkKeyScan( ac );
+		if ( vk & 0xFF00 )
+			modifier |= WKEY_SHIFT;
+		acclTable(acclTable_da.cnt-1).acclKey = (modifier<<8) | (vk&0x00FF);
+		acclTable(acclTable_da.cnt-1).mp = (wMenuPush_p)mi;
+	}
+	rc = AppendMenu( m->menu, MF_STRING, mi->index, label );
+
+	/* add the correct bitmaps for radio buttons */
+
+    rc = SetMenuItemBitmaps(m->menu, mi->index, FALSE, uncheckedRadio, checkedRadio ); 
+
+	if( m->radioGroup == NULL ) {
+		m->radioGroup = malloc( sizeof( struct radioButtonGroup ));
+		assert( m->radioGroup );
+		m->radioGroup->firstButton = mi->index;
+	} else {
+		m->radioGroup->lastButton = mi->index;
+	}
+
+	return mi;
+}
+
+void wMenuRadioSetActive(wMenuRadio_p mi )
+{
+	BOOL rc;
+
+	rc = CheckMenuRadioItem( mi->mparent->menu, 
+							 mi->mparent->radioGroup->firstButton, 
+							 mi->mparent->radioGroup->lastButton,
+							 mi->index,
+							 MF_BYCOMMAND );
+} 
+
+
+wMenuPush_p wMenuPushCreate(
+		wMenu_p m, 
+		const char * helpStr,
+		const char * labelStr,
+		long acclKey,
+		wMenuCallBack_p action,
+		void	*data )
+{
+	wMenuPush_p mi;
+	int rc;
+	char label[80];
+	char *cp;
+	char ac;
+	UINT vk;
+	long modifier;
+
+	mi = (wMenuPush_p)createMenuItem( m, M_PUSH, helpStr, labelStr, sizeof *mi );
+	mi->action = action;
+	mi->data = data;
+	mi->mparent = m;
+	mi->acclKey = acclKey;
+	mi->enabled = TRUE;
+	strcpy( label, mi->labelStr );
+	modifier = 0;
+	if ( acclKey != 0 ) {
+		DYNARR_APPEND( acclTable_t, acclTable_da, 10 );
+		cp = label + strlen( label );
+		*cp++ = '\t';
+		if (acclKey & WCTL ) {
+			strcpy( cp, "Ctrl+" );
+			cp += 5;
+			modifier |= WKEY_CTRL;
+		}
+		if (acclKey & WALT ) {
+			strcpy( cp, "Alt+" );
+			cp += 4;
+			modifier |= WKEY_ALT;
+		}
+		if (acclKey & WSHIFT ) {
+			strcpy( cp, "Shift+" );
+			cp += 6;
+			modifier |= WKEY_SHIFT;
+		}
+		*cp++ = toupper( (char)(acclKey & 0xFF) );
+		*cp++ = '\0';
+		ac = (char)(acclKey & 0xFF);
+		if (isalpha(ac)) {
+			ac = tolower( ac );
+		}
+		vk = VkKeyScan( ac );
+		if ( vk & 0xFF00 )
+			modifier |= WKEY_SHIFT;
+		acclTable(acclTable_da.cnt-1).acclKey = (modifier<<8) | (vk&0x00FF);
+		acclTable(acclTable_da.cnt-1).mp = mi;
+	}
+	rc = AppendMenu( m->menu, MF_STRING, mi->index, label );
+	return mi;
+}
+
+
+void wMenuPushEnable(
+		wMenuPush_p mi,
+		BOOL_T enable )
+{
+	EnableMenuItem( mi->mparent->menu, mi->index,
+		MF_BYCOMMAND|(enable?MF_ENABLED:(MF_DISABLED|MF_GRAYED)) );
+	mi->enabled = enable;
+}
+
+
+wMenu_p wMenuMenuCreate(
+		wMenu_p m, 
+		const char * helpStr,
+		const char * labelStr )
+{
+	wMenu_p mm;
+	int rc;
+
+	mm = (wMenu_p)createMenuItem( NULL, M_MENU, NULL, labelStr, sizeof *mm );
+	mm->menu = CreatePopupMenu();
+	mm->mmtype = MM_MENU;
+	/*mm->parent = (wControl_p)m;*/
+	mm->first = mm->last = NULL;
+
+	rc = AppendMenu( m->menu, MF_STRING|MF_ENABLED|MF_POPUP, (UINT)mm->menu, mm->labelStr );
+
+	return mm;
+}
+
+void wMenuSeparatorCreate(
+		wMenu_p m ) 
+{
+	int rc;
+	createMenuItem( m, M_SEPARATOR, NULL, NULL, sizeof *(wMenuItem_p)NULL );
+	rc = AppendMenu( m->menu, MF_SEPARATOR, (UINT)0, NULL );
+}
+
+/*
+ *****************************************************************************
+ *
+ * Menu List
+ *
+ *****************************************************************************
+ */
+
+
+static void appendItem(
+		wMenuListItem_p ml,
+		wMenuListItem_p mi )
+{
+	mi->right = ml->right;
+	ml->right->left = mi;
+	mi->left = ml;
+	ml->right = mi;
+}
+
+
+static void removeItem(
+		wMenuListItem_p mi )
+{
+	mi->left->right = mi->right;
+	mi->right->left = mi->left;
+	mi->right = mi->left = mi;
+}
+
+
+wMenuList_p wMenuListCreate(
+		wMenu_p m, 
+		const char * helpStr,
+		int max,
+		wMenuListCallBack_p action )
+{
+	wMenuList_p mi;
+	mi = (wMenuList_p)createMenuItem( m, M_LIST, helpStr, NULL, sizeof *mi );
+	mi->count = 0;
+	mi->max = max;
+	mi->mlparent = m;
+	mi->action = action;
+	mi->right = mi->left = (wMenuListItem_p)mi;
+	return mi;
+}
+
+
+int getMlistOrigin( wMenu_p m, wMenuList_p ml )
+{
+	wMenuItem_p mi;
+	int count;
+	count = 0;
+	for ( mi = m->first; mi != NULL; mi = mi->mnext ) {
+		switch( mi->mtype ) {
+		case M_SEPARATOR:
+		case M_PUSH:
+		case M_MENU:
+			count++;
+			break;
+		case M_LIST:
+			if (mi == (wMenuItem_p)ml)
+				return count;
+			count += ((wMenuList_p)mi)->count;
+			break;
+		default:
+			mswFail( "getMlistOrigin" );
+		}
+	}
+	return count;
+}
+
+
+void wMenuListAdd(
+		wMenuList_p ml,
+		int index,
+		const char * labelStr,
+		void * data )
+{
+	int origin;
+	wMenuListItem_p wl_p;
+	wMenuListItem_p mi;
+	int count;
+	int rc;
+
+	origin = getMlistOrigin(ml->mlparent, ml);
+	for ( count=0,wl_p=ml->right; wl_p!=(wMenuListItem_p)ml; count++,wl_p=wl_p->right ) {
+		if (wl_p->labelStr != NULL && strcmp( labelStr, wl_p->labelStr ) == 0) {
+			/* move item */
+			if (count != index) {
+				RemoveMenu( ml->mlparent->menu, origin+count, MF_BYPOSITION );
+				removeItem( wl_p );
+				goto add;
+			}
+			((wMenuListItem_p)wl_p)->data = data;
+			return;
+		}
+	}
+	if (ml->max > 0 && ml->count >= ml->max) {
+		RemoveMenu( ml->mlparent->menu, origin+ml->count-1, MF_BYPOSITION );
+		wl_p = ml->left;
+		removeItem( ml->left );
+add:
+		ml->count--;
+		if (wl_p->labelStr )
+			free( CAST_AWAY_CONST wl_p->labelStr );
+		wl_p->labelStr = mswStrdup( labelStr );
+	} else {
+		wl_p = (wMenuListItem_p)createMenuItem( NULL, M_LISTITEM, NULL,
+								labelStr, sizeof *wl_p );
+	}
+	((wMenuListItem_p)wl_p)->data = data;
+	((wMenuListItem_p)wl_p)->action = ml->action;
+	if (index < 0 || index > ml->count)
+		index = ml->count;
+	for ( mi=(wMenuListItem_p)ml,count=0; count<index; mi=mi->right,count++);
+	rc = InsertMenu( ml->mlparent->menu, origin+index,
+					 MF_BYPOSITION|MF_STRING, wl_p->index, wl_p->labelStr );
+	appendItem( mi, wl_p );
+	ml->count++;
+}
+
+
+void wMenuListDelete(
+		wMenuList_p ml,
+		const char * labelStr )
+{
+	int origin, count;
+	wMenuListItem_p wl_p;
+
+	origin = getMlistOrigin(ml->mlparent, ml);
+	for ( count=0,wl_p=ml->right; wl_p!=(wMenuListItem_p)ml; count++,wl_p=wl_p->right ) {
+		if (wl_p->labelStr != NULL && strcmp( labelStr, wl_p->labelStr ) == 0) {
+			/* delete item */
+			mswUnregister( wl_p->index );
+			RemoveMenu( ml->mlparent->menu, origin+count, MF_BYPOSITION );
+			removeItem( wl_p );
+			ml->count--;
+			free( wl_p );
+			return;
+		}
+	}
+}
+
+
+const char * wMenuListGet(
+		wMenuList_p ml,
+		int index,
+		void ** data )
+{
+	int origin, count;
+	wMenuListItem_p wl_p;
+
+	if (index >= ml->count)
+		return NULL;
+	origin = getMlistOrigin(ml->mlparent, ml);
+	for ( count=0,wl_p=ml->right; wl_p&&count<index; count++,wl_p=wl_p->right );
+	if (wl_p==NULL)
+		return NULL;
+	if ( data )
+		*data = wl_p->data;
+	return wl_p->labelStr;
+}
+
+
+void wMenuListClear(
+		wMenuList_p ml )
+{
+	int origin, count;
+	wMenuListItem_p wl_p, wl_q;
+
+	origin = getMlistOrigin(ml->mlparent, ml);
+	for ( count=0,wl_p=ml->right; count<ml->count; count++,wl_p=wl_q ) {
+		/* delete item */
+		mswUnregister( wl_p->index );
+		RemoveMenu( ml->mlparent->menu, origin, MF_BYPOSITION );
+		wl_q = wl_p->right;
+		free( wl_p );
+	}
+	ml->count = 0;
+	ml->right = ml->left = (wMenuListItem_p)ml;
+}
+
+
+
+wMenuToggle_p wMenuToggleCreate(
+		wMenu_p m, 
+		const char * helpStr,
+		const char * labelStr,
+		long acclKey,
+		wBool_t set,
+		wMenuToggleCallBack_p action,
+		void * data )
+{
+	wMenuToggle_p mt;
+	int rc;
+
+	mt = (wMenuToggle_p)createMenuItem( m, M_TOGGLE, helpStr, labelStr, sizeof *mt );
+	/*setAcclKey( m->parent, m->menu, mt->menu_item, acclKey );*/
+	mt->action = action;
+	mt->data = data;
+	mt->mparent = m;
+	mt->enabled = TRUE;
+	mt->parentMenu = m;
+	rc = AppendMenu( m->menu, MF_STRING, mt->index, labelStr );
+	wMenuToggleSet( mt, set );
+	return mt;
+}
+
+
+wBool_t wMenuToggleGet(
+		wMenuToggle_p mt )
+{
+	return (GetMenuState( mt->mparent->menu, mt->index, MF_BYCOMMAND ) & MF_CHECKED) != 0;
+}
+
+
+wBool_t wMenuToggleSet(
+		wMenuToggle_p mt,
+		wBool_t set )
+{
+	wBool_t rc;
+	CheckMenuItem( mt->mparent->menu, mt->index, MF_BYCOMMAND|(set?MF_CHECKED:MF_UNCHECKED) );
+	rc = (GetMenuState( mt->mparent->menu, mt->index, MF_BYCOMMAND ) & MF_CHECKED) != 0;
+	return rc;
+}
+
+void wMenuToggleEnable(
+		wMenuToggle_p mt,
+		wBool_t enable )
+{
+	EnableMenuItem( mt->mparent->menu, mt->index,
+		MF_BYCOMMAND|(enable?MF_ENABLED:(MF_DISABLED|MF_GRAYED)) );
+	mt->enabled = enable;
+}	  
+
+/*
+ *****************************************************************************
+ *
+ * Menu Create
+ *
+ *****************************************************************************
+ */
+
+
+void mswMenuMove(
+		wMenu_p m,
+		wPos_t x,
+		wPos_t y )
+{
+	wControl_p b;
+	b = (wControl_p)m->parent;
+	if (b && b->hWnd)
+		if (!SetWindowPos( b->hWnd, HWND_TOP, x, y,
+				CW_USEDEFAULT, CW_USEDEFAULT,
+				SWP_NOSIZE|SWP_NOZORDER))
+				mswFail("mswMenuMove");
+}
+
+
+static void pushMenuButt(
+		void * data )
+{
+	wMenu_p m = (wMenu_p)data;
+	RECT rect;
+	mswAllowBalloonHelp = FALSE;
+	GetWindowRect( m->hWnd, &rect );
+	TrackPopupMenu( m->menu, TPM_LEFTALIGN, rect.left, rect.bottom,
+						0, ((wControl_p)(m->parent))->hWnd, NULL );
+}
+
+
+wMenu_p wMenuCreate(
+		wWin_p	parent,
+		POS_T	x,
+		POS_T	y,
+		const char	* helpStr,
+		const char	* labelStr,
+		long	option )
+{
+	wMenu_p m;
+	wControl_p b;
+	long buttOption = 0;
+	const char * label = labelStr;
+
+	if (option & BM_ICON) {
+		buttOption = BO_ICON;
+		label = "ICON";
+	}
+	m = (wMenu_p)createMenuItem( NULL, M_MENU, helpStr, label, sizeof *m );
+	m->button = wButtonCreate( parent, x, y, helpStr, labelStr,
+						buttOption, 0, pushMenuButt, (void*)m );
+	b = (wControl_p)m->button;
+	m->parent = b->parent;
+	m->x = b->x;
+	m->y = b->y;
+	m->w = b->w;
+	m->h = b->h;
+	m->hWnd = b->hWnd;
+	m->helpStr = b->helpStr;
+
+	m->menu = CreatePopupMenu();
+	m->mmtype = MM_BUTT;
+	m->first = m->last = NULL;
+
+	return m;
+}
+
+
+wMenu_p wMenuBarAdd(
+		wWin_p w,
+		const char * helpStr,
+		const char * labelStr )
+{
+	HMENU menu;
+	wMenu_p m;
+	int rc;
+
+	menu = GetMenu( ((wControl_p)w)->hWnd );
+	if (menu == (HMENU)0) {
+		menu = CreateMenu();
+		SetMenu( ((wControl_p)w)->hWnd, menu );
+	}
+
+	m = (wMenu_p)createMenuItem( NULL, M_MENU, helpStr, labelStr, sizeof *m );
+	m->menu = CreateMenu();
+	m->parent = w;
+	m->mmtype = MM_BAR;
+	m->first = m->last = NULL;
+
+	rc = AppendMenu( menu, MF_STRING|MF_POPUP|MF_ENABLED, (UINT)m->menu, labelStr );
+
+	DrawMenuBar( ((wControl_p)w)->hWnd );
+	return m;
+}
+
+
+
+wMenu_p wMenuPopupCreate(
+		wWin_p w,
+		const char * labelStr )
+{
+	wMenu_p m;
+	long buttOption = 0;
+	const char * label = labelStr;
+
+	m = (wMenu_p)createMenuItem( NULL, M_MENU, NULL, label, sizeof *m );
+	m->button = NULL;
+	m->parent = w;
+	m->x = 0;
+	m->y = 0;
+	m->w = 0;
+	m->h = 0;
+	m->hWnd = ((wControl_p)w)->hWnd;
+	m->helpStr = NULL;
+
+	m->menu = CreatePopupMenu();
+	m->mmtype = MM_POPUP;
+	m->first = m->last = NULL;
+
+	return m;
+}
+
+
+void wMenuPopupShow( wMenu_p mp )
+{
+	POINT pt;
+	GetCursorPos( &pt );
+	TrackPopupMenu( mp->menu, TPM_LEFTALIGN, pt.x, pt.y, 0, mp->hWnd, NULL );
+}
+		
+/*-----------------------------------------------------------------*/
+
+void wMenuSetTraceCallBack(
+		wMenu_p m,
+		wMenuTraceCallBack_p func,
+		void * data )
+{
+	m->traceFunc = func;
+	m->traceData = data;
+}
+
+wBool_t wMenuAction(
+		wMenu_p m,
+		const char * label )
+{
+	wMenuItem_p mi;
+	wMenuToggle_p mt;
+	wBool_t set;
+	for ( mi = m->first; mi != NULL; mi = (wMenuItem_p)mi->mnext ) {
+		if ( mi->labelStr != NULL && strcmp( mi->labelStr, label ) == 0 ) {
+			switch( mi->mtype ) {
+			case M_SEPARATOR:
+				break;
+			case M_PUSH:
+				if ( ((wMenuPush_p)mi)->enabled == FALSE )
+					wBeep();
+				else
+					((wMenuPush_p)mi)->action( ((wMenuPush_p)mi)->data );
+				break;
+			case M_TOGGLE:
+				mt = (wMenuToggle_p)mi;
+				if ( mt->enabled == FALSE ) {
+					wBeep();
+				} else {
+					set = wMenuToggleGet( mt );
+					wMenuToggleSet( mt, !set );
+					mt->action( set, mt->data );
+				}
+				break;
+			case M_MENU:
+				break;
+			case M_LIST:
+				break;
+			default:
+				fprintf(stderr, "Oops: wMenuAction\n");
+			}
+			return TRUE;
+		}
+	}
+	return FALSE;
+}
diff --git a/app/wlib/mswlib/mswmisc.c b/app/wlib/mswlib/mswmisc.c
new file mode 100644
index 0000000..fc1dbe6
--- /dev/null
+++ b/app/wlib/mswlib/mswmisc.c
@@ -0,0 +1,2778 @@
+/** \file mswmisc.c
+ * Basic windows functions and main entry point for application.
+ *
+ * $Header: /home/dmarkle/xtrkcad-fork-cvs/xtrkcad/app/wlib/mswlib/mswmisc.c,v 1.28 2010-04-28 04:04:38 dspagnol Exp $
+ */
+
+/*  XTrkCad - Model Railroad CAD
+ *  Copyright (C) 2005 Dave Bullis, 2009 Martin Fischer
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#define _WIN32_WINNT 0x0500
+#include <windows.h>
+#include <string.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <commdlg.h>
+#include <math.h>
+#include <stdio.h>
+#include <assert.h>
+#include <htmlhelp.h>
+#include "mswint.h"
+#include "i18n.h"
+
+#if _MSC_VER > 1300
+	#define stricmp _stricmp
+	#define strnicmp _strnicmp
+	#define strdup _strdup
+#endif
+
+#define OFN_LONGFILENAMES		0x00200000L
+
+char * mswStrdup( const char * );
+
+#define PAUSE_TIMER		(901)
+#define ALARM_TIMER		(902)
+#define BALLOONHELP_TIMER		(903)
+#define TRIGGER_TIMER	(904)
+
+#define WANT_LITTLE_LABEL_FONT
+
+#ifndef WANT_LITTLE_LABEL_FONT
+#define LABELFONTDECL
+#define LABELFONTSELECT
+#define LABELFONTRESET
+#else
+#define LABELFONTDECL	HFONT hFont;
+#define LABELFONTRESET	if (!mswThickFont) {SelectObject( hDc, hFont );}
+#define LABELFONTSELECT if (!mswThickFont) {hFont = SelectObject( hDc, mswLabelFont );}
+#endif
+
+/*
+ * EXPORTED VARIABLES
+ */
+
+long debugWindow = 0;
+HINSTANCE mswHInst;
+HWND mswHWnd = (HWND)0;
+
+const char *mswDrawWindowClassName = "DRAWWINDOW";
+char mswTmpBuff[1024];
+int mswEditHeight;
+int mswAllowBalloonHelp = TRUE;
+int mswGroupStyle;
+HFONT mswOldTextFont;
+HFONT mswLabelFont;
+long mswThickFont = 1;
+double mswScale = 1.0;
+
+callBacks_t *mswCallBacks[CALLBACK_CNT];
+
+void closeBalloonHelp( void );
+static wControl_p getControlFromCursor( HWND, wWin_p * );
+/*
+ * LOCAL VARIABLES
+ */
+
+struct wWin_t {
+		WOBJ_COMMON
+		wPos_t lastX, lastY;
+		wPos_t padX, padY;
+		wControl_p first, last;
+		wWinCallBack_p winProc;
+		BOOL_T busy;
+#ifdef OWNERICON
+		HBITMAP wicon_bm;
+		wPos_t wicon_w, wicon_h;
+#endif
+		DWORD baseStyle;
+		wControl_p focusChainFirst;
+		wControl_p focusChainLast;
+		char * nameStr;
+		wBool_t centerWin;
+		DWORD style;
+		int isBusy;
+		int pendingShow;
+		int modalLevel;
+		};
+
+static needToDoPendingShow = FALSE;
+
+/* System metrics: */
+static int mTitleH;
+static int mFixBorderW;
+static int mFixBorderH;
+static int mResizeBorderW;
+static int mResizeBorderH;
+static int mMenuH;
+static int screenWidth = 0, screenHeight = 0;
+
+wWin_p mswWin = NULL;
+wWin_p winFirst, winLast;
+
+static long count51 = 0;
+
+static UINT alarmTimer;
+static UINT pauseTimer;
+static UINT balloonHelpTimer = (UINT)0;
+static UINT triggerTimer;
+
+static UINT balloonHelpTimeOut = 500;
+static wControl_p balloonHelpButton = NULL;
+static enum { balloonHelpIdle , balloonHelpWait, balloonHelpShow } balloonHelpState = balloonHelpIdle;
+static HWND balloonHelpHWnd = (HWND)0;
+static int balloonHelpFontSize = 8;
+static char balloonHelpFaceName[] = "MS Sans Serif";
+static HFONT balloonHelpOldFont;
+static HFONT balloonHelpNewFont;
+static int balloonHelpEnable = TRUE;			 
+static wControl_p balloonControlButton = NULL;
+
+static BOOL_T helpInitted = FALSE;
+static DWORD dwCookie;
+
+#define CONTROL_BASE (1)
+typedef struct {
+		wControl_p b;
+		} controlMap_t;
+dynArr_t controlMap_da;
+#define controlMap(N) DYNARR_N(controlMap_t,controlMap_da,N)
+
+
+static char * appName;
+static char * helpFile;
+char *mswProfileFile;
+
+static wBalloonHelp_t * balloonHelpStrings;
+
+static wCursor_t curCursor = wCursorNormal;
+
+#ifdef HELPSTR
+static FILE * helpStrF;
+#endif
+static int inMainWndProc = FALSE;
+
+int newHelp = 1;
+
+static wBool_t mswWinBlockEnabled = TRUE;
+
+static FILE * dumpControlsF;
+static int dumpControls;
+
+extern char *userLocale;
+
+
+/*
+ *****************************************************************************
+ *
+ * Internal Utility functions
+ *
+ *****************************************************************************
+ */
+
+
+DWORD GetTextExtent(
+		HDC hDc,
+		CHAR * str,
+		UINT len )
+{
+		SIZE size;
+		GetTextExtentPoint( hDc, str, len, &size );
+		return size.cx + (size.cy<<16);
+}
+
+
+static char * controlNames[] = {
+		"MAIN", "POPUP",
+		"BUTTON", "STRING", "INTEGER", "FLOAT",
+		"LIST", "DROPLIST", "COMBOLIST",
+		"RADIO", "TOGGLE",
+		"DRAW", "TEXT", "MESSAGE", "LINES",
+		"MENUITEM", "CHOICEITEM", "BOX" };
+
+static void doDumpControls(void)
+{
+	wControl_p b;
+	int inx;
+	if ( !dumpControls )
+		return;
+	if ( !dumpControlsF ) {
+		dumpControlsF = fopen( "controls.lst", "w" );
+		if ( !dumpControlsF )
+			abort();
+	}
+	for ( inx=0; inx<controlMap_da.cnt-1; inx++ ) {
+		b = controlMap(inx).b;
+		if ( b ) {
+			fprintf( dumpControlsF, "[%0.3d] [%x] %s %s %s\n", inx,
+				b->hWnd,
+				(b->type>=0&&b->type<=B_BOX?controlNames[b->type]:"NOTYPE"),
+				(b->labelStr?b->labelStr:"<NULL>"),
+				(b->helpStr?b->helpStr:"<NULL>") );
+		} else {
+			fprintf( dumpControlsF, "[%0.3d] <NULL>\n", inx );
+		}
+	}
+	fflush( dumpControlsF );
+	fclose( dumpControlsF );
+	dumpControls = 0;
+}
+
+void mswFail( const char * where )
+{
+	sprintf( mswTmpBuff, "%s\n# Controls %d", where, controlMap_da.cnt );
+	MessageBox( NULL, mswTmpBuff, "FAIL", MB_TASKMODAL|MB_OK );
+	doDumpControls();
+}
+/*
+static UINT curSysRes = 100;
+static UINT curGdiRes = 100;
+static UINT curUsrRes = 100;
+static UINT curMinRes = 100;
+*/
+
+wControl_p mswMapIndex( INDEX_T inx )
+{
+	if (inx < CONTROL_BASE || inx > controlMap_da.cnt) {
+		mswFail("mswMapIndex- bad index");
+		exit(1);
+	}
+	return controlMap(inx-CONTROL_BASE).b;
+}
+
+
+void mswRepaintLabel( HWND hWnd, wControl_p b )
+{
+	HDC hDc;
+	HBRUSH oldBrush, newBrush;
+	RECT rect;
+	DWORD dw;
+	LABELFONTDECL
+
+				
+	if (b->labelStr) {
+		hDc = GetDC( hWnd );
+		LABELFONTSELECT
+		newBrush = CreateSolidBrush( GetSysColor( COLOR_BTNFACE ) );
+		oldBrush = SelectObject( hDc, newBrush );
+	dw = GetTextExtent( hDc, CAST_AWAY_CONST b->labelStr, strlen(b->labelStr) );
+		rect.left = b->labelX;
+		rect.top = b->labelY;
+		rect.right = b->labelX + LOWORD(dw);
+		rect.bottom = b->labelY + HIWORD(dw);
+		FillRect( hDc, &rect, newBrush );
+		DeleteObject( SelectObject( hDc, oldBrush ) );
+		/*SetBkMode( hDc, OPAQUE );*/
+		SetBkColor( hDc, GetSysColor( COLOR_BTNFACE ) );
+		if (!TextOut( hDc, b->labelX, b->labelY, b->labelStr, strlen(b->labelStr) ) )
+			mswFail( "Repainting text label" );
+		LABELFONTRESET
+		ReleaseDC( hWnd, hDc );
+	}
+}
+
+
+
+int mswRegister(
+		wControl_p w )
+{
+	int index;
+	DYNARR_APPEND( controlMap_t, controlMap_da, 25 );
+	index = controlMap_da.cnt-1+CONTROL_BASE;
+	controlMap(controlMap_da.cnt-1).b = (wControl_p)w;
+	return index;
+}
+
+
+void mswUnregister(
+		int index )
+{
+	if (index < 0 || index > controlMap_da.cnt) {
+		mswFail("mswMapIndex- bad index");
+		exit(1);
+	}
+	controlMap(index-CONTROL_BASE).b = NULL;
+}
+
+void * mswAlloc(
+		wWin_p parent,
+		wType_e type,
+		const char * labelStr,
+		int size,
+		void * data,
+		int * index )
+{
+	wControl_p w = (wControl_p)calloc( 1, size );
+
+	if (w == NULL)
+		abort();
+	*index = mswRegister( w );
+	w->type = type;
+	w->next = NULL;
+	w->parent = parent;
+	w->x = 0;
+	w->y = 0;
+	w->w = 0;
+	w->h = 0;
+	w->option = 0;
+	w->labelX = w->labelY = 0;
+	w->labelStr = labelStr;
+	w->helpStr = NULL;
+	w->hWnd = (HWND)0;
+	w->data = data;
+	w->focusChainNext = NULL;
+	w->shown = TRUE;
+	return w;
+}
+
+
+void mswComputePos(
+		wControl_p b,
+		wPos_t origX,
+		wPos_t origY )
+{
+	wWin_p w = b->parent;
+
+	if (origX >= 0) 
+		b->x = origX;
+	else
+		b->x = w->lastX + (-origX) - 1;
+	if (origY >= 0) 
+		b->y = origY;
+	else
+		b->y = w->lastY + (-origY) - 1;
+
+	b->labelX = b->x;
+	b->labelY = b->y+2;
+
+	if (b->labelStr) {
+		int lab_l;
+		HDC hDc;
+		DWORD dw;
+		LABELFONTDECL
+
+		hDc = GetDC( w->hWnd );
+		LABELFONTSELECT
+		lab_l = strlen(b->labelStr);
+		dw = GetTextExtent( hDc, CAST_AWAY_CONST b->labelStr, lab_l );
+		b->labelX -= LOWORD(dw) + 5;
+		LABELFONTRESET
+		ReleaseDC( w->hWnd, hDc );
+	}
+}
+
+void mswAddButton(
+		wControl_p b,
+		BOOL_T paintLabel,
+		const char * helpStr )
+{
+	wWin_p w = b->parent;
+	BOOL_T resize = FALSE;
+	RECT rect;
+
+	if (w->first == NULL) {
+		w->first = b;
+	} else {
+		w->last->next = b;
+	}
+	w->last = b;
+	b->next = NULL;
+	b->parent = w;
+	w->lastX = b->x + b->w;
+	w->lastY = b->y + b->h;
+	if ((w->option&F_AUTOSIZE)!=0 && w->lastX > w->w) {
+		w->w = w->lastX;
+		resize = TRUE;
+	}
+	if ((w->option&F_AUTOSIZE)!=0 && w->lastY > w->h) {
+		w->h = w->lastY;
+		resize = TRUE;
+	}
+
+	if (resize) {
+		w->busy = TRUE;
+		rect.left = 0;
+		rect.top = 0;
+		rect.right = w->w+w->padX;
+		rect.bottom = w->h+w->padY;
+		AdjustWindowRect( &rect, w->style, (w->option&F_MENUBAR)?1:0 );
+		rect.bottom += mFixBorderH;
+		if (!SetWindowPos( w->hWnd, HWND_TOP, CW_USEDEFAULT, CW_USEDEFAULT,
+			rect.right-rect.left, rect.bottom-rect.top,
+			SWP_NOMOVE))
+			mswFail("SetWindowPos");
+		w->busy = FALSE;
+	}
+
+	if (paintLabel)
+		mswRepaintLabel( w->hWnd, (wControl_p)b );
+
+	if (helpStr == NULL)
+		return;
+	b->helpStr = mswStrdup( helpStr );
+	
+#ifdef HELPSTR
+	if (helpStrF)
+		fprintf( helpStrF, "HELPSTR - %s\n", helpStr?helpStr:"<>" );
+#endif
+}
+
+
+void mswResize(
+		wWin_p w )
+{
+	wControl_p b;
+	RECT rect;
+
+	w->lastX = 0;
+	w->lastY = 0;
+	for (b=w->first; b; b=b->next) {
+		if (w->lastX < (b->x + b->w))
+			w->lastX = b->x + b->w;
+		if (w->lastY < (b->y + b->h))
+			w->lastY = b->y + b->h;
+	}
+
+	if (w->option&F_AUTOSIZE) {
+		w->w = w->lastX;
+		w->h = w->lastY;
+		w->busy = TRUE;
+		rect.left = 0;
+		rect.top = 0;
+		rect.right = w->w + w->padX;
+		rect.bottom = w->h + w->padY;
+		AdjustWindowRect( &rect, w->style, (w->option&F_MENUBAR)?1:0 );
+		rect.bottom += mFixBorderH;
+		if (!SetWindowPos( w->hWnd, HWND_TOP, CW_USEDEFAULT, CW_USEDEFAULT,
+			rect.right-rect.left, rect.bottom-rect.top,
+			SWP_NOMOVE|SWP_NOZORDER))
+			mswFail("SetWindowPos");
+		w->busy = FALSE;
+	}
+}
+
+
+
+void mswChainFocus(
+		wControl_p b )
+{
+	wWin_p w;
+	w = b->parent;
+	if (w->option&F_NOTAB)
+		return;
+	if (b->option&BO_NOTAB)
+		return;
+	if (w->focusChainFirst == NULL) {
+		w->focusChainFirst = w->focusChainLast = w->focusChainNext = b;
+		b->focusChainNext = b;
+	} else {
+		w->focusChainLast->focusChainNext = b;
+		w->focusChainLast = b;
+		b->focusChainNext = w->focusChainFirst;
+	}
+}
+
+void mswSetFocus(
+		wControl_p b )
+{
+	if (b && b->type != B_MENUITEM && b->focusChainNext) 
+		b->parent->focusChainNext = b;
+}
+
+/*
+ ******************************************************************************
+ *
+ * Main and Popup Windows
+ *
+ ******************************************************************************
+ */
+
+static void getSavedSizeAndPos(
+		long option,
+		const char * nameStr,
+		wPos_t *rw,
+		wPos_t *rh,
+		wPos_t *rx,
+		wPos_t *ry,
+		int *showCmd )
+{
+	int x, y, w, h;
+	const char *cp;
+    char *cq;
+	int state;
+
+	*showCmd = SW_SHOWNORMAL;
+
+	if ( (option&F_RECALLPOS) && nameStr ) {
+			if ( (option & F_RESIZE) &&
+				 (cp = wPrefGetString( "msw window size", nameStr)) &&
+				 (state = (int)strtol( cp, &cq, 10 ), cp != cq) &&
+				 (cp = cq, w = (wPos_t)strtod( cp, &cq ), cp != cq ) &&
+				 (cp = cq, h = (int)strtod( cp, &cq ), cp != cq)
+				) {
+				if (state == 1)
+					*showCmd = SW_SHOWMINIMIZED;
+				else if (state == 2)
+					*showCmd = SW_SHOWMAXIMIZED;
+				if (w < 10)
+					w = 10;
+				if (h < 10)
+					h = 10;
+				if (w > screenWidth)
+					w = screenWidth;
+				if (h > screenHeight)
+					h = screenHeight;
+				*rw = w;
+				*rh = h;
+			}
+
+			if ((cp = wPrefGetString( "msw window pos", nameStr)) &&
+				(x = (wPos_t)strtod( cp, &cq ), cp != cq) &&
+				(cp = cq, y = (wPos_t)strtod( cp, &cq ), cp != cq)
+				) {
+				if (y < 0)
+					y = 0;
+				if (x < 0)
+					x = 0;
+				if ( y > screenHeight-40 )
+					y = screenHeight-40;
+				if ( x > screenWidth-40 )
+					x = screenWidth-40;
+				*rx = x;
+				*ry = y;
+			}
+	}
+}
+
+
+static wWin_p winCommonCreate(
+		HWND hWnd,
+		int typ,
+		long option,
+		const char * className,
+		long style,
+		const char * labelStr,
+		wWinCallBack_p winProc,
+		wPos_t w,
+		wPos_t h,
+		void * data,
+		const char * nameStr,
+		int * showCmd )
+{
+	wWin_p win;
+	int index;
+	wPos_t ww, hh, xx, yy;
+	RECT rect;
+
+	win = (wWin_p)mswAlloc( NULL, typ, mswStrdup(labelStr), sizeof *win, data, &index );
+	win->option = option;
+	win->first = win->last = NULL;
+	win->lastX = 0;
+	win->lastY = 0;
+	win->winProc = winProc;
+	win->centerWin = TRUE;
+	win->modalLevel = 0;
+#ifdef OWNERICON
+	win->wicon_bm = (HBITMAP)0;
+#endif
+	win->busy = TRUE;
+	ww = hh = xx = yy = CW_USEDEFAULT;
+	getSavedSizeAndPos( option, nameStr, &ww, &hh, &xx, &yy, showCmd );
+	if (xx != CW_USEDEFAULT)
+		win->centerWin = FALSE;
+	if (option & F_RESIZE) {
+		style |= WS_THICKFRAME;
+		if ( ww != CW_USEDEFAULT ) {
+			w = ww;
+			h = hh;
+			option &= ~F_AUTOSIZE;
+			win->option = option;
+		}
+	}
+
+	if ( option & F_AUTOSIZE ) {
+		win->padX = w;
+		win->padY = h;
+	} else {
+		win->padX = 0;
+		win->padY = 0;
+		win->w = w;
+		win->h = h;
+	}
+	win->style = style;
+	rect.left = 0;
+	rect.top = 0;
+	rect.right = win->w + win->padX;
+	rect.bottom = win->h + win->padY;
+	AdjustWindowRect( &rect, win->style, (win->option&F_MENUBAR)?1:0 );
+	rect.bottom += mFixBorderH;
+	win->hWnd = CreateWindow( className, labelStr, style,
+				xx, yy,
+				rect.right-rect.left, rect.bottom-rect.top,
+				hWnd, NULL,
+				mswHInst, NULL );
+	if (win->hWnd == (HWND)0) {
+		mswFail( "CreateWindow(POPUP)" );
+	} else {
+		SetWindowWord( win->hWnd, 0, (WORD)index );
+	}
+	win->baseStyle = WS_GROUP;
+	win->focusChainFirst = win->focusChainLast = win->focusChainNext = NULL;
+	if (winFirst == NULL) {
+		winFirst = winLast = win;
+	} else {
+		winLast->next = (wControl_p)win;
+		winLast = win;
+	}
+#ifdef HELPSTR
+	if (helpStrF)
+		fprintf( helpStrF, "WINDOW - %s\n", labelStr );
+#endif
+	win->nameStr = mswStrdup( nameStr );
+	if (typ == W_MAIN)
+		mswInitColorPalette();
+#ifdef LATER
+	hDc = GetDC( win->hWnd );
+	oldHPal = SelectPalette( hDc, mswPalette, 0 );
+	ReleaseDC( win->hWnd, hDc );
+#endif
+	return win;
+}
+
+void wInitAppName(char *_appName)
+{
+	appName = (char *)malloc( strlen(_appName) + 1 );
+	strcpy(appName, _appName);
+}
+
+
+/**
+ * Initialize the application's main window. This function does the necessary initialization 
+ * of the application including creation of the main window.
+ *
+ * \param name IN internal name of the application. Used for filenames etc. 
+ * \param x    IN size 
+ * \param y    IN size 
+ * \param helpStr IN ??
+ * \param labelStr IN window title
+ * \param nameStr IN ??
+ * \param option IN options for window creation
+ * \param winProc IN pointer to main window procedure
+ * \param data IN ??
+ * \return    window handle or NULL on error
+ */
+
+wWin_p wWinMainCreate(
+		const char * name,
+		POS_T x,
+		POS_T y,
+		const char * helpStr,
+		const char * labelStr,
+		const char * nameStr,
+		long option,
+		wWinCallBack_p winProc,
+		void * data )
+{
+	wWin_p w;
+	RECT rect;
+	const char * appDir;
+	const char * libDir;
+	int showCmd;
+	int error;
+	HDC hDc;
+	TEXTMETRIC tm;
+	char *pos;
+	char * configName;
+
+	/* check for configuration name */
+	if( pos = strchr( name, ';' )) {
+		/* if found, split application name and configuration name */
+		configName = (char *)malloc( strlen( name ) + 1 );
+		strcpy( configName, pos + 1 );
+	} else {
+		/* if not found, application name and configuration name are same */
+		configName  = (char*)malloc( strlen(name)+1 );
+		strcpy( configName, name );
+	}
+
+	appDir = wGetAppWorkDir();
+	if ( appDir == NULL ) {
+		free( configName );
+		return NULL;
+	}
+	mswProfileFile = (char*)malloc( strlen(appDir)+1+strlen(configName)+1+3+1 );
+	wsprintf( mswProfileFile, "%s\\%s.ini", appDir, configName );
+	free( configName );
+
+	error = WritePrivateProfileString( "mswtest", "test", "ok", mswProfileFile );
+	if ( error <= 0 ) {
+		sprintf( mswTmpBuff, "Can not write to %s.\nPlease make sure the directory exists and is writable", mswProfileFile );
+		wNoticeEx( NT_ERROR, mswTmpBuff, "Ok", NULL );
+		return NULL;
+	}
+	libDir = wGetAppLibDir();
+	/* length of path + \ + length of filename + . + length of extension + \0 */
+	helpFile = (char*)malloc( strlen(libDir) + 1 + strlen(appName) + 1 + 3 + 1 );
+	wsprintf( helpFile, "%s\\%s.chm", libDir, appName );
+
+	wPrefGetInteger( "msw tweak", "ThickFont", &mswThickFont, 0 );
+
+	showCmd = SW_SHOW;
+	w = winCommonCreate( NULL, W_MAIN, option|F_RESIZE, "MswMainWindow", 
+						WS_OVERLAPPEDWINDOW, labelStr, winProc, x, y, data,
+						nameStr, &showCmd );
+	mswHWnd = w->hWnd;
+	if ( !mswThickFont ) {
+		DWORD dw;
+		SendMessage( w->hWnd, WM_SETFONT, (WPARAM)mswLabelFont, 0L );
+		hDc = GetDC( w->hWnd );
+		GetTextMetrics( hDc, &tm );
+		mswEditHeight = tm.tmHeight+2;
+		dw = GetTextExtent( hDc, "AXqypj", 6 );
+		mswEditHeight = HIWORD(dw)+2;
+		ReleaseDC( w->hWnd, hDc );
+	}
+	ShowWindow( w->hWnd, showCmd );
+	UpdateWindow( w->hWnd );
+	GetWindowRect( w->hWnd, &rect );
+	GetClientRect( w->hWnd, &rect );
+	w->busy = FALSE;
+
+
+	return w;
+}
+
+wWin_p wWinPopupCreate(
+		wWin_p parent,
+		POS_T x,
+		POS_T y,
+		const char * helpStr,
+		const char * labelStr,
+		const char * nameStr,
+		long option,
+		wWinCallBack_p winProc,
+		void * data )
+{
+	wWin_p w;
+	DWORD style;
+	HMENU sysMenu;
+	int showCmd;
+	static DWORD overlapped = WS_OVERLAPPED;
+	static DWORD popup = WS_POPUP;
+
+	style = popup;
+	style |= WS_BORDER | WS_CAPTION | WS_SYSMENU;
+	w = winCommonCreate( parent?parent->hWnd:mswHWnd, W_POPUP, option,
+						  "MswPopUpWindow",
+						  style, labelStr, winProc, x, y, data, nameStr, &showCmd );
+
+	w->helpStr = mswStrdup( helpStr );
+
+	sysMenu = GetSystemMenu( w->hWnd, FALSE );
+	if (sysMenu) {
+		DeleteMenu( sysMenu, SC_RESTORE, MF_BYCOMMAND );
+		/*DeleteMenu( sysMenu, SC_MOVE, MF_BYCOMMAND );*/
+		/*DeleteMenu( sysMenu, SC_SIZE, MF_BYCOMMAND );*/
+		DeleteMenu( sysMenu, SC_MINIMIZE, MF_BYCOMMAND );
+		DeleteMenu( sysMenu, SC_MAXIMIZE, MF_BYCOMMAND );
+		DeleteMenu( sysMenu, SC_TASKLIST, MF_BYCOMMAND );
+		DeleteMenu( sysMenu, 4, MF_BYPOSITION );
+	}
+	w->busy = FALSE;
+	return w;
+}
+
+void wWinSetBigIcon(
+		wWin_p win,
+		wIcon_p bm )
+{
+#ifdef OWNERICON
+	win->wicon_w = bm->w;
+	win->wicon_h = bm->h;
+	win->wicon_bm = mswCreateBitMap(
+		GetSysColor(COLOR_BTNTEXT), RGB( 255, 255, 255 ), RGB( 255, 255, 255 ),
+		bm->w, bm->h, bm->bits );
+#endif
+}
+
+
+void wWinSetSmallIcon(
+		wWin_p win,
+		wIcon_p bm )
+{
+#ifdef OWNERICON
+	win->wicon_w = bm->w;
+	win->wicon_h = bm->h;
+	win->wicon_bm = mswCreateBitMap(
+		GetSysColor(COLOR_BTNTEXT), RGB( 255, 255, 255 ), RGB( 255, 255, 255 ),
+		bm->w, bm->h, bm->bits );
+#endif
+}
+
+
+void wWinTop(
+		wWin_p win )
+{
+	/*BringWindowToTop( win->hWnd );*/
+	SetWindowPos( win->hWnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE );
+	SetFocus( win->hWnd );
+}
+
+
+DWORD mswGetBaseStyle( wWin_p win )
+{
+	DWORD style;
+	style = win->baseStyle;
+	win->baseStyle = 0;
+	return style;
+}
+
+
+static wAccelKey_e translateExtKey( UINT wParam )
+{
+	wAccelKey_e extChar;
+		extChar = wAccelKey_None;
+		switch( wParam ) {
+		case VK_DELETE: extChar = wAccelKey_Del; break;
+		case VK_INSERT: extChar = wAccelKey_Ins; break;
+		case VK_HOME:	extChar = wAccelKey_Home; break;
+		case VK_END:	extChar = wAccelKey_End; break;
+		case VK_PRIOR:	extChar = wAccelKey_Pgup; break;
+		case VK_NEXT:	extChar = wAccelKey_Pgdn; break;
+		case VK_UP:		extChar = wAccelKey_Up; break;
+		case VK_DOWN:	extChar = wAccelKey_Down; break;
+		case VK_RIGHT:	extChar = wAccelKey_Right; break;
+		case VK_LEFT:	extChar = wAccelKey_Left; break;
+		case VK_BACK:	extChar = wAccelKey_Back; break;
+		/*case VK_F1:	extChar = wAccelKey_F1; break;*/
+		case VK_F2:		extChar = wAccelKey_F2; break;
+		case VK_F3:		extChar = wAccelKey_F3; break;
+		case VK_F4:		extChar = wAccelKey_F4; break;
+		case VK_F5:		extChar = wAccelKey_F5; break;
+		case VK_F6:		extChar = wAccelKey_F6; break;
+		case VK_F7:		extChar = wAccelKey_F7; break;
+		case VK_F8:		extChar = wAccelKey_F8; break;
+		case VK_F9:		extChar = wAccelKey_F9; break;
+		case VK_F10:	extChar = wAccelKey_F10; break;
+		case VK_F11:	extChar = wAccelKey_F11; break;
+		case VK_F12:	extChar = wAccelKey_F12; break;
+		}
+	return extChar;
+}
+
+
+long notModKey;
+int mswTranslateAccelerator(
+		HWND hWnd,
+		LPMSG pMsg )
+{
+	long acclKey;
+	long state;
+	wWin_p win;
+	wControl_p b;
+
+	if ( pMsg->message != WM_KEYDOWN )
+		return FALSE;
+	acclKey = pMsg->wParam;
+	b = getControlFromCursor( pMsg->hwnd, &win );
+	if ( win == NULL )
+		return 0;
+	if ( b != NULL ) {
+		switch (b->type) {
+		case B_STRING:
+		case B_INTEGER:
+		case B_FLOAT:
+		case B_LIST:
+		case B_DROPLIST:
+		case B_COMBOLIST:
+		case B_TEXT:
+			return 0;
+		}
+	}
+	if ( acclKey == (long)VK_F1 ) {
+		closeBalloonHelp();
+		if (!b && win) {
+			wHelp( win->helpStr );
+		} else {
+			if (b->helpStr)
+				wHelp( b->helpStr ); 
+			else if (b->parent)
+				wHelp( b->parent->nameStr ); 
+		}
+		return 1;
+	}
+	/*acclKey = translateExtKey( (WORD)acclKey );*/
+	state = 0;
+	if ( GetKeyState(VK_CONTROL) & 0x1000 )
+		state |= WKEY_CTRL;
+	if ( GetKeyState(VK_MENU) & 0x1000 )
+		state |= WKEY_ALT;
+	if ( GetKeyState(VK_SHIFT) & 0x1000 )
+		state |= WKEY_SHIFT;
+	state <<= 8;
+	acclKey |= state;
+	if (pMsg->wParam > 0x12)
+		notModKey = TRUE;
+	return mswMenuAccelerator( win, acclKey );
+}
+
+/*
+ ******************************************************************************
+ *
+ * Window Utilities
+ *
+ ******************************************************************************
+ */
+
+
+
+void wGetDisplaySize( POS_T * width, POS_T * height )
+{
+	*width = screenWidth;
+	*height = screenHeight;
+}
+
+
+void wWinGetSize( wWin_p w, POS_T * width, POS_T * height )
+{
+	RECT rect;
+	GetWindowRect( w->hWnd, &rect );
+	GetClientRect( w->hWnd, &rect );
+	w->w = rect.right - rect.left;
+	w->h = rect.bottom - rect.top;
+	*width = w->w;
+	*height = w->h;
+}
+
+
+void wWinSetSize( wWin_p w, POS_T width, POS_T height )
+{
+	RECT rect;
+	w->w = width;
+	w->h = height;
+	rect.left = 0;
+	rect.top = 0;
+	rect.right = w->w /*+w->padX*/;
+	rect.bottom = w->h /*+w->padY*/;
+	AdjustWindowRect( &rect, w->style, (w->option&F_MENUBAR)?1:0 );
+	rect.bottom += mFixBorderH;
+	if (!SetWindowPos( w->hWnd, HWND_TOP, CW_USEDEFAULT, CW_USEDEFAULT,
+		rect.right-rect.left, rect.bottom-rect.top,
+		SWP_NOMOVE|SWP_NOZORDER))
+		mswFail("wWinSetSize");
+	InvalidateRect( w->hWnd, NULL, TRUE );
+}
+
+
+static int blocking;
+static void blockingLoop( void )
+{
+	MSG msg;
+	int myBlocking=blocking;
+	while (blocking>=myBlocking && GetMessage( &msg, NULL, 0, 0 )) {
+		if ( 
+#ifdef DOTRANSACCEL
+			 (!TranslateAccelerator( mswWin->hWnd, hMswAccel, &msg )) &&
+#endif
+			 (!mswTranslateAccelerator( mswWin->hWnd, &msg )) ) {
+			TranslateMessage( &msg );
+			DispatchMessage( &msg );
+		}
+	}
+}
+
+
+static void savePos( wWin_p win )
+{
+	char posStr[20];
+	WINDOWPLACEMENT windowPlace;
+	wPos_t w, h;
+	RECT rect;
+
+	if ( win->nameStr &&
+		 IsWindowVisible( win->hWnd) /*&& !IsIconic( win->hWnd )*/ ) {
+		windowPlace.length = sizeof windowPlace;
+		GetWindowPlacement( win->hWnd, &windowPlace );
+		if (win->option&F_RECALLPOS) {
+			wsprintf( posStr, "%d %d",
+				windowPlace.rcNormalPosition.left,
+				windowPlace.rcNormalPosition.top );
+			wPrefSetString( "msw window pos", win->nameStr, posStr );
+			if (win->option&F_RESIZE) {
+				GetClientRect( win->hWnd, &rect );
+				w = rect.right - rect.left;
+				h = rect.bottom - rect.top;
+				w = windowPlace.rcNormalPosition.right - windowPlace.rcNormalPosition.left;
+				h = windowPlace.rcNormalPosition.bottom - windowPlace.rcNormalPosition.top;
+				w -= mResizeBorderW*2;
+				h -= mResizeBorderH*2 + mTitleH;
+				if (win->option&F_MENUBAR)
+					h -= mMenuH;
+				wsprintf( posStr, "%d %d %d",
+					(  windowPlace.showCmd == SW_SHOWMINIMIZED ? 1 :
+					  (windowPlace.showCmd == SW_SHOWMAXIMIZED ? 2 : 0 ) ),
+					w, h );
+				wPrefSetString( "msw window size", win->nameStr, posStr );
+			}
+		}
+	}
+}
+
+
+void wWinShow(
+		wWin_p win,
+		BOOL_T show )
+{
+	wPos_t x, y;
+	wWin_p win1;
+
+	win->busy = TRUE;
+	if (show) {
+		if (win->centerWin) {
+			x = (screenWidth-win->w)/2;
+			y = (screenHeight-win->h)/2;
+			if (x<0)
+				y = 0;
+			if (x<0)
+				y = 0;
+			if (!SetWindowPos( win->hWnd, HWND_TOP, x, y,
+				CW_USEDEFAULT, CW_USEDEFAULT,
+				SWP_NOSIZE|SWP_NOZORDER))
+				mswFail( "wWinShow:SetWindowPos()" );
+		}
+		win->centerWin = FALSE;
+		win->shown = TRUE;
+		if (mswHWnd == (HWND)0 || !IsIconic(mswHWnd) ) {
+			ShowWindow( win->hWnd, SW_SHOW );
+			if (win->focusChainFirst) {
+				SetFocus( win->focusChainFirst->hWnd );
+			}
+			win->pendingShow = FALSE;
+			if ( mswWinBlockEnabled && (win->option & F_BLOCK) ) {
+				blocking++;
+				inMainWndProc = FALSE;
+				for ( win1 = winFirst; win1; win1=(wWin_p)win1->next ) {
+					if ( win1->shown && win1 != win ) {
+						if (win1->modalLevel == 0 )
+							EnableWindow( win1->hWnd, FALSE );
+						win1->modalLevel++;
+					}
+				}
+				win->busy = FALSE;
+				blockingLoop();
+			}
+		} else {
+			win->pendingShow = TRUE;
+			needToDoPendingShow = TRUE;
+		}
+	} else {
+		savePos( win );
+		ShowWindow( win->hWnd, SW_HIDE );
+		/*SetWindowPos( win->hWnd, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_HIDEWINDOW );*/
+		if ( mswWinBlockEnabled && (win->option & F_BLOCK) ) {
+			blocking--;
+				for ( win1 = winFirst; win1; win1=(wWin_p)win1->next ) {
+					if ( win1->shown && win1 != win ) {
+						if ( win1->modalLevel > 0 )
+							win1->modalLevel--;
+						if (win1->modalLevel == 0 )
+							EnableWindow( win1->hWnd, TRUE );
+					}
+				}
+		}
+		savePos( win );
+		win->pendingShow = FALSE;
+		win->shown = FALSE;
+	}
+	win->busy = FALSE;
+}
+
+
+void wWinBlockEnable(
+		wBool_t enabled )
+{
+	 mswWinBlockEnabled = enabled;
+}
+
+
+wBool_t wWinIsVisible(
+		wWin_p w )
+{
+	return IsWindowVisible(w->hWnd);
+}
+
+
+void wWinSetTitle(
+		wWin_p w,
+		const char * title )
+{
+	SetWindowText( w->hWnd, title );
+}
+
+
+void wWinSetBusy(
+		wWin_p w,
+		BOOL_T busy )
+{
+	HMENU menuH;
+	UINT uEnable;
+	int cnt, inx;
+	wControl_p b;
+
+	w->isBusy = busy;
+	menuH = GetMenu( w->hWnd );
+	if (menuH) {
+		uEnable = MF_BYPOSITION|(busy?MF_DISABLED:MF_ENABLED);
+		cnt = GetMenuItemCount(menuH);
+		for (inx=0; inx<cnt; inx++)
+			EnableMenuItem( menuH, inx, uEnable );
+	}
+	for (b=w->first; b; b=b->next) {
+		if ( (b->option&BO_DISABLED)==0) {
+			if (mswCallBacks[b->type] != NULL &&
+				mswCallBacks[b->type]->setBusyProc) {
+				mswCallBacks[b->type]->setBusyProc( b, busy );
+			} else {
+				if (b->hWnd)
+					EnableWindow( b->hWnd, (BOOL)!busy );
+			}
+		}
+	}
+}
+
+
+const char * wWinGetTitle(
+		wWin_p w )
+{
+	return w->labelStr;
+}
+
+
+void wWinClear(
+		wWin_p win,
+		wPos_t x,
+		wPos_t y,
+		wPos_t width,
+		wPos_t height )
+{
+}
+
+void wSetCursor(
+		wCursor_t cursor )
+{
+	switch ( cursor ) {
+	case wCursorNormal:
+	case wCursorQuestion:
+	default:
+		SetCursor( LoadCursor( NULL, IDC_ARROW ) );
+		break;
+	case wCursorWait:
+		SetCursor( LoadCursor( NULL, IDC_WAIT ) );
+		break;
+	case wCursorCross:
+		SetCursor( LoadCursor( NULL, IDC_CROSS ) );
+		break;
+	case wCursorIBeam:
+		SetCursor( LoadCursor( NULL, IDC_IBEAM ) );
+		break;
+	}
+	curCursor = cursor;
+}
+
+void wWinDoCancel( wWin_p win )
+{
+	wControl_p b;
+	for (b=win->first; b; b=b->next) {
+		if ((b->type == B_BUTTON) && (b->option & BB_CANCEL) ) {
+			mswButtPush( b );
+		}
+	}
+}
+
+unsigned long wGetTimer( void )
+{
+	return (unsigned long)GetTickCount();
+}
+
+
+/*
+ ******************************************************************************
+ *
+ * Control Utilities
+ *
+ ******************************************************************************
+ */
+
+
+
+void wControlSetHelp(
+		wControl_p b,
+		const char * help )
+{
+	if (b->helpStr)
+		free(CAST_AWAY_CONST b->helpStr);
+	if (help)
+		b->helpStr = mswStrdup( help );
+	else
+		b->helpStr = NULL;
+}
+
+
+/**
+ * Add control to circular list of synonymous controls. Synonymous controls are kept in sync by 
+ * calling wControlLinkedActive for one member of the list 
+ *
+ * \param IN  first control
+ * \param IN  second control
+ * \return    none
+ */
+ 
+void wControlLinkedSet( wControl_p b1, wControl_p b2 )
+{
+	b2->synonym = b1->synonym;
+	if( b2->synonym == NULL )
+		b2->synonym = b1;
+		
+	b1->synonym = b2;
+} 	
+
+/**
+ * Activate/deactivate a group of synonymous controls.
+ *
+ * \param IN  control
+ * \param IN  state
+ * \return    none
+ */
+ 
+void wControlLinkedActive( wControl_p b, int active )
+{
+	wControl_p savePtr = b;
+
+	if( savePtr->type == B_MENUITEM )
+		wMenuPushEnable( (wMenuPush_p)savePtr, active );
+	else 	
+		wControlActive( savePtr, active );		
+
+	savePtr = savePtr->synonym;
+
+	while( savePtr && savePtr != b ) {	
+
+		if( savePtr->type == B_MENUITEM )
+			wMenuPushEnable( (wMenuPush_p)savePtr, active );
+		else 	
+			wControlActive( savePtr, active );		
+
+		savePtr = savePtr->synonym;
+	}	
+}
+
+void wControlShow( wControl_p b, BOOL_T show )
+{
+	RECT rc;
+	if (show) {
+		if (mswCallBacks[b->type] != NULL &&
+			mswCallBacks[b->type]->repaintProc)
+			mswCallBacks[b->type]->repaintProc( b->parent->hWnd, b );
+	} else {
+		if( b->labelStr ) {
+			rc.left = b->labelX;
+			rc.right = b->x;
+			rc.top = b->labelY;
+			rc.bottom = b->labelY+b->h;
+			InvalidateRect( ((wControl_p)b->parent)->hWnd, &rc, TRUE );
+		}
+	}
+	if (mswCallBacks[b->type] != NULL &&
+		mswCallBacks[b->type]->showProc) {
+		mswCallBacks[b->type]->showProc( b, show );
+	} else {
+		ShowWindow( b->hWnd, show?SW_SHOW:SW_HIDE );
+#ifdef SHOW_DOES_SETFOCUS
+		if (show && (b->option&BO_READONLY)==0 && b->hWnd != GetFocus() ) {
+			hWnd = SetFocus( b->hWnd );
+		}
+#endif
+	}
+	b->shown = show;
+}
+
+
+void wControlSetFocus(
+		wControl_p b )
+{
+	if ( b->hWnd )
+		SetFocus( b->hWnd );
+}
+
+
+void wControlActive(
+		wControl_p b,
+		int active )
+{
+	if (active)
+		b->option &= ~BO_DISABLED;
+	else
+		b->option |= BO_DISABLED;
+	if (b->parent->isBusy)
+		return;
+	if (mswCallBacks[b->type] != NULL &&
+		mswCallBacks[b->type]->setBusyProc) {
+		mswCallBacks[b->type]->setBusyProc( b, !active );
+	} else {
+		EnableWindow( b->hWnd, (BOOL)active );
+		InvalidateRect( b->hWnd, NULL, TRUE );
+	}
+}
+
+
+const char * wControlGetHelp( wControl_p b )
+{
+	return b->helpStr;
+}
+
+
+wPos_t wLabelWidth( const char * labelStr )
+{
+	int lab_l;
+	HDC hDc;
+	DWORD dw;
+	LABELFONTDECL
+
+	hDc = GetDC( mswHWnd );
+	lab_l = strlen(labelStr);
+	LABELFONTSELECT
+	dw = GetTextExtent( hDc, CAST_AWAY_CONST labelStr, lab_l );
+	LABELFONTRESET
+	ReleaseDC( mswHWnd, hDc );
+	return LOWORD(dw) + 5;
+}
+
+
+wPos_t wControlGetWidth(
+		wControl_p b)			/* Control */
+{
+	return b->w;
+}
+
+
+wPos_t wControlGetHeight(
+		wControl_p b)			/* Control */
+{
+	return b->h;
+}
+
+
+wPos_t wControlGetPosX(
+		wControl_p b)			/* Control */
+{
+	return b->x;
+}
+
+
+wPos_t wControlGetPosY(
+		wControl_p b)			/* Control */
+{
+	return b->y;
+}
+
+
+void wControlSetPos(
+		wControl_p b,
+		wPos_t x,
+		wPos_t y )
+{
+	b->labelX = x;
+	b->labelY = y+2;
+
+	if (b->labelStr) {
+		int lab_l;
+		HDC hDc;
+		DWORD dw;
+		LABELFONTDECL
+
+		hDc = GetDC( b->parent->hWnd );
+		LABELFONTSELECT
+		lab_l = strlen(b->labelStr);
+		dw = GetTextExtent( hDc, CAST_AWAY_CONST b->labelStr, lab_l );
+		b->labelX -= LOWORD(dw) + 5;
+		LABELFONTRESET
+		ReleaseDC( b->parent->hWnd, hDc );
+	}
+
+	if (mswCallBacks[b->type] != NULL &&
+		mswCallBacks[b->type]->setPosProc) {
+		mswCallBacks[b->type]->setPosProc( b, x, y );
+	} else {
+		b->x = x;
+		b->y = y;
+		if (b->hWnd)
+			if (!SetWindowPos( b->hWnd, HWND_TOP, x, y,
+				CW_USEDEFAULT, CW_USEDEFAULT,
+				SWP_NOSIZE|SWP_NOZORDER))
+				mswFail("wControlSetPos");
+	}
+}
+
+
+void wControlSetLabel(
+		wControl_p b,
+		const char * labelStr )
+{
+	if ( b->type == B_RADIO || b->type == B_TOGGLE ) {
+		;
+	} else {
+		int lab_l;
+		HDC hDc;
+		DWORD dw;
+		LABELFONTDECL
+
+		hDc = GetDC( b->parent->hWnd );
+		lab_l = strlen(labelStr);
+		LABELFONTSELECT
+		dw = GetTextExtent( hDc, CAST_AWAY_CONST labelStr, lab_l );
+		LABELFONTRESET
+		b->labelX = b->x - LOWORD(dw) - 5;
+		ReleaseDC( b->parent->hWnd, hDc );
+		b->labelStr = mswStrdup( labelStr );
+		if (b->type == B_BUTTON)
+			SetWindowText( b->hWnd, labelStr );
+	}
+}
+
+
+void wControlSetContext(
+		wControl_p b,
+		void * context )
+{
+	b->data = context;
+}
+
+static int controlHiliteWidth = 5;
+static int controlHiliteWidth2 = 3;
+void wControlHilite(
+		wControl_p b,
+		wBool_t hilite )
+{
+	HDC hDc;
+	HPEN oldPen, newPen;
+	int oldMode;
+
+	if ( b == NULL ) return;
+    if ( !IsWindowVisible(b->parent->hWnd) ) return;
+    if ( !IsWindowVisible(b->hWnd) ) return;
+	hDc = GetDC( b->parent->hWnd );
+	newPen = CreatePen( PS_SOLID, controlHiliteWidth, RGB(0,0,0) );
+	oldPen = SelectObject( hDc, newPen );
+	oldMode = SetROP2( hDc, R2_NOTXORPEN );
+	MoveTo( hDc, b->x-controlHiliteWidth2, b->y-controlHiliteWidth2 );
+	LineTo( hDc, b->x+b->w+controlHiliteWidth2, b->y-controlHiliteWidth2 );
+	LineTo( hDc, b->x+b->w+controlHiliteWidth2, b->y+b->h+controlHiliteWidth2 );
+	LineTo( hDc, b->x-controlHiliteWidth2, b->y+b->h+controlHiliteWidth2 );
+	LineTo( hDc, b->x-controlHiliteWidth2, b->y-controlHiliteWidth2 );
+	SetROP2( hDc, oldMode );
+	SelectObject( hDc, oldPen );
+	DeleteObject( newPen );
+	ReleaseDC( b->parent->hWnd, hDc );
+}
+
+/*
+ *****************************************************************************
+ *
+ * Exported Utility Functions 
+ *
+ *****************************************************************************
+ */
+
+
+void wMessage(
+		wWin_p w,
+		const char * msg,
+		int beep )
+{
+	HDC hDc;
+	int oldRop;
+	POS_T h;
+	RECT rect;
+	LABELFONTDECL
+
+	if (beep)
+		MessageBeep(0);
+	GetClientRect( w->hWnd, &rect );
+	hDc = GetDC( w->hWnd );
+	oldRop = SetROP2( hDc, R2_WHITE );
+	h = w->h+2;
+	Rectangle( hDc, 0, h, w->w, h );
+	SetROP2( hDc, oldRop );
+	LABELFONTSELECT
+	TextOut( hDc, 0, h, msg, strlen(msg) );
+	LABELFONTRESET
+	ReleaseDC( w->hWnd, hDc );
+}
+
+
+void wExit( int rc )
+{
+	INDEX_T inx;
+	wControl_p b;
+
+	mswPutCustomColors();
+	wPrefFlush();
+	for ( inx=controlMap_da.cnt-1; inx>=0; inx-- ) {
+		b = controlMap(inx).b;
+		if (b != NULL) {
+			if (b->type == W_MAIN || b->type == W_POPUP) {
+				wWin_p w = (wWin_p)b;
+				savePos( w );
+				if (w->winProc != NULL)
+					w->winProc( w, wQuit_e, w->data );
+			}
+		}
+	}
+	for ( inx=controlMap_da.cnt-1; inx>=0; inx-- ) {
+		b = controlMap(inx).b;
+		if (b != NULL) {
+			if (mswCallBacks[b->type] != NULL &&
+				mswCallBacks[b->type]->doneProc != NULL)
+				mswCallBacks[b->type]->doneProc( b );
+		}
+		controlMap(inx).b = NULL;
+	}
+	deleteBitmaps();
+	if (mswOldTextFont != (HFONT)0)
+		DeleteObject( mswOldTextFont );
+	if (helpInitted) {
+		WinHelp(mswHWnd, helpFile, HELP_QUIT, 0L );
+		helpInitted = FALSE;
+	}
+	if (balloonHelpHWnd) {
+		HDC hDc;
+		hDc = GetDC( balloonHelpHWnd );
+		SelectObject( hDc, balloonHelpOldFont );
+		DeleteObject( balloonHelpNewFont );
+		ReleaseDC( balloonHelpHWnd, hDc );
+	}
+#ifdef HELPSTR
+	fclose( helpStrF );
+#endif
+	DestroyWindow( mswHWnd );
+	if (mswPalette) {
+		DeleteObject( mswPalette );
+		/*DeleteObject( mswPrintPalette );*/
+	}
+}
+
+
+void wFlush(
+		void )
+{
+	wWin_p win;
+
+	inMainWndProc = FALSE;
+	mswRepaintAll();
+	for (win=winFirst; win; win=(wWin_p)win->next)
+		UpdateWindow( win->hWnd );
+}
+
+void wUpdate(
+		wWin_p	win )
+{
+	UpdateWindow( win->hWnd );
+}
+
+static wBool_t paused;
+static wAlarmCallBack_p alarmFunc;
+static setTriggerCallback_p triggerFunc;
+static wControl_p triggerControl;
+
+/**
+ * Wait until the pause timer expires. During that time, the message loop is
+ * handled and queued messages are processed 
+ */
+
+static void pausedLoop( void )
+{
+	MSG msg;
+	while (paused && GetMessage( &msg, NULL, 0, 0 )) {
+		if ( (mswWin) && (!mswTranslateAccelerator( mswWin->hWnd, &msg )) ) {
+			TranslateMessage( &msg );
+		}
+		DispatchMessage( &msg );
+	}
+}
+
+/**
+ *	Timer callback function for the pause timer. The only purpose of this 
+ *  timer proc is to clear the waiting flag and kill the timer itself.
+ */
+void CALLBACK TimerProc( HWND hWnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime )
+{
+	if (idEvent == PAUSE_TIMER) {				
+		paused = FALSE;
+		KillTimer( hWnd, PAUSE_TIMER );
+	} 
+}
+
+/**
+ * Pause the application for a specified time. 
+ */
+
+void wPause( long msec )
+{
+	paused = TRUE;
+	if (msec > 65000L)
+		msec = 65000L;
+	pauseTimer = SetTimer( mswHWnd, PAUSE_TIMER, (UINT)msec, TimerProc );
+	if (pauseTimer == 0)
+		mswFail("wPause: No timers");
+	else
+		pausedLoop();
+}
+
+
+void wAlarm(
+		long msec,
+		wAlarmCallBack_p func )
+{
+	alarmFunc = func;
+	if (msec > 65000L)
+		msec = 65000L;
+	alarmTimer = SetTimer( mswHWnd, ALARM_TIMER, (UINT)msec, NULL );
+	if (alarmTimer == 0)
+		mswFail("wAlarm: No timers");
+}
+
+
+void mswSetTrigger(
+		wControl_p control,
+		setTriggerCallback_p func )
+{
+	UINT msec = (UINT)500;
+	triggerControl = control;
+	triggerFunc = func;
+	if (func == NULL && triggerTimer != 0) {
+		KillTimer( mswHWnd, triggerTimer );
+		triggerTimer = 0;
+		return;
+	}
+	if (msec > 65000L)
+		msec = 65000L;
+	triggerTimer = SetTimer( mswHWnd, TRIGGER_TIMER, (UINT)msec, NULL );
+	if (triggerTimer == 0)
+		mswFail("wAlarm: No timers");
+}
+
+
+void wBeep( void )
+{
+	MessageBeep( MB_OK );
+}
+
+/**
+ * Show a notification window with a yes/no reply and an icon.
+ *
+ * \param type IN type of message: Information, Warning, Error
+ * \param msg  IN message to display
+ * \param yes  IN text for accept button
+ * \param no   IN text for cancel button
+ * \return    True when accept was selected, false otherwise
+ */
+
+int wNoticeEx(
+		int type, 
+		const char * msg,
+		const char * yes,
+		const char * no )
+{
+	int res;
+	UINT flag;
+	char *headline;
+
+	switch( type ) {
+		case NT_INFORMATION:
+			flag = MB_ICONINFORMATION;
+			headline = _("Information");
+			break;
+		case NT_WARNING:
+			flag = MB_ICONWARNING;
+			headline = _("Warning");
+			break;
+		case NT_ERROR:
+			flag = MB_ICONERROR;
+			headline = _("Error");
+			break;
+	}
+	res = MessageBox( mswHWnd, msg, headline, flag | MB_TASKMODAL|((no==NULL)?MB_OK:MB_YESNO) );
+	return res == IDOK || res == IDYES;
+}
+
+int wNotice(
+		const char * msg,
+		const char * yes,
+		const char * no )
+{
+	int res;
+	res = MessageBox( mswHWnd, msg, "Notice", MB_TASKMODAL|((no==NULL)?MB_OK:MB_YESNO) );
+	return res == IDOK || res == IDYES;
+}
+
+/**
+ * Show a notification window with three choices and an icon.
+ *
+ * \param msg  IN message to display
+ * \param yes  IN text for yes button
+ * \param no   IN text for no button
+ * \param cancel IN  text for cancel button
+ * \return    1 for yes, -1 for no, 0 for cancel
+ */
+
+
+int wNotice3(
+		const char * msg,
+		const char * yes,
+		const char * no,
+		const char * cancel )
+{
+	int res;
+	res = MessageBox( mswHWnd, msg, _("Warning"), MB_ICONWARNING | MB_TASKMODAL|MB_YESNOCANCEL );
+	if ( res == IDOK || res == IDYES )
+		return 1;
+	else if ( res == IDNO )
+		return -1;
+	else
+		return 0;
+}
+
+
+void wHelp(
+		const char * topic )
+{
+	char *pszHelpTopic;
+	HWND hwndHelp;
+
+	if (!helpInitted) {
+		HtmlHelp( NULL, NULL, HH_INITIALIZE, (DWORD)&dwCookie) ;
+		helpInitted = TRUE;
+	}
+/*	             "c:\\help.chm::/intro.htm>mainwin", */
+	/* attention: always adapt constant value (10) to needed number of formatting characters */
+	pszHelpTopic = malloc( strlen( helpFile ) + strlen( topic ) + 10 );
+	assert( pszHelpTopic != NULL );	
+
+	sprintf( pszHelpTopic, "/%s.html", topic );
+	hwndHelp = HtmlHelp(mswHWnd, helpFile, HH_DISPLAY_TOPIC, (DWORD_PTR)pszHelpTopic);
+	if( !hwndHelp )
+		wNoticeEx( NT_ERROR, pszHelpTopic, "Ok", NULL );
+
+	free( pszHelpTopic );
+}
+
+
+void doHelpMenu( void * context )
+{
+	HH_FTS_QUERY ftsQuery;
+	
+	if( !helpInitted ) {
+		HtmlHelp( NULL, NULL, HH_INITIALIZE, (DWORD)&dwCookie) ;
+		helpInitted = TRUE;
+	}
+	
+	switch ((int)(long)context) {
+	case 1: /* Contents */
+		HtmlHelp( mswHWnd, helpFile, HH_DISPLAY_TOC, (DWORD_PTR)NULL );
+		break;
+	case 2: /* Search */
+		ftsQuery.cbStruct = sizeof( ftsQuery );
+		ftsQuery.fExecute = FALSE;
+		ftsQuery.fStemmedSearch = FALSE;
+		ftsQuery.fTitleOnly = FALSE;
+		ftsQuery.pszSearchQuery = NULL;
+		ftsQuery.pszWindow = NULL;
+
+		HtmlHelp( mswHWnd, helpFile, HH_DISPLAY_SEARCH,(DWORD)&ftsQuery );
+		break;
+	default:
+		return;
+	}
+	helpInitted = TRUE;
+}
+
+void wMenuAddHelp(
+		wMenu_p m )
+{
+	wMenuPushCreate( m, NULL, "&Contents", 0, doHelpMenu, (void*)1 );
+	wMenuPushCreate( m, NULL, "&Search for Help on...", 0, doHelpMenu, (void*)2 );
+}
+
+
+void wSetBalloonHelp( wBalloonHelp_t * bh )
+{
+	balloonHelpStrings = bh;
+}
+
+
+void wEnableBalloonHelp( int enable )
+{
+	balloonHelpEnable = enable;
+}
+
+
+void wBalloonHelpUpdate ( void )
+{
+}
+
+
+void wControlSetBalloonText(  wControl_p b, const char * text )
+{
+	b->tipStr = mswStrdup( text );
+}
+
+
+void startBalloonHelp( void )
+{
+	HDC hDc;
+	DWORD extent;
+	int w, h;
+	RECT rect;
+	POINT pt;
+	wBalloonHelp_t * bh;
+	const char * hs;
+	HFONT hFont;
+
+	if (!balloonHelpStrings)
+		return;
+	if (!balloonHelpEnable)
+		return;
+	if (balloonHelpHWnd) {
+		if ( balloonHelpButton->tipStr ) {
+			hs = balloonHelpButton->tipStr;
+		} else {
+			hs = balloonHelpButton->helpStr;
+			if (!hs)
+				return;
+			for ( bh = balloonHelpStrings; bh->name && strcmp(bh->name,hs) != 0; bh++ );
+			if (!bh->name || !bh->value)
+				return;
+			balloonHelpButton->tipStr = hs = bh->value;
+		}
+if (newHelp) {
+		wControlSetBalloon( balloonHelpButton, 0, 0, hs );
+} else {
+		hDc = GetDC( balloonHelpHWnd );
+		hFont = SelectObject( hDc, mswLabelFont );
+		extent = GetTextExtent( hDc, CAST_AWAY_CONST hs, strlen(hs) );
+		w = LOWORD( extent );
+		h = HIWORD( extent );
+		pt.x = 0;
+		if ( balloonHelpButton->type == B_RADIO ||
+			 balloonHelpButton->type == B_TOGGLE ) {
+			pt.y = balloonHelpButton->h;
+		} else {
+			GetClientRect( balloonHelpButton->hWnd, &rect );
+			pt.y = rect.bottom;
+		}
+		ClientToScreen( balloonHelpButton->hWnd, &pt );
+		if (pt.x + w+2 > screenWidth)
+			pt.x = screenWidth-(w+2);
+		if (pt.x < 0)
+			pt.x = 0;
+		SetWindowPos( balloonHelpHWnd, HWND_TOPMOST, pt.x, pt.y, w+6, h+4,
+						SWP_SHOWWINDOW|SWP_NOACTIVATE );
+		SetBkColor( hDc, GetSysColor( COLOR_INFOBK ));
+		TextOut( hDc, 2, 1, hs, strlen(hs) );
+		SelectObject( hDc, hFont );
+		ReleaseDC( balloonHelpHWnd, hDc );
+}
+	}
+}
+
+void closeBalloonHelp( void )
+{
+	if (balloonHelpTimer) {
+		KillTimer( mswHWnd, balloonHelpTimer );
+		balloonHelpTimer = 0;
+	}
+	if (balloonHelpState == balloonHelpShow)
+		if (balloonHelpHWnd)
+			 ShowWindow( balloonHelpHWnd, SW_HIDE );
+	balloonHelpState = balloonHelpIdle;
+}
+
+
+void wControlSetBalloon( wControl_p b, wPos_t dx, wPos_t dy, const char * msg )
+{
+	HDC hDc;
+	DWORD extent;
+	int w, h;
+	RECT rect;
+	POINT pt;
+	HFONT hFont;
+
+	if ( msg ) {
+		hDc = GetDC( balloonHelpHWnd );
+		hFont = SelectObject( hDc, mswLabelFont );
+		extent = GetTextExtent( hDc, CAST_AWAY_CONST msg, strlen(msg) );
+		w = LOWORD( extent );
+		h = HIWORD( extent );
+		if ( b->type == B_RADIO ||
+			 b->type == B_TOGGLE ) {
+			pt.y = b->h;
+		} else {
+			GetClientRect( b->hWnd, &rect );
+			pt.y = rect.bottom;
+		}
+		pt.x = dx;
+		pt.y -= dy;
+		ClientToScreen( b->hWnd, &pt );
+		if (pt.x + w+2 > screenWidth)
+			pt.x = screenWidth-(w+2);
+		if (pt.x < 0)
+			pt.x = 0;
+		SetWindowPos( balloonHelpHWnd, HWND_TOPMOST, pt.x, pt.y, w+6, h+4,
+						SWP_SHOWWINDOW|SWP_NOACTIVATE );
+		SetBkColor( hDc, GetSysColor( COLOR_INFOBK ) ); 
+		TextOut( hDc, 2, 1, msg, strlen(msg) );
+		SelectObject( hDc, hFont );
+		ReleaseDC( balloonHelpHWnd, hDc );
+
+		balloonHelpState = balloonHelpShow; 
+		balloonControlButton = b;
+	} else {
+		closeBalloonHelp();
+	}
+}
+
+
+int wGetKeyState( void )
+{
+	int rc, keyState;
+	rc = 0;
+	keyState = GetAsyncKeyState( VK_SHIFT );
+	if (keyState & 0x8000)
+		rc |= WKEY_SHIFT;
+	keyState = GetAsyncKeyState( VK_CONTROL );
+	if (keyState & 0x8000)
+		rc |= WKEY_CTRL;
+	keyState = GetAsyncKeyState( VK_MENU );
+	if (keyState & 0x8000)
+		rc |= WKEY_ALT;
+	return rc;
+}
+
+
+/*
+ ******************************************************************************
+ *
+ * File Selection
+ *
+ ******************************************************************************
+ */
+
+FILE * wFileOpen(
+		const char * fileName,
+		const char * mode )
+{
+		return fopen( fileName, mode );
+}
+
+
+struct wFilSel_t {
+		wWin_p parent;
+		wFilSelMode_e mode;
+		int option;
+		const char * title;
+		char * extList;
+		wFilSelCallBack_p action;
+		void * data;
+		};
+		
+static char selFileName[1024];
+static char selFileTitle[1024];
+static char sysDirName[1024];
+
+int wFilSelect(
+		struct wFilSel_t * fs,
+		const char * dirName )
+{
+	int rc;
+	OPENFILENAME ofn;
+	char * fileName;
+	const char * ext;
+	char defExt[4];
+	int i;
+
+	if (dirName == NULL ||
+		dirName[0] == '\0' ||
+		strcmp(dirName, ".") == 0 ) {
+		GetSystemDirectory( CAST_AWAY_CONST (dirName = sysDirName), sizeof sysDirName );
+	}
+	memset( &ofn, 0, sizeof ofn );
+	ofn.lStructSize = sizeof ofn;
+	ofn.hwndOwner = mswHWnd;
+	ofn.lpstrFilter = fs->extList;
+	ofn.nFilterIndex = 0;
+	selFileName[0] = '\0';
+	ofn.lpstrFile = selFileName;
+	ofn.nMaxFile = sizeof selFileName;
+	selFileTitle[0] = '\0';
+	ofn.lpstrFileTitle = selFileTitle;
+	ofn.nMaxFileTitle = sizeof selFileTitle;
+	ofn.lpstrInitialDir = dirName;
+	ofn.lpstrTitle = fs->title;
+	ext = fs->extList + strlen(fs->extList)+1;
+	if (*ext++ == '*' && *ext++ == '.') {
+		for ( i=0; i<3 && ext[i] && ext[i]!=';'; i++ )
+			defExt[i] = ext[i];
+		defExt[i] = '\0';
+	} else {
+		defExt[0] = '\0';
+	}
+	ofn.lpstrDefExt = defExt;
+	ofn.Flags |= OFN_LONGFILENAMES;
+	if (fs->mode == FS_LOAD) {
+		ofn.Flags |= OFN_FILEMUSTEXIST;
+		rc = GetOpenFileName( &ofn );
+	} else if (fs->mode == FS_SAVE) {
+		ofn.Flags |= OFN_OVERWRITEPROMPT;
+		rc = GetSaveFileName( &ofn );
+	} else if (fs->mode == FS_UPDATE) {
+		rc = GetSaveFileName( &ofn );
+	} else
+		return FALSE;
+	if (!rc)
+		return FALSE;
+	fileName = strrchr( selFileName, '\\' );
+	if (fileName == NULL) {
+		mswFail( "wFilSelect: cant extract fileName" );
+		return FALSE;
+	}
+	fs->action( selFileName, fileName+1, fs->data );
+	return TRUE;
+}
+
+
+struct wFilSel_t * wFilSelCreate(
+		wWin_p parent,
+		wFilSelMode_e mode,
+		int option,
+		const char * title,
+		const char * extList,
+		wFilSelCallBack_p action,
+		void * data )
+{
+	char * cp;
+	struct wFilSel_t * ret;
+	int len;
+	ret = (struct wFilSel_t*)malloc(sizeof *ret);
+	ret->parent = parent;
+	ret->mode = mode;
+	ret->option = option;
+	ret->title = mswStrdup(title);
+	len = strlen(extList);
+	ret->extList = (char*)malloc(len+2);
+	strcpy(ret->extList,extList);
+	for ( cp=ret->extList; *cp; cp++ ) {
+		if (*cp == '|')
+			*cp = '\0';
+	}
+	*++cp = '\0';
+	ret->action = action;
+	ret->data = data;
+	return ret;
+}
+
+
+const char * wMemStats( void )
+{
+	int rc;
+	static char msg[80];
+	long usedSize = 0;
+	long usedCnt = 0;
+	long freeSize = 0;
+	long freeCnt = 0;
+	_HEAPINFO heapinfo;
+	heapinfo._pentry = NULL;
+
+	while ( (rc=_heapwalk( &heapinfo )) == _HEAPOK ) {
+		switch (heapinfo._useflag) {
+		case _FREEENTRY:
+			freeSize += (long)heapinfo._size;
+			freeCnt++;
+			break;
+		case _USEDENTRY:
+			usedSize += (long)heapinfo._size;
+			usedCnt++;
+			break;
+		}
+	}
+		
+	sprintf( msg, "Used: %ld(%ld), Free %ld(%ld)%s",
+		usedSize, usedCnt, freeSize, freeCnt,
+		(rc==_HEAPOK)?"":
+		(rc==_HEAPEMPTY)?"":
+		(rc==_HEAPBADBEGIN)?", BADBEGIN":
+		(rc==_HEAPEND)?"":
+		(rc==_HEAPBADPTR)?", BADPTR":
+		", Unknown Heap Status" );
+	return msg;
+}
+
+/*
+ *****************************************************************************
+ *
+ * Main
+ *
+ *****************************************************************************
+ */
+
+static wControl_p getControlFromCursor( HWND hWnd, wWin_p * winR )
+{
+	POINT pt;
+	wWin_p w;
+	wControl_p b;
+	wIndex_t inx;
+	HWND hTopWnd;
+
+	if (winR)
+		*winR = NULL;
+	GetCursorPos( &pt );
+	hTopWnd = GetActiveWindow();
+	inx = GetWindowWord( hWnd, 0 );
+	if ( inx < CONTROL_BASE || inx > controlMap_da.cnt ) {
+		/* Unknown control */
+		/*MessageBeep( MB_ICONEXCLAMATION );*/
+		return NULL;
+	}
+	w=(wWin_p)controlMap(inx-CONTROL_BASE).b;
+	if (!w)
+		return NULL;
+	if (w->type != W_MAIN && w->type != W_POPUP)
+		return NULL;
+	if ( winR )
+		*winR = w;
+	ScreenToClient( hWnd, &pt );
+	for (b = w->first; b; b=b->next) {
+		if (b->type == B_BOX || b->type == B_LINES)
+			continue;
+		if (b->hWnd == NULL)
+			continue;
+		if (IsWindowVisible( b->hWnd ) == FALSE)
+			continue;
+		if (pt.x > b->x && pt.x < b->x+b->w &&
+			pt.y > b->y && pt.y < b->y+b->h )
+			return b;
+	}
+	return b;	
+}
+
+/**
+ * Window function for the main window and all popup windows. 
+ *
+ */
+
+LRESULT 
+FAR 
+PASCAL 
+MainWndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
+{
+	int inx;
+	wWin_p w;
+	wControl_p b, oldW;
+	int child = ((GetWindowLong( hWnd, GWL_STYLE) & WS_CHILD) != 0);
+	POS_T newW, newH;
+	RECT rect;
+	PAINTSTRUCT ps;
+	HWND hWnd2;
+	LRESULT ret;
+	HDC hDc;
+	wAccelKey_e extChar;
+
+	switch (message) {
+		
+	case WM_MOUSEWHEEL:
+		inx = GetWindowWord( hWnd, 0 );
+		b = getControlFromCursor( hWnd, NULL );
+		if( b && b->type == B_DRAW )
+			if (mswCallBacks[b->type] != NULL &&
+				mswCallBacks[b->type]->messageProc)
+				return mswCallBacks[b->type]->messageProc( (wControl_p)b, hWnd,
+								message, wParam, lParam );
+		return( 0 );
+	case WM_DRAWITEM:
+	case WM_COMMAND:
+	case WM_MEASUREITEM:
+	case WM_NOTVALID:
+		if (WCMD_PARAM_ID == IDM_DOHELP) {
+			b = getControlFromCursor( hWnd, NULL );
+			closeBalloonHelp();
+			if (!b)
+				return 0L;
+			if (b->helpStr)
+				wHelp( b->helpStr );
+			return 0L;
+		}
+		closeBalloonHelp();
+		if (WCMD_PARAM_ID < CONTROL_BASE || WCMD_PARAM_ID > (WPARAM)controlMap_da.cnt)
+			break;
+		b = controlMap(WCMD_PARAM_ID-CONTROL_BASE).b;
+		if (!b)
+			break;
+		if( b->type == B_BITMAP ) {
+			// draw the bitmap
+			mswDrawIcon(((LPDRAWITEMSTRUCT)lParam)->hDC, 0, 0, (wIcon_p)(b->data), FALSE, (COLORREF)0, (COLORREF)0 );
+			return( TRUE );
+		} else {
+			mswSetFocus( b );
+			ret = 0L;
+			if (!inMainWndProc) {
+				inMainWndProc = TRUE;
+				if (mswCallBacks[b->type] != NULL &&
+					mswCallBacks[b->type]->messageProc) {
+					ret = mswCallBacks[b->type]->messageProc( b, hWnd, message, wParam, lParam );
+				}
+				inMainWndProc = FALSE;
+			}
+			return ret;
+		}
+	case WM_PAINT:
+		inx = GetWindowWord( hWnd, 0 );
+		if (inx >= CONTROL_BASE && inx <= controlMap_da.cnt &&
+			(w = (wWin_p)controlMap(inx-CONTROL_BASE).b) &&
+			(w->type == W_MAIN || w->type == W_POPUP) &&
+			(!IsIconic(mswHWnd)) &&
+			(GetUpdateRect( hWnd, &rect, FALSE ) ) ) {
+			BeginPaint( hWnd, &ps );
+			for (b=w->first; b; b=b->next ) {
+				if (b->shown &&
+					mswCallBacks[b->type] != NULL &&
+					mswCallBacks[b->type]->repaintProc)
+					mswCallBacks[b->type]->repaintProc( hWnd, b );
+			}
+			EndPaint( hWnd, &ps );
+			return 1L;
+		}
+		break;
+
+	case WM_SIZE:
+		inx = GetWindowWord( hWnd, 0 );
+		if (inx < CONTROL_BASE || inx > controlMap_da.cnt)
+			break;
+		w = (wWin_p)controlMap(inx-CONTROL_BASE).b;
+		if (!w)
+			break;
+		if (w->type != W_MAIN && w->type != W_POPUP) 
+			break;
+		if (w->busy)
+			break;
+		switch( wParam ) {
+		case SIZE_MAXIMIZED:
+		case SIZE_MINIMIZED:
+		case SIZE_RESTORED:
+			newW = LOWORD( lParam );		/* WIN32?? */
+			newH = HIWORD( lParam );		/* WIN32?? */
+			if (newW <= 0 || newH <= 0)
+				break;
+			if (newW == w->w && newH == w->h)
+				break;
+			GetWindowRect( w->hWnd, &rect );
+			GetClientRect( w->hWnd, &rect );
+			InvalidateRect( w->hWnd, NULL, TRUE );
+			w->w = newW;
+			w->h = newH;
+			if (w->winProc)
+				w->winProc( w, wResize_e, w->data );
+			break;
+		default:
+			break;
+		}
+		break;
+
+	case WM_CHAR:  
+	case WM_KEYUP:	
+		inx = GetWindowWord( hWnd, 0 );
+		if ( inx < CONTROL_BASE || inx > controlMap_da.cnt )
+			break;
+		w = (wWin_p)controlMap(inx-CONTROL_BASE).b;
+		if (!w)
+			break;
+		if (w->type != W_MAIN && w->type != W_POPUP) {
+			if (mswCallBacks[w->type] != NULL &&
+				mswCallBacks[w->type]->messageProc)
+				return mswCallBacks[w->type]->messageProc( (wControl_p)w, hWnd,
+								message, wParam, lParam );
+			break;
+		}
+		extChar = translateExtKey( WCMD_PARAM_ID );
+		if (message == WM_KEYUP ) {
+			if (extChar == wAccelKey_None)
+				break;
+			if (extChar == wAccelKey_Back)
+				break;
+		}
+		b = getControlFromCursor( hWnd, NULL );
+		closeBalloonHelp();
+		if (b && b->type == B_DRAW) {
+			return SendMessage( b->hWnd, WM_CHAR, wParam, lParam );
+		}
+		switch (WCMD_PARAM_ID) {
+		case 0x0D:
+			/* CR - push default button */
+			for (b=w->first; b; b=b->next) {
+				if (b->type == B_BUTTON && (b->option & BB_DEFAULT) != 0) {
+					inMainWndProc = TRUE;
+					if (mswCallBacks[B_BUTTON] != NULL &&
+						mswCallBacks[B_BUTTON]->messageProc) {
+						ret = mswCallBacks[B_BUTTON]->messageProc( b, b->hWnd,
+								WM_COMMAND, wParam, lParam );
+					}
+					inMainWndProc = FALSE;
+					break;
+				}
+			}
+			return 0L;
+		case 0x1B:
+			/* ESC - push cancel button */
+			for (b=w->first; b; b=b->next) {
+				if (b->type == B_BUTTON && (b->option & BB_CANCEL) != 0) {
+					inMainWndProc = TRUE;
+					if (mswCallBacks[B_BUTTON] != NULL &&
+						mswCallBacks[B_BUTTON]->messageProc) {
+						ret = mswCallBacks[B_BUTTON]->messageProc( b, b->hWnd,
+								WM_COMMAND, wParam, lParam );
+					}
+					inMainWndProc = FALSE;
+					break;
+				}
+			}
+			mswSetTrigger( (wControl_p)TRIGGER_TIMER, NULL );
+			return 0L;
+		case 0x20:
+			/* SPC - push current button with focus */
+			if ( (b=w->focusChainNext) != NULL ) {
+				switch (b->type) {
+				case B_BUTTON:
+				case B_CHOICEITEM:
+					inMainWndProc = TRUE;
+					if (mswCallBacks[b->type] != NULL &&
+						mswCallBacks[b->type]->messageProc) {
+						ret = mswCallBacks[b->type]->messageProc( b, b->hWnd,
+								WM_COMMAND, MAKELPARAM( LOWORD(wParam), BN_CLICKED), (LPARAM)(b->hWnd) );
+					}
+					inMainWndProc = FALSE;
+					break;
+				}
+			}
+			return 0L;
+		case 0x09:
+			/* TAB - jump to next control */
+			if ( w->focusChainNext ) {
+				for ( b = w->focusChainNext->focusChainNext;
+				      b!=w->focusChainNext;
+					  b=b->focusChainNext ) {
+						if( IsWindowVisible(b->hWnd) && IsWindowEnabled(b->hWnd))
+							break;
+				}
+				oldW = w->focusChainNext;
+				w->focusChainNext = b;
+				if (!inMainWndProc) {
+					inMainWndProc = TRUE;
+					SetFocus( b->hWnd );					
+/*					if( b->type == B_BUTTON)
+						InvalidateRect( b->hWnd, NULL, TRUE ); */
+					if( oldW->type == B_BUTTON) 						
+						InvalidateRect( oldW->hWnd, NULL, TRUE );
+
+					inMainWndProc = FALSE;
+				}
+			}
+			return 0L;
+		}
+		/* Not a Draw control */
+		MessageBeep( MB_ICONHAND );
+		return 0L;
+		break;					   
+
+	case WM_ENABLE:
+		if (wParam == 1) {		/* WIN32??? */
+			hWnd2 = SetFocus( hWnd );
+		}		 
+		break;
+
+	case WM_F1DOWN:
+		if ((hWnd2 = GetActiveWindow()) == hWnd ||
+			(inx=GetWindowWord(hWnd2,0)) < CONTROL_BASE || inx > controlMap_da.cnt )
+			return DefWindowProc( hWnd, message, wParam, lParam );
+		b=controlMap(inx-CONTROL_BASE).b;
+		if (!b)
+			break;
+		closeBalloonHelp();
+		wHelp( b->helpStr );
+		return 0L;
+
+	case WM_SETCURSOR:
+		/*if (any buttons down)
+			break;*/
+		wSetCursor( curCursor );
+		if (!mswAllowBalloonHelp)
+			break;
+		if (IsIconic(mswHWnd))
+			break;
+		b = getControlFromCursor(hWnd, NULL);
+		if ( b == balloonControlButton )
+				break;
+		if ( /*(!IsWindowEnabled(hWnd))*/ GetActiveWindow() != hWnd ||
+			 (!b) || b->type == B_DRAW || b->helpStr == NULL ) {
+			closeBalloonHelp();
+			break;
+		}
+		if ( b != balloonHelpButton )
+			 closeBalloonHelp();
+		if (balloonHelpState != balloonHelpIdle) {
+			break;
+		}
+		balloonHelpTimer = SetTimer( mswHWnd, BALLOONHELP_TIMER,
+				balloonHelpTimeOut, NULL );
+		if (balloonHelpTimer == (UINT)0)
+			break;
+		balloonHelpState = balloonHelpWait;
+		balloonHelpButton = b;
+		break;
+
+	case WM_SYSCOMMAND:
+		inx = GetWindowWord( hWnd, 0 );
+		if (inx < CONTROL_BASE || inx > controlMap_da.cnt)
+			break;
+		w = (wWin_p)controlMap(inx-CONTROL_BASE).b;
+		if (!w)
+			break;
+		if (w->type != W_POPUP) 
+			break;
+		if (w->busy)
+			break;
+		if ( (wParam&0xFFF0) != SC_CLOSE )
+			break;
+		if (w->winProc)
+			w->winProc( w, wClose_e, w->data );
+		wWinShow( w, FALSE );
+		return 0L;
+
+		
+
+	case WM_CLOSE:
+		inx = GetWindowWord( hWnd, 0 );
+		if (inx < CONTROL_BASE || inx > controlMap_da.cnt)
+			break;
+		w = (wWin_p)controlMap(inx-CONTROL_BASE).b;
+		if (!w)
+			break;
+		if (w->type == W_MAIN) {
+			/* It's the big one! */
+			/* call main window procedure for processing of shutdown */
+			if( w->winProc )
+				(w->winProc( w, wClose_e, NULL ));
+			return 0L;
+		}
+
+	case WM_DESTROY:
+		if ( hWnd == mswHWnd ) {
+			PostQuitMessage(0L);
+			return 0L;
+		}
+		break;
+
+	case WM_TIMER:
+		if (wParam == ALARM_TIMER) {
+			KillTimer( mswHWnd, alarmTimer );
+			alarmFunc();
+		} else if (wParam == TRIGGER_TIMER) {
+			KillTimer( mswHWnd, triggerTimer );
+			triggerTimer = 0;
+			if (triggerFunc)
+				triggerFunc( triggerControl );
+		} else if (wParam == BALLOONHELP_TIMER) {
+			KillTimer( hWnd, balloonHelpTimer );
+			balloonHelpTimer = (UINT)0;
+			startBalloonHelp();
+		}
+		return 0L;
+
+	case WM_MENUSELECT:
+		mswAllowBalloonHelp = TRUE;
+		closeBalloonHelp();
+		break;
+
+	case WM_WINDOWPOSCHANGED:
+		if (hWnd == mswHWnd && !IsIconic(hWnd) && needToDoPendingShow) {
+			for (w=winFirst; w; w=(wWin_p)w->next) {
+				if (w->hWnd != mswHWnd &&
+					w->pendingShow )
+					ShowWindow( w->hWnd, SW_SHOW );
+				w->pendingShow = FALSE;
+			}
+			needToDoPendingShow = FALSE;
+		}
+		break;
+
+	case 51:
+		count51++;
+		/*return NULL;*/
+
+#ifdef LATER
+	case WM_SETFOCUS:
+		hDc = GetDC( hWnd );
+		rc = RealizePalette( hDc );
+		ReleaseDC( hWnd, hDc );
+		inx = GetWindowWord( hWnd, 0 );
+		if ( inx < CONTROL_BASE || inx > controlMap_da.cnt )
+			break;
+		w = (wWin_p)controlMap(inx-CONTROL_BASE).b;
+		if (!w)
+			break;
+		if (w->type != W_MAIN && w->type != W_POPUP)
+			break;
+		for (b=w->first; b; b=b->next) {
+			if (b->hWnd && (b->type == B_BUTTON || b->type==B_DRAW)) {
+				hDc = GetDC( b->hWnd );
+				rc = RealizePalette( hDc );
+				ReleaseDC( b->hWnd, hDc );
+			}
+		}
+		break;
+#endif
+
+	case WM_PALETTECHANGED:
+		if (wParam == (WPARAM)hWnd)
+			return 0L;
+
+	case WM_QUERYNEWPALETTE:
+		if (mswPalette) {
+			hDc = GetDC( hWnd );
+			SelectPalette( hDc, mswPalette, 0 );
+			inx = RealizePalette( hDc );
+			ReleaseDC( hWnd, hDc );
+			if (inx>0)
+				InvalidateRect( hWnd, NULL, TRUE );
+			return inx;
+		}
+
+	case WM_ACTIVATE:
+		if ( LOWORD(wParam) == WA_INACTIVE )
+			closeBalloonHelp();
+		break;
+		
+	case WM_HSCROLL:
+	case WM_VSCROLL:
+		b = getControlFromCursor( hWnd, NULL );
+		if (!b)
+			break;
+		/*mswSetFocus( b );*/
+		ret = 0L;
+		if (!inMainWndProc) {
+			inMainWndProc = TRUE;
+			if (mswCallBacks[b->type] != NULL &&
+				mswCallBacks[b->type]->messageProc) {
+				ret = mswCallBacks[b->type]->messageProc( b, hWnd, message, wParam, lParam );
+			}
+			inMainWndProc = FALSE;
+		}
+		return ret;
+		
+   case WM_LBUTTONDOWN:
+   case WM_MOUSEMOVE:
+   case WM_LBUTTONUP:
+		b = getControlFromCursor( hWnd, NULL );
+		if (!b)
+			break;
+		/*mswSetFocus( b );*/
+		ret = 0L;
+		if (!inMainWndProc) {
+			inMainWndProc = TRUE;
+			if (mswCallBacks[b->type] != NULL &&
+				mswCallBacks[b->type]->messageProc) {
+				ret = mswCallBacks[b->type]->messageProc( b, hWnd, message, wParam, lParam );
+			}
+			inMainWndProc = FALSE;
+		}
+		return ret;
+				
+	default:
+		;
+	}
+	return DefWindowProc( hWnd, message, wParam, lParam );
+}
+
+/*
+ *****************************************************************************
+ *
+ * INIT
+ *
+ *****************************************************************************
+ */
+
+/**
+ * Register window classes used by the application. These are the main window, 
+ * the popup windows, the tooltip window and the drawing area. 
+ *
+ * \param hinstCurrent IN application instance
+ * \return    FALSE in case of error, else TRUE
+ */
+
+static BOOL InitApplication( HINSTANCE hinstCurrent )
+{
+	WNDCLASS wc;
+
+	wc.style = 0L;
+	wc.lpfnWndProc = MainWndProc;
+
+	wc.cbClsExtra = 0;
+	wc.cbWndExtra = 4;
+	wc.hInstance = hinstCurrent;			
+	wc.hIcon = LoadIcon( hinstCurrent, "MSWAPPICON" );
+	wc.hCursor = NULL; 
+	wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
+	wc.lpszMenuName = NULL;
+	wc.lpszClassName = "MswMainWindow";
+	if (!RegisterClass(&wc)) {
+		mswFail("RegisterClass(MainWindow)");
+		return FALSE;
+	}
+
+	wc.style = CS_SAVEBITS;
+	wc.lpfnWndProc = MainWndProc;
+
+	wc.cbClsExtra = 0;
+	wc.cbWndExtra = 8;
+	wc.hInstance = hinstCurrent;
+	wc.hIcon = LoadIcon( NULL, "wAppIcon" );
+	wc.hCursor = NULL; 
+	wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
+	wc.lpszMenuName = "GenericMenu";
+	wc.lpszClassName = "MswPopUpWindow";
+	if (!RegisterClass(&wc)) {
+		mswFail("RegisterClass(PopUpWindow)");
+		return FALSE;
+	}
+
+	wc.style = CS_SAVEBITS;
+	wc.lpfnWndProc = DefWindowProc;
+
+	wc.cbClsExtra = 0;
+	wc.cbWndExtra = 4;
+	wc.hInstance = hinstCurrent;
+	wc.hIcon = 0;
+	wc.hCursor = 0;
+	wc.hbrBackground = CreateSolidBrush( GetSysColor( COLOR_INFOBK ) ); 
+	wc.lpszMenuName = NULL;
+	wc.lpszClassName = "MswBalloonHelp";
+	if (!RegisterClass(&wc)) {
+		mswFail("RegisterClass(BalloonHelp)");
+		return FALSE;
+		}
+ 
+	wc.style = CS_VREDRAW | CS_HREDRAW | CS_OWNDC;
+	wc.lpfnWndProc = mswDrawPush;
+	wc.lpszClassName = mswDrawWindowClassName;
+	wc.cbWndExtra = 4;
+	if (!RegisterClass(&wc)) {
+		mswFail("RegisterClass(drawClass)");
+		return FALSE;
+	}
+	return TRUE;
+}
+
+/**
+ * Standard entry point for the app. Nothing special, 
+ * create some window classes, initialize some global 
+ * variables with system information, call the application main
+ * and finally process the message queue.
+ */
+
+int PASCAL WinMain( HINSTANCE hinstCurrent, HINSTANCE hinstPrevious, LPSTR lpszCmdLine, int nCmdShow )
+{
+	MSG msg;
+	HDC hDc;
+	char **argv;
+	int argc;
+	TEXTMETRIC tm;
+	DWORD dw;
+
+	if (!hinstPrevious)
+		if (!InitApplication(hinstCurrent))
+			return FALSE;
+
+	mswHInst = hinstCurrent;
+
+	mTitleH = GetSystemMetrics( SM_CYCAPTION ) - 1;
+	mFixBorderW = GetSystemMetrics( SM_CXBORDER );
+	mFixBorderH = GetSystemMetrics( SM_CYBORDER );
+	mResizeBorderW = GetSystemMetrics( SM_CXFRAME );
+	mResizeBorderH = GetSystemMetrics( SM_CYFRAME );
+	mMenuH = GetSystemMetrics( SM_CYMENU ) + 1;
+	screenWidth = GetSystemMetrics( SM_CXSCREEN );
+	screenHeight = GetSystemMetrics( SM_CYSCREEN );
+	mswLabelFont = GetStockObject( DEFAULT_GUI_FONT );
+
+	hDc = GetDC( 0 );
+	mswScale = GetDeviceCaps( hDc, LOGPIXELSX ) / 96.0;
+	if ( mswScale < 1.0 )
+		mswScale = 1.0;
+	GetTextMetrics( hDc, &tm );
+	mswEditHeight = tm.tmHeight + 8;
+	dw = GetTextExtent( hDc, "AXqypj", 6 );
+	mswEditHeight = HIWORD(dw)+2;
+	ReleaseDC( 0, hDc );
+
+	mswCreateCheckBitmaps();
+
+	/* 
+	   get the command line parameters in standard C style and pass them to the main function. The
+	   globals are predefined by Visual C
+	*/
+	argc = __argc;
+	argv = __argv;
+
+	mswWin = wMain( argc, (char**)argv );
+	if (mswWin == NULL)
+		return 0;
+
+	balloonHelpHWnd = CreateWindow( "MswBalloonHelp", "BalloonHelp",
+				WS_POPUP|WS_BORDER,
+				0, 0, 80, 40, mswHWnd, NULL, mswHInst, NULL );
+	if (balloonHelpHWnd == (HWND)0) {
+		mswFail( "CreateWindow(BALLOONHELP)" );
+	} else {
+		hDc = GetDC( balloonHelpHWnd );
+		/* We need to remember this because the hDc gets changed somehow,
+		/* and we when we select the oldFont back in we don't get newFont */
+		balloonHelpNewFont = CreateFont( - balloonHelpFontSize, 0, 0, 0, 0, 0,
+				0, 0, 0, 0, 0, 0, 0, balloonHelpFaceName );
+		balloonHelpOldFont = SelectObject( hDc, balloonHelpNewFont );
+		ReleaseDC( balloonHelpHWnd, hDc );
+	}
+
+	SetCursor( LoadCursor( NULL, IDC_ARROW ) );
+	while (GetMessage( &msg, NULL, 0, 0 )) {
+		if (!mswTranslateAccelerator( mswWin->hWnd, &msg )) {
+			TranslateMessage( &msg );
+			DispatchMessage( &msg );
+		}
+	}
+
+	if( helpInitted == TRUE )
+		HtmlHelp( NULL, NULL, HH_UNINITIALIZE, (DWORD)dwCookie);
+
+	return msg.wParam;
+}
diff --git a/app/wlib/mswlib/mswmsg.c b/app/wlib/mswlib/mswmsg.c
new file mode 100644
index 0000000..b128534
--- /dev/null
+++ b/app/wlib/mswlib/mswmsg.c
@@ -0,0 +1,212 @@
+#include <windows.h>
+#include <string.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <commdlg.h>
+#include <math.h>
+#include "mswint.h"
+
+/*
+ *****************************************************************************
+ *
+ * Message Boxes
+ *
+ *****************************************************************************
+ */
+
+/**
+ * factors by which fonts are resized if nonstandard text height is used
+ */
+
+#define SCALE_LARGE 1.6
+#define SCALE_SMALL 0.8
+
+#ifdef CONTROL3D
+static int messageHeight = 18;
+#endif
+
+struct wMessage_t {
+		WOBJ_COMMON
+		long flags;
+		const char * message;
+		};
+
+#ifndef CONTROL3D
+static void repaintMessage(
+		HWND hWnd,
+		wControl_p b )
+{
+	wMessage_p bm = (wMessage_p)b;
+	HDC hDc;
+	RECT rect;
+	HFONT hFont;
+	LOGFONT msgFont;
+	double scale = 1.0;
+
+	hDc = GetDC( hWnd );
+
+	if ( !mswThickFont )
+		hFont = SelectObject( hDc, mswLabelFont );
+
+	switch( wMessageSetFont( ((wMessage_p)b)->flags )) 
+	{
+		case BM_LARGE:
+			scale = SCALE_LARGE;
+			break;
+		case BM_SMALL:
+			scale = SCALE_SMALL;
+			break;
+	}
+
+	/* is a non-standard text height required? */	 
+	if( scale != 1.0 )
+	{
+		/* if yes, get information about the standard font used */
+		GetObject( GetStockObject( DEFAULT_GUI_FONT ), sizeof( LOGFONT ), &msgFont );
+
+		/* change the height */
+		msgFont.lfHeight = (long)((double)msgFont.lfHeight * scale); 
+
+		/* create and activate the new font */
+		hFont = SelectObject( hDc, CreateFontIndirect( &msgFont ) );
+	} else {
+		if ( !mswThickFont )
+			hFont = SelectObject( hDc, mswLabelFont );
+	}
+
+	rect.bottom = (long)(bm->y+( bm->h ));
+	rect.right = (long)(bm->x+( scale * bm->w ));
+	rect.top = bm->y;
+	rect.left = bm->x;
+
+	SetBkColor( hDc, GetSysColor( COLOR_BTNFACE ) );
+	ExtTextOut( hDc, bm->x, bm->y, ETO_CLIPPED|ETO_OPAQUE, &rect, bm->message, strlen( bm->message ), NULL );
+
+	if( scale != 1.0 )
+		/* in case we did create a new font earlier, delete it now */
+		DeleteObject( SelectObject( hDc, GetStockObject( DEFAULT_GUI_FONT )));
+	else 
+		if ( !mswThickFont )
+			SelectObject( hDc, hFont );
+
+	ReleaseDC( hWnd, hDc );
+}
+#endif
+
+void wMessageSetValue(
+		wMessage_p b,
+		const char * arg )
+{
+	if (b->message)
+		free( CAST_AWAY_CONST b->message );
+	if (arg)
+		b->message = mswStrdup( arg );
+	else
+		b->message = NULL;
+#ifdef CONTROL3D
+	SetWindowText( b->hWnd, arg );
+#else
+	repaintMessage( ((wControl_p)(b->parent))->hWnd, (wControl_p)b );
+#endif
+}
+
+void wMessageSetWidth(
+		wMessage_p b,
+		wPos_t width )
+{
+	b->w = width;
+#ifdef CONTROL3D
+	SetWindowPos( b->hWnd, HWND_TOP, CW_USEDEFAULT, CW_USEDEFAULT,
+				width, messageHeight, SWP_NOMOVE );
+#endif
+}
+
+
+wPos_t wMessageGetHeight( long flags )
+{
+#ifdef CONTROL3D
+	return messageHeight;
+#else
+	double scale = 1.0;
+
+	if( flags & BM_LARGE )
+		scale = SCALE_LARGE;
+	if( flags & BM_SMALL )
+		scale = SCALE_SMALL;
+
+	return((wPos_t)((mswEditHeight - 4) * scale ));
+#endif
+}
+
+static void mswMessageSetBusy(
+		wControl_p b,
+		BOOL_T busy )
+{
+}
+
+
+#ifndef CONTROL3D
+static callBacks_t messageCallBacks = {
+		repaintMessage,
+		NULL,
+		NULL,
+		mswMessageSetBusy };
+#endif
+
+
+wMessage_p wMessageCreateEx(
+		wWin_p	parent,
+		POS_T	x,
+		POS_T	y,
+		const char	* helpStr,
+		POS_T	width,
+		const char	*message,
+		long	flags )
+{
+	wMessage_p b;
+	int index;
+	
+#ifdef CONTROL3D
+	RECT rect;
+#endif
+	
+	b = (wMessage_p)mswAlloc( parent, B_MESSAGE, NULL, sizeof *b, NULL, &index );
+	mswComputePos( (wControl_p)b, x, y );
+	b->option |= BO_READONLY;
+	b->message = mswStrdup( message );
+	b->flags = flags;
+
+#ifdef CONTROL3D
+	if ( width <= 0	 && strlen(b->message) > 0 ) {
+		width = wLabelWidth( b->message );
+	}
+		
+	b->hWnd = CreateWindow( "STATIC", NULL,
+						SS_LEFTNOWORDWRAP | WS_CHILD | WS_VISIBLE,
+						b->x, b->y,
+						width, messageHeight,
+						((wControl_p)parent)->hWnd, (HMENU)index, mswHInst, NULL );
+	if (b->hWnd == NULL) {
+		mswFail("CreateWindow(MESSAGE)");
+		return b;
+	}
+
+	if ( !mswThickFont )
+		SendMessage( b->hWnd, WM_SETFONT, (WPARAM)mswLabelFont, 0L );
+	SetWindowText( b->hWnd, message );
+
+	GetWindowRect( b->hWnd, &rect );
+	b->w = rect.right - rect.left;
+	b->h = rect.bottom - rect.top;
+#else
+	b->w = width;
+	b->h = wMessageGetHeight( flags ) + 1;
+
+	repaintMessage( ((wControl_p)parent)->hWnd, (wControl_p)b );
+#endif
+	mswAddButton( (wControl_p)b, FALSE, helpStr );
+#ifndef CONTROL3D
+	mswCallBacks[B_MESSAGE] = &messageCallBacks;
+#endif
+	return b;
+}
diff --git a/app/wlib/mswlib/mswpref.c b/app/wlib/mswlib/mswpref.c
new file mode 100644
index 0000000..90cf8fc
--- /dev/null
+++ b/app/wlib/mswlib/mswpref.c
@@ -0,0 +1,274 @@
+#include <windows.h>
+#include <string.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <commdlg.h>
+#include <math.h>
+#include <stdio.h>
+#include "mswint.h"
+#include <shlobj.h>
+#include <Shlwapi.h>
+
+#if _MSC_VER >=1400
+	#define stricmp _stricmp
+#endif
+
+char * mswStrdup( const char * );
+static char appLibDirName[MAX_PATH];
+static char appWorkDirName[MAX_PATH];
+
+/**
+ * Get the location of the shared files (parameters, help file, etc. ): This location is
+ * derived from the modulename, ie. the directory where the exe is installed.
+ * For an instalaltion directory of somedir/bin/xtrkcad.exe the library directory is
+ * somedir/share/xtrkcad/
+ */
+
+const char * wGetAppLibDir( void )
+{
+	char *cp;
+	char module_name[MAX_PATH];
+
+	if (appLibDirName[0] != '\0') {
+		return appLibDirName;
+	}
+
+	GetModuleFileName( mswHInst, module_name, sizeof module_name );
+	cp = strrchr( module_name, '\\' );
+	if (cp)
+		*cp = '\0';
+
+#ifdef XTRKCAD_CMAKE_BUILD
+	strcpy(appLibDirName, module_name);
+	strcat(appLibDirName, "\\..\\share\\xtrkcad");
+	_fullpath( appLibDirName, appLibDirName, MAX_PATH );
+	return appLibDirName;
+#endif	
+
+	strcpy(appLibDirName, module_name);
+	return appLibDirName;
+}
+
+
+/**
+ * Gets the working directory for the application. At least the INI file is stored here. 
+ * The working directory can be specified manually by creating a file called xtrkcad0.ini
+ * in the application lib dir (the directory where the .EXE is located). 
+ *
+ * [workdir]
+ *		path=somepath
+ * 
+ * when somepath is set to the keyword "installdir", the install directory for the EXE is
+ * used.
+ *
+ * If no xtrkcad0.ini could be found, the user settings directory (appdata) is used.
+ *
+ */
+const char * wGetAppWorkDir( void )
+{
+	char *cp;
+	int rc;
+	if ( appWorkDirName[0] != 0 ) {
+		return appWorkDirName;
+	}
+	wGetAppLibDir();
+	sprintf( mswTmpBuff, "%s\\xtrkcad0.ini", appLibDirName );
+	rc = GetPrivateProfileString( "workdir", "path", "", appWorkDirName, sizeof appWorkDirName, mswTmpBuff );
+	if ( rc!=0 ) {
+		if ( stricmp( appWorkDirName, "installdir" ) == 0 ) {
+			strcpy( appWorkDirName, appLibDirName );
+		} else {
+			cp = &appWorkDirName[strlen(appWorkDirName)-1];
+			while (cp>appWorkDirName && *cp == '\\') *cp-- = 0;
+		}
+		return appWorkDirName;
+	}
+
+	if (SHGetSpecialFolderPath( NULL, mswTmpBuff, CSIDL_APPDATA, 0 ) == 0 ) {
+			wNoticeEx( NT_ERROR, "Cannot get user's profile directory", "Exit", NULL );
+			wExit(0);
+	} else {
+		sprintf( appWorkDirName, "%s\\%s", mswTmpBuff, "XTrackCad" );
+		if( !PathIsDirectory( appWorkDirName )) {
+			if( !CreateDirectory( appWorkDirName, NULL )) {
+				wNoticeEx( NT_ERROR, "Cannot create user's profile directory", "Exit", NULL );
+				wExit(0);
+			}
+		}
+	}
+
+	return appWorkDirName;
+}
+
+/** Get the user's home directory.  The environment variable HOME is
+ * assumed to contain the proper directory.
+ *
+ * \return    pointer to the user's home directory
+ */
+
+const char *wGetUserHomeDir( void )
+{
+	if (SHGetSpecialFolderPath( NULL, mswTmpBuff, CSIDL_PERSONAL, 0 ) == 0 ) {
+		wNoticeEx( NT_ERROR, "Cannot get user's home directory", "Exit", NULL );
+		wExit(0);
+		return( NULL );
+	} else {
+		return( mswTmpBuff );
+	}
+}
+
+typedef struct {
+		char * section;
+		char * name;
+		BOOL_T present;
+		BOOL_T dirty;
+		char * val;
+		} prefs_t;
+dynArr_t prefs_da;
+#define prefs(N) DYNARR_N(prefs_t,prefs_da,N)
+
+void wPrefSetString( const char * section, const char * name, const char * sval )
+{
+	prefs_t * p;
+	
+	for (p=&prefs(0); p<&prefs(prefs_da.cnt); p++) {
+		if ( strcmp( p->section, section ) == 0 && strcmp( p->name, name ) == 0 ) {
+			if (p->val)
+				free(p->val);
+			p->dirty = TRUE;
+			p->val = mswStrdup( sval );
+			return;
+		}
+	}
+	DYNARR_APPEND( prefs_t, prefs_da, 10 );
+	p = &prefs(prefs_da.cnt-1);
+	p->name = mswStrdup(name);
+	p->section = mswStrdup(section);
+	p->dirty = TRUE;
+	p->val = mswStrdup(sval);
+}
+
+
+const char * wPrefGetString( const char * section, const char * name )
+{
+	prefs_t * p;
+	int rc;
+	
+	for (p=&prefs(0); p<&prefs(prefs_da.cnt); p++) {
+		if ( strcmp( p->section, section ) == 0 && strcmp( p->name, name ) == 0 ) {
+			return p->val;
+		}
+	}
+	rc = GetPrivateProfileString( section, name, "", mswTmpBuff, sizeof mswTmpBuff, mswProfileFile );
+	if (rc==0)
+		return NULL;
+	DYNARR_APPEND( prefs_t, prefs_da, 10 );
+	p = &prefs(prefs_da.cnt-1);
+	p->name = mswStrdup(name);
+	p->section = mswStrdup(section);
+	p->dirty = FALSE;
+	p->val = mswStrdup(mswTmpBuff);
+	return p->val;
+}
+
+
+void wPrefSetInteger( const char * section, const char * name, long lval )
+{
+	char tmp[20];
+	
+	sprintf( tmp, "%ld", lval );
+	wPrefSetString( section, name, tmp );
+}
+
+
+wBool_t wPrefGetInteger(
+		const char * section,
+		const char * name,
+		long *res,
+		long def )
+{
+	const char * cp;
+        char * cp1;
+
+	cp = wPrefGetString( section, name );
+	if (cp == NULL) {
+		*res = def;
+		return FALSE;
+	}
+	*res = strtol(cp,&cp1,0);
+	if (cp==cp1) {
+		*res = def;
+		return FALSE;
+	}
+	return TRUE;
+}
+
+
+void wPrefSetFloat(
+		const char * section,			/* Section */
+		const char * name,			/* Name */
+		double lval )			/* Value */
+/*
+*/
+{
+	char tmp[20];
+
+	sprintf(tmp, "%0.6f", lval );
+	wPrefSetString( section, name, tmp );
+}
+
+
+wBool_t wPrefGetFloat(
+		const char * section,			/* Section */
+		const char * name,			/* Name */
+		double * res,			/* Address of result */
+		double def )			/* Default value */
+/*
+*/
+{
+	const char * cp;
+        char * cp1;
+
+	cp = wPrefGetString( section, name );
+	if (cp == NULL) {
+		*res = def;
+		return FALSE;
+	}
+	*res = strtod(cp, &cp1);
+	if (cp == cp1) {
+		*res = def;
+		return FALSE;
+	}
+	return TRUE;
+}
+
+
+void wPrefFlush( void )
+{
+	prefs_t * p;
+	
+	for (p=&prefs(0); p<&prefs(prefs_da.cnt); p++) {
+	  if ( p->dirty )
+		   WritePrivateProfileString( p->section, p->name, p->val, mswProfileFile );
+	}
+	WritePrivateProfileString( NULL, NULL, NULL, mswProfileFile );
+}
+
+
+void wPrefReset(
+		void )
+/*
+*/
+{
+	prefs_t * p;
+
+	for (p=&prefs(0); p<&prefs(prefs_da.cnt); p++) {
+		if (p->section)
+			free( p->section );
+		if (p->name)
+			free( p->name );
+		if (p->val)
+			free( p->val );
+	}
+	prefs_da.cnt = 0;
+}
diff --git a/app/wlib/mswlib/mswprint.c b/app/wlib/mswlib/mswprint.c
new file mode 100644
index 0000000..91f05ea
--- /dev/null
+++ b/app/wlib/mswlib/mswprint.c
@@ -0,0 +1,387 @@
+#include <windows.h>
+#include <string.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <commdlg.h>
+#include <math.h>
+#ifndef WIN32
+#include <print.h>
+#endif
+#include "mswint.h"
+
+/*
+ *****************************************************************************
+ *
+ * PRINT
+ *
+ *****************************************************************************
+ */
+
+
+struct wDraw_t print_d;
+
+#ifdef WIN32
+struct tagPDA printDlg;
+#else
+struct tagPD printDlg;
+#endif
+static int printStatus = FALSE;
+static DOCINFO docInfo;
+static double pageSizeW = 8.5, pageSizeH = 11.0;
+static double physSizeW = 8.5, physSizeH = 11.0;
+static int pageCount = -1;
+
+static HPALETTE newPrintPalette;
+static HPALETTE oldPrintPalette;
+
+
+void wPrintClip( wPos_t x, wPos_t y, wPos_t w, wPos_t h )
+{
+	wDrawClip( &print_d, x, y, w, h );
+}
+
+
+void getPageDim( HDC hDc )
+{
+	int rc;
+	POINT dims;
+	POINT offs;
+	int res_w, res_h, size_w, size_h;
+	rc = Escape( hDc, GETPHYSPAGESIZE, 0, NULL, (LPPOINT)&dims );
+	if (rc <0) {
+	   mswFail( "GETPHYPAGESIZE" );
+	}
+	rc = Escape( hDc, GETPRINTINGOFFSET, 0, NULL, (LPPOINT)&offs );
+	if (rc <0) {
+	   mswFail( "GETPRINTINGOFFSET" );
+	}
+	print_d.wFactor = (double)GetDeviceCaps( hDc, LOGPIXELSX );
+	print_d.hFactor = (double)GetDeviceCaps( hDc, LOGPIXELSY );
+	if (print_d.wFactor <= 0 || print_d.hFactor <= 0) {
+		mswFail( "getPageDim: LOGPIXELS... <= 0" );
+		abort();
+	}
+	print_d.DPI = min( print_d.wFactor, print_d.hFactor );
+	size_w = GetDeviceCaps( hDc, HORZSIZE );
+	size_h = GetDeviceCaps( hDc, VERTSIZE );
+	print_d.w = res_w = GetDeviceCaps( hDc, HORZRES );
+	print_d.h = res_h = GetDeviceCaps( hDc, VERTRES );
+	pageSizeW = ((double)res_w)/print_d.wFactor;
+	pageSizeH = ((double)res_h)/print_d.hFactor;
+	physSizeW = ((double)dims.x)/print_d.wFactor;
+	physSizeH = ((double)dims.y)/print_d.hFactor;
+}
+
+static wBool_t printInit( void )
+{
+	static int initted = FALSE;
+	static int printerOk = FALSE;
+	if (initted) {
+		if (!printerOk) {
+			mswFail( "No Printers are defined" );
+		}
+		return printerOk;
+	}
+	initted = TRUE;
+	printDlg.lStructSize = sizeof printDlg;
+	printDlg.hwndOwner = NULL;
+	printDlg.Flags = PD_RETURNDC|PD_RETURNDEFAULT;
+	if (PrintDlg(&printDlg) != 0  && printDlg.hDC) {
+		getPageDim( printDlg.hDC );
+		DeleteDC( printDlg.hDC );
+	}
+#ifdef LATER
+	DEVMODE * printMode;
+	HDC hDc;
+	char ptrInfo[80];
+	char ptrDrvrDvr[80];
+	char *temp;
+	char *ptrDevice;
+	char *ptrDrvr;
+	char *ptrPort;
+	int size;
+	int rc;
+	FARPROC extDeviceMode;
+	FARPROC deviceMode;
+	HINSTANCE hDriver;
+
+	GetProfileString("windows", "device", "", ptrInfo, sizeof ptrInfo );
+	if (ptrInfo[0] == 0) {
+		mswFail( "No Printers are defined" );
+		return FALSE;
+	}
+	temp = ptrDevice = ptrInfo;
+	ptrDrvr = ptrPort = NULL;
+	while (*temp) {
+		if (*temp == ',') {
+			*temp++ = 0;
+			while( *temp == ' ' )
+				temp++;
+			if (!ptrDrvr)
+				ptrDrvr = temp;
+			else {
+				ptrPort = temp;
+				break;
+			}
+		}
+		else
+			temp = AnsiNext(temp);
+	}
+	strcpy( ptrDrvrDvr, ptrDrvr );
+	strcat( ptrDrvrDvr, ".drv" );
+	if ((long)(hDriver = LoadLibrary( ptrDrvrDvr )) <= 32) {
+		mswFail( "printInit: LoadLibrary" );
+		return FALSE;
+	}
+	if (( extDeviceMode = GetProcAddress( hDriver, "ExtDeviceMode" )) != NULL) {
+		size = extDeviceMode( mswHWnd, (HANDLE)hDriver, (LPDEVMODE)NULL, (LPSTR)ptrDevice, (LPSTR)ptrPort, (LPDEVMODE)NULL, (LPSTR)NULL, 0 );
+		printMode = (DEVMODE*)malloc( size );
+		rc = extDeviceMode( mswHWnd, (HANDLE)hDriver, (LPDEVMODE)printMode, (LPSTR)ptrDevice, (LPSTR)ptrPort, (LPDEVMODE)NULL, (LPSTR)NULL, DM_OUT_BUFFER );
+#ifdef LATER
+		if (rc != IDOK && rc != IDCANCEL) {
+			mswFail( "printInit: extDeviceMode" );
+			return FALSE;
+		}
+#endif
+	} else if (( deviceMode = GetProcAddress( hDriver, "DeviceMode" )) != NULL) {
+		rc = deviceMode( mswHWnd, (HANDLE)hDriver, (LPSTR)ptrDevice, (LPSTR)ptrPort );
+#ifdef LATER
+		if (rc != IDOK && rc != IDCANCEL) {
+			mswFail( "printInit: deviceMode" );
+			return FALSE;
+		}
+#endif
+	}
+
+	hDc = CreateDC( (LPSTR)ptrDrvr, (LPSTR)ptrDevice, (LPSTR)ptrPort, NULL );
+	if (hDc == NULL) {
+		mswFail("printInit: createDC" );
+		abort();
+	}
+	getPageDim( hDc );
+	DeleteDC( hDc );
+	
+	FreeLibrary( hDriver );
+#endif
+	printerOk = TRUE;
+	return TRUE;
+}
+
+
+wBool_t wPrintInit( void )
+{
+	if (!printInit()) {
+		return FALSE;
+	}
+	return TRUE;
+}
+
+
+void wPrintSetup( wPrintSetupCallBack_p callback )
+{
+	if (!printInit()) {
+		return;
+	}
+	/*memset( &printDlg, 0, sizeof printDlg );*/
+	printDlg.lStructSize = sizeof printDlg;
+	printDlg.hwndOwner = NULL;
+	printDlg.Flags = PD_RETURNDC|PD_PRINTSETUP;
+	if (PrintDlg(&printDlg) != 0  && printDlg.hDC) {
+		getPageDim( printDlg.hDC );
+	}
+	if ( callback ) {
+		callback( TRUE );
+	}
+}
+
+
+void wPrintGetPageSize( double *w, double *h )
+{
+	printInit();
+	*w = pageSizeW;
+	*h = pageSizeH;
+}
+
+
+void wPrintGetPhysSize( double *w, double *h )
+{
+	printInit();
+	*w = physSizeW;
+	*h = physSizeH;
+}
+
+
+HDC mswGetPrinterDC( void )
+{
+	if (!printInit()) {
+		return (HDC)0;
+	}
+	/*memset( &printDlg, 0, sizeof printDlg );*/
+	printDlg.lStructSize = sizeof printDlg;
+	printDlg.hwndOwner = NULL;
+	printDlg.Flags = PD_RETURNDC|PD_NOPAGENUMS|PD_NOSELECTION;
+	if (PrintDlg(&printDlg) != 0)
+		return printDlg.hDC;
+	else
+		return (HDC)0;
+}
+
+
+static wBool_t printAbort = FALSE;
+HWND hAbortDlgWnd;
+FARPROC lpAbortDlg, lpAbortProc;
+static int pageNumber;
+
+int FAR PASCAL mswAbortDlg( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
+{
+	if (msg == WM_COMMAND) {
+		if (WCMD_PARAM_ID == IDCANCEL) {
+			printAbort = TRUE;
+			EndDialog( hWnd, wParam );
+			return TRUE;
+		}
+	} else if (msg == WM_INITDIALOG) {
+		SetFocus( GetDlgItem( hWnd, IDCANCEL ) );
+		return TRUE;
+	}
+	return FALSE;
+}
+
+
+int FAR PASCAL _export mswAbortProc( HDC hdcPrinter, int Code )
+{
+	MSG msg;
+	while (PeekMessage((LPMSG)&msg, (HWND)0, 0, 0, PM_REMOVE)) {
+		if (!IsDialogMessage(hAbortDlgWnd, (LPMSG)&msg) ) {
+			TranslateMessage( (LPMSG)&msg );
+			DispatchMessage( (LPMSG)&msg );
+		}
+	}
+	return !printAbort;
+}
+
+
+wBool_t wPrintDocStart( const char * title, int fpageCount, int * copiesP )
+{
+	printStatus = FALSE;
+	pageCount = fpageCount;
+	pageNumber = 0;
+	print_d.hDc = mswGetPrinterDC();
+	if (print_d.hDc == (HDC)0) {
+		return FALSE;
+	}
+		printStatus = TRUE;
+		docInfo.cbSize = sizeof docInfo;
+		docInfo.lpszDocName = title;
+		docInfo.lpszOutput = NULL;
+		lpAbortDlg = MakeProcInstance( (FARPROC)mswAbortDlg, mswHInst );
+		lpAbortProc = MakeProcInstance( (FARPROC)mswAbortProc, mswHInst );
+		SetAbortProc( print_d.hDc, (ABORTPROC)lpAbortProc );
+		if (StartDoc( print_d.hDc, &docInfo ) < 0) {
+			MessageBox( mswHWnd, "Unable to start print job",
+						NULL, MB_OK|MB_ICONHAND );
+			FreeProcInstance( lpAbortDlg );
+			FreeProcInstance( lpAbortProc );
+			DeleteDC( print_d.hDc );
+			return FALSE;
+		}
+		printAbort = FALSE;
+		hAbortDlgWnd = CreateDialog( mswHInst, "MswAbortDlg", mswHWnd,
+						(DLGPROC)lpAbortDlg );
+		/*SetDlgItemText( hAbortDlgWnd, IDM_PRINTAPP, title );*/
+		SetWindowText( hAbortDlgWnd, title );
+		ShowWindow( hAbortDlgWnd, SW_NORMAL );
+		UpdateWindow( hAbortDlgWnd );
+		EnableWindow( mswHWnd, FALSE );
+		if (copiesP)
+			*copiesP = printDlg.nCopies;
+		if (printDlg.nCopies>1)
+			pageCount *= printDlg.nCopies;
+		if ( (GetDeviceCaps( printDlg.hDC, RASTERCAPS ) & RC_PALETTE) ) {
+			newPrintPalette = mswCreatePalette();
+			oldPrintPalette = SelectPalette( printDlg.hDC, newPrintPalette, 0 );
+			RealizePalette( printDlg.hDC );
+		}
+		return TRUE;
+}
+
+wDraw_p wPrintPageStart( void )
+{
+	char pageL[80];
+	if (!printStatus)
+		return NULL;
+	pageNumber++;
+	if (pageCount > 0)
+		wsprintf( pageL, "Page %d of %d", pageNumber, pageCount );
+	else
+		wsprintf( pageL, "Page %d", pageNumber );
+	SetDlgItemText( hAbortDlgWnd, IDM_PRINTPAGE, pageL );
+	StartPage( printDlg.hDC );
+#ifdef LATER
+	if (mswPrintPalette) {
+		SelectPalette( printDlg.hDC, mswPrintPalette, 0 );
+		RealizePalette( printDlg.hDC );
+	}
+#endif
+	getPageDim( printDlg.hDC );
+	SelectClipRgn( print_d.hDc, NULL );
+	return &print_d;
+}
+
+wBool_t wPrintPageEnd( wDraw_p d )
+{
+	return EndPage( printDlg.hDC ) >= 0;
+}
+
+wBool_t wPrintQuit( void )
+{
+	MSG msg;
+	while (PeekMessage((LPMSG)&msg, (HWND)0, 0, 0, PM_REMOVE)) {
+		if (!IsDialogMessage(hAbortDlgWnd, (LPMSG)&msg) ) {
+			TranslateMessage( (LPMSG)&msg );
+			DispatchMessage( (LPMSG)&msg );
+		}
+	}
+	return printAbort;
+}
+
+void wPrintDocEnd( void )
+{
+	if (!printStatus)
+		return;
+	EndDoc( printDlg.hDC );
+	if ( newPrintPalette ) {
+		SelectPalette( printDlg.hDC, oldPrintPalette, 0 );
+		DeleteObject( newPrintPalette );
+		newPrintPalette = (HPALETTE)0;
+	}
+		
+	EnableWindow( mswHWnd, TRUE );
+	DestroyWindow( hAbortDlgWnd );
+	FreeProcInstance( lpAbortDlg );
+	FreeProcInstance( lpAbortProc );
+	DeleteDC( printDlg.hDC );
+	printStatus = FALSE;
+}
+
+wBool_t wPrintFontAlias( const char * font, const char * alias )
+{
+	return TRUE;
+}
+
+wBool_t wPrintNewPrinter( const char * printer )
+{
+	return TRUE;
+}
+
+wBool_t wPrintNewMargin( const char * name, double t, double b, double l, double r )
+{
+	return TRUE;
+}
+
+void wPrintSetCallBacks(
+		wAddPrinterCallBack_p newPrinter,
+		wAddMarginCallBack_p newMargin,
+		wAddFontAliasCallBack_p newFontAlias )
+{
+}
diff --git a/app/wlib/mswlib/mswsplash.c b/app/wlib/mswlib/mswsplash.c
new file mode 100644
index 0000000..bddd081
--- /dev/null
+++ b/app/wlib/mswlib/mswsplash.c
@@ -0,0 +1,266 @@
+/**
+ *	Splash window for Windows
+ *  $header$
+ */
+
+ /*  XTrkCad - Model Railroad CAD
+ *  Copyright (C) 2007 Martin Fischer
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <windows.h>
+#include <string.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <commdlg.h>
+#include <math.h>
+#include <ctype.h>
+#include <assert.h>
+#include "mswint.h"
+
+extern HINSTANCE mswHInst;
+extern HWND mswHWnd;
+
+static HWND hSplash;
+
+#define IDAPPNAME   150
+#define IDMESSAGE   200
+#define IDBITMAP	250
+
+static LPWORD lpwAlign( LPWORD lpIn )
+{
+    ULONG ul;
+
+    ul = (ULONG) lpIn;
+    ul +=3;
+    ul >>=2;
+    ul <<=2;
+    return (LPWORD) ul;
+}
+
+/**
+ * Draw the logo bitmap. Thanks to Charles Petzold.
+ */
+
+BOOL
+PaintBitmap( HWND hWnd, HBITMAP hBmp )
+{
+	HDC hdc, hdcMem;	
+	RECT rect;
+
+	UpdateWindow( hWnd );
+
+	/* get device context for destination window ( the dialog control ) */
+	hdc = GetDC( hWnd );
+	GetClientRect( hWnd, &rect );
+	
+	/* create a memory dc holding the bitmap */
+	hdcMem = CreateCompatibleDC( hdc );
+	SelectObject( hdcMem, hBmp );
+
+	/* 
+	   show it in the uppler left corner 
+	   the window is created with the size of the bitmap, so there is no need 
+	   for any special transformation 
+	*/
+
+	BitBlt( hdc, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top,
+			hdcMem, 0, 0, SRCCOPY );
+
+	/* release the DCs that are not needed any more */
+	DeleteDC( hdcMem );
+	ReleaseDC( hWnd, hdc );
+
+	return( 0 );
+}
+
+/**
+ * This is the dialog procedure for the splash window. Main activity is to 
+ * catch the WM_PAINT message and draw the logo bitmap into that area.
+ */
+
+BOOL CALLBACK 
+SplashDlgProc( HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam )
+{
+	static HWND hWndBmp;
+	static HBITMAP hBmp;
+
+	switch( msg ) {
+		case WM_INITDIALOG:
+			/* bitmap handle is passed at dialog creation */
+			hBmp = (HBITMAP)lParam;
+
+			hWndBmp = GetDlgItem( hDlg, IDBITMAP );
+			return TRUE;
+		case WM_PAINT:
+			/* paint the logo bitmap */
+			PaintBitmap( hWndBmp, hBmp );
+			break;
+		case WM_DESTROY:
+			/* destroy the bitmap */
+			DeleteObject( hBmp );
+			break;
+	}
+	return FALSE;
+}
+
+/**
+ * Show the splash screen. For display of the splash screen, a dialog template is
+ * created in memory. This template has three static elements:
+ * - the logo
+ * - the application name
+ * - the progress message
+ *
+ * return TRUE if successful, FALSE otherwise.
+ *
+ */
+
+int
+wCreateSplash( char *appname, char *appver )
+{
+	HGLOBAL hgbl;
+    LPDLGTEMPLATE lpdt;
+	LPWORD lpw;
+	LPDLGITEMTEMPLATE lpdit;
+	int cxDlgUnit, cyDlgUnit;
+	int cx, cy;
+	char *pszBuf;
+	HBITMAP hBmp;
+	BITMAP bmp;
+	char logoPath[MAX_PATH];
+
+	/* find the size of a dialog unit */
+	cxDlgUnit = LOWORD(GetDialogBaseUnits());
+	cyDlgUnit = HIWORD(GetDialogBaseUnits());
+
+	/* load the logo bitmap */
+	sprintf( logoPath, "%s\\logo.bmp", wGetAppLibDir());
+	hBmp = LoadImage( mswHInst, logoPath, IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR | LR_LOADFROMFILE );
+	if( !hBmp )
+		return( 0 );
+
+	/* get info about the loaded logo file */	
+	GetObject( hBmp, sizeof(BITMAP), (LPVOID)&bmp );
+
+	/* calculate the size of dialog box */
+	cx = (bmp.bmWidth * 4) / cxDlgUnit;			/* start with the size of the bitmap */
+	cy = (bmp.bmHeight * 8) / cyDlgUnit + 20;	/* 20 is enough for two lines of text and some room */
+
+	/* allocate memory block for dialog template */
+	hgbl = GlobalAlloc(GMEM_ZEROINIT, 1024);
+    if (!hgbl)
+		return -1;
+    lpdt = (LPDLGTEMPLATE)GlobalLock(hgbl);
+
+    /* Define a dialog box. */
+    lpdt->style = WS_POPUP | WS_BORDER | WS_VISIBLE | DS_MODALFRAME | DS_CENTER;
+    lpdt->cdit = 3;  // number of controls
+    lpdt->x  = 0;  lpdt->y  = 0;
+    lpdt->cx = cx; lpdt->cy = cy;
+
+    lpw = (LPWORD) (lpdt + 1);
+    *lpw++ = 0;   /* no menu */
+    *lpw++ = 0;   /* predefined dialog box class (by default) */
+	*lpw++ = 0; 
+
+	/* add the static control for the logo bitmap */
+	lpdit = (LPDLGITEMTEMPLATE)lpwAlign(lpw);
+	lpdit->x  = 0; lpdit->y  = 0;
+    lpdit->cx = (SHORT)((bmp.bmWidth * 4) / cxDlgUnit); 
+	lpdit->cy = (SHORT)((bmp.bmHeight * 8) / cyDlgUnit);
+
+    lpdit->id = IDBITMAP;  
+    lpdit->style = WS_CHILD | WS_VISIBLE | SS_LEFT;
+    lpw = (LPWORD) (lpdit + 1);
+    *lpw++ = 0xFFFF;
+    *lpw++ = 0x0082;		/* static class */
+
+	lpw  += 1+MultiByteToWideChar (CP_ACP, 0, "Logo should be here...", -1, (LPWSTR)lpw, 50);
+
+	/* add the static control for the program title */
+	lpdit = (LPDLGITEMTEMPLATE)lpwAlign(lpw);
+
+	lpdit->x  = 2; lpdit->y  = (short)( 1 + (bmp.bmHeight * 8) / cyDlgUnit );
+    lpdit->cx = cx - 2; lpdit->cy = cyDlgUnit;
+    lpdit->id = IDAPPNAME;  
+    lpdit->style = WS_CHILD | WS_VISIBLE | SS_CENTER;
+    lpw = (LPWORD) (lpdit + 1);
+    *lpw++ = 0xFFFF;
+    *lpw++ = 0x0082;		/* static class */
+
+	/* create the title string */	
+	pszBuf = malloc( strlen( appname ) + strlen( appver ) + 2 );
+	if( !pszBuf )
+		return( 0 );
+	sprintf( pszBuf, "%s %s", appname, appver );
+
+	lpw  += 1+MultiByteToWideChar (CP_ACP, 0, pszBuf, -1, (LPWSTR)lpw, 50);
+
+	/* add the static control for the loading message */
+	lpdit = (LPDLGITEMTEMPLATE)lpwAlign(lpw);
+	lpdit->x  = 2; lpdit->y  = (short)(bmp.bmHeight * 8) / cyDlgUnit  + 10;
+    lpdit->cx = cx - 2; lpdit->cy = cyDlgUnit;
+    lpdit->id = IDMESSAGE;  
+    lpdit->style = WS_CHILD | WS_VISIBLE | SS_LEFT;
+    lpw = (LPWORD) (lpdit + 1);
+    *lpw++ = 0xFFFF;
+    *lpw++ = 0x0082;		/* static class */
+
+	lpw  += 1+MultiByteToWideChar (CP_ACP, 0, "Starting Application...", -1, (LPWSTR)lpw, 50);
+
+	/* create the dialog */
+    GlobalUnlock(hgbl); 
+    hSplash = CreateDialogIndirectParam( mswHInst, (LPDLGTEMPLATE) hgbl, 
+        mswHWnd, (DLGPROC)SplashDlgProc, (LPARAM)hBmp ); 
+	GetLastError();
+	
+	/* free allocated memory */
+	GlobalFree(hgbl);     
+	free( pszBuf );
+
+	/* that's it */
+	return 1; 
+}
+
+
+/**
+ * Update the progress message inside the splash window
+ * msg	text message to display
+ * return nonzero if ok
+ */ 
+
+int 
+wSetSplashInfo( char *msg )
+{
+	if( msg ) {
+		SetWindowText( GetDlgItem( hSplash, IDMESSAGE ), msg );
+		wFlush();
+		return TRUE;
+	}
+	wFlush();
+	return FALSE;
+}
+
+/**
+ * Remove the splash window from the screen.
+ */
+
+void
+wDestroySplash(void)
+{
+	DestroyWindow( hSplash );
+	return;
+}
\ No newline at end of file
diff --git a/app/wlib/mswlib/mswtext.c b/app/wlib/mswlib/mswtext.c
new file mode 100644
index 0000000..95f6268
--- /dev/null
+++ b/app/wlib/mswlib/mswtext.c
@@ -0,0 +1,383 @@
+#include <windows.h>
+#include <string.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <commdlg.h>
+#include <math.h>
+#include <stdio.h>
+#include "mswint.h"
+
+/*
+ *****************************************************************************
+ *
+ * Multi-line Text Boxes
+ *
+ *****************************************************************************
+ */
+
+static LOGFONT fixedFont = {
+		/* Initial default values */
+		-18, 0, /* H, W */
+		0,		/* A */
+		0,
+		FW_REGULAR,
+		0, 0, 0,/* I, U, SO */
+		ANSI_CHARSET,
+		0,		/* OP */
+		0,		/* CP */
+		0,		/* Q */
+		FIXED_PITCH|FF_MODERN,	/* P&F */
+		"Courier" };
+static HFONT fixedTextFont, prevTextFont;
+
+struct wText_t {
+		WOBJ_COMMON
+		HANDLE hText;
+		};
+
+BOOL_T textPrintAbort = FALSE;
+
+
+void wTextClear(
+		wText_p b )
+{
+	long rc;
+	rc = SendMessage( b->hWnd, EM_SETREADONLY, 0, 0L );
+#ifdef WIN32
+	rc = SendMessage( b->hWnd, EM_SETSEL, 0, -1 );
+#else
+	rc = SendMessage( b->hWnd, EM_SETSEL, 1, MAKELONG( 0, -1 ) );
+#endif
+	rc = SendMessage( b->hWnd, WM_CLEAR, 0, 0L );
+	if ( b->option&BO_READONLY )
+		rc = SendMessage( b->hWnd, EM_SETREADONLY, 1, 0L );
+}
+
+
+void wTextAppend(
+		wText_p b,
+		const char * text )
+{
+	HANDLE hMem;
+	char * pMem, *cp;
+	int len, textSize;
+	long rc;
+	long lc;
+	len = strlen(text);
+	if (len <= 0)
+		return;
+	for (cp= CAST_AWAY_CONST text; *cp; cp++) {
+		if ( *cp == '\n' )
+			len++;
+	}
+	hMem = GlobalAlloc( GHND, (DWORD)len+10+1 );
+	pMem = (char*)GlobalLock( hMem );
+	for (cp=pMem; *text; cp++,text++) {
+		if (*text == '\n') {
+			*cp++ = '\r';
+			*cp = '\n';
+		} else
+			*cp = *text;
+	}
+	textSize = LocalSize( b->hText );
+	if ((long)textSize+(long)len > 10000L) {
+		if (len < 1024)
+			len = 1024;
+#ifdef WIN32
+		rc = SendMessage( b->hWnd, EM_SETSEL, 0, len );
+#else
+		rc = SendMessage( b->hWnd, EM_SETSEL, 0, MAKELONG( 0, len ) );
+#endif
+		rc = SendMessage( b->hWnd, WM_CLEAR, 0, 0L );
+#ifdef WIN32
+		rc = SendMessage( b->hWnd, EM_SCROLLCARET, 0, 0 );
+#else
+		rc = SendMessage( b->hWnd, EM_SETSEL, 0, MAKELONG( 32767, 32767 ) );
+#endif
+	}
+	lc = SendMessage( b->hWnd, EM_GETFIRSTVISIBLELINE, 0, 0L );
+	if ( lc < 0 )
+		lc = 0;
+	GlobalUnlock( hMem );
+	rc = OpenClipboard( b->hWnd );
+	rc = EmptyClipboard();
+	rc = (long)SetClipboardData( CF_TEXT, hMem );
+	rc = CloseClipboard();
+	rc = SendMessage( b->hWnd, EM_SETREADONLY, 0, 0L );
+	rc = SendMessage( b->hWnd, WM_PASTE, 0, 0L );
+	lc -= SendMessage( b->hWnd, EM_GETFIRSTVISIBLELINE, 0, 0L );
+#ifdef LATER
+	if ( lc < 0 )
+		SendMessage( b->hWnd, EM_LINESCROLL, 0, MAKELPARAM((WPARAM)lc,0) );
+#endif
+	lc = GetWindowTextLength( b->hWnd );
+	if ( b->option&BO_READONLY )
+		rc = SendMessage( b->hWnd, EM_SETREADONLY, 1, 0L );
+}
+
+
+BOOL_T wTextSave(
+		wText_p b,
+		const char * fileName )
+{
+	FILE * f;
+	int lc, l, len;
+	char line[255];
+
+	f = wFileOpen( fileName, "w" );
+	if (f == NULL) {
+		MessageBox( ((wControl_p)(b->parent))->hWnd, "TextSave", "", MB_OK|MB_ICONHAND );
+		return FALSE;
+	}
+
+	lc = (int)SendMessage( b->hWnd, EM_GETLINECOUNT, 0, 0L );
+
+	for ( l=0; l<lc; l++ ) {
+		*(WORD*)line = sizeof(line)-1;
+		len = (int)SendMessage( b->hWnd, EM_GETLINE, l, (DWORD)(LPSTR)line );
+		line[len] = '\0';
+		fprintf( f, "%s\n", line );
+	}
+	fclose( f );
+	return TRUE;
+}
+
+
+BOOL_T wTextPrint(
+		wText_p b )
+{
+	int lc, l, len;
+	char line[255];
+	HDC hDc;
+	int lineSpace;
+	int linesPerPage;
+	int currentLine;
+	int IOStatus;
+	TEXTMETRIC textMetric;
+	DOCINFO docInfo;
+
+	hDc = mswGetPrinterDC();
+	if (hDc == (HDC)0) {
+		MessageBox( ((wControl_p)(b->parent))->hWnd, "Print", "Cannot print", MB_OK|MB_ICONHAND );
+		return FALSE;
+	}
+	docInfo.cbSize = sizeof(DOCINFO);
+	docInfo.lpszDocName = "XTrkcad Log";
+	docInfo.lpszOutput = (LPSTR)NULL;
+	if (StartDoc(hDc, &docInfo) < 0) {
+		MessageBox( ((wControl_p)(b->parent))->hWnd, "Unable to start print job", NULL, MB_OK|MB_ICONHAND );
+		DeleteDC( hDc );
+		return FALSE;
+	}
+	StartPage( hDc );
+	GetTextMetrics( hDc, &textMetric );
+	lineSpace = textMetric.tmHeight + textMetric.tmExternalLeading;
+	linesPerPage = GetDeviceCaps( hDc, VERTRES ) / lineSpace;
+	currentLine = 1;
+
+	lc = (int)SendMessage( b->hWnd, EM_GETLINECOUNT, 0, 0L );
+
+	IOStatus = 0;
+	for ( l=0; l<lc; l++ ) {
+		*(WORD*)line = sizeof(line)-1;
+		len = (int)SendMessage( b->hWnd, EM_GETLINE, l, (DWORD)(LPSTR)line );
+		TextOut( hDc, 0, currentLine*lineSpace, line, len );
+		if (++currentLine > linesPerPage) {
+			EndPage( hDc );
+			currentLine = 1;
+			IOStatus = EndPage(hDc);
+			if (IOStatus < 0 || textPrintAbort )
+				break;
+			StartPage( hDc );
+		}
+	}
+	if (IOStatus >= 0 && !textPrintAbort ) {
+		EndPage( hDc );
+		EndDoc( hDc );
+	}
+	DeleteDC( hDc );
+	return TRUE;
+}
+
+
+wBool_t wTextGetModified(
+		wText_p b )
+{
+	int rc;
+	rc = (int)SendMessage( b->hWnd, EM_GETMODIFY, 0, 0L );
+	return (wBool_t)rc;
+}
+
+int wTextGetSize(
+		wText_p b )
+{
+	int lc, l, li, len=0;
+	lc = (int)SendMessage( b->hWnd, EM_GETLINECOUNT, 0, 0L );
+	for ( l=0; l<lc ; l++ ) {
+		li = (int)SendMessage( b->hWnd, EM_LINEINDEX, l, 0L );
+		len += (int)SendMessage( b->hWnd, EM_LINELENGTH, l, 0L ) + 1;
+	}
+	if ( len == 1 )
+		len = 0;
+	return len;
+}
+
+void wTextGetText(
+		wText_p b,
+		char * t,
+		int s )
+{
+	int lc, l, len;
+	s--;
+	lc = (int)SendMessage( b->hWnd, EM_GETLINECOUNT, 0, 0L );
+	for ( l=0; l<lc && s>=0; l++ ) {
+		*(WORD*)t = s;
+		len = (int)SendMessage( b->hWnd, EM_GETLINE, l, (DWORD)(LPSTR)t );
+		t += len;
+		*t++ = '\n';
+		s -= len+1;
+	}
+	*t++ = '\0';
+}
+
+
+void wTextSetReadonly(
+		wText_p b,
+		wBool_t ro )
+{
+	if (ro)
+		b->option |= BO_READONLY;
+	else
+		b->option &= ~BO_READONLY;
+	SendMessage( b->hWnd, EM_SETREADONLY, ro, 0L );
+}
+
+
+void wTextSetSize(
+		wText_p bt,
+		wPos_t width,
+		wPos_t height )
+{
+	bt->w = width;
+	bt->h = height;
+	if (!SetWindowPos( bt->hWnd, HWND_TOP, 0, 0,
+		bt->w, bt->h, SWP_NOMOVE|SWP_NOZORDER)) {
+		mswFail("wTextSetSize: SetWindowPos");
+	}
+}
+
+
+void wTextComputeSize(
+		wText_p bt,
+		int rows,
+		int lines,
+		wPos_t * w,
+		wPos_t * h )
+{
+	static wPos_t scrollV_w = -1;
+	static wPos_t scrollH_h = -1;
+	HDC hDc;
+	TEXTMETRIC metrics;
+
+	if (scrollV_w < 0)
+		scrollV_w = GetSystemMetrics( SM_CXVSCROLL );
+	if (scrollH_h < 0)
+		scrollH_h = GetSystemMetrics( SM_CYHSCROLL );
+	hDc = GetDC( bt->hWnd );
+	GetTextMetrics( hDc, &metrics );
+	*w = rows * metrics.tmAveCharWidth + scrollV_w;
+	*h = lines * (metrics.tmHeight + metrics.tmExternalLeading);
+	ReleaseDC( bt->hWnd, hDc );
+	if (bt->option&BT_HSCROLL)
+		 *h += scrollH_h;
+}
+
+
+void wTextSetPosition(
+		wText_p bt,
+		int pos )
+{
+	long rc;
+	rc = SendMessage( bt->hWnd, EM_LINESCROLL, 0, MAKELONG( -65535, 0 ) );
+}
+
+static void textDoneProc( wControl_p b )
+{
+	wText_p t = (wText_p)b;
+		HDC hDc;
+		hDc = GetDC( t->hWnd );
+	SelectObject( hDc, mswOldTextFont );
+		ReleaseDC( t->hWnd, hDc );
+}
+
+static callBacks_t textCallBacks = {
+		mswRepaintLabel,
+		textDoneProc,
+		NULL };
+
+wText_p wTextCreate(
+		wWin_p	parent,
+		POS_T	x,
+		POS_T	y,
+		const char	* helpStr,
+		const char	* labelStr,
+		long	option,
+		POS_T	width,
+		POS_T	height )
+{
+	wText_p b;
+	DWORD style;
+	RECT rect;
+	int index;
+
+	b = mswAlloc( parent, B_TEXT, labelStr, sizeof *b, NULL, &index );
+	mswComputePos( (wControl_p)b, x, y );
+	b->option = option;
+	style = ES_MULTILINE | ES_LEFT | ES_AUTOVSCROLL | ES_WANTRETURN |
+			WS_CHILD | WS_VISIBLE | WS_BORDER | WS_VSCROLL;
+#ifdef BT_HSCROLL
+	if (option & BT_HSCROLL)
+		style |= WS_HSCROLL | ES_AUTOHSCROLL;
+#endif
+/*	  if (option & BO_READONLY)
+		style |= ES_READONLY;*/
+
+	b->hWnd = CreateWindow( "EDIT", NULL,
+						style, b->x, b->y,
+						width, height,
+						((wControl_p)parent)->hWnd, (HMENU)index, mswHInst, NULL );
+	if (b->hWnd == NULL) {
+		mswFail("CreateWindow(TEXT)");
+		return b;
+	}
+#ifdef CONTROL3D
+	Ctl3dSubclassCtl( b->hWnd );
+#endif
+
+	if (option & BT_FIXEDFONT) {
+		if (fixedTextFont == (HFONT)0)
+			fixedTextFont =	 CreateFontIndirect( &fixedFont );
+		SendMessage( b->hWnd, WM_SETFONT, (WPARAM)fixedTextFont, (LPARAM)MAKELONG( 1, 0 ) );
+	} else 	if ( !mswThickFont ) {
+		SendMessage( b->hWnd, WM_SETFONT, (WPARAM)mswLabelFont, 0L );
+	}
+
+	b->hText = (HANDLE)SendMessage( b->hWnd, EM_GETHANDLE, 0, 0L );
+
+	if (option & BT_CHARUNITS) {
+		wPos_t w, h;
+		wTextComputeSize( b, width, height, &w, &h );
+		if (!SetWindowPos( b->hWnd, HWND_TOP, 0, 0,
+			w, h, SWP_NOMOVE|SWP_NOZORDER)) {
+			mswFail("wTextCreate: SetWindowPos");
+		}
+	}
+
+	GetWindowRect( b->hWnd, &rect );
+	b->w = rect.right - rect.left;
+	b->h = rect.bottom - rect.top;
+
+	mswAddButton( (wControl_p)b, FALSE, helpStr );
+	mswCallBacks[B_TEXT] = &textCallBacks;
+	return b;
+}
diff --git a/app/wlib/mswlib/simple-gettext.c b/app/wlib/mswlib/simple-gettext.c
new file mode 100644
index 0000000..295d515
--- /dev/null
+++ b/app/wlib/mswlib/simple-gettext.c
@@ -0,0 +1,522 @@
+/* simple-gettext.c  - a simplified version of gettext.
+ * Copyright (C) 1995, 1996, 1997, 1999,
+ *               2005 Free Software Foundation, Inc.
+ *
+ * This file is part of XTrackCAD.
+ *
+ * GnuPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * GnuPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+/* This is a simplified version of gettext written by Ulrich Drepper.
+ * It is used for the Win32 version of GnuPG beucase all the overhead
+ * of gettext is not needed and we have to do some special Win32 stuff.
+ * I decided that this is far easier than to tweak gettext for the special
+ * cases (I tried it but it is a lot of code).	wk 15.09.99
+ */
+
+/*
+ * Based on the simple-gettext from GnuPG a version appropriate for the 
+ * needs of XTrackCAD was derived. This is a workaround for any compiler 
+ * specifics or runtime library dependencies. mf 26.07.09
+ */
+
+#ifdef USE_SIMPLE_GETTEXT
+#if !defined (_WIN32) && !defined (__CYGWIN32__)
+#error This file can only be used under Windows or Cygwin32
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <windows.h>
+
+#include "mswint.h"
+
+#if _MSC_VER > 1300
+	#define stricmp _stricmp
+	#define strnicmp _strnicmp
+	#define strdup _strdup
+	#define fileno _fileno
+#endif
+
+typedef unsigned long u32;
+
+/* The magic number of the GNU message catalog format.	*/
+#define MAGIC	      0x950412de
+#define MAGIC_SWAPPED 0xde120495
+
+/* Revision number of the currently used .mo (binary) file format.  */
+#define MO_REVISION_NUMBER 0
+
+
+/* Header for binary .mo file format.  */
+struct mo_file_header
+{
+  /* The magic number.	*/
+  u32 magic;
+  /* The revision number of the file format.  */
+  u32 revision;
+  /* The number of strings pairs.  */
+  u32 nstrings;
+  /* Offset of table with start offsets of original strings.  */
+  u32 orig_tab_offset;
+  /* Offset of table with start offsets of translation strings.  */
+  u32 trans_tab_offset;
+  /* Size of hashing table.  */
+  u32 hash_tab_size;
+  /* Offset of first hashing entry.  */
+  u32 hash_tab_offset;
+};
+
+struct string_desc
+{
+  /* Length of addressed string.  */
+  u32 length;
+  /* Offset of string in file.	*/
+  u32 offset;
+};
+
+
+struct overflow_space_s
+{
+  struct overflow_space_s *next;
+  u32 idx;
+  char d[1];
+};
+
+struct loaded_domain
+{
+  char *data;
+  int must_swap;
+  u32 nstrings;
+  char *mapped;  /* 0 = not yet mapped, 1 = mapped,
+                    2 = mapped to
+                    overflow space */
+  struct overflow_space_s *overflow_space;
+  struct string_desc *orig_tab;
+  struct string_desc *trans_tab;
+  u32 hash_size;
+  u32 *hash_tab;
+};
+
+static struct loaded_domain *the_domain;
+
+/**
+ *	Translate the input string from UTF8 to Windows codepage.
+ * 
+ * \param str IN string in UTF-8 format to translate.
+ * \param len IN number of chars to translate
+ * \param  dummy IN ?
+ * \return pointer to translated string. Free after usage
+ */
+char *
+utf8_to_native( char *str, unsigned int len, int dummy )
+{
+	/* maximum output length is size of string * 2 */ 
+	int buflen = (len + 1) * 2;
+	char *buf = malloc( buflen );
+	int wcharLen;
+	/* maximum result size is size of UTF-8 string */
+	char *resBuffer = malloc( len + 1 );
+
+	if( !resBuffer ) {
+		resBuffer = "ERROR in UTF-8 MALLOC";
+	} else {
+		/* as Windows has no way fo a direct translation fom UTF-8 to */
+		/* the system codepage, we need to take two steps */
+
+		/* 1. convert from UTF-8 to UTF-16 */
+		wcharLen = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)str, -1, (LPWSTR)buf, buflen / 2 );
+	
+		/* 2. convert from UTF-8 to system codepage */
+		WideCharToMultiByte(CP_ACP, 0, (LPWSTR)buf, wcharLen, resBuffer, len + 1, NULL, NULL );
+
+		free( buf );
+	}
+	return( resBuffer );	
+}
+
+
+static u32
+do_swap_u32( u32 i )
+{
+  return (i << 24) | ((i & 0xff00) << 8) | ((i >> 8) & 0xff00) | (i >> 24);
+}
+
+#define SWAPIT(flag, data) ((flag) ? do_swap_u32(data) : (data) )
+
+
+/* We assume to have `unsigned long int' value with at least 32 bits.  */
+#define HASHWORDBITS 32
+
+/* The so called `hashpjw' function by P.J. Weinberger
+   [see Aho/Sethi/Ullman, COMPILERS: Principles, Techniques and Tools,
+   1986, 1987 Bell Telephone Laboratories, Inc.]  */
+
+static unsigned long
+hash_string( const char *str_param )
+{
+    unsigned long int hval, g;
+    const char *str = str_param;
+
+    hval = 0;
+    while (*str != '\0')
+    {
+	hval <<= 4;
+	hval += (unsigned long int) *str++;
+	g = hval & ((unsigned long int) 0xf << (HASHWORDBITS - 4));
+	if (g != 0)
+	{
+	  hval ^= g >> (HASHWORDBITS - 8);
+	  hval ^= g;
+	}
+    }
+    return hval;
+}
+
+
+static struct loaded_domain *
+load_domain( const char *filename )
+{
+    FILE *fp;
+    size_t size;
+    struct stat st;
+    struct mo_file_header *data = NULL;
+    struct loaded_domain *domain = NULL;
+    size_t to_read;
+    char *read_ptr;
+
+    fp = fopen( filename, "rb" );
+    if( !fp )
+       return NULL; /* can't open the file */
+    /* we must know about the size of the file */
+    if( fstat( fileno(fp ), &st )
+	|| (size = (size_t)st.st_size) != st.st_size
+	|| size < sizeof (struct mo_file_header) ) {
+	fclose( fp );
+	return NULL;
+    }
+
+    data = malloc( size );
+    if( !data ) {
+	fclose( fp );
+	return NULL; /* out of memory */
+    }
+
+    to_read = size;
+    read_ptr = (char *) data;
+    do {
+	unsigned long int nb = fread( read_ptr, 1, to_read, fp );
+	if( nb < to_read ) {
+	    fclose (fp);
+	    free(data);
+	    return NULL; /* read error */
+	}
+	read_ptr += nb;
+	to_read -= nb;
+    } while( to_read > 0 );
+    fclose (fp);
+
+    /* Using the magic number we can test whether it really is a message
+     * catalog file.  */
+    if( data->magic != MAGIC && data->magic != MAGIC_SWAPPED ) {
+	/* The magic number is wrong: not a message catalog file.  */
+	free( data );
+	return NULL;
+    }
+
+    domain = calloc( 1, sizeof *domain );
+    if( !domain )  {
+	free( data );
+	return NULL;
+    }
+    domain->data = (char *) data;
+    domain->must_swap = data->magic != MAGIC;
+
+    /* Fill in the information about the available tables.  */
+    switch( SWAPIT(domain->must_swap, data->revision) ) {
+      case 0:
+	domain->nstrings = SWAPIT(domain->must_swap, data->nstrings);
+	domain->orig_tab = (struct string_desc *)
+	  ((char *) data + SWAPIT(domain->must_swap, data->orig_tab_offset));
+	domain->trans_tab = (struct string_desc *)
+	  ((char *) data + SWAPIT(domain->must_swap, data->trans_tab_offset));
+	domain->hash_size = SWAPIT(domain->must_swap, data->hash_tab_size);
+	domain->hash_tab = (u32 *)
+	  ((char *) data + SWAPIT(domain->must_swap, data->hash_tab_offset));
+      break;
+
+      default: /* This is an invalid revision.	*/
+	free( data );
+	free( domain );
+	return NULL;
+    }
+
+    /* Allocate an array to keep track of code page mappings. */
+    domain->mapped = calloc( 1, domain->nstrings );
+    if( !domain->mapped ) {
+        free( data );
+        free( domain );
+        return NULL;
+    }
+
+    return domain;
+}
+
+
+/**
+ * Set the file used for translations. Pass a NULL to disable
+ * translation.  A new filename may be set at anytime.  WARNING: 
+ * After changing the filename you should not access any data 
+ * retrieved by gettext().
+ */
+int
+set_gettext_file ( const char *filename, const char *regkey )
+{
+    struct loaded_domain *domain = NULL;
+
+    if( filename && *filename ) {
+	if( filename[0] == '/'
+	    || ( isalpha(filename[0])
+		 && filename[1] == ':'
+		 && (filename[2] == '/' || filename[2] == '\\') )
+	   ) {
+	    /* absolute path - use it as is */
+	    domain = load_domain( filename );
+	}
+	if (!domain)
+	    return -1;
+    }
+
+    if( the_domain ) {
+        struct overflow_space_s *os, *os2;
+	free( the_domain->data );
+  	free( the_domain->mapped );
+        for (os=the_domain->overflow_space; os; os = os2) {
+            os2 = os->next;
+            free (os);
+        }
+	free( the_domain );
+	the_domain = NULL;
+    }
+    the_domain = domain;
+    return 0;
+}
+
+/**
+ * Return the required string from the message table. Before returning the result, 
+ * codepage translation from UTF8 to current codepage is performed.
+ */
+
+static const char*
+get_string( struct loaded_domain *domain, u32 idx )
+{
+  struct overflow_space_s *os;
+  char *p;
+
+  p = domain->data + SWAPIT(domain->must_swap, domain->trans_tab[idx].offset);
+  if (!domain->mapped[idx]) 
+    {
+      size_t plen, buflen;
+      char *buf;
+
+      domain->mapped[idx] = 1;
+
+      plen = strlen (p);
+      buf = utf8_to_native (p, plen, -1);
+      buflen = strlen (buf);
+	  if (buflen <= plen){
+        strcpy (p, buf);
+		free( buf );
+	  } else {
+          /* There is not enough space for the translation - store it
+             in the overflow_space else and mark that in the mapped
+             array.  Because we expect that this won't happen too
+             often, we use a simple linked list.  */
+          os = malloc (sizeof *os + buflen);
+          if (os)
+            {
+              os->idx = idx;
+              strcpy (os->d, buf);
+              os->next = domain->overflow_space;
+              domain->overflow_space = os;
+              p = os->d;
+            }
+          else
+            p = "ERROR in GETTEXT MALLOC";
+          free (buf);
+	   }
+    }
+  else if (domain->mapped[idx] == 2) 
+    { /* We need to get the string from the overflow_space. */
+      for (os=domain->overflow_space; os; os = os->next)
+        if (os->idx == idx)
+          return (const char*)os->d;
+      p = "ERROR in GETTEXT\n";
+    }
+  return (const char*)p;
+}
+
+/**
+ * This is the translation function itself.
+ */
+
+char *
+gettext( char *msgid )
+{
+    struct loaded_domain *domain;
+    size_t act = 0;
+    size_t top, bottom;
+
+    if( !(domain = the_domain) )
+	goto not_found;
+
+    /* Locate the MSGID and its translation.  */
+    if( domain->hash_size > 2 && domain->hash_tab ) {
+	/* Use the hashing table.  */
+	u32 len = strlen (msgid);
+	u32 hash_val = hash_string (msgid);
+	u32 idx = hash_val % domain->hash_size;
+	u32 incr = 1 + (hash_val % (domain->hash_size - 2));
+	u32 nstr = SWAPIT (domain->must_swap, domain->hash_tab[idx]);
+
+	if ( !nstr ) /* Hash table entry is empty.  */
+	    goto not_found;
+
+	if( SWAPIT(domain->must_swap,
+		    domain->orig_tab[nstr - 1].length) == len
+	    && !strcmp( msgid,
+		       domain->data + SWAPIT(domain->must_swap,
+				    domain->orig_tab[nstr - 1].offset)) )
+	    return (char *)get_string( domain, nstr - 1 );
+
+	for(;;) {
+	    if (idx >= domain->hash_size - incr)
+		idx -= domain->hash_size - incr;
+	    else
+		idx += incr;
+
+	    nstr = SWAPIT(domain->must_swap, domain->hash_tab[idx]);
+	    if( !nstr )
+		goto not_found; /* Hash table entry is empty.  */
+
+	    if ( SWAPIT(domain->must_swap,
+				domain->orig_tab[nstr - 1].length) == len
+		 && !strcmp (msgid,
+			 domain->data + SWAPIT(domain->must_swap,
+					   domain->orig_tab[nstr - 1].offset)))
+		return (char *)get_string( domain, nstr-1 );
+	}
+	/* NOTREACHED */
+    }
+
+    /* Now we try the default method:  binary search in the sorted
+       array of messages.  */
+    bottom = 0;
+    top = domain->nstrings;
+    while( bottom < top ) {
+	int cmp_val;
+
+	act = (bottom + top) / 2;
+	cmp_val = strcmp(msgid, domain->data
+			       + SWAPIT(domain->must_swap,
+					domain->orig_tab[act].offset));
+	if (cmp_val < 0)
+	    top = act;
+	else if (cmp_val > 0)
+	    bottom = act + 1;
+	else
+	    return (char *)get_string( domain, act );
+    }
+
+  not_found:
+    return msgid;
+}
+
+/**
+ * This is the main initialization function for simple gettext. The message file is 
+ * opened and read into memory. The function must be called once before translating 
+ * a string.
+ *
+ * The message files are expected to be in a directory named in the UNIXish form en_US
+ * in the path passed to this function. The filename is expected to be domainname.mo
+ *
+ * \param domainname IN domain
+ * \param dirname IN directory for the message files
+ * \return    always NULL
+ */
+
+char *
+bindtextdomain( char *domainname, char *dirname )
+{
+	char *loc;
+	char *dir;
+
+	/* get thread's locale in UNIXish style eg. en_US */
+	loc = g_win32_getlocale();
+
+	/* make sure that path does not end with trailing slash */
+	if( dirname[ strlen(dirname) ] == '/' )
+		dirname[ strlen(dirname) ] = '\0';
+
+	/* allocate buffer for filename, 20 bytes should be enough for extension etc. */
+	dir = malloc( strlen( domainname ) + strlen( dirname ) + strlen( loc ) + 20 );
+	
+	if( dir ) {
+		/* create the full filename */
+		sprintf( dir, "%s/%s/LC_MESSAGES/%s.mo", dirname, loc, domainname );
+		/* load the file */
+		set_gettext_file( dir, NULL );
+		free( dir );
+	}
+	
+	free( loc );
+	return( NULL );
+}
+
+/**
+ * This is a dummy function to maintain source code compatibility 
+ * with other implementations of gettext.
+ * For this implementation, UTF-8 input encoding is assumed
+ *
+ * \param domainname IN domain
+ * \param codeset In codeset 
+ * \return    always NULL
+ */
+
+char *
+bind_textdomain_codeset(char *domainname, char *codeset )
+{
+	return( NULL );
+}
+
+/**
+ * This is a dummy function to maintain source code compatibility 
+ * with other implementations of gettext.
+ *
+ * \param domainname IN domain
+ * \return    always NULL
+ */
+
+char *
+textdomain( char *domainname )
+{
+	return( NULL );
+}
+#endif /* USE_SIMPLE_GETTEXT */
diff --git a/app/wlib/mswlib/square10.bmp b/app/wlib/mswlib/square10.bmp
new file mode 100644
index 0000000..c45fb75
--- /dev/null
+++ b/app/wlib/mswlib/square10.bmp
@@ -0,0 +1,6 @@
+#define square10_width 14
+#define square10_height 14
+static unsigned char square10_bits[] = {
+   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+   0xff, 0xff, 0xff, 0xff};