--- np2/win9x/toolwin.cpp	2003/10/29 10:09:37	1.3
+++ np2/win9x/toolwin.cpp	2005/03/20 13:12:49	1.19
@@ -2,35 +2,23 @@
 #include	"strres.h"
 #include	"resource.h"
 #include	"np2.h"
+#include	"winloc.h"
+#include	"oemtext.h"
 #include	"dosio.h"
 #include	"soundmng.h"
 #include	"sysmng.h"
 #include	"menu.h"
 #include	"toolwin.h"
 #include	"ini.h"
+#include	"np2class.h"
 #include	"dialog.h"
+#include	"dialogs.h"
 #include	"pccore.h"
 #include	"diskdrv.h"
 
 
-#ifdef STRICT
-#define	SCPROC	WNDPROC
-#else
-#define	SCPROC	FARPROC
-#endif
-
-
-	NP2TOOL		np2tool;
-
-static const char np2toolclass[] = "np2-toolwin";
-static const char np2tooltitle[] = "NP2 tool";
+extern WINLOCEX np2_winlocexallwin(HWND base);
 
-static const char str_deffont[] = "ＭＳ Ｐゴシック";
-static const char str_static[] = "STATIC";
-static const char str_combobox[] = "COMBOBOX";
-static const char str_button[] = "BUTTON";
-static const char str_browse[] = "...";
-static const char str_eject[] = "Eject";
 
 enum {
 	IDC_TOOLHDDACC			= 0,
@@ -42,84 +30,148 @@ enum {
 	IDC_TOOLFDD2LIST,
 	IDC_TOOLFDD2BROWSE,
 	IDC_TOOLFDD2EJECT,
+	IDC_TOOLRESET,
+	IDC_TOOLPOWER,
 	IDC_MAXITEMS,
 
-	IDC_BASE				= 3000
+	IDC_BASE				= 3000,
+
+	IDM_SKINSEL				= 3100,
+	IDM_SKINDEF				= 3101,
+	IDM_SKINMRU				= 3102,
+	IDM_TOOLCLOSE			= IDM_SKINMRU + SKINMRU_MAX
+};
+
+enum {
+	TCTL_STATIC				= 0,
+	TCTL_BUTTON				= 1,
+	TCTL_DDLIST				= 2
 };
 
 typedef struct {
-const char	*cname;
-const char	*text;
-	DWORD	style;
-	DWORD	exstyle;
-	short	posx;
-	short	posy;
-	short	width;
-	short	height;
+	OEMCHAR	main[MAX_PATH];
+	OEMCHAR	font[64];
+	SINT32	fontsize;
+	UINT32	color1;
+	UINT32	color2;
+} TOOLSKIN;
+
+typedef struct {
+	UINT		tctl;
+const OEMCHAR	*text;
+	short		posx;
+	short		posy;
+	short		width;
+	short		height;
+	short		extend;
+	short		padding;
 } SUBITEM;
 
-static const BYTE fddlist[FDDLIST_DRV] = {
-					IDC_TOOLFDD1LIST, IDC_TOOLFDD2LIST};
+typedef struct {
+	HWND			hwnd;
+	WINLOCEX		wlex;
+	HBITMAP			hbmp;
+	UINT8			fddaccess[2];
+	UINT8			hddaccess;
+	UINT8			_padding;
+	int				winflg;
+	int				wingx;
+	int				wingy;
+	int				wintx;
+	int				winty;
+	UINT			parentcn;
+	int				parentx;
+	int				parenty;
+	HFONT			hfont;
+	HDC				hdcfont;
+	HBRUSH			access[2];
+	HWND			sub[IDC_MAXITEMS];
+	SUBCLASSPROC	subproc[IDC_MAXITEMS];
+} TOOLWIN;
 
-static const SUBITEM subitem[IDC_MAXITEMS] = {
-		{str_static, NULL, WS_VISIBLE, 0, 49, 44, 8, 3},
-		{str_static, NULL, WS_VISIBLE, 0, 93, 19, 8, 3},
-		{str_combobox,	NULL,
-			WS_VISIBLE | CBS_DROPDOWNLIST | WS_VSCROLL, 0, 104, 6, 248, 160},
-		{str_button,	str_browse,
-			WS_VISIBLE | BS_PUSHBUTTON, 0, 352, 7, 18, 17},
-		{str_button,	str_eject,
-			WS_VISIBLE | BS_PUSHBUTTON, 0, 370, 7, 34, 17},
-		{str_static, NULL, WS_VISIBLE, 0, 93, 41, 8, 3},
-		{str_combobox,	NULL,
-			WS_VISIBLE | CBS_DROPDOWNLIST | WS_VSCROLL, 0, 104, 28, 248, 160},
-		{str_button,	str_browse,
-			WS_VISIBLE | BS_PUSHBUTTON, 0, 352, 29, 18, 17},
-		{str_button,	str_eject,
-			WS_VISIBLE | BS_PUSHBUTTON, 0, 370, 29, 34, 17},
+enum {
+	GTWL_FOCUS		= NP2GWL_SIZE + 0,
+	GTWL_SIZE		= NP2GWL_SIZE + 4
 };
 
-// static const DWORD mvccol[MVC_MAXCOLOR] = {
-//						0xc0e8f8, 0xd8ecf4, 0x48a8c8, 0x000000};
+		NP2TOOL		np2tool;
+static	TOOLSKIN	toolskin;
+static	SUBITEM		subitem[IDC_MAXITEMS];
+static	TOOLWIN		toolwin;
 
-typedef struct {
-	HWND	hwnd;
-	BYTE	fddaccess[2];
-	BYTE	hddaccess;
-	BYTE	_padding;
-	int		winflg;
-	int		wingx;
-	int		wingy;
-	int		wintx;
-	int		winty;
-	int		parentcn;
-	int		parentx;
-	int		parenty;
-	HFONT	hfont;
-	HDC		hdcfont;
-	HBRUSH	access[2];
-	HWND	sub[IDC_MAXITEMS];
-	SCPROC	subproc[IDC_MAXITEMS];
-} TOOLWIN;
+#include	"toolwin.res"
 
-static	TOOLWIN		toolwin;
 
 typedef struct {
-	WORD	idc;
-	BYTE	*counter;
+	UINT16	idc;
+	UINT8	*counter;
 } DISKACC;
 
+static const UINT8 fddlist[FDDLIST_DRV] = {
+					IDC_TOOLFDD1LIST, IDC_TOOLFDD2LIST};
+
 static const DISKACC diskacc[3] = {
-			{IDC_TOOLFDD1ACC,	&toolwin.fddaccess[0]},
-			{IDC_TOOLFDD2ACC,	&toolwin.fddaccess[1]},
-			{IDC_TOOLHDDACC,	&toolwin.hddaccess}};
+					{IDC_TOOLFDD1ACC,	&toolwin.fddaccess[0]},
+					{IDC_TOOLFDD2ACC,	&toolwin.fddaccess[1]},
+					{IDC_TOOLHDDACC,	&toolwin.hddaccess}};
+
+
+// ----
+
+static HBITMAP skinload(const OEMCHAR *path) {
+
+	OEMCHAR	fname[MAX_PATH];
+	UINT	i;
+	HBITMAP	ret;
+
+	ZeroMemory(&toolskin, sizeof(toolskin));
+	toolskin.fontsize = 12;
+	milstr_ncpy(toolskin.font, str_deffont, NELEMENTS(toolskin.font));
+	toolskin.color1 = 0x600000;
+	toolskin.color2 = 0xff0000;
+	if (path) {
+		ini_read(path, skintitle, skinini1, NELEMENTS(skinini1));
+	}
+	if (toolskin.main[0]) {
+		ZeroMemory(subitem, sizeof(defsubitem));
+		for (i=0; i<IDC_MAXITEMS; i++) {
+			subitem[i].tctl = defsubitem[i].tctl;
+			subitem[i].text = defsubitem[i].text;
+		}
+	}
+	else {
+		CopyMemory(subitem, defsubitem, sizeof(defsubitem));
+	}
+	if (path) {
+		ini_read(path, skintitle, skinini2, NELEMENTS(skinini2));
+	}
+	if (toolskin.main[0]) {
+		milstr_ncpy(fname, path, NELEMENTS(fname));
+		file_cutname(fname);
+		file_catname(fname, toolskin.main, NELEMENTS(fname));
+#if defined(OSLANG_UTF8)
+		TCHAR tchr[MAX_PATH];
+		oemtotchar(tchr, NELEMENTS(tchr), fname, -1);
+#else
+		const TCHAR *tchr = fname;
+#endif
+		ret = (HBITMAP)LoadImage(hInst, tchr, IMAGE_BITMAP,
+													0, 0, LR_LOADFROMFILE);
+		if (ret != NULL) {
+			return(ret);
+		}
+	}
+	return(LoadBitmap(hInst, _T("NP2TOOL")));
+}
+
 
+// ----
 
-static void calctextsize(char *path, int leng, const char *p, int width) {
+static void calctextsize(OEMCHAR *path, int leng, const OEMCHAR *p, int width) {
 
 	HDC		hdc;
 	SIZE	cur;
-	char	work[MAX_PATH];
+	OEMCHAR	work[MAX_PATH];
 	int		l;
 	SIZE	tail;
 	int		pos;
@@ -127,7 +179,7 @@ static void calctextsize(char *path, int
 
 	milstr_ncpy(path, p, leng);
 	hdc = toolwin.hdcfont;
-	GetTextExtentPoint32(hdc, p, strlen(p), &cur);
+	GetTextExtentPoint32(hdc, p, OEMSTRLEN(p), &cur);
 	if (cur.cx < width) {
 		return;
 	}
@@ -135,19 +187,14 @@ static void calctextsize(char *path, int
 	file_cutname(path);
 	file_cutseparator(path);
 	file_cutname(path);
-	l = strlen(path);
-	if (l > 1) {
-		l -= 1;
-		if (milstr_kanji2nd(p, l - 1)) {
-			l--;
-		}
-	}
-	else {
-		l = 0;
+	file_cutseparator(path);
+	l = OEMSTRLEN(path);
+	work[0] = '\0';
+	if (l) {
+		milstr_ncpy(work, str_browse, NELEMENTS(work));
 	}
-	milstr_ncpy(work, str_browse, sizeof(work));
-	milstr_ncat(work, p + l, sizeof(work));
-	GetTextExtentPoint32(hdc, work, strlen(work), &tail);
+	milstr_ncat(work, p + l, NELEMENTS(work));
+	GetTextExtentPoint32(hdc, work, OEMSTRLEN(work), &tail);
 	pos = 0;
 	while(pos < l) {
 		step = ((((p[pos] ^ 0x20) - 0xa1) & 0xff) < 0x3c)?2:1;
@@ -163,72 +210,104 @@ static void calctextsize(char *path, int
 	milstr_ncat(path, work, leng);
 }
 
-static void setlist(UINT drv) {
+static void setlist(HWND hwnd, const TOOLFDD *fdd, UINT sel) {
 
-	HWND	hwnd;
-	RECT	rc;
-	int		width;
-	TOOLFDD	*fdd;
-	char	*p;
-	UINT	i;
-	char	basedir[MAX_PATH];
-	char	dir[MAX_PATH];
-	char	*q;
+	RECT		rc;
+	int			width;
+	OEMCHAR		basedir[MAX_PATH];
+	UINT		i;
+const OEMCHAR	*p;
+	OEMCHAR		dir[MAX_PATH];
+const OEMCHAR	*q;
 
-	if (drv >= FDDLIST_DRV) {
-		return;
-	}
-	hwnd = toolwin.sub[fddlist[drv]];
+	SendMessage(hwnd, CB_RESETCONTENT, (WPARAM)0, (LPARAM)0);
 	GetClientRect(hwnd, &rc);
 	width = rc.right - rc.left - 6;			// border size?
-	SendMessage(hwnd, CB_RESETCONTENT, (WPARAM)0, (LPARAM)0);
-	fdd = np2tool.fdd + drv;
-	p = fdd->name[0];
 	basedir[0] = '\0';
-	if (fdd->insert) {
-		milstr_ncpy(basedir, p, sizeof(basedir));
+	if (sel < fdd->cnt) {
+		milstr_ncpy(basedir, fdd->name[fdd->pos[sel]], NELEMENTS(basedir));
 		file_cutname(basedir);
 	}
-	for (i=0; i<FDDLIST_MAX; i++) {
-		if (p[0] == '\0') {
-			break;
-		}
-		milstr_ncpy(dir, p, sizeof(dir));
+	for (i=0; i<fdd->cnt; i++) {
+		p = fdd->name[fdd->pos[i]];
+		milstr_ncpy(dir, p, NELEMENTS(dir));
 		file_cutname(dir);
 		if (!file_cmpname(basedir, dir)) {
 			q = file_getname(p);
 		}
 		else {
-			calctextsize(dir, sizeof(dir), p, width);
+			calctextsize(dir, NELEMENTS(dir), p, width);
 			q = dir;
 		}
 		SendMessage(hwnd, CB_INSERTSTRING, (WPARAM)i, (LPARAM)q);
-		p += sizeof(fdd->name[0]);
+		p += NELEMENTS(fdd->name[0]);
 	}
-	if (fdd->insert) {
-		SendMessage(hwnd, CB_SETCURSEL, (WPARAM)0, (LPARAM)0);
+	if (sel < fdd->cnt) {
+		SendMessage(hwnd, CB_SETCURSEL, (WPARAM)sel, (LPARAM)0);
 	}
 }
 
 static void sellist(UINT drv) {
 
 	HWND	hwnd;
+	TOOLFDD	*fdd;
 	UINT	sel;
-	char	path[MAX_PATH];
 
 	if (drv >= FDDLIST_DRV) {
 		return;
 	}
 	hwnd = toolwin.sub[fddlist[drv]];
+	fdd = np2tool.fdd + drv;
 	sel = (UINT)SendMessage(hwnd, CB_GETCURSEL, 0, 0);
-	if (sel < FDDLIST_MAX) {
-		milstr_ncpy(path, np2tool.fdd[drv].name[sel], sizeof(path));
-		diskdrv_setfdd(drv, path, 0);
-		toolwin_setfdd(drv, path);
+	if (sel < fdd->cnt) {
+		diskdrv_setfdd(drv, fdd->name[fdd->pos[sel]], 0);
+		fdd->insert = 1;
+		setlist(hwnd, fdd, sel);
 	}
 }
 
-static void accdraw(HWND hWnd, BYTE count) {
+static void remakefddlist(HWND hwnd, TOOLFDD *fdd) {
+
+	OEMCHAR	*p;
+	UINT	cnt;
+	OEMCHAR	*q;
+	OEMCHAR	*fname[FDDLIST_MAX];
+	UINT	i;
+	UINT	j;
+	UINT	sel;
+
+	p = fdd->name[0];
+	for (cnt=0; cnt<FDDLIST_MAX; cnt++) {
+		if (p[0] == '\0') {
+			break;
+		}
+		q = file_getname(p);
+		fname[cnt] = q;
+		for (i=0; i<cnt; i++) {
+			if (file_cmpname(q, fname[fdd->pos[i]]) < 0) {
+				break;
+			}
+		}
+		for (j=cnt; j>i; j--) {
+			fdd->pos[j] = fdd->pos[j-1];
+		}
+		fdd->pos[i] = cnt;
+		p += NELEMENTS(fdd->name[0]);
+	}
+	fdd->cnt = cnt;
+	sel = (UINT)-1;
+	if (fdd->insert) {
+		for (i=0; i<cnt; i++) {
+			if (fdd->pos[i] == 0) {
+				sel = i;
+				break;
+			}
+		}
+	}
+	setlist(hwnd, fdd, sel);
+}
+
+static void accdraw(HWND hWnd, UINT8 count) {
 
 	HDC			hdc;
 	PAINTSTRUCT	ps;
@@ -246,21 +325,48 @@ static void accdraw(HWND hWnd, BYTE coun
 static LRESULT CALLBACK twsub(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp) {
 
 	UINT	idc;
+	int		dir;
+	UINT	newidc;
 	int		files;
-	char	fname[MAX_PATH];
+	OEMCHAR	fname[MAX_PATH];
 
-	for (idc=0; idc<IDC_MAXITEMS; idc++) {
-		if (toolwin.sub[idc] == hWnd) {
-			break;
-		}
-	}
+	idc = GetWindowLong(hWnd, GWL_ID) - IDC_BASE;
 	if (idc >= IDC_MAXITEMS) {
 		return(0);
 	}
-	if (msg == WM_DROPFILES) {
+	if (msg == WM_KEYDOWN) {
+		if ((short)wp == VK_TAB) {
+			dir = (GetKeyState(VK_SHIFT) >= 0)?1:-1;
+			newidc = idc;
+			do {
+				newidc += dir;
+				if (newidc >= IDC_MAXITEMS) {
+					newidc = (dir >= 0)?0:(IDC_MAXITEMS - 1);
+				}
+				if ((toolwin.sub[newidc] != NULL) &&
+					(subitem[newidc].tctl != TCTL_STATIC)) {
+					SetFocus(toolwin.sub[newidc]);
+					break;
+				}
+			} while(idc != newidc);
+		}
+		else if ((short)wp == VK_RETURN) {
+			if (subitem[idc].tctl == TCTL_BUTTON) {
+				return(CallWindowProc(toolwin.subproc[idc],
+										hWnd, WM_KEYDOWN, VK_SPACE, 0));
+			}
+		}
+	}
+	else if (msg == WM_DROPFILES) {
    	    files = DragQueryFile((HDROP)wp, (UINT)-1, NULL, 0);
 		if (files == 1) {
-			DragQueryFile((HDROP)wp, 0, fname, sizeof(fname));
+#if defined(OSLANG_UTF8)
+			TCHAR tchr[MAX_PATH];
+			DragQueryFile((HDROP)wp, 0, tchr, NELEMENTS(tchr));
+			tchartooem(fname, NELEMENTS(fname), tchr, -1);
+#else
+			DragQueryFile((HDROP)wp, 0, fname, NELEMENTS(fname));
+#endif
 			if (idc == IDC_TOOLFDD1LIST) {
 				diskdrv_setfdd(0, fname, 0);
 				toolwin_setfdd(0, fname);
@@ -287,21 +393,24 @@ static LRESULT CALLBACK twsub(HWND hWnd,
 			return(FALSE);
 		}
 	}
+	else if (msg == WM_SETFOCUS) {
+		SetWindowLong(GetParent(hWnd), GTWL_FOCUS, idc);
+	}
 	return(CallWindowProc(toolwin.subproc[idc], hWnd, msg, wp, lp));
 }
 
-static void toolwincreate(HWND hWnd, LPARAM lp) {
+static void toolwincreate(HWND hWnd) {
 
-	HDC			hdc;
-	HINSTANCE	hinstance;
-const SUBITEM	*p;
-	UINT		i;
-	HWND		sub;
-
-	toolwin.hfont = CreateFont(12, 0, 0, 0, 0, 0, 0, 0, 
+#if defined(OSLANG_UTF8)
+	TCHAR fontface[64];
+	oemtotchar(fontface, NELEMENTS(fontface), toolskin.font, -1);
+#else
+	const TCHAR *fontface = toolskin.font;
+#endif
+	toolwin.hfont = CreateFont(toolskin.fontsize, 0, 0, 0, 0, 0, 0, 0,
 					SHIFTJIS_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
-					DEFAULT_QUALITY, FIXED_PITCH, str_deffont);
-    hdc = GetDC(NULL);
+					DEFAULT_QUALITY, FIXED_PITCH, fontface);
+	HDC hdc = GetDC(NULL);
 	toolwin.hdcfont = CreateCompatibleDC(hdc);
 	ReleaseDC(NULL, hdc);
 	SelectObject(toolwin.hdcfont, toolwin.hfont);
@@ -309,219 +418,300 @@ const SUBITEM	*p;
 	toolwin.access[0] = CreateSolidBrush(0x000060);
 	toolwin.access[1] = CreateSolidBrush(0x0000ff);
 
-	hinstance = ((LPCREATESTRUCT)lp)->hInstance;
-	p = subitem;
+	const SUBITEM *p = subitem;
+	UINT i;
 	for (i=0; i<IDC_MAXITEMS; i++) {
-		sub = CreateWindowEx(p->exstyle, p->cname, p->text,
-				WS_CHILD | p->style, p->posx, p->posy, p->width, p->height,
-				hWnd, (HMENU)(i + IDC_BASE), hinstance, NULL);
+		HWND sub = NULL;
+		const TCHAR *cls = NULL;
+		DWORD style;
+		switch(p->tctl) {
+			case TCTL_STATIC:
+				cls = str_static;
+				style = 0;
+				break;
+
+			case TCTL_BUTTON:
+				if (p->extend == 0) {
+					cls = str_button;
+					style = BS_PUSHBUTTON;
+				}
+				else if (p->extend == 1) {
+					cls = str_button;
+					style = BS_OWNERDRAW;
+				}
+				break;
+
+			case TCTL_DDLIST:
+				cls = str_combobox;
+				style = CBS_DROPDOWNLIST | WS_VSCROLL;
+				break;
+		}
+		if ((cls) && (p->width > 0) && (p->height > 0)) {
+#if defined(OSLANG_UTF8)
+			TCHAR ptext[64];
+			oemtotchar(ptext, NELEMENTS(ptext), p->text, -1);
+#else
+			const TCHAR *ptext = p->text;
+#endif
+			sub = CreateWindow(cls, ptext, WS_CHILD | WS_VISIBLE | style,
+							p->posx, p->posy, p->width, p->height,
+							hWnd, (HMENU)(i + IDC_BASE), hInst, NULL);
+		}
 		toolwin.sub[i] = sub;
-		toolwin.subproc[i] = (SCPROC)GetWindowLong(sub, GWL_WNDPROC);
-		SetWindowLong(sub, GWL_WNDPROC, (LONG)twsub);
-		SendMessage(sub, WM_SETFONT, (WPARAM)toolwin.hfont,
+		toolwin.subproc[i] = NULL;
+		if (sub) {
+			toolwin.subproc[i] = (SUBCLASSPROC)GetWindowLong(sub, GWL_WNDPROC);
+			SetWindowLong(sub, GWL_WNDPROC, (LONG)twsub);
+			SendMessage(sub, WM_SETFONT, (WPARAM)toolwin.hfont,
 														MAKELPARAM(TRUE, 0));
+		}
 		p++;
 	}
 	for (i=0; i<FDDLIST_DRV; i++) {
-		DragAcceptFiles(toolwin.sub[fddlist[i]], TRUE);
-		setlist((BYTE)i);
+		HWND sub = toolwin.sub[fddlist[i]];
+		if (sub) {
+			DragAcceptFiles(sub, TRUE);
+			remakefddlist(sub, np2tool.fdd + i);
+		}
+	}
+	for (i=0; i<IDC_MAXITEMS; i++) {
+		if ((toolwin.sub[i]) && (subitem[i].tctl != TCTL_STATIC)) {
+			break;
+		}
 	}
+	SetWindowLong(hWnd, GTWL_FOCUS, i);
 }
 
 static void toolwindestroy(void) {
 
 	UINT	i;
+	HWND	sub;
 
-	for (i=0; i<IDC_MAXITEMS; i++) {
-		DestroyWindow(toolwin.sub[i]);
+	if (toolwin.hbmp) {
+		for (i=0; i<IDC_MAXITEMS; i++) {
+			sub = toolwin.sub[i];
+			if (sub) {
+				DestroyWindow(sub);
+			}
+		}
+		DeleteObject(toolwin.access[0]);
+		DeleteObject(toolwin.access[1]);
+		DeleteObject(toolwin.hdcfont);
+		DeleteObject(toolwin.hfont);
+		DeleteObject(toolwin.hbmp);
+		toolwin.hbmp = NULL;
 	}
-	DeleteObject(toolwin.access[0]);
-	DeleteObject(toolwin.access[1]);
-	DeleteObject(toolwin.hdcfont);
-	DeleteObject(toolwin.hfont);
 }
 
 static void toolwinpaint(HWND hWnd) {
 
 	HDC			hdc;
 	PAINTSTRUCT	ps;
-	HINSTANCE	hinst;
-	HBITMAP		hbmp;
 	BITMAP		bmp;
 	HDC			hmdc;
 
 	hdc = BeginPaint(hWnd, &ps);
-	hinst = (HINSTANCE)GetWindowLong(hWnd, GWL_HINSTANCE);
-	hbmp = LoadBitmap(hinst, "NP2TOOL");
-	GetObject(hbmp, sizeof(BITMAP), &bmp);
-	hmdc = CreateCompatibleDC(hdc);
-	SelectObject(hmdc, hbmp);
-	BitBlt(hdc, 0, 0, bmp.bmWidth, bmp.bmHeight, hmdc, 0, 0, SRCCOPY);
-	DeleteDC(hmdc);
-	DeleteObject(hbmp);
+	if (toolwin.hbmp) {
+		GetObject(toolwin.hbmp, sizeof(BITMAP), &bmp);
+		hmdc = CreateCompatibleDC(hdc);
+		SelectObject(hmdc, toolwin.hbmp);
+		BitBlt(hdc, 0, 0, bmp.bmWidth, bmp.bmHeight, hmdc, 0, 0, SRCCOPY);
+		DeleteDC(hmdc);
+	}
 	EndPaint(hWnd, &ps);
 }
 
+static void tooldrawbutton(HWND hWnd, UINT idc, LPDRAWITEMSTRUCT lpdis) {
 
-// ---- moving
-
-enum {
-	SNAPDOTPULL		= 12,
-	SNAPDOTREL		= 16
-};
-
-static void movingstart(void) {
+	POINT	pt;
+	HWND	sub;
+	RECT	rect;
+	HDC		hdc;
+	HDC		hmdc;
+	RECT	btn;
 
-	toolwin.winflg = 0;
-	toolwin.wingx = 0;
-	toolwin.wingy = 0;
+	idc -= IDC_BASE;
+	if (idc >= IDC_MAXITEMS) {
+		return;
+	}
+	pt.x = 0;
+	pt.y = 0;
+	ClientToScreen(hWnd, &pt);
+	sub = toolwin.sub[idc];
+	GetWindowRect(sub, &rect);
+	btn.left = 0;
+	btn.top = 0;
+	btn.right = rect.right - rect.left;
+	btn.bottom = rect.bottom - rect.top;
+	hdc = lpdis->hDC;
+	if (toolwin.hbmp) {
+		hmdc = CreateCompatibleDC(hdc);
+		SelectObject(hmdc, toolwin.hbmp);
+		BitBlt(hdc, 0, 0, btn.right, btn.bottom,
+					hmdc, rect.left - pt.x, rect.top - pt.y, SRCCOPY);
+		DeleteDC(hmdc);
+	}
+	if (lpdis->itemState & ODS_FOCUS) {
+		DrawFocusRect(hdc, &btn);
+	}
 }
 
-static void movingproc(RECT *rect) {
-
-	RECT	workrc;
-	RECT	mainrc;
-	int		winlx, winly;
-	BOOL	connectx;
-	BOOL	connecty;
-	int		d;
-
-	SystemParametersInfo(SPI_GETWORKAREA, 0, &workrc, 0);
-	GetWindowRect(hWndMain, &mainrc);
-	winlx = rect->right - rect->left;
-	winly = rect->bottom - rect->top;
 
-	if ((winlx > (workrc.right - workrc.left)) ||
-		(winly > (workrc.bottom - workrc.top))) {
-		return;
-	}
+// ----
 
-	connectx = ((rect->right >= mainrc.left) && (rect->left <= mainrc.right));
-	connecty = ((rect->bottom >= mainrc.top) && (rect->top <= mainrc.bottom));
-	if ((toolwin.winflg & 3) && (!connectx) && (!connecty)) {
-		toolwin.winflg &= ~3;
-		rect->left += toolwin.wingx;
-		rect->top += toolwin.wingy;
-		toolwin.wingx = 0;
-		toolwin.wingy = 0;
-	}
+static HMENU createskinmenu(void) {
 
-	if (toolwin.winflg & 1) {
-		toolwin.wingx += rect->left - toolwin.wintx;
-		rect->left = toolwin.wintx;
-	}
-	else {
-		d = SNAPDOTPULL;
-		do {
-			if (connecty) {
-				d = rect->right - mainrc.left;
-				if ((d < SNAPDOTPULL) && (d > -SNAPDOTPULL)) {
-					break;
-				}
-				d = rect->left - mainrc.right;
-				if ((d < SNAPDOTPULL) && (d > -SNAPDOTPULL)) {
-					break;
-				}
-				if ((rect->bottom == mainrc.top) ||
-					(rect->top == mainrc.bottom)) {
-					d = rect->left - mainrc.left;
-					if ((d < SNAPDOTPULL) && (d > -SNAPDOTPULL)) {
-						break;
-					}
-					d = rect->right - mainrc.right;
-					if ((d < SNAPDOTPULL) && (d > -SNAPDOTPULL)) {
-						break;
-					}
-				}
-			}
-			d = rect->left - workrc.left;
-			if ((d < SNAPDOTPULL) && (d > -SNAPDOTPULL)) {
-				break;
-			}
-			d = rect->right - workrc.right;
-			if ((d < SNAPDOTPULL) && (d > -SNAPDOTPULL)) {
+	HMENU		ret;
+	UINT		cnt;
+const OEMCHAR	*base;
+	UINT		flag;
+	OEMCHAR		*p;
+	UINT		i;
+	UINT		j;
+	UINT		id[SKINMRU_MAX];
+const OEMCHAR	*file[SKINMRU_MAX];
+
+	ret = CreatePopupMenu();
+	AppendMenu(ret, MF_STRING, IDM_SKINSEL, str_skinsel);
+	AppendMenu(ret, MF_SEPARATOR, 0, NULL);
+
+	base = np2tool.skin;
+	flag = (base[0] == '\0')?MF_CHECKED:0;
+	AppendMenu(ret, MF_STRING + flag, IDM_SKINDEF, str_skindef);
+	for (cnt=0; cnt<SKINMRU_MAX; cnt++) {
+		p = np2tool.skinmru[cnt];
+		if (p[0] == '\0') {
+			break;
+		}
+		p = file_getname(p);
+		for (i=0; i<cnt; i++) {
+			if (file_cmpname(p, file[id[i]]) < 0) {
 				break;
 			}
-		} while(0);
-		if ((d < SNAPDOTPULL) && (d > -SNAPDOTPULL)) {
-			toolwin.winflg |= 1;
-			rect->left -= d;
-			toolwin.wingx = d;
-			toolwin.wintx = rect->left;
-		}
-	}
-	if ((toolwin.wingx >= SNAPDOTREL) || (toolwin.wingx <= -SNAPDOTREL)) {
-		toolwin.winflg &= ~1;
-		rect->left += toolwin.wingx;
-		toolwin.wingx = 0;
-	}
-
-	if (toolwin.winflg & 2) {
-		toolwin.wingy += rect->top - toolwin.winty;
-		rect->top = toolwin.winty;
+		}
+		for (j=cnt; j>i; j--) {
+			id[j] = id[j-1];
+		}
+		id[i] = cnt;
+		file[cnt] = p;
 	}
-	else {
-		d = SNAPDOTPULL;
-		do {
-			if (connectx) {
-				d = rect->bottom - mainrc.top;
-				if ((d < SNAPDOTPULL) && (d > -SNAPDOTPULL)) {
-					break;
-				}
-				d = rect->top - mainrc.bottom;
-				if ((d < SNAPDOTPULL) && (d > -SNAPDOTPULL)) {
-					break;
-				}
-				if ((rect->right == mainrc.left) ||
-					(rect->left == mainrc.right)) {
-					d = rect->top - mainrc.top;
-					if ((d < SNAPDOTPULL) && (d > -SNAPDOTPULL)) {
-						break;
-					}
-					d = rect->bottom - mainrc.bottom;
-					if ((d < SNAPDOTPULL) && (d > -SNAPDOTPULL)) {
-						break;
-					}
-				}
-			}
-			d = rect->top - workrc.top;
-			if ((d < SNAPDOTPULL) && (d > -SNAPDOTPULL)) {
-				break;
-			}
-			d = rect->bottom - workrc.bottom;
-			if ((d < SNAPDOTPULL) && (d > -SNAPDOTPULL)) {
+	for (i=0; i<cnt; i++) {
+		j = id[i];
+		flag = (!file_cmpname(base, np2tool.skinmru[j]))?MF_CHECKED:0;
+#if defined(OSLANG_UTF8)
+		TCHAR path[MAX_PATH];
+		oemtotchar(path, NELEMENTS(path), file[j], -1);
+#else
+		const TCHAR *path = file[j];
+#endif
+		AppendMenu(ret, MF_STRING + flag, IDM_SKINMRU + j, path);
+	}
+	return(ret);
+}
+
+static void skinchange(HWND hWnd) {
+
+const OEMCHAR	*p;
+	UINT		i;
+	HBITMAP		hbmp;
+	BITMAP		bmp;
+	WINLOCEX	wlex;
+
+	p = np2tool.skin;
+	if (p[0]) {
+		for (i=0; i<(SKINMRU_MAX - 1); i++) {
+			if (!file_cmpname(p, np2tool.skinmru[i])) {
 				break;
 			}
-		} while(0);
-		if ((d < SNAPDOTPULL) && (d > -SNAPDOTPULL)) {
-			toolwin.winflg |= 2;
-			rect->top -= d;
-			toolwin.wingy = d;
-			toolwin.winty = rect->top;
-		}
-	}
-	if ((toolwin.wingy >= SNAPDOTREL) || (toolwin.wingy <= -SNAPDOTREL)) {
-		toolwin.winflg &= ~2;
-		rect->top += toolwin.wingy;
-		toolwin.wingy = 0;
+		}
+		while(i > 0) {
+			CopyMemory(np2tool.skinmru[i], np2tool.skinmru[i-1],
+												sizeof(np2tool.skinmru[0]));
+			i--;
+		}
+		file_cpyname(np2tool.skinmru[0], p, NELEMENTS(np2tool.skinmru[0]));
 	}
+	ModifyMenu(np2class_gethmenu(hWnd), 0, MF_BYPOSITION | MF_POPUP,
+									(UINT)createskinmenu(), str_toolskin);
+	ModifyMenu(GetSystemMenu(hWnd, FALSE), 0, MF_BYPOSITION | MF_POPUP,
+									(UINT)createskinmenu(), str_toolskin);
+	DrawMenuBar(hWnd);
+	sysmng_update(SYS_UPDATEOSCFG);
 
-	rect->right = rect->left + winlx;
-	rect->bottom = rect->top + winly;
+	wlex = np2_winlocexallwin(hWndMain);
+	winlocex_setholdwnd(wlex, hWnd);
+	toolwindestroy();
+	hbmp = skinload(np2tool.skin);
+	if (hbmp == NULL) {
+		SendMessage(hWnd, WM_CLOSE, 0, 0);
+		return;
+	}
+	GetObject(hbmp, sizeof(BITMAP), &bmp);
+	toolwin.hbmp = hbmp;
+	winloc_setclientsize(hWnd, bmp.bmWidth, bmp.bmHeight);
+	toolwincreate(hWnd);
+	winlocex_move(wlex);
+	winlocex_destroy(wlex);
 }
 
 
 // ----
 
+static void openpopup(HWND hWnd, LPARAM lp) {
+
+	HMENU	hMenu;
+	HMENU	mainmenu;
+	POINT	pt;
+
+	hMenu = CreatePopupMenu();
+	if (!winui_en) {
+		mainmenu = np2class_gethmenu(hWndMain);
+		menu_addmenubar(hMenu, mainmenu);
+	}
+	AppendMenu(hMenu, MF_POPUP, (UINT)createskinmenu(), str_toolskin);
+	AppendMenu(hMenu, MF_SEPARATOR, 0, NULL);
+	AppendMenu(hMenu, MF_STRING, IDM_TOOLCLOSE, str_toolclose);
+	pt.x = LOWORD(lp);
+	pt.y = HIWORD(lp);
+	ClientToScreen(hWnd, &pt);
+	TrackPopupMenu(hMenu, TPM_LEFTALIGN, pt.x, pt.y, 0, hWnd, NULL);
+	DestroyMenu(hMenu);
+}
+
 static LRESULT CALLBACK twproc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp) {
 
+	HMENU		hMenu;
+	BOOL		r;
+	UINT		idc;
+	WINLOCEX	wlex;
+
 	switch(msg) {
 		case WM_CREATE:
-			SetWindowLong(hWnd, GWL_STYLE,
-							GetWindowLong(hWnd, GWL_STYLE) & (~WS_CAPTION));
-			SetWindowPos(hWnd, 0, 0, 0, 0, 0,
-					SWP_DRAWFRAME | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER);
-			toolwincreate(hWnd, lp);
+			np2class_wmcreate(hWnd);
+			ModifyMenu(np2class_gethmenu(hWnd), 0, MF_BYPOSITION | MF_POPUP,
+									(UINT)createskinmenu(), str_toolskin);
+			hMenu = GetSystemMenu(hWnd, FALSE);
+			InsertMenu(hMenu, 0, MF_BYPOSITION | MF_POPUP,
+									(UINT)createskinmenu(), str_toolskin);
+			InsertMenu(hMenu, 1, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
+
+			np2class_windowtype(hWnd, (np2tool.type & 1) << 1);
+			toolwincreate(hWnd);
+			break;
+
+		case WM_SYSCOMMAND:
+			switch(wp) {
+				case IDM_SKINSEL:
+				case IDM_SKINDEF:
+				case IDM_SKINMRU + 0:
+				case IDM_SKINMRU + 1:
+				case IDM_SKINMRU + 2:
+				case IDM_SKINMRU + 3:
+					return(SendMessage(hWnd, WM_COMMAND, wp, lp));
+
+				default:
+					return(DefWindowProc(hWnd, msg, wp, lp));
+			}
 			break;
 
 		case WM_COMMAND:
@@ -533,9 +723,9 @@ static LRESULT CALLBACK twproc(HWND hWnd
 					break;
 
 				case IDC_BASE + IDC_TOOLFDD1BROWSE:
-					soundmng_stop();
-					dialog_changefdd(hWnd, 0);
-					soundmng_play();
+					if (!winui_en) {
+						SendMessage(hWndMain, WM_COMMAND, IDM_FDD1OPEN, 0);
+					}
 					break;
 
 				case IDC_BASE + IDC_TOOLFDD1EJECT:
@@ -550,41 +740,112 @@ static LRESULT CALLBACK twproc(HWND hWnd
 					break;
 
 				case IDC_BASE + IDC_TOOLFDD2BROWSE:
-					soundmng_stop();
-					dialog_changefdd(hWnd, 1);
-					soundmng_play();
+					if (!winui_en) {
+						SendMessage(hWndMain, WM_COMMAND, IDM_FDD2OPEN, 0);
+					}
 					break;
 
 				case IDC_BASE + IDC_TOOLFDD2EJECT:
 					diskdrv_setfdd(1, NULL, 0);
 					toolwin_setfdd(1, NULL);
 					break;
+
+				case IDC_BASE + IDC_TOOLRESET:
+					if (!winui_en) {
+						SendMessage(hWndMain, WM_COMMAND, IDM_RESET, 0);
+						SetForegroundWindow(hWndMain);
+					}
+					break;
+
+				case IDC_BASE + IDC_TOOLPOWER:
+					if (!winui_en) {
+						SendMessage(hWndMain, WM_CLOSE, 0, 0L);
+					}
+					break;
+
+				case IDM_SKINSEL:
+					soundmng_disable(SNDPROC_TOOL);
+					r = dlgs_selectfile(hWnd, &skinui, np2tool.skin,
+											NELEMENTS(np2tool.skin), NULL);
+					soundmng_enable(SNDPROC_TOOL);
+					if (r) {
+						skinchange(hWnd);
+					}
+					break;
+
+				case IDM_SKINDEF:
+					np2tool.skin[0] = '\0';
+					skinchange(hWnd);
+					break;
+
+				case IDM_SKINMRU + 0:
+				case IDM_SKINMRU + 1:
+				case IDM_SKINMRU + 2:
+				case IDM_SKINMRU + 3:
+					file_cpyname(np2tool.skin,
+									np2tool.skinmru[LOWORD(wp) - IDM_SKINMRU],
+									NELEMENTS(np2tool.skin));
+					skinchange(hWnd);
+					break;
+
+				case IDM_TOOLCLOSE:
+					SendMessage(hWnd, WM_CLOSE, 0, 0);
+					break;
+
+				default:
+					if (!winui_en) {
+						return(SendMessage(hWndMain, msg, wp, lp));
+					}
+					break;
 			}
 			break;
 
+		case WM_KEYDOWN:						// TABを押した時に復帰
+			if ((short)wp == VK_TAB) {
+				idc = GetWindowLong(hWnd, GTWL_FOCUS);
+				if (idc < IDC_MAXITEMS) {
+					SetFocus(toolwin.sub[idc]);
+				}
+				return(0);
+			}
+			return(SendMessage(hWndMain, msg, wp, lp));
+
+		case WM_KEYUP:
+			if ((short)wp == VK_TAB) {
+				return(0);
+			}
+			return(SendMessage(hWndMain, msg, wp, lp));
+
 		case WM_PAINT:
 			toolwinpaint(hWnd);
 			break;
 
+		case WM_DRAWITEM:
+			tooldrawbutton(hWnd, wp, (LPDRAWITEMSTRUCT)lp);
+			break;
+
 		case WM_ENTERMENULOOP:
-			soundmng_stop();
+			soundmng_disable(SNDPROC_TOOL);
 			break;
 
 		case WM_EXITMENULOOP:
-			soundmng_play();
+			soundmng_enable(SNDPROC_TOOL);
 			break;
 
 		case WM_ENTERSIZEMOVE:
-			soundmng_stop();
-			movingstart();
+			soundmng_disable(SNDPROC_TOOL);
+			winlocex_destroy(toolwin.wlex);
+			toolwin.wlex = np2_winlocexallwin(hWnd);
 			break;
 
-		case WM_EXITSIZEMOVE:
-			soundmng_play();
+		case WM_MOVING:
+			winlocex_moving(toolwin.wlex, (RECT *)lp);
 			break;
 
-		case WM_MOVING:
-			movingproc((RECT *)lp);
+		case WM_EXITSIZEMOVE:
+			winlocex_destroy(toolwin.wlex);
+			toolwin.wlex = NULL;
+			soundmng_enable(SNDPROC_TOOL);
 			break;
 
 		case WM_MOVE:
@@ -599,17 +860,35 @@ static LRESULT CALLBACK twproc(HWND hWnd
 			break;
 
 		case WM_CLOSE:
-			xmenu_settoolwin(0);
+			sysmenu_settoolwin(0);
+			sysmng_update(SYS_UPDATEOSCFG);
 			DestroyWindow(hWnd);
 			break;
 
 		case WM_DESTROY:
+			np2class_wmdestroy(hWnd);
 			toolwindestroy();
 			toolwin.hwnd = NULL;
 			break;
 
 		case WM_LBUTTONDOWN:
-			SendMessage(hWnd, WM_NCLBUTTONDOWN, HTCAPTION, 0L);
+			if (np2tool.type & 1) {
+				return(SendMessage(hWnd, WM_NCLBUTTONDOWN, HTCAPTION, 0L));
+			}
+			break;
+
+		case WM_RBUTTONDOWN:
+			openpopup(hWnd, lp);
+			break;
+
+		case WM_LBUTTONDBLCLK:
+			np2tool.type ^= 1;
+			wlex = np2_winlocexallwin(hWndMain);
+			winlocex_setholdwnd(wlex, hWnd);
+			np2class_windowtype(hWnd, (np2tool.type & 1) << 1);
+			winlocex_move(wlex);
+			winlocex_destroy(wlex);
+			sysmng_update(SYS_UPDATEOSCFG);
 			break;
 
 		default:
@@ -622,90 +901,78 @@ BOOL toolwin_initapp(HINSTANCE hInstance
 
 	WNDCLASS wc;
 
-	wc.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
+	wc.style = CS_BYTEALIGNCLIENT | CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
 	wc.lpfnWndProc = twproc;
 	wc.cbClsExtra = 0;
-	wc.cbWndExtra = 0;
+	wc.cbWndExtra = GTWL_SIZE;
 	wc.hInstance = hInstance;
 	wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON2));
 	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
 	wc.hbrBackground = (HBRUSH)GetStockObject(NULL_BRUSH);
-	wc.lpszMenuName = NULL;
+	wc.lpszMenuName = MAKEINTRESOURCE(IDR_TOOLWIN);
 	wc.lpszClassName = np2toolclass;
 	return(RegisterClass(&wc));
 }
 
-void toolwin_open(void) {
+void toolwin_create(void) {
 
+	HBITMAP	hbmp;
+	BITMAP	bmp;
 	HWND	hWnd;
 
 	if (toolwin.hwnd) {
 		return;
 	}
 	ZeroMemory(&toolwin, sizeof(toolwin));
-	hWnd = CreateWindowEx(0, np2toolclass, np2tooltitle, WS_SYSMENU,
-							np2tool.posx, np2tool.posy, 410, 52,
+	hbmp = skinload(np2tool.skin);
+	if (hbmp == NULL) {
+		goto twope_err1;
+	}
+	GetObject(hbmp, sizeof(BITMAP), &bmp);
+	toolwin.hbmp = hbmp;
+	hWnd = CreateWindow(np2toolclass, np2tooltitle,
+							WS_SYSMENU | WS_MINIMIZEBOX,
+							np2tool.posx, np2tool.posy,
+							bmp.bmWidth, bmp.bmHeight,
 							NULL, NULL, hInst, NULL);
+	winloc_setclientsize(hWnd, bmp.bmWidth, bmp.bmHeight);
 	toolwin.hwnd = hWnd;
 	if (hWnd == NULL) {
-		return;
+		goto twope_err2;
 	}
 	UpdateWindow(hWnd);
-	ShowWindow(hWnd, SW_SHOW);
+	ShowWindow(hWnd, SW_SHOWNOACTIVATE);
+	SetForegroundWindow(hWndMain);
+	return;
+
+twope_err2:
+	DeleteObject(hbmp);
+
+twope_err1:
+	sysmenu_settoolwin(0);
+	sysmng_update(SYS_UPDATEOSCFG);
+	return;
 }
 
-void toolwin_close(void) {
+void toolwin_destroy(void) {
 
 	if (toolwin.hwnd) {
 		DestroyWindow(toolwin.hwnd);
 	}
 }
 
-void toolwin_movingstart(void) {
-
-	RECT	mainrc;
-	RECT	toolrc;
-
-	if (toolwin.hwnd == NULL) {
-		return;
-	}
-	GetWindowRect(hWndMain, &mainrc);
-	GetWindowRect(toolwin.hwnd, &toolrc);
-	if (((toolrc.right >= mainrc.left) && (toolrc.left <= mainrc.right) &&
-		((toolrc.bottom == mainrc.top) || (toolrc.top == mainrc.bottom))) ||
-		((toolrc.bottom >= mainrc.top) && (toolrc.top <= mainrc.bottom) &&
-		((toolrc.right == mainrc.left) || (toolrc.left == mainrc.right)))) {
-		toolwin.parentcn = 1;
-		toolwin.parentx = mainrc.left;
-		toolwin.parenty = mainrc.top;
-	}
-}
+HWND toolwin_gethwnd(void) {
 
-void toolwin_movingend(void) {
-
-	RECT	mainrc;
-	RECT	toolrc;
-	int		dx;
-	int		dy;
-
-	if ((toolwin.hwnd) && (toolwin.parentcn)) {
-		GetWindowRect(hWndMain, &mainrc);
-		GetWindowRect(toolwin.hwnd, &toolrc);
-		dx = mainrc.left - toolwin.parentx;
-		dy = mainrc.top - toolwin.parenty;
-		MoveWindow(toolwin.hwnd, toolrc.left + dx, toolrc.top + dy,
-								toolrc.right - toolrc.left,
-								toolrc.bottom - toolrc.top, TRUE);
-	}
-	toolwin.parentcn = 0;
+	return(toolwin.hwnd);
 }
 
-void toolwin_setfdd(BYTE drv, const char *name) {
+void toolwin_setfdd(UINT8 drv, const OEMCHAR *name) {
 
 	TOOLFDD	*fdd;
-	char	*q;
-	char	*p;
+	OEMCHAR	*q;
+	OEMCHAR	*p;
 	UINT	i;
+	HWND	sub;
 
 	if (drv >= FDDLIST_DRV) {
 		return;
@@ -718,63 +985,69 @@ void toolwin_setfdd(BYTE drv, const char
 		fdd->insert = 1;
 		q = fdd->name[0];
 		for (i=0; i<(FDDLIST_MAX - 1); i++) {
-			if (!milstr_cmp(q, name)) {
+			if (!file_cmpname(q, name)) {
 				break;
 			}
-			q += sizeof(fdd->name[0]);
+			q += NELEMENTS(fdd->name[0]);
 		}
-		p = q - sizeof(fdd->name[0]);
+		p = q - NELEMENTS(fdd->name[0]);
 		while(i > 0) {
 			i--;
 			CopyMemory(q, p, sizeof(fdd->name[0]));
-			p -= sizeof(fdd->name[0]);
-			q -= sizeof(fdd->name[0]);
+			p -= NELEMENTS(fdd->name[0]);
+			q -= NELEMENTS(fdd->name[0]);
 		}
-		milstr_ncpy(fdd->name[0], name, sizeof(fdd->name[0]));
+		file_cpyname(fdd->name[0], name, NELEMENTS(fdd->name[0]));
 	}
 	sysmng_update(SYS_UPDATEOSCFG);
 	if (toolwin.hwnd != NULL) {
-		setlist(drv);
-		SetForegroundWindow(hWndMain);
+		sub = toolwin.sub[fddlist[drv]];
+		if (sub) {
+			remakefddlist(sub, fdd);
+			SetForegroundWindow(hWndMain);
+		}
 	}
 }
 
-
-static void setdiskacc(UINT num, BYTE count) {
+static void setdiskacc(UINT num, UINT8 count) {
 
 const DISKACC	*acc;
-	BYTE		counter;
+	HWND		sub;
 
 	if (toolwin.hwnd == NULL) {
 		return;
 	}
-	if (num < (sizeof(diskacc)/sizeof(DISKACC))) {
+	if (num < NELEMENTS(diskacc)) {
 		acc = diskacc + num;
-		counter = *(acc->counter);
+		sub = NULL;
+		if (*(acc->counter) == 0) {
+			sub = toolwin.sub[acc->idc];
+		}
 		*(acc->counter) = count;
-		if (counter) {
-			InvalidateRect(toolwin.sub[acc->idc], NULL, TRUE);
+		if (sub) {
+			InvalidateRect(sub, NULL, TRUE);
 		}
 	}
 }
 
-void toolwin_fddaccess(BYTE drv) {
+void toolwin_fddaccess(UINT8 drv) {
 
 	if (drv < 2) {
 		setdiskacc(drv, 20);
 	}
 }
 
-void toolwin_hddaccess(BYTE drv) {
+void toolwin_hddaccess(UINT8 drv) {
 
 	setdiskacc(2, 10);
 }
 
-void toolwin_draw(BYTE frame) {
+void toolwin_draw(UINT8 frame) {
 
 const DISKACC	*acc;
 const DISKACC	*accterm;
-	BYTE		counter;
+	UINT8		counter;
+	HWND		sub;
 
 	if (toolwin.hwnd == NULL) {
 		return;
@@ -783,13 +1056,16 @@ const DISKACC	*accterm;
 		frame = 1;
 	}
 	acc = diskacc;
-	accterm = acc + (sizeof(diskacc)/sizeof(DISKACC));
+	accterm = acc + NELEMENTS(diskacc);
 	while(acc < accterm) {
 		counter = *acc->counter;
 		if (counter) {
 			if (counter <= frame) {
 				*(acc->counter) = 0;
-				InvalidateRect(toolwin.sub[acc->idc], NULL, TRUE);
+				sub = toolwin.sub[acc->idc];
+				if (sub) {
+					InvalidateRect(sub, NULL, TRUE);
+				}
 			}
 			else {
 				*(acc->counter) -= frame;
@@ -802,52 +1078,51 @@ const DISKACC	*accterm;
 
 // ----
 
-static const char np2toolini[] = "np2tool.ini";
-static const char ini_title[] = "NP2 tool";
+static const OEMCHAR ini_title[] = OEMTEXT("NP2 tool");
 
-static const INITBL iniitem[] = {
-	{"WindposX", INITYPE_SINT32,	&np2tool.posx,			0},
-	{"WindposY", INITYPE_SINT32,	&np2tool.posy,			0},
-	{"FD1NAME0", INITYPE_STR,		np2tool.fdd[0].name[0],	MAX_PATH},
-	{"FD1NAME1", INITYPE_STR,		np2tool.fdd[0].name[1],	MAX_PATH},
-	{"FD1NAME2", INITYPE_STR,		np2tool.fdd[0].name[2],	MAX_PATH},
-	{"FD1NAME3", INITYPE_STR,		np2tool.fdd[0].name[3],	MAX_PATH},
-	{"FD1NAME4", INITYPE_STR,		np2tool.fdd[0].name[4],	MAX_PATH},
-	{"FD1NAME5", INITYPE_STR,		np2tool.fdd[0].name[5],	MAX_PATH},
-	{"FD1NAME6", INITYPE_STR,		np2tool.fdd[0].name[6],	MAX_PATH},
-	{"FD1NAME7", INITYPE_STR,		np2tool.fdd[0].name[7],	MAX_PATH},
-	{"FD2NAME0", INITYPE_STR,		np2tool.fdd[1].name[0],	MAX_PATH},
-	{"FD2NAME1", INITYPE_STR,		np2tool.fdd[1].name[1],	MAX_PATH},
-	{"FD2NAME2", INITYPE_STR,		np2tool.fdd[1].name[2],	MAX_PATH},
-	{"FD2NAME3", INITYPE_STR,		np2tool.fdd[1].name[3],	MAX_PATH},
-	{"FD2NAME4", INITYPE_STR,		np2tool.fdd[1].name[4],	MAX_PATH},
-	{"FD2NAME5", INITYPE_STR,		np2tool.fdd[1].name[5],	MAX_PATH},
-	{"FD2NAME6", INITYPE_STR,		np2tool.fdd[1].name[6],	MAX_PATH},
-	{"FD2NAME7", INITYPE_STR,		np2tool.fdd[1].name[7],	MAX_PATH}};
-
-static void getinifile(char *path, int leng) {
-
-	milstr_ncpy(path, modulefile, leng);
-	file_cutname(path);
-	file_catname(path, np2toolini, leng);
-}
+static const PFTBL iniitem[] = {
+	PFVAL("WindposX", PFTYPE_SINT32,	&np2tool.posx),
+	PFVAL("WindposY", PFTYPE_SINT32,	&np2tool.posy),
+	PFVAL("WindType", PFTYPE_BOOL,		&np2tool.type),
+	PFSTR("SkinFile", PFTYPE_STR,		np2tool.skin),
+	PFSTR("SkinMRU0", PFTYPE_STR,		np2tool.skinmru[0]),
+	PFSTR("SkinMRU1", PFTYPE_STR,		np2tool.skinmru[1]),
+	PFSTR("SkinMRU2", PFTYPE_STR,		np2tool.skinmru[2]),
+	PFSTR("SkinMRU3", PFTYPE_STR,		np2tool.skinmru[3]),
+	PFSTR("FD1NAME0", PFTYPE_STR,		np2tool.fdd[0].name[0]),
+	PFSTR("FD1NAME1", PFTYPE_STR,		np2tool.fdd[0].name[1]),
+	PFSTR("FD1NAME2", PFTYPE_STR,		np2tool.fdd[0].name[2]),
+	PFSTR("FD1NAME3", PFTYPE_STR,		np2tool.fdd[0].name[3]),
+	PFSTR("FD1NAME4", PFTYPE_STR,		np2tool.fdd[0].name[4]),
+	PFSTR("FD1NAME5", PFTYPE_STR,		np2tool.fdd[0].name[5]),
+	PFSTR("FD1NAME6", PFTYPE_STR,		np2tool.fdd[0].name[6]),
+	PFSTR("FD1NAME7", PFTYPE_STR,		np2tool.fdd[0].name[7]),
+	PFSTR("FD2NAME0", PFTYPE_STR,		np2tool.fdd[1].name[0]),
+	PFSTR("FD2NAME1", PFTYPE_STR,		np2tool.fdd[1].name[1]),
+	PFSTR("FD2NAME2", PFTYPE_STR,		np2tool.fdd[1].name[2]),
+	PFSTR("FD2NAME3", PFTYPE_STR,		np2tool.fdd[1].name[3]),
+	PFSTR("FD2NAME4", PFTYPE_STR,		np2tool.fdd[1].name[4]),
+	PFSTR("FD2NAME5", PFTYPE_STR,		np2tool.fdd[1].name[5]),
+	PFSTR("FD2NAME6", PFTYPE_STR,		np2tool.fdd[1].name[6]),
+	PFSTR("FD2NAME7", PFTYPE_STR,		np2tool.fdd[1].name[7])};
 
 void toolwin_readini(void) {
 
-	char	path[MAX_PATH];
+	OEMCHAR	path[MAX_PATH];
 
 	ZeroMemory(&np2tool, sizeof(np2tool));
 	np2tool.posx = CW_USEDEFAULT;
 	np2tool.posy = CW_USEDEFAULT;
-	getinifile(path, sizeof(path));
-	ini_read(path, ini_title, iniitem, sizeof(iniitem)/sizeof(INITBL));
+	np2tool.type = 1;
+	initgetfile(path, NELEMENTS(path));
+	ini_read(path, ini_title, iniitem, NELEMENTS(iniitem));
 }
 
 void toolwin_writeini(void) {
 
-	char	path[MAX_PATH];
+	OEMCHAR	path[MAX_PATH];
 
-	getinifile(path, sizeof(path));
-	ini_write(path, ini_title, iniitem, sizeof(iniitem)/sizeof(INITBL));
+	initgetfile(path, NELEMENTS(path));
+	ini_write(path, ini_title, iniitem, NELEMENTS(iniitem));
 }