--- np2/io/serial.c	2003/10/21 11:22:05	1.2
+++ np2/io/serial.c	2004/02/11 17:39:59	1.10
@@ -4,7 +4,7 @@
 #include	"iocore.h"
 
 
-static const BYTE joykeytable[12] = {
+static const UINT8 joykeytable[12] = {
 				0x2a,	0x34,
 				0x29,	0x1c,
 				0x3c,	0x48,
@@ -12,7 +12,7 @@ static const BYTE joykeytable[12] = {
 				0x3d,	0x4b,
 				0x3a,	0x43};
 
-static const BYTE kbexflag[0x80] = {
+static const UINT8 kbexflag[0x80] = {
 		//	 ESC,  １,  ２,  ３,  ４,  ５,  ６,  ７		; 00h
 			   0,   0,   0,   0,   0,   0,   0,   0,
 		//	  ８,  ９,  ０,  −,  ＾,  ￥,  BS, TAB		; 08h
@@ -47,60 +47,64 @@ static const BYTE kbexflag[0x80] = {
 			   0,   0,   0,   0,   0,   0,   0,   0};
 
 
-static void keyb_int(BOOL absolute) {
+static void keybrd_int(BOOL absolute) {
 
-	if (keyb.buffers) {
-		if (!((pic.pi[0].irr | pic.pi[0].isr) & PIC_KEYBOARD)) {
-			keyb.status |= 2;
-			keyb.data = keyb.buf[keyb.pos];
-			keyb.pos = (keyb.pos + 1) & KB_BUFMASK;
-			keyb.buffers--;
-			pic_setirq(1);
+	if (keybrd.buffers) {
+		if (!(keybrd.status & 2)) {
+			keybrd.status |= 2;
+			keybrd.data = keybrd.buf[keybrd.pos];
+			keybrd.pos = (keybrd.pos + 1) & KB_BUFMASK;
+			keybrd.buffers--;
 		}
-		nevent_set(NEVENT_KEYBOARD, pc.keyboardclock,
-											keyb_callback, absolute);
-	}
-	else {
-		keyb.status &= ~2;
+		pic_setirq(1);
+		nevent_set(NEVENT_KEYBOARD, keybrd.xferclock,
+											keybrd_callback, absolute);
 	}
 }
 
-void keyb_callback(NEVENTITEM item) {
+void keybrd_callback(NEVENTITEM item) {
 
 	if (item->flag & NEVENT_SETEVENT) {
-		keyb_int(NEVENT_RELATIVE);
+		keybrd_int(NEVENT_RELATIVE);
 	}
 }
 
-static void keyb_out(BYTE data) {
+static void keybrd_out(REG8 data) {
 
-	if (keyb.buffers < KB_BUF) {
-		keyb.buf[(keyb.pos + keyb.buffers) & KB_BUFMASK] = data;
-		keyb.buffers++;
+	if (keybrd.buffers < KB_BUF) {
+		keybrd.buf[(keybrd.pos + keybrd.buffers) & KB_BUFMASK] = data;
+		keybrd.buffers++;
 		if (!nevent_iswork(NEVENT_KEYBOARD)) {
-			keyb_int(NEVENT_ABSOLUTE);
+			keybrd_int(NEVENT_ABSOLUTE);
 		}
 	}
 	else {
-		keyb.status |= 0x10;
+		keybrd.status |= 0x10;
 	}
 }
 
 
 // ----
 
-	BYTE	keystat[0x80];
+static	UINT8	keystat[0x80];
 
 void keystat_reset(void) {
 
 	ZeroMemory(keystat, sizeof(keystat));
 }
 
-void keystat_senddata(BYTE data) {
 
-	BYTE	key = data & 0x7f;
-	BOOL	keynochange = FALSE;
+void keystat_senddata(REG8 data) {
+
+	REG8	key;
+	BOOL	keynochange;
+const UINT8	*user;
+	UINT	i;
+
+	key = data & 0x7f;
+	keynochange = FALSE;
 
+	// CTRL:カナ 0x71,0x72 bit7==0でトグル処理 (標準処理)
 	if ((key == 0x71) || (key == 0x72)) {
 		if (data & 0x80) {
 			return;
@@ -108,6 +112,17 @@ void keystat_senddata(BYTE data) {
 		data = key | (keystat[key] & 0x80);
 		keystat[key] ^= 0x80;
 	}
+	else if ((key == 0x76) || (key == 0x77)) {		// user key
+		user = np2cfg.userkey[key - 0x76];
+		for (i=0; i<user[0]; i++) {
+			key = user[i+1] & 0x7f;
+			if (!((keystat[key] ^ data) & 0x80)) {
+				keystat[key] ^= 0x80;
+				keybrd_out((REG8)(key | (data & 0x80)));
+			}
+		}
+		return;
+	}
 	else {
 		if ((np2cfg.XSHIFT) &&
 			(((key == 0x70) && (np2cfg.XSHIFT & 1)) ||
@@ -120,6 +135,12 @@ void keystat_senddata(BYTE data) {
 			keystat[key] ^= 0x80;
 		}
 		else {
+			// CTRL:カナ 0x79,0x7a bit7をそのまま通知
+			// (ハードウェアでメカニカル処理してる場合)
+			if ((key == 0x79) || (key == 0x7a)) {
+				key -= 0x08;
+				data -= 0x08;
+			}
 			if (!((keystat[key] ^ data) & 0x80)) {
 				keystat[key] ^= 0x80;
 			}
@@ -136,124 +157,256 @@ void keystat_senddata(BYTE data) {
 			if (data & 0x80) {						// ver0.30
 				return;
 			}
-			keyb_out((BYTE)(data ^ 0x80));
+			keybrd_out((REG8)(data ^ 0x80));
+		}
+		keybrd_out(data);
+	}
+}
+
+void keystat_forcerelease(REG8 value) {
+
+	REG8	key;
+const UINT8	*user;
+	UINT	i;
+
+	key = value & 0x7f;
+	if ((key != 0x76) && (key != 0x77)) {
+		if (keystat[key] & 0x80) {
+			keystat[key] &= ~0x80;
+			keybrd_out((REG8)(key | 0x80));
+		}
+	}
+	else {
+		user = np2cfg.userkey[key - 0x76];
+		for (i=0; i<user[0]; i++) {
+			key = user[i+1] & 0x7f;
+			if (keystat[key] & 0x80) {
+				keystat[key] &= ~0x80;
+				keybrd_out((REG8)(key | 0x80));
+			}
 		}
-		keyb_out(data);
 	}
 }
 
 void keystat_resetcopyhelp(void) {
 
-	BYTE	i;
+	REG8	i;
 
 	for (i=0x60; i<0x62; i++) {
 		if (keystat[i] & 0x80) {
 			keystat[i] &= 0x7f;
-			keyb_out((BYTE)(i | 0x80));
+			keybrd_out((REG8)(i | 0x80));
 		}
 	}
 }
 
-void keystat_forcerelease(BYTE value) {
+void keystat_allrelease(void) {
+
+	REG8	i;
 
-	if (keystat[value & 0x7f] & 0x80) {
-		keystat[value & 0x7f] &= ~0x80;
-		keyb_out((BYTE)(value | 0x80));
+	for (i=0; i<0x80; i++) {
+		if (keystat[i] & 0x80) {
+			keystat[i] &= ~0x80;
+			keybrd_out((REG8)(i | 0x80));
+		}
 	}
 }
 
 void keystat_resetjoykey(void) {
 
 	int		i;
-	BYTE	key;
+	REG8	key;
 
 	for (i=0; i<12; i++) {
 		key = joykeytable[i];
 		if (keystat[key] & 0x80) {
 			keystat[key] &= 0x7f;
-			keyb_out((BYTE)(key | 0x80));
+			keybrd_out((REG8)(key | 0x80));
 		}
 	}
 }
 
-BYTE keystat_getjoy(void) {
 
-	BYTE	ret = 0xff;
-	BYTE	*p = (BYTE *)joykeytable;
+// ----
+
+typedef struct {
+	UINT8	joysync;
+	UINT8	joylast;
+	UINT8	mouselast;
+	UINT8	padding;
+	UINT8	d_up;
+	UINT8	d_dn;
+	UINT8	d_lt;
+	UINT8	d_rt;
+} KEYEXT;
+
+static	KEYEXT	keyext;
+static const UINT8 mousedelta[] = {1, 1, 1, 1,
+									2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4};
+#define	MOUSESTEPMAX ((sizeof(mousedelta) / sizeof(UINT8)) - 1)
+
+void keyext_flash(void) {
+
+	keyext.joysync = 0;
+}
+
+BYTE keyext_getjoy(void) {
+
+	BYTE	flg;
+const BYTE	*p;
 	BYTE	bit;
 
-	for (bit=0x20; bit; bit>>=1, p+=2) {
-		if ((keystat[*p] & 0x80) || (keystat[*(p+1)] & 0x80)) {
-			ret &= ~bit;
+	if (!keyext.joysync) {
+		keyext.joysync = 1;
+		flg = 0xff;
+		p = joykeytable;
+		for (bit=0x20; bit; bit>>=1) {
+			if ((keystat[p[0]] & 0x80) || (keystat[p[1]] & 0x80)) {
+				flg ^= bit;
+			}
+			p += 2;
+		}
+		keyext.joylast = flg;
+	}
+	return(keyext.joylast);
+}
+
+BYTE keyext_getmouse(SINT16 *x, SINT16 *y) {
+
+	BYTE	btn;
+	BYTE	acc;
+	SINT16	tmp;
+	BYTE	ret;
+
+	btn = keyext_getjoy();
+	acc = btn | keyext.mouselast;
+	keyext.mouselast = btn;
+	tmp = 0;
+	if (!(btn & 1)) {
+		tmp -= mousedelta[keyext.d_up];
+	}
+	if (!(acc & 1)) {
+		if (keyext.d_up < MOUSESTEPMAX) {
+			keyext.d_up++;
+		}
+	}
+	else {
+		keyext.d_up = 0;
+	}
+	if (!(btn & 2)) {
+		tmp += mousedelta[keyext.d_dn];
+	}
+	if (!(acc & 2)) {
+		if (keyext.d_dn < MOUSESTEPMAX) {
+			keyext.d_dn++;
 		}
 	}
+	else {
+		keyext.d_dn = 0;
+	}
+	*y += tmp;
+
+	tmp = 0;
+	if (!(btn & 4)) {
+		tmp -= mousedelta[keyext.d_lt];
+	}
+	if (!(acc & 4)) {
+		if (keyext.d_lt < MOUSESTEPMAX) {
+			keyext.d_lt++;
+		}
+	}
+	else {
+		keyext.d_lt = 0;
+	}
+	if (!(btn & 8)) {
+		tmp += mousedelta[keyext.d_rt];
+	}
+	if (!(acc & 8)) {
+		if (keyext.d_rt < MOUSESTEPMAX) {
+			keyext.d_rt++;
+		}
+	}
+	else {
+		keyext.d_rt = 0;
+	}
+	*x += tmp;
+
+	ret = 0x5f;
+	ret += (btn & 0x10) << 3;
+	ret += (btn & 0x20);
 	return(ret);
 }
 
 
 // ----
 
-static void IOOUTCALL keyb_o41(UINT port, BYTE dat) {
+static void IOOUTCALL keybrd_o41(UINT port, REG8 dat) {
 
-	keyb.mode = dat;
+	keybrd.mode = dat;
 	(void)port;
 }
 
-static void IOOUTCALL keyb_o43(UINT port, BYTE dat) {
+static void IOOUTCALL keybrd_o43(UINT port, REG8 dat) {
 
-	if ((!(dat & 0x08)) && (keyb.cmd & 0x08)) {
+	if ((!(dat & 0x08)) && (keybrd.cmd & 0x08)) {
 		keyboard_resetsignal();
 	}
 	if (dat & 0x10) {
-		keyb.status &= ~(0x38);
+		keybrd.status &= ~(0x38);
 	}
-	keyb.cmd = dat;
+	keybrd.cmd = dat;
 	(void)port;
 }
 
-static BYTE IOINPCALL keyb_i41(UINT port) {
+static REG8 IOINPCALL keybrd_i41(UINT port) {
 
 	(void)port;
-	return(keyb.data);
+	keybrd.status &= ~2;
+	return(keybrd.data);
 }
 
-static BYTE IOINPCALL keyb_i43(UINT port) {
+static REG8 IOINPCALL keybrd_i43(UINT port) {
 
 	(void)port;
-	return(keyb.status);
+	return(keybrd.status);
 }
 
 
 // ----
 
-static const IOOUT keybo41[2] = {
-					keyb_o41,	keyb_o43};
+static const IOOUT keybrdo41[2] = {
+					keybrd_o41,	keybrd_o43};
 
-static const IOINP keybi41[2] = {
-					keyb_i41,	keyb_i43};
+static const IOINP keybrdi41[2] = {
+					keybrd_i41,	keybrd_i43};
 
 
 void keyboard_reset(void) {
 
-	ZeroMemory(&keyb, sizeof(keyb));
-	keyb.data = 0xff;
-	keyb.mode = 0x5e;
+	ZeroMemory(&keybrd, sizeof(keybrd));
+	keybrd.data = 0xff;
+	keybrd.mode = 0x5e;
 }
 
 void keyboard_bind(void) {
 
-	iocore_attachsysoutex(0x0041, 0x0cf1, keybo41, 2);
-	iocore_attachsysinpex(0x0041, 0x0cf1, keybi41, 2);
+	keybrd.xferclock = pccore.realclock / 1920;
+	iocore_attachsysoutex(0x0041, 0x0cf1, keybrdo41, 2);
+	iocore_attachsysinpex(0x0041, 0x0cf1, keybrdi41, 2);
 }
 
 void keyboard_resetsignal(void) {									// ver0.29
 
 	int		i;
 
-	keyboard_reset();
+	keybrd.mode = 0x5e;
+	keybrd.cmd = 0;
+	keybrd.status = 0;
+	keybrd.buffers = 0;
+	keybrd.pos = 0;
 	for (i=0; i<0x80; i++) {
 		if (keystat[i]) {
-			keyb_out((BYTE)i);
+			keybrd_out((REG8)i);
 		}
 	}
 }
@@ -325,10 +478,10 @@ void rs232c_midipanic(void) {
 
 // ----
 
-static void IOOUTCALL rs232c_o30(UINT port, BYTE dat) {
+static void IOOUTCALL rs232c_o30(UINT port, REG8 dat) {
 
 	if (cm_rs232c) {
-		cm_rs232c->write(cm_rs232c, dat);
+		cm_rs232c->write(cm_rs232c, (UINT8)dat);
 	}
 	if (sysport.c & 4) {
 		rs232c.send = 0;
@@ -340,7 +493,7 @@ static void IOOUTCALL rs232c_o30(UINT po
 	(void)port;
 }
 
-static void IOOUTCALL rs232c_o32(UINT port, BYTE dat) {
+static void IOOUTCALL rs232c_o32(UINT port, REG8 dat) {
 
 	if (!(dat & 0xfd)) {
 		rs232c.dummyinst++;
@@ -398,13 +551,13 @@ static void IOOUTCALL rs232c_o32(UINT po
 	(void)port;
 }
 
-static BYTE IOINPCALL rs232c_i30(UINT port) {
+static REG8 IOINPCALL rs232c_i30(UINT port) {
 
 	(void)port;
 	return(rs232c.data);
 }
 
-static BYTE IOINPCALL rs232c_i32(UINT port) {
+static REG8 IOINPCALL rs232c_i32(UINT port) {
 
 	if (!(rs232c_stat() & 0x20)) {
 		return(rs232c.result | 0x80);