OSDN Git Service

[VM][EMU] Merge Upstream 2017-06-22.
authorK.Ohta <whatisthis.sowhat@gmail.com>
Fri, 23 Jun 2017 00:55:44 +0000 (09:55 +0900)
committerK.Ohta <whatisthis.sowhat@gmail.com>
Fri, 23 Jun 2017 00:55:44 +0000 (09:55 +0900)
[EMU][ROMAKANA] Fix not convert with Qt.
[EMU][ROMAKANA] Use functions within EMU:: , not use original ROMAKANA functions.

58 files changed:
source/src/config.h
source/src/emu.cpp
source/src/emu.h
source/src/vm/fm7/fm7.cpp
source/src/vm/fm7/fm7.h
source/src/vm/fm7/fm7_keyboard.h
source/src/vm/multi8/keyboard.h
source/src/vm/multi8/multi8.cpp
source/src/vm/multi8/multi8.h
source/src/vm/mycomz80a/keyboard.h
source/src/vm/mycomz80a/mycomz80a.cpp
source/src/vm/mycomz80a/mycomz80a.h
source/src/vm/mz3500/keyboard.h
source/src/vm/mz3500/mz3500.cpp
source/src/vm/mz3500/mz3500.h
source/src/vm/mz5500/keyboard.h
source/src/vm/mz5500/mz5500.cpp
source/src/vm/mz5500/mz5500.h
source/src/vm/mz80k/keyboard.h
source/src/vm/mz80k/mz80k.cpp
source/src/vm/mz80k/mz80k.h
source/src/vm/n5200/keyboard.h
source/src/vm/n5200/n5200.cpp
source/src/vm/n5200/n5200.h
source/src/vm/pc100/ioctrl.h
source/src/vm/pc100/pc100.cpp
source/src/vm/pc100/pc100.h
source/src/vm/pc8201/keyboard.h
source/src/vm/pc8201/pc8201.cpp
source/src/vm/pc8201/pc8201.h
source/src/vm/pc8801/pc88.cpp
source/src/vm/pc8801/pc88.h
source/src/vm/pc8801/pc8801.cpp
source/src/vm/pc8801/pc8801.h
source/src/vm/pc9801/keyboard.h
source/src/vm/pc9801/pc9801.cpp
source/src/vm/pc9801/pc9801.h
source/src/vm/pc98ha/keyboard.h
source/src/vm/pc98ha/pc98ha.cpp
source/src/vm/pc98ha/pc98ha.h
source/src/vm/smc777/memory.h
source/src/vm/smc777/smc777.cpp
source/src/vm/smc777/smc777.h
source/src/vm/tk80bs/keyboard.h
source/src/vm/tk80bs/tk80bs.cpp
source/src/vm/tk80bs/tk80bs.h
source/src/vm/upd765a.cpp
source/src/vm/x07/io.h
source/src/vm/x07/x07.cpp
source/src/vm/x07/x07.h
source/src/vm/x1/keyboard.h
source/src/vm/x1/psub.h
source/src/vm/x1/x1.cpp
source/src/vm/x1/x1.h
source/src/vm/yis/keyboard.h
source/src/vm/yis/yis.cpp
source/src/vm/yis/yis.h
source/src/vm/ym2203.cpp

index 74a3e25..6c6de99 100644 (file)
@@ -113,6 +113,9 @@ typedef struct {
                bool direct_load_mzt[MAX_TAPE_TMP];
                bool baud_high[MAX_TAPE_TMP];
        #endif
+       #if defined(USE_SHARED_DLL) || defined(USE_AUTO_KEY)
+               bool romaji_to_kana;
+       #endif
        
        int cpu_power;
        bool full_speed;
index dd7fbcb..cf4adce 100644 (file)
@@ -234,6 +234,11 @@ int EMU::run()
 
 void EMU::reset()
 {
+#ifdef USE_AUTO_KEY
+       stop_auto_key();
+       config.romaji_to_kana = false;
+#endif
+       
        // check if virtual machine should be reinitialized
        bool reinitialize = false;
 #ifdef USE_CPU_TYPE
@@ -288,6 +293,11 @@ void EMU::reset()
 #ifdef USE_SPECIAL_RESET
 void EMU::special_reset()
 {
+#ifdef USE_AUTO_KEY
+       stop_auto_key();
+       config.romaji_to_kana = false;
+#endif
+       
        // reset virtual machine
        osd->lock_vm();         
        vm->special_reset();
@@ -368,15 +378,54 @@ int EMU::get_mouse_button()
        #endif
 #endif
 
-void EMU::key_down(int code, bool repeat)
+void EMU::key_down(int code, bool extended, bool repeat)
+{
+#ifdef USE_AUTO_KEY
+       if(config.romaji_to_kana) {
+               if(!repeat) {
+                       // Page Up, Page Down, End, Home, Left, Up, Right, Down, Ins, Del, Help, and F1-F12
+                       if((code >= 0x21 && code <= 0x2f) || (code >= 0x70 && code <= 0x7b)) {
+                               auto_key_buffer->write(code);
+                               if(!is_auto_key_running()) {
+                                       start_auto_key();
+                               }
+                       }
+               }
+       } else if(!is_auto_key_running())
+#endif
+       osd->key_down(code, extended, repeat);
+}
+
+void EMU::key_up(int code, bool extended)
+{
+#ifdef USE_AUTO_KEY
+       if(config.romaji_to_kana) {
+               // do nothing
+       } else if(!is_auto_key_running())
+#endif
+       osd->key_up(code, extended);
+}
+
+void EMU::key_char(char code)
+{
+#ifdef USE_AUTO_KEY
+       if(config.romaji_to_kana) {
+               set_auto_key_char(code);
+       }
+#endif
+}
+
+#ifdef USE_KEY_LOCKED
+bool EMU::get_caps_locked()
 {
-       osd->key_down(code, repeat);
+       return vm->get_caps_locked();
 }
 
-void EMU::key_up(int code)
+bool EMU::get_kana_locked()
 {
-       osd->key_up(code);
+       return vm->get_kana_locked();
 }
+#endif
 
 void EMU::key_lost_focus()
 {
@@ -421,6 +470,573 @@ bool EMU::is_mouse_enabled()
 #endif
 
 #ifdef USE_AUTO_KEY
+static const int auto_key_table_base[][2] = {
+       // 0x100: shift
+       // 0x200: kana
+       // 0x400: alphabet
+       // 0x800: ALPHABET
+       {0x08,  0x000 | 0x08},  // BS
+       {0x09,  0x000 | 0x09},  // Tab
+       {0x0d,  0x000 | 0x0d},  // Enter
+       {0x20,  0x000 | 0x20},  // ' '
+#ifdef AUTO_KEY_US
+       {0x21,  0x100 | 0x31},  // '!'
+       {0x22,  0x100 | 0xba},  // '"'
+       {0x23,  0x100 | 0x33},  // '#'
+       {0x24,  0x100 | 0x34},  // '$'
+       {0x25,  0x100 | 0x35},  // '%'
+       {0x26,  0x100 | 0x37},  // '&'
+       {0x27,  0x000 | 0xba},  // '''
+       {0x28,  0x100 | 0x39},  // '('
+       {0x29,  0x100 | 0x30},  // ')'
+       {0x2a,  0x100 | 0x38},  // '*'
+       {0x2b,  0x100 | 0xde},  // '+'
+       {0x2c,  0x000 | 0xbc},  // ','
+       {0x2d,  0x000 | 0xbd},  // '-'
+       {0x2e,  0x000 | 0xbe},  // '.'
+       {0x2f,  0x000 | 0xbf},  // '/'
+#else
+       {0x21,  0x100 | 0x31},  // '!'
+       {0x22,  0x100 | 0x32},  // '"'
+       {0x23,  0x100 | 0x33},  // '#'
+       {0x24,  0x100 | 0x34},  // '$'
+       {0x25,  0x100 | 0x35},  // '%'
+       {0x26,  0x100 | 0x36},  // '&'
+       {0x27,  0x100 | 0x37},  // '''
+       {0x28,  0x100 | 0x38},  // '('
+       {0x29,  0x100 | 0x39},  // ')'
+       {0x2a,  0x100 | 0xba},  // '*'
+       {0x2b,  0x100 | 0xbb},  // '+'
+       {0x2c,  0x000 | 0xbc},  // ','
+       {0x2d,  0x000 | 0xbd},  // '-'
+       {0x2e,  0x000 | 0xbe},  // '.'
+       {0x2f,  0x000 | 0xbf},  // '/'
+#endif
+       {0x30,  0x000 | 0x30},  // '0'
+       {0x31,  0x000 | 0x31},  // '1'
+       {0x32,  0x000 | 0x32},  // '2'
+       {0x33,  0x000 | 0x33},  // '3'
+       {0x34,  0x000 | 0x34},  // '4'
+       {0x35,  0x000 | 0x35},  // '5'
+       {0x36,  0x000 | 0x36},  // '6'
+       {0x37,  0x000 | 0x37},  // '7'
+       {0x38,  0x000 | 0x38},  // '8'
+       {0x39,  0x000 | 0x39},  // '9'
+#ifdef AUTO_KEY_US
+       {0x3a,  0x100 | 0xbb},  // ':'
+       {0x3b,  0x000 | 0xbb},  // ';'
+       {0x3c,  0x100 | 0xbc},  // '<'
+       {0x3d,  0x000 | 0xde},  // '='
+       {0x3e,  0x100 | 0xbe},  // '>'
+       {0x3f,  0x100 | 0xbf},  // '?'
+       {0x40,  0x100 | 0x32},  // '@'
+#else
+       {0x3a,  0x000 | 0xba},  // ':'
+       {0x3b,  0x000 | 0xbb},  // ';'
+       {0x3c,  0x100 | 0xbc},  // '<'
+       {0x3d,  0x100 | 0xbd},  // '='
+       {0x3e,  0x100 | 0xbe},  // '>'
+       {0x3f,  0x100 | 0xbf},  // '?'
+       {0x40,  0x000 | 0xc0},  // '@'
+#endif
+       {0x41,  0x400 | 0x41},  // 'A'
+       {0x42,  0x400 | 0x42},  // 'B'
+       {0x43,  0x400 | 0x43},  // 'C'
+       {0x44,  0x400 | 0x44},  // 'D'
+       {0x45,  0x400 | 0x45},  // 'E'
+       {0x46,  0x400 | 0x46},  // 'F'
+       {0x47,  0x400 | 0x47},  // 'G'
+       {0x48,  0x400 | 0x48},  // 'H'
+       {0x49,  0x400 | 0x49},  // 'I'
+       {0x4a,  0x400 | 0x4a},  // 'J'
+       {0x4b,  0x400 | 0x4b},  // 'K'
+       {0x4c,  0x400 | 0x4c},  // 'L'
+       {0x4d,  0x400 | 0x4d},  // 'M'
+       {0x4e,  0x400 | 0x4e},  // 'N'
+       {0x4f,  0x400 | 0x4f},  // 'O'
+       {0x50,  0x400 | 0x50},  // 'P'
+       {0x51,  0x400 | 0x51},  // 'Q'
+       {0x52,  0x400 | 0x52},  // 'R'
+       {0x53,  0x400 | 0x53},  // 'S'
+       {0x54,  0x400 | 0x54},  // 'T'
+       {0x55,  0x400 | 0x55},  // 'U'
+       {0x56,  0x400 | 0x56},  // 'V'
+       {0x57,  0x400 | 0x57},  // 'W'
+       {0x58,  0x400 | 0x58},  // 'X'
+       {0x59,  0x400 | 0x59},  // 'Y'
+       {0x5a,  0x400 | 0x5a},  // 'Z'
+#ifdef AUTO_KEY_US
+       {0x5b,  0x000 | 0xc0},  // '['
+       {0x5c,  0x000 | 0xe2},  // '\'
+       {0x5d,  0x000 | 0xdb},  // ']'
+       {0x5e,  0x100 | 0x36},  // '^'
+       {0x5f,  0x100 | 0xbd},  // '_'
+       {0x60,  0x000 | 0xdd},  // '`'
+#else
+       {0x5b,  0x000 | 0xdb},  // '['
+       {0x5c,  0x000 | 0xdc},  // '\'
+       {0x5d,  0x000 | 0xdd},  // ']'
+       {0x5e,  0x000 | 0xde},  // '^'
+       {0x5f,  0x100 | 0xe2},  // '_'
+       {0x60,  0x100 | 0xc0},  // '`'
+#endif
+       {0x61,  0x800 | 0x41},  // 'a'
+       {0x62,  0x800 | 0x42},  // 'b'
+       {0x63,  0x800 | 0x43},  // 'c'
+       {0x64,  0x800 | 0x44},  // 'd'
+       {0x65,  0x800 | 0x45},  // 'e'
+       {0x66,  0x800 | 0x46},  // 'f'
+       {0x67,  0x800 | 0x47},  // 'g'
+       {0x68,  0x800 | 0x48},  // 'h'
+       {0x69,  0x800 | 0x49},  // 'i'
+       {0x6a,  0x800 | 0x4a},  // 'j'
+       {0x6b,  0x800 | 0x4b},  // 'k'
+       {0x6c,  0x800 | 0x4c},  // 'l'
+       {0x6d,  0x800 | 0x4d},  // 'm'
+       {0x6e,  0x800 | 0x4e},  // 'n'
+       {0x6f,  0x800 | 0x4f},  // 'o'
+       {0x70,  0x800 | 0x50},  // 'p'
+       {0x71,  0x800 | 0x51},  // 'q'
+       {0x72,  0x800 | 0x52},  // 'r'
+       {0x73,  0x800 | 0x53},  // 's'
+       {0x74,  0x800 | 0x54},  // 't'
+       {0x75,  0x800 | 0x55},  // 'u'
+       {0x76,  0x800 | 0x56},  // 'v'
+       {0x77,  0x800 | 0x57},  // 'w'
+       {0x78,  0x800 | 0x58},  // 'x'
+       {0x79,  0x800 | 0x59},  // 'y'
+       {0x7a,  0x800 | 0x5a},  // 'z'
+#ifdef AUTO_KEY_US
+       {0x7b,  0x100 | 0xc0},  // '{'
+       {0x7c,  0x100 | 0xe2},  // '|'
+       {0x7d,  0x100 | 0xdb},  // '}'
+       {0x7e,  0x100 | 0xdd},  // '~'
+#else
+       {0x7b,  0x100 | 0xdb},  // '{'
+       {0x7c,  0x100 | 0xdc},  // '|'
+       {0x7d,  0x100 | 0xdd},  // '}'
+       {0x7e,  0x100 | 0xde},  // '~'
+#endif
+       {-1, -1},
+};
+
+static const int auto_key_table_kana_base[][2] = {
+       {0xa1,  0x300 | 0xbe},  // '¡'
+       {0xa2,  0x300 | 0xdb},  // '¢'
+       {0xa3,  0x300 | 0xdd},  // '£'
+       {0xa4,  0x300 | 0xbc},  // '¤'
+       {0xa5,  0x300 | 0xbf},  // '¥'
+       {0xa6,  0x300 | 0x30},  // '¦'
+       {0xa7,  0x300 | 0x33},  // '§'
+       {0xa8,  0x300 | 0x45},  // '¨'
+       {0xa9,  0x300 | 0x34},  // '©'
+       {0xaa,  0x300 | 0x35},  // 'ª'
+       {0xab,  0x300 | 0x36},  // '«'
+       {0xac,  0x300 | 0x37},  // '¬'
+       {0xad,  0x300 | 0x38},  // '­'
+       {0xae,  0x300 | 0x39},  // '®'
+       {0xaf,  0x300 | 0x5a},  // '¯'
+       {0xb0,  0x200 | 0xdc},  // '°'
+       {0xb1,  0x200 | 0x33},  // '±'
+       {0xb2,  0x200 | 0x45},  // '²'
+       {0xb3,  0x200 | 0x34},  // '³'
+       {0xb4,  0x200 | 0x35},  // '´'
+       {0xb5,  0x200 | 0x36},  // 'µ'
+       {0xb6,  0x200 | 0x54},  // '¶'
+       {0xb7,  0x200 | 0x47},  // '·'
+       {0xb8,  0x200 | 0x48},  // '¸'
+       {0xb9,  0x200 | 0xba},  // '¹'
+       {0xba,  0x200 | 0x42},  // 'º'
+       {0xbb,  0x200 | 0x58},  // '»'
+       {0xbc,  0x200 | 0x44},  // '¼'
+       {0xbd,  0x200 | 0x52},  // '½'
+       {0xbe,  0x200 | 0x50},  // '¾'
+       {0xbf,  0x200 | 0x43},  // '¿'
+       {0xc0,  0x200 | 0x51},  // 'À'
+       {0xc1,  0x200 | 0x41},  // 'Á'
+       {0xc2,  0x200 | 0x5a},  // 'Â'
+       {0xc3,  0x200 | 0x57},  // 'Ã'
+       {0xc4,  0x200 | 0x53},  // 'Ä'
+       {0xc5,  0x200 | 0x55},  // 'Å'
+       {0xc6,  0x200 | 0x49},  // 'Æ'
+       {0xc7,  0x200 | 0x31},  // 'Ç'
+       {0xc8,  0x200 | 0xbc},  // 'È'
+       {0xc9,  0x200 | 0x4b},  // 'É'
+       {0xca,  0x200 | 0x46},  // 'Ê'
+       {0xcb,  0x200 | 0x56},  // 'Ë'
+       {0xcc,  0x200 | 0x32},  // 'Ì'
+       {0xcd,  0x200 | 0xde},  // 'Í'
+       {0xce,  0x200 | 0xbd},  // 'Î'
+       {0xcf,  0x200 | 0x4a},  // 'Ï'
+       {0xd0,  0x200 | 0x4e},  // 'Ð'
+       {0xd1,  0x200 | 0xdd},  // 'Ñ'
+       {0xd2,  0x200 | 0xbf},  // 'Ò'
+       {0xd3,  0x200 | 0x4d},  // 'Ó'
+       {0xd4,  0x200 | 0x37},  // 'Ô'
+       {0xd5,  0x200 | 0x38},  // 'Õ'
+       {0xd6,  0x200 | 0x39},  // 'Ö'
+       {0xd7,  0x200 | 0x4f},  // '×'
+       {0xd8,  0x200 | 0x4c},  // 'Ø'
+       {0xd9,  0x200 | 0xbe},  // 'Ù'
+       {0xda,  0x200 | 0xbb},  // 'Ú'
+       {0xdb,  0x200 | 0xe2},  // 'Û'
+       {0xdc,  0x200 | 0x30},  // 'Ü'
+       {0xdd,  0x200 | 0x59},  // 'Ý'
+       {0xde,  0x200 | 0xc0},  // 'Þ'
+       {0xdf,  0x200 | 0xdb},  // 'ß'
+       {-1, -1},
+};
+
+static const int auto_key_table_50on_base[][2] = {
+       {0xa1,  0x300 | 0xbf},  // '¡'
+       {0xa2,  0x300 | 0xdb},  // '¢'
+       {0xa3,  0x300 | 0xdd},  // '£'
+       {0xa4,  0x300 | 0xbe},  // '¤'
+       {0xa5,  0x300 | 0xe2},  // '¥'
+       {0xa6,  0x200 | 0xbf},  // '¦'
+       {0xa7,  0x300 | 0x31},  // '§'
+       {0xa8,  0x300 | 0x32},  // '¨'
+       {0xa9,  0x300 | 0x33},  // '©'
+       {0xaa,  0x300 | 0x34},  // 'ª'
+       {0xab,  0x300 | 0x35},  // '«'
+       {0xac,  0x300 | 0x4e},  // '¬'
+       {0xad,  0x300 | 0x4d},  // '­'
+       {0xae,  0x300 | 0xbc},  // '®'
+       {0xaf,  0x300 | 0x43},  // '¯'
+       {0xb0,  0x300 | 0xba},  // '°'
+       {0xb1,  0x200 | 0x31},  // '±'
+       {0xb2,  0x200 | 0x32},  // '²'
+       {0xb3,  0x200 | 0x33},  // '³'
+       {0xb4,  0x200 | 0x34},  // '´'
+       {0xb5,  0x200 | 0x35},  // 'µ'
+       {0xb6,  0x200 | 0x51},  // '¶'
+       {0xb7,  0x200 | 0x57},  // '·'
+       {0xb8,  0x200 | 0x45},  // '¸'
+       {0xb9,  0x200 | 0x52},  // '¹'
+       {0xba,  0x200 | 0x54},  // 'º'
+       {0xbb,  0x200 | 0x41},  // '»'
+       {0xbc,  0x200 | 0x53},  // '¼'
+       {0xbd,  0x200 | 0x44},  // '½'
+       {0xbe,  0x200 | 0x46},  // '¾'
+       {0xbf,  0x200 | 0x47},  // '¿'
+       {0xc0,  0x200 | 0x5a},  // 'À'
+       {0xc1,  0x200 | 0x58},  // 'Á'
+       {0xc2,  0x200 | 0x43},  // 'Â'
+       {0xc3,  0x200 | 0x56},  // 'Ã'
+       {0xc4,  0x200 | 0x42},  // 'Ä'
+       {0xc5,  0x200 | 0x36},  // 'Å'
+       {0xc6,  0x200 | 0x37},  // 'Æ'
+       {0xc7,  0x200 | 0x38},  // 'Ç'
+       {0xc8,  0x200 | 0x39},  // 'È'
+       {0xc9,  0x200 | 0x30},  // 'É'
+       {0xca,  0x200 | 0x59},  // 'Ê'
+       {0xcb,  0x200 | 0x55},  // 'Ë'
+       {0xcc,  0x200 | 0x49},  // 'Ì'
+       {0xcd,  0x200 | 0x4f},  // 'Í'
+       {0xce,  0x200 | 0x50},  // 'Î'
+       {0xcf,  0x200 | 0x48},  // 'Ï'
+       {0xd0,  0x200 | 0x4a},  // 'Ð'
+       {0xd1,  0x200 | 0x4b},  // 'Ñ'
+       {0xd2,  0x200 | 0x4c},  // 'Ò'
+       {0xd3,  0x200 | 0xbb},  // 'Ó'
+       {0xd4,  0x200 | 0x4e},  // 'Ô'
+       {0xd5,  0x200 | 0x4d},  // 'Õ'
+       {0xd6,  0x200 | 0xbc},  // 'Ö'
+       {0xd7,  0x200 | 0xbd},  // '×'
+       {0xd8,  0x200 | 0xde},  // 'Ø'
+       {0xd9,  0x200 | 0xdc},  // 'Ù'
+       {0xda,  0x200 | 0xc0},  // 'Ú'
+       {0xdb,  0x200 | 0xdb},  // 'Û'
+       {0xdc,  0x200 | 0xbe},  // 'Ü'
+       {0xdd,  0x200 | 0xe2},  // 'Ý'
+       {0xde,  0x200 | 0xba},  // 'Þ'
+       {0xdf,  0x200 | 0xdd},  // 'ß'
+       {-1, -1},
+};
+
+static const struct {
+       const char *romaji;
+       const uint8_t kana[4];
+} romaji_table[] = {
+       {"ltsu",        {0xaf, 0x00}},
+       {"xtsu",        {0xaf, 0x00}},
+       {"ltu",         {0xaf, 0x00}},
+       {"xtu",         {0xaf, 0x00}},
+       {"bya",         {0xcb, 0xde, 0xac, 0x00}},
+       {"byi",         {0xcb, 0xde, 0xa8, 0x00}},
+       {"byu",         {0xcb, 0xde, 0xad, 0x00}},
+       {"bye",         {0xcb, 0xde, 0xaa, 0x00}},
+       {"byo",         {0xcb, 0xde, 0xae, 0x00}},
+       {"cha",         {0xc1, 0xac, 0x00}},
+       {"chi",         {0xc1, 0x00}},
+       {"chu",         {0xc1, 0xad, 0x00}},
+       {"che",         {0xc1, 0xaa, 0x00}},
+       {"cho",         {0xc1, 0xae, 0x00}},
+       {"cya",         {0xc1, 0xac, 0x00}},
+       {"cyi",         {0xc1, 0xa8, 0x00}},
+       {"cyu",         {0xc1, 0xad, 0x00}},
+       {"cye",         {0xc1, 0xaa, 0x00}},
+       {"cyo",         {0xc1, 0xae, 0x00}},
+       {"dha",         {0xc3, 0xde, 0xac, 0x00}},
+       {"dhi",         {0xc3, 0xde, 0xa8, 0x00}},
+       {"dhu",         {0xc3, 0xde, 0xad, 0x00}},
+       {"dhe",         {0xc3, 0xde, 0xaa, 0x00}},
+       {"dho",         {0xc3, 0xde, 0xae, 0x00}},
+       {"dwa",         {0xc4, 0xde, 0xa7, 0x00}},
+       {"dwi",         {0xc4, 0xde, 0xa8, 0x00}},
+       {"dwu",         {0xc4, 0xde, 0xa9, 0x00}},
+       {"dwe",         {0xc4, 0xde, 0xaa, 0x00}},
+       {"dwo",         {0xc4, 0xde, 0xab, 0x00}},
+       {"dya",         {0xc1, 0xde, 0xac, 0x00}},
+       {"dyi",         {0xc1, 0xde, 0xa8, 0x00}},
+       {"dyu",         {0xc1, 0xde, 0xad, 0x00}},
+       {"dye",         {0xc1, 0xde, 0xaa, 0x00}},
+       {"dyo",         {0xc1, 0xde, 0xae, 0x00}},
+       {"fwa",         {0xcc, 0xa7, 0x00}},
+       {"fwi",         {0xcc, 0xa8, 0x00}},
+       {"fwu",         {0xcc, 0xa9, 0x00}},
+       {"fwe",         {0xcc, 0xaa, 0x00}},
+       {"fwo",         {0xcc, 0xab, 0x00}},
+       {"fya",         {0xcc, 0xac, 0x00}},
+       {"fyi",         {0xcc, 0xa8, 0x00}},
+       {"fyu",         {0xcc, 0xad, 0x00}},
+       {"fye",         {0xcc, 0xaa, 0x00}},
+       {"fyo",         {0xcc, 0xae, 0x00}},
+       {"gwa",         {0xb8, 0xde, 0xa7, 0x00}},
+       {"gwi",         {0xb8, 0xde, 0xa8, 0x00}},
+       {"gwu",         {0xb8, 0xde, 0xa9, 0x00}},
+       {"gwe",         {0xb8, 0xde, 0xaa, 0x00}},
+       {"gwo",         {0xb8, 0xde, 0xab, 0x00}},
+       {"gya",         {0xb7, 0xde, 0xac, 0x00}},
+       {"gyi",         {0xb7, 0xde, 0xa8, 0x00}},
+       {"gyu",         {0xb7, 0xde, 0xad, 0x00}},
+       {"gye",         {0xb7, 0xde, 0xaa, 0x00}},
+       {"gyo",         {0xb7, 0xde, 0xae, 0x00}},
+       {"hya",         {0xcb, 0xac, 0x00}},
+       {"hyi",         {0xcb, 0xa8, 0x00}},
+       {"hyu",         {0xcb, 0xad, 0x00}},
+       {"hye",         {0xcb, 0xaa, 0x00}},
+       {"hyo",         {0xcb, 0xae, 0x00}},
+       {"jya",         {0xbc, 0xde, 0xac, 0x00}},
+       {"jyi",         {0xbc, 0xde, 0xa8, 0x00}},
+       {"jyu",         {0xbc, 0xde, 0xad, 0x00}},
+       {"jye",         {0xbc, 0xde, 0xaa, 0x00}},
+       {"jyo",         {0xbc, 0xde, 0xae, 0x00}},
+       {"kya",         {0xb7, 0xac, 0x00}},
+       {"kyi",         {0xb7, 0xa8, 0x00}},
+       {"kyu",         {0xb7, 0xad, 0x00}},
+       {"kye",         {0xb7, 0xaa, 0x00}},
+       {"kyo",         {0xb7, 0xae, 0x00}},
+       {"lya",         {0xac, 0x00}},
+       {"lyi",         {0xa8, 0x00}},
+       {"lyu",         {0xad, 0x00}},
+       {"lye",         {0xaa, 0x00}},
+       {"lyo",         {0xae, 0x00}},
+       {"mya",         {0xd0, 0xac, 0x00}},
+       {"myi",         {0xd0, 0xa8, 0x00}},
+       {"myu",         {0xd0, 0xad, 0x00}},
+       {"mye",         {0xd0, 0xaa, 0x00}},
+       {"myo",         {0xd0, 0xae, 0x00}},
+       {"nya",         {0xc6, 0xac, 0x00}},
+       {"nyi",         {0xc6, 0xa8, 0x00}},
+       {"nyu",         {0xc6, 0xad, 0x00}},
+       {"nye",         {0xc6, 0xaa, 0x00}},
+       {"nyo",         {0xc6, 0xae, 0x00}},
+       {"pya",         {0xcb, 0xdf, 0xac, 0x00}},
+       {"pyi",         {0xcb, 0xdf, 0xa8, 0x00}},
+       {"pyu",         {0xcb, 0xdf, 0xad, 0x00}},
+       {"pye",         {0xcb, 0xdf, 0xaa, 0x00}},
+       {"pyo",         {0xcb, 0xdf, 0xae, 0x00}},
+       {"qwa",         {0xb8, 0xa7, 0x00}},
+       {"qwi",         {0xb8, 0xa8, 0x00}},
+       {"qwu",         {0xb8, 0xa9, 0x00}},
+       {"qwe",         {0xb8, 0xaa, 0x00}},
+       {"qwo",         {0xb8, 0xab, 0x00}},
+       {"qya",         {0xb8, 0xac, 0x00}},
+       {"qyi",         {0xb8, 0xa8, 0x00}},
+       {"qyu",         {0xb8, 0xad, 0x00}},
+       {"qye",         {0xb8, 0xaa, 0x00}},
+       {"qyo",         {0xb8, 0xae, 0x00}},
+       {"rya",         {0xd8, 0xac, 0x00}},
+       {"ryi",         {0xd8, 0xa8, 0x00}},
+       {"ryu",         {0xd8, 0xad, 0x00}},
+       {"rye",         {0xd8, 0xaa, 0x00}},
+       {"ryo",         {0xd8, 0xae, 0x00}},
+       {"sha",         {0xbc, 0xac, 0x00}},
+       {"shi",         {0xbc, 0x00}},
+       {"shu",         {0xbc, 0xad, 0x00}},
+       {"she",         {0xbc, 0xaa, 0x00}},
+       {"sho",         {0xbc, 0xae, 0x00}},
+       {"swa",         {0xbd, 0xa7, 0x00}},
+       {"swi",         {0xbd, 0xa8, 0x00}},
+       {"swu",         {0xbd, 0xa9, 0x00}},
+       {"swe",         {0xbd, 0xaa, 0x00}},
+       {"swo",         {0xbd, 0xab, 0x00}},
+       {"sya",         {0xbc, 0xac, 0x00}},
+       {"syi",         {0xbc, 0xa8, 0x00}},
+       {"syu",         {0xbc, 0xad, 0x00}},
+       {"sye",         {0xbc, 0xaa, 0x00}},
+       {"syo",         {0xbc, 0xae, 0x00}},
+       {"tha",         {0xc3, 0xac, 0x00}},
+       {"thi",         {0xc3, 0xa8, 0x00}},
+       {"thu",         {0xc3, 0xad, 0x00}},
+       {"the",         {0xc3, 0xaa, 0x00}},
+       {"tho",         {0xc3, 0xae, 0x00}},
+       {"tsa",         {0xc2, 0xa7, 0x00}},
+       {"tsi",         {0xc2, 0xa8, 0x00}},
+       {"tsu",         {0xc2, 0x00}},
+       {"tse",         {0xc2, 0xaa, 0x00}},
+       {"tso",         {0xc2, 0xab, 0x00}},
+       {"twa",         {0xc4, 0xa7, 0x00}},
+       {"twi",         {0xc4, 0xa8, 0x00}},
+       {"twu",         {0xc4, 0xa9, 0x00}},
+       {"twe",         {0xc4, 0xaa, 0x00}},
+       {"two",         {0xc4, 0xab, 0x00}},
+       {"tya",         {0xc1, 0xac, 0x00}},
+       {"tyi",         {0xc1, 0xa8, 0x00}},
+       {"tyu",         {0xc1, 0xad, 0x00}},
+       {"tye",         {0xc1, 0xaa, 0x00}},
+       {"tyo",         {0xc1, 0xae, 0x00}},
+       {"vya",         {0xb3, 0xde, 0xac, 0x00}},
+       {"vyi",         {0xb3, 0xde, 0xa8, 0x00}},
+       {"vyu",         {0xb3, 0xde, 0xad, 0x00}},
+       {"vye",         {0xb3, 0xde, 0xaa, 0x00}},
+       {"vyo",         {0xb3, 0xde, 0xae, 0x00}},
+       {"wha",         {0xb3, 0xa7, 0x00}},
+       {"whi",         {0xb3, 0xa8, 0x00}},
+       {"whu",         {0xb3, 0x00}},
+       {"whe",         {0xb3, 0xaa, 0x00}},
+       {"who",         {0xb3, 0xab, 0x00}},
+       {"xya",         {0xac, 0x00}},
+       {"xyi",         {0xa8, 0x00}},
+       {"xyu",         {0xad, 0x00}},
+       {"xye",         {0xaa, 0x00}},
+       {"xyo",         {0xae, 0x00}},
+       {"zya",         {0xbc, 0xde, 0xac, 0x00}},
+       {"zyi",         {0xbc, 0xde, 0xa8, 0x00}},
+       {"zyu",         {0xbc, 0xde, 0xad, 0x00}},
+       {"zye",         {0xbc, 0xde, 0xaa, 0x00}},
+       {"zyo",         {0xbc, 0xde, 0xae, 0x00}},
+       {"ba",          {0xca, 0xde, 0x00}},
+       {"bi",          {0xcb, 0xde, 0x00}},
+       {"bu",          {0xcc, 0xde, 0x00}},
+       {"be",          {0xcd, 0xde, 0x00}},
+       {"bo",          {0xce, 0xde, 0x00}},
+       {"ca",          {0xb6, 0x00}},
+       {"ci",          {0xbc, 0x00}},
+       {"cu",          {0xb8, 0x00}},
+       {"ce",          {0xbe, 0x00}},
+       {"co",          {0xba, 0x00}},
+       {"da",          {0xc0, 0xde, 0x00}},
+       {"di",          {0xc1, 0xde, 0x00}},
+       {"du",          {0xc2, 0xde, 0x00}},
+       {"de",          {0xc3, 0xde, 0x00}},
+       {"do",          {0xc4, 0xde, 0x00}},
+       {"fa",          {0xcc, 0xa7, 0x00}},
+       {"fi",          {0xcc, 0xa8, 0x00}},
+       {"fu",          {0xcc, 0x00}},
+       {"fe",          {0xcc, 0xaa, 0x00}},
+       {"fo",          {0xcc, 0xab, 0x00}},
+       {"ga",          {0xb6, 0xde, 0x00}},
+       {"gi",          {0xb7, 0xde, 0x00}},
+       {"gu",          {0xb8, 0xde, 0x00}},
+       {"ge",          {0xb9, 0xde, 0x00}},
+       {"go",          {0xba, 0xde, 0x00}},
+       {"ha",          {0xca, 0x00}},
+       {"hi",          {0xcb, 0x00}},
+       {"hu",          {0xcc, 0x00}},
+       {"he",          {0xcd, 0x00}},
+       {"ho",          {0xce, 0x00}},
+       {"ja",          {0xbc, 0xde, 0xac, 0x00}},
+       {"ji",          {0xbc, 0xde, 0x00}},
+       {"ju",          {0xbc, 0xde, 0xad, 0x00}},
+       {"je",          {0xbc, 0xde, 0xaa, 0x00}},
+       {"jo",          {0xbc, 0xde, 0xae, 0x00}},
+       {"ka",          {0xb6, 0x00}},
+       {"ki",          {0xb7, 0x00}},
+       {"ku",          {0xb8, 0x00}},
+       {"ke",          {0xb9, 0x00}},
+       {"ko",          {0xba, 0x00}},
+       {"la",          {0xa7, 0x00}},
+       {"li",          {0xa8, 0x00}},
+       {"lu",          {0xa9, 0x00}},
+       {"le",          {0xaa, 0x00}},
+       {"lo",          {0xab, 0x00}},
+       {"ma",          {0xcf, 0x00}},
+       {"mi",          {0xd0, 0x00}},
+       {"mu",          {0xd1, 0x00}},
+       {"me",          {0xd2, 0x00}},
+       {"mo",          {0xd3, 0x00}},
+       {"na",          {0xc5, 0x00}},
+       {"ni",          {0xc6, 0x00}},
+       {"nu",          {0xc7, 0x00}},
+       {"ne",          {0xc8, 0x00}},
+       {"no",          {0xc9, 0x00}},
+//     {"nn",          {0xdd, 0x00}},
+       {"pa",          {0xca, 0xdf, 0x00}},
+       {"pi",          {0xcb, 0xdf, 0x00}},
+       {"pu",          {0xcc, 0xdf, 0x00}},
+       {"pe",          {0xcd, 0xdf, 0x00}},
+       {"po",          {0xce, 0xdf, 0x00}},
+       {"qa",          {0xb8, 0xa7, 0x00}},
+       {"qi",          {0xb8, 0xa8, 0x00}},
+       {"qu",          {0xb8, 0x00}},
+       {"qe",          {0xb8, 0xaa, 0x00}},
+       {"qo",          {0xb8, 0xab, 0x00}},
+       {"ra",          {0xd7, 0x00}},
+       {"ri",          {0xd8, 0x00}},
+       {"ru",          {0xd9, 0x00}},
+       {"re",          {0xda, 0x00}},
+       {"ro",          {0xdb, 0x00}},
+       {"sa",          {0xbb, 0x00}},
+       {"si",          {0xbc, 0x00}},
+       {"su",          {0xbd, 0x00}},
+       {"se",          {0xbe, 0x00}},
+       {"so",          {0xbf, 0x00}},
+       {"ta",          {0xc0, 0x00}},
+       {"ti",          {0xc1, 0x00}},
+       {"tu",          {0xc2, 0x00}},
+       {"te",          {0xc3, 0x00}},
+       {"to",          {0xc4, 0x00}},
+       {"va",          {0xb3, 0xde, 0xa7, 0x00}},
+       {"vi",          {0xb3, 0xde, 0xa8, 0x00}},
+       {"vu",          {0xb3, 0xde, 0x00}},
+       {"ve",          {0xb3, 0xde, 0xaa, 0x00}},
+       {"vo",          {0xb3, 0xde, 0xab, 0x00}},
+       {"wa",          {0xdc, 0x00}},
+       {"wi",          {0xb3, 0xa8, 0x00}},
+       {"wu",          {0xb3, 0x00}},
+       {"we",          {0xb3, 0xaa, 0x00}},
+       {"wo",          {0xa6, 0x00}},
+       {"xa",          {0xa7, 0x00}},
+       {"xi",          {0xa8, 0x00}},
+       {"xu",          {0xa9, 0x00}},
+       {"xe",          {0xaa, 0x00}},
+       {"xo",          {0xab, 0x00}},
+       {"ya",          {0xd4, 0x00}},
+       {"yi",          {0xb2, 0x00}},
+       {"yu",          {0xd5, 0x00}},
+       {"ye",          {0xb2, 0xaa, 0x00}},
+       {"yo",          {0xd6, 0x00}},
+       {"za",          {0xbb, 0xde, 0x00}},
+       {"zi",          {0xbc, 0xde, 0x00}},
+       {"zu",          {0xbd, 0xde, 0x00}},
+       {"ze",          {0xbe, 0xde, 0x00}},
+       {"zo",          {0xbf, 0xde, 0x00}},
+       {"a",           {0xb1, 0x00}},
+       {"i",           {0xb2, 0x00}},
+       {"u",           {0xb3, 0x00}},
+       {"e",           {0xb4, 0x00}},
+       {"o",           {0xb5, 0x00}},
+       {"[",           {0xa2, 0x00}},
+       {"]",           {0xa3, 0x00}},
+       {"-",           {0xb0, 0x00}},
+       {",",           {0xa4, 0x00}},
+       {".",           {0xa1, 0x00}},
+       {"/",           {0xa5, 0x00}},
+       {"",            {0x00}},
+};
+
 void EMU::initialize_auto_key()
 {
        auto_key_buffer = new FIFO(65536);
@@ -437,6 +1053,230 @@ void EMU::release_auto_key()
        }
 }
 
+int EMU::get_auto_key_code(int code)
+{
+       static int auto_key_table[256];
+       static bool initialized = false;
+#ifdef USE_KEYBOARD_TYPE
+       static int keyboard_type = -1;
+       
+       if(keyboard_type != config.keyboard_type) {
+               initialized = false;
+               keyboard_type = config.keyboard_type;
+       }
+#endif
+       if(!initialized) {
+               memset(auto_key_table, 0, sizeof(auto_key_table));
+               for(int i = 0;; i++) {
+                       if(auto_key_table_base[i][0] == -1) {
+                               break;
+                       }
+                       auto_key_table[auto_key_table_base[i][0]] = auto_key_table_base[i][1];
+               }
+#if defined(_X1TURBO) || defined(_X1TURBOZ)
+               // FIXME
+               if(config.keyboard_type) {
+                       for(int i = 0;; i++) {
+                               if(auto_key_table_50on_base[i][0] == -1) {
+                                       break;
+                               }
+                               auto_key_table[auto_key_table_50on_base[i][0]] = auto_key_table_50on_base[i][1];
+                       }
+               } else
+#endif
+               for(int i = 0;; i++) {
+                       if(auto_key_table_kana_base[i][0] == -1) {
+                               break;
+                       }
+                       auto_key_table[auto_key_table_kana_base[i][0]] = auto_key_table_kana_base[i][1];
+               }
+#ifdef USE_VM_AUTO_KEY_TABLE
+               for(int i = 0;; i++) {
+                       if(vm_auto_key_table_base[i][0] == -1) {
+                               break;
+                       }
+                       auto_key_table[vm_auto_key_table_base[i][0]] = vm_auto_key_table_base[i][1];
+               }
+#endif
+               initialized = true;
+       }
+       return auto_key_table[code];
+}
+
+void EMU::set_auto_key_code(int code)
+{
+       if(code == 0xf2 || (code = get_auto_key_code(code)) != 0) {
+               if(code == 0x08 || code == 0x09 || code == 0x0d || code == 0x20 || code == 0xf2) {
+                       auto_key_buffer->write(code);
+               } else if(code & 0x200) {
+                       // kana
+                       auto_key_buffer->write(code & 0x1ff);
+               } else {
+                       // ank other than alphabet and kana
+                       auto_key_buffer->write(0xf2); // kana unlock
+                       auto_key_buffer->write(code & 0x1ff);
+                       auto_key_buffer->write(0xf2); // kana lock
+               }
+               if(!is_auto_key_running()) {
+                       start_auto_key();
+               }
+       }
+}
+
+void EMU::set_auto_key_list(char *buf, int size)
+{
+#if defined(USE_KEY_LOCKED)
+       bool prev_caps = get_caps_locked();
+       bool prev_kana = get_kana_locked();
+#else
+       bool prev_caps = false;
+       bool prev_kana = false;
+#endif
+       auto_key_buffer->clear();
+       
+       for(int i = 0; i < size; i++) {
+               int code = buf[i] & 0xff;
+               if((0x81 <= code && code <= 0x9f) || 0xe0 <= code) {
+                       i++;    // kanji ?
+                       continue;
+               } else if(code == 0x0a) {
+                       continue;       // cr-lf
+               }
+               if((code = get_auto_key_code(code)) != 0) {
+                       // kana lock
+                       bool kana = ((code & 0x200) != 0);
+                       if(prev_kana != kana) {
+                               auto_key_buffer->write(0xf2);
+                       }
+                       prev_kana = kana;
+#if defined(USE_AUTO_KEY_CAPS_LOCK)
+                       // use caps lock key to switch uppercase/lowercase of alphabet
+                       // USE_AUTO_KEY_CAPS_LOCK shows the caps lock key code
+                       bool caps = ((code & 0x400) != 0);
+                       if(prev_caps != caps) {
+                               auto_key_buffer->write(USE_AUTO_KEY_CAPS_LOCK);
+                       }
+                       prev_caps = caps;
+#endif
+#if defined(USE_AUTO_KEY_CAPS_LOCK) || defined(USE_AUTO_KEY_NO_CAPS)
+                       code &= ~(0x400 | 0x800); // don't press shift key for both alphabet and ALPHABET
+#elif defined(USE_KEY_LOCKED)
+                       if(get_caps_locked()) {
+                               code &= ~0x400; // don't press shift key for ALPHABET
+                       } else {
+                               code &= ~0x800; // don't press shift key for alphabet
+                       }
+#elif defined(USE_AUTO_KEY_CAPS)
+                       code &= ~0x400; // don't press shift key for ALPHABET
+#else
+                       code &= ~0x800; // don't press shift key for alphabet
+#endif
+                       if(code & (0x100 | 0x400 | 0x800)) {
+                               auto_key_buffer->write((code & 0xff) | 0x100);
+                       } else {
+                               auto_key_buffer->write(code & 0xff);
+                       }
+               }
+       }
+       // release kana lock
+       if(prev_kana) {
+               auto_key_buffer->write(0xf2);
+       }
+#if defined(USE_AUTO_KEY_CAPS_LOCK)
+       // release caps lock
+       if(prev_caps) {
+               auto_key_buffer->write(USE_AUTO_KEY_CAPS_LOCK);
+       }
+#endif
+}
+
+bool is_alphabet(char code)
+{
+       return (code >= 'a' && code <= 'z');
+}
+
+bool is_vowel(char code)
+{
+       return (code == 'a' || code == 'i' || code == 'u' || code == 'e' || code == 'o');
+}
+
+bool is_consonant(char code)
+{
+       return (is_alphabet(code) && !is_vowel(code));
+}
+
+void EMU::set_auto_key_char(char code)
+{
+       static char codes[5] = {0};
+       if(code == 1) {
+               // start
+#ifdef USE_KEY_LOCKED
+               if(!get_kana_locked())
+#endif
+               set_auto_key_code(0xf2);
+               memset(codes, 0, sizeof(codes));
+       } else if(code == 0) {
+               // end
+               if(codes[3] == 'n') {
+                       set_auto_key_code(0xdd); // 'Ý'
+               }
+               set_auto_key_code(0xf2);
+               memset(codes, 0, sizeof(codes));
+       } else if(code == 0x08 || code == 0x09 || code == 0x0d || code == 0x20) {
+               if(codes[3] == 'n') {
+                       set_auto_key_code(0xdd); // 'Ý'
+               }
+               set_auto_key_code(code);
+               memset(codes, 0, sizeof(codes));
+       } else {
+               codes[0] = codes[1];
+               codes[1] = codes[2];
+               codes[2] = codes[3];
+               codes[3] = (code >= 'A' && code <= 'Z') ? ('a' + (code - 'A')) : code;
+               codes[4] = '\0';
+               
+               if(codes[2] == 'n' && !is_vowel(codes[3])) {
+                       set_auto_key_code(0xdd); // 'Ý'
+                       if(codes[3] == 'n') {
+                               memset(codes, 0, sizeof(codes));
+                               return;
+                       }
+               } else if(codes[2] == codes[3] && is_consonant(codes[3])) {
+                       set_auto_key_code(0xaf); // '¯'
+                       return;
+               }
+               for(int i = 0;; i++) {
+                       int len = strlen(romaji_table[i].romaji), comp = -1;
+                       if(len == 0) {
+                               // end of table
+                               if(!is_alphabet(codes[3])) {
+                                       set_auto_key_code(codes[3]);
+                                       memset(codes, 0, sizeof(codes));
+                               }
+                               break;
+                       } else if(len == 1) {
+                               comp = strcmp(romaji_table[i].romaji, &codes[3]);
+                       } else if(len == 2) {
+                               comp = strcmp(romaji_table[i].romaji, &codes[2]);
+                       } else if(len == 3) {
+                               comp = strcmp(romaji_table[i].romaji, &codes[1]);
+                       } else if(len == 4) {
+                               comp = strcmp(romaji_table[i].romaji, &codes[0]);
+                       }
+                       if(comp == 0) {
+                               for(int j = 0; j < 4; j++) {
+                                       if(!romaji_table[i].kana[j]) {
+                                               break;
+                                       }
+                                       set_auto_key_code(romaji_table[i].kana[j]);
+                               }
+                               memset(codes, 0, sizeof(codes));
+                               break;
+                       }
+               }
+       }
+}
+
 void EMU::start_auto_key()
 {
        auto_key_phase = 1;
@@ -1848,6 +2688,11 @@ void EMU::save_state(const _TCHAR* file_path)
 void EMU::load_state(const _TCHAR* file_path)
 {
        if(FILEIO::IsFileExisting(file_path)) {
+#ifdef USE_AUTO_KEY
+               stop_auto_key();
+               config.romaji_to_kana = false;
+#endif
+               
                save_state(create_local_path(_T("$temp$.sta")));
                if(!load_state_tmp(file_path)) {
                        out_debug_log(_T("failed to load state file\n"));
index 8aaf201..c469b91 100644 (file)
@@ -113,6 +113,8 @@ private:
        int auto_key_phase, auto_key_shift;
        void initialize_auto_key();
        void release_auto_key();
+       int get_auto_key_code(int code);
+       void set_auto_key_code(int code);
        void update_auto_key();
 #endif
 #ifdef USE_JOYSTICK
@@ -226,8 +228,13 @@ public:
 #ifdef OSD_QT
        void key_modifiers(uint32_t mod);
 #endif
-       void key_down(int code, bool repeat);
-       void key_up(int code);
+       void key_down(int code, bool extended, bool repeat);
+       void key_up(int code, bool extended);
+       void key_char(char code);
+#ifdef USE_KEY_LOCKED
+       bool get_caps_locked();
+       bool get_kana_locked();
+#endif
        void key_lost_focus();
 #ifdef ONE_BOARD_MICRO_COMPUTER
        void press_button(int num);
@@ -239,6 +246,8 @@ public:
        bool is_mouse_enabled();
 #endif 
 #ifdef USE_AUTO_KEY
+       void set_auto_key_list(char *buf, int size);
+       void set_auto_key_char(char code);
        void start_auto_key();
        void stop_auto_key();
        bool is_auto_key_running()
index 4a36131..386a74f 100644 (file)
@@ -675,6 +675,16 @@ void VM::key_up(int code)
        keyboard->key_up(code);
 }
 
+bool VM::get_caps_locked()
+{
+       return keyboard->get_caps_locked();
+}
+
+bool VM::get_kana_locked()
+{
+       return keyboard->get_kana_locked();
+}
+
 // ----------------------------------------------------------------------------
 // user interface
 // ----------------------------------------------------------------------------
index a96b075..b07dd00 100644 (file)
@@ -30,6 +30,7 @@
 //#define NOTIFY_KEY_UP
 #define NOTIFY_KEY_DOWN_LR_SHIFT
 #define NOTIFY_KEY_DOWN_LR_MENU
+#define USE_KEY_LOCKED
 #define USE_ALT_F10_KEY
 #define USE_AUTO_KEY           5
 #define USE_AUTO_KEY_RELEASE   6
@@ -504,6 +505,8 @@ public:
        // notify key
        void key_down(int code, bool repeat);
        void key_up(int code);
+       bool get_caps_locked();
+       bool get_kana_locked();
        
        // user interface
        void open_floppy_disk(int drv, const _TCHAR* file_path, int bank);
index ff791d1..ee6164c 100644 (file)
@@ -126,6 +126,14 @@ private:
    
        void key_up(uint32_t vk);
        void key_down(uint32_t vk);
+       bool get_caps_locked()
+       {
+               return caps_pressed;
+       }
+       bool get_kana_locked()
+       {
+               return kana_pressed;
+       }
        void event_callback(int event_id, int err);
        void write_signal(int id, uint32_t data, uint32_t mask);
        uint32_t read_signal(int id);
index d0d99e8..9b254f0 100644 (file)
@@ -39,6 +39,16 @@ public:
        void event_frame();
        void save_state(FILEIO* state_fio);
        bool load_state(FILEIO* state_fio);
+       
+       // unique functions
+       bool get_caps_locked()
+       {
+               return caps;
+       }
+       bool get_kana_locked()
+       {
+               return kana;
+       }
 };
 
 #endif
index 97c9fe2..7cecdf3 100644 (file)
@@ -240,6 +240,20 @@ void VM::set_sound_device_volume(int ch, int decibel_l, int decibel_r)
 #endif
 
 // ----------------------------------------------------------------------------
+// notify key
+// ----------------------------------------------------------------------------
+
+bool VM::get_caps_locked()
+{
+       return key->get_caps_locked();
+}
+
+bool VM::get_kana_locked()
+{
+       return key->get_kana_locked();
+}
+
+// ----------------------------------------------------------------------------
 // user interface
 // ----------------------------------------------------------------------------
 
index dd0ae8a..faff085 100644 (file)
@@ -36,6 +36,7 @@
 #define USE_FD2
 //#define USE_FD3
 //#define USE_FD4
+#define USE_KEY_LOCKED
 #define USE_SHIFT_NUMPAD_KEY
 #define USE_ALT_F10_KEY
 #define USE_AUTO_KEY           5
@@ -141,6 +142,10 @@ public:
        void set_sound_device_volume(int ch, int decibel_l, int decibel_r);
 #endif
        
+       // notify key
+       bool get_caps_locked();
+       bool get_kana_locked();
+       
        // user interface
        void open_floppy_disk(int drv, const _TCHAR* file_path, int bank);
        void close_floppy_disk(int drv);
index 5b2522f..bb15e23 100644 (file)
@@ -57,6 +57,15 @@ public:
        }
        void key_down(int code);
        void key_up(int code);
+       bool get_caps_locked()
+       {
+//             return caps;
+               return true;
+       }
+       bool get_kana_locked()
+       {
+               return kana;
+       }
 };
 
 #endif
index da5fb8b..39f6bed 100644 (file)
@@ -269,6 +269,16 @@ void VM::key_up(int code)
        keyboard->key_up(code);
 }
 
+bool VM::get_caps_locked()
+{
+       return keyboard->get_caps_locked();
+}
+
+bool VM::get_kana_locked()
+{
+       return keyboard->get_kana_locked();
+}
+
 // ----------------------------------------------------------------------------
 // user interface
 // ----------------------------------------------------------------------------
index be65e62..3b605f3 100644 (file)
@@ -28,6 +28,7 @@
 // device informations for win32
 #define USE_TAPE1
 #define NOTIFY_KEY_DOWN
+#define USE_KEY_LOCKED
 #define USE_SHIFT_NUMPAD_KEY
 #define USE_ALT_F10_KEY
 #define USE_AUTO_KEY           5
@@ -125,6 +126,8 @@ public:
        // notify key
        void key_down(int code, bool repeat);
        void key_up(int code);
+       bool get_caps_locked();
+       bool get_kana_locked();
        
        // user interface
        void play_tape(int drv, const _TCHAR* file_path);
index 5e48ded..e4d8df0 100644 (file)
@@ -68,6 +68,14 @@ public:
        }
        void key_down(int code);
        void key_up(int code);
+       bool get_caps_locked()
+       {
+               return caps;
+       }
+       bool get_kana_locked()
+       {
+               return kana;
+       }
 };
 
 #endif
index 5159ec4..7103e58 100644 (file)
@@ -400,6 +400,16 @@ void VM::key_up(int code)
        kbd->key_up(code);
 }
 
+bool VM::get_caps_locked()
+{
+       return kbd->get_caps_locked();
+}
+
+bool VM::get_kana_locked()
+{
+       return kbd->get_kana_locked();
+}
+
 // ----------------------------------------------------------------------------
 // user interface
 // ----------------------------------------------------------------------------
index 2c63079..d69fd3d 100644 (file)
@@ -37,6 +37,7 @@
 #define USE_FD3
 #define USE_FD4
 #define NOTIFY_KEY_DOWN
+#define USE_KEY_LOCKED
 #define USE_SHIFT_NUMPAD_KEY
 #define USE_ALT_F10_KEY
 #define USE_AUTO_KEY           5
@@ -156,6 +157,8 @@ public:
        // notify key
        void key_down(int code, bool repeat);
        void key_up(int code);
+       bool get_caps_locked();
+       bool get_kana_locked();
        
        // user interface
        void open_floppy_disk(int drv, const _TCHAR* file_path, int bank);
index 3ab18a2..c88e0b3 100644 (file)
@@ -62,6 +62,14 @@ public:
        }
        void key_down(int code);
        void key_up(int code);
+       bool get_caps_locked()
+       {
+               return caps;
+       }
+       bool get_kana_locked()
+       {
+               return kana;
+       }
 };
 
 #endif
index aaad36d..d036b7c 100644 (file)
@@ -369,6 +369,16 @@ void VM::key_up(int code)
 //     keyboard->key_up(code);
 }
 
+bool VM::get_caps_locked()
+{
+       return keyboard->get_caps_locked();
+}
+
+bool VM::get_kana_locked()
+{
+       return keyboard->get_kana_locked();
+}
+
 // ----------------------------------------------------------------------------
 // user interface
 // ----------------------------------------------------------------------------
index f513ee6..e884bc6 100644 (file)
@@ -54,6 +54,7 @@
 #define USE_FD3
 #define USE_FD4
 #define NOTIFY_KEY_DOWN
+#define USE_KEY_LOCKED
 #define USE_SHIFT_NUMPAD_KEY
 #define USE_ALT_F10_KEY
 #define USE_AUTO_KEY           5
@@ -185,6 +186,8 @@ public:
        // notify key
        void key_down(int code, bool repeat);
        void key_up(int code);
+       bool get_caps_locked();
+       bool get_kana_locked();
        
        // user interface
        void open_floppy_disk(int drv, const _TCHAR* file_path, int bank);
index 8f60eed..fb90290 100644 (file)
@@ -50,6 +50,15 @@ public:
                d_pio = device;
        }
        void key_down(int code);
+       bool get_caps_locked()
+       {
+//             return caps;
+               return true;
+       }
+       bool get_kana_locked()
+       {
+               return kana;
+       }
 };
 
 #endif
index d6b1d7c..8d2349c 100644 (file)
@@ -320,6 +320,16 @@ void VM::key_up(int code)
 //     keyboard->key_up(code);
 }
 
+bool VM::get_caps_locked()
+{
+       return keyboard->get_caps_locked();
+}
+
+bool VM::get_kana_locked()
+{
+       return keyboard->get_kana_locked();
+}
+
 // ----------------------------------------------------------------------------
 // user interface
 // ----------------------------------------------------------------------------
index 1e91266..eca1374 100644 (file)
@@ -53,6 +53,7 @@
 #define USE_TAPE1
 #define USE_TAPE_BUTTON
 #define NOTIFY_KEY_DOWN
+#define USE_KEY_LOCKED
 #define USE_SHIFT_NUMPAD_KEY
 #define USE_ALT_F10_KEY
 #define USE_AUTO_KEY           5
@@ -185,6 +186,8 @@ public:
        // notify key
        void key_down(int code, bool repeat);
        void key_up(int code);
+       bool get_caps_locked();
+       bool get_kana_locked();
        
        // user interface
 #if defined(SUPPORT_MZ80AIF) || defined(SUPPORT_MZ80FIO)
index 00068ba..e9b4871 100644 (file)
@@ -44,6 +44,14 @@ public:
        }
        void key_down(int code);
        void key_up(int code);
+       bool get_caps_locked()
+       {
+               return caps;
+       }
+       bool get_kana_locked()
+       {
+               return kana;
+       }
 };
 
 #endif
index 36ce118..d9fb60e 100644 (file)
@@ -342,7 +342,16 @@ void VM::key_down(int code, bool repeat)
 void VM::key_up(int code)
 {
        keyboard->key_up(code);
-//     this->out_debug_log(_T("-----\n"));
+}
+
+bool VM::get_caps_locked()
+{
+       return keyboard->get_caps_locked();
+}
+
+bool VM::get_kana_locked()
+{
+       return keyboard->get_kana_locked();
 }
 
 // ----------------------------------------------------------------------------
index 00324ce..7e6ab58 100644 (file)
@@ -29,6 +29,7 @@
 #define USE_FD1
 #define USE_FD2
 #define NOTIFY_KEY_DOWN
+#define USE_KEY_LOCKED
 #define USE_SHIFT_NUMPAD_KEY
 #define USE_ALT_F10_KEY
 #define USE_AUTO_KEY           5
@@ -125,6 +126,8 @@ public:
        // notify key
        void key_down(int code, bool repeat);
        void key_up(int code);
+       bool get_caps_locked();
+       bool get_kana_locked();
        
        // user interface
        void open_floppy_disk(int drv, const _TCHAR* file_path, int bank);
index 02fbfbc..d511e5d 100644 (file)
@@ -72,6 +72,14 @@ public:
        }
        void key_down(int code);
        void key_up(int code);
+       bool get_caps_locked()
+       {
+               return caps;
+       }
+       bool get_kana_locked()
+       {
+               return kana;
+       }
 };
 
 #endif
index 1f7c1b3..ca2e78c 100644 (file)
@@ -273,6 +273,16 @@ void VM::key_up(int code)
        ioctrl->key_up(code);
 }
 
+bool VM::get_caps_locked()
+{
+       return ioctrl->get_caps_locked();
+}
+
+bool VM::get_kana_locked()
+{
+       return ioctrl->get_kana_locked();
+}
+
 // ----------------------------------------------------------------------------
 // user interface
 // ----------------------------------------------------------------------------
index fbd9737..85d9eb5 100644 (file)
@@ -35,6 +35,7 @@
 #define USE_FD1
 #define USE_FD2
 #define NOTIFY_KEY_DOWN
+#define USE_KEY_LOCKED
 #define USE_SHIFT_NUMPAD_KEY
 #define USE_ALT_F10_KEY
 #define USE_AUTO_KEY           5
@@ -139,6 +140,8 @@ public:
        // notify key
        void key_down(int code, bool repeat);
        void key_up(int code);
+       bool get_caps_locked();
+       bool get_kana_locked();
        
        // user interface
        void open_floppy_disk(int drv, const _TCHAR* file_path, int bank);
index c7d3898..e0e80a2 100644 (file)
@@ -38,8 +38,16 @@ public:
        void save_state(FILEIO* state_fio);
        bool load_state(FILEIO* state_fio);
        
-       // unique function
+       // unique functions
        void key_down(int code);
+       bool get_caps_locked()
+       {
+               return caps;
+       }
+       bool get_kana_locked()
+       {
+               return kana;
+       }
 };
 
 #endif
index b6c5157..441465b 100644 (file)
@@ -218,6 +218,16 @@ void VM::key_up(int code)
 {
 }
 
+bool VM::get_caps_locked()
+{
+       return keyboard->get_caps_locked();
+}
+
+bool VM::get_kana_locked()
+{
+       return keyboard->get_kana_locked();
+}
+
 // ----------------------------------------------------------------------------
 // user interface
 // ----------------------------------------------------------------------------
index 6a1db01..4d9c9b3 100644 (file)
@@ -29,6 +29,7 @@
 // device informations for win32
 #define USE_TAPE1
 #define NOTIFY_KEY_DOWN
+#define USE_KEY_LOCKED
 #define USE_ALT_F10_KEY
 #define USE_AUTO_KEY           5
 #define USE_AUTO_KEY_RELEASE   6
@@ -117,6 +118,8 @@ public:
        // notify key
        void key_down(int code, bool repeat);
        void key_up(int code);
+       bool get_caps_locked();
+       bool get_kana_locked();
        
        // user interface
        void play_tape(int drv, const _TCHAR* file_path);
index 90568a0..da0a290 100644 (file)
@@ -304,10 +304,13 @@ void PC88::initialize()
                dest[6] = dest[7] = ((i & 8) ? 0xf0 : 0) | ((i & 0x80) ? 0x0f : 0);
        }
        
-       // initialize text palette
+       // initialize text/graph palette
        for(int i = 0; i < 9; i++) {
                palette_text_pc[i] = RGBA_COLOR((i & 2) ? 255 : 0, (i & 4) ? 255 : 0, (i & 1) ? 255 : 0, 255); // A is a flag for crt filter
        }
+       for(int i = 0; i < 8; i++) {
+               palette_graph_pc[i] = RGB_COLOR((i & 2) ? 255 : 0, (i & 4) ? 255 : 0, (i & 1) ? 255 : 0);
+       }
        
 #ifdef SUPPORT_PC88_HIGH_CLOCK
        cpu_clock_low = (config.cpu_type == 1);         // 4MHz
@@ -1496,7 +1499,7 @@ void PC88::update_low_memmap()
                        SET_BANK_R(0x0000, 0x7fff, exram + 0x8000 * PortE3_ERAMSL);
                } else {
 #endif
-                       SET_BANK_R(0x0000, 0x7fff, rdmy);
+//                     SET_BANK_R(0x0000, 0x7fff, rdmy);
 #ifdef PC88_EXRAM_BANKS
                }
 #endif
@@ -1525,7 +1528,8 @@ void PC88::update_low_memmap()
                        SET_BANK_W(0x0000, 0x7fff, exram + 0x8000 * PortE3_ERAMSL);
                } else {
 #endif
-                       SET_BANK_W(0x0000, 0x7fff, wdmy);
+//                     SET_BANK_W(0x0000, 0x7fff, wdmy);
+                       SET_BANK_W(0x0000, 0x7fff, ram);
 #ifdef PC88_EXRAM_BANKS
                }
 #endif
@@ -1950,6 +1954,7 @@ void PC88::draw_screen()
 #endif
                for(int y = 0; y < 200; y++) {
                        // for Xak2 opening (XM8 version 1.00)
+/*
                        if(crtc.char_height == 0x10) {
                                if(y >= (crtc.height * crtc.char_height / 2)) {
                                        while(y < 200) {
@@ -1962,6 +1967,7 @@ void PC88::draw_screen()
                                        break;
                                }
                        }
+*/
                        scrntype_t* dest0 = emu->get_screen_buffer(y * 2);
                        scrntype_t* dest1 = emu->get_screen_buffer(y * 2 + 1);
                        uint8_t* src_t = text[y];
@@ -2027,23 +2033,41 @@ void PC88::draw_screen()
 
 void PC88::draw_text()
 {
+       uint8_t ct = 0;
+       
+       if(crtc.status & 0x88) {
+               crtc.status &= ~0x80;
+               ct = crtc.reverse ? 3 : 2;
+       }
        // for Advanced Fantasian Opening (20line) (XM8 version 1.00)
        if(!(crtc.status & 0x10) || Port53_TEXTDS) {
 //     if(!(crtc.status & 0x10) || (crtc.status & 8) || Port53_TEXTDS) {
-               memset(text, 0, sizeof(text));
-               return;
+//             memset(text, 0, sizeof(text));
+//             return;
+               ct = 2;
+       }
+       if(ct) {
+               memset(crtc.text.expand, 0, 200 * 80);
+               memset(crtc.attrib.expand, ct, 200 * 80);
        }
        
+       // for Xak2 opening
+       memset(text, 8, sizeof(text));
+       
        int char_height = crtc.char_height;
        uint8_t color_mask = Port30_COLOR ? 0 : 7;
        
        if(!hireso) {
                char_height <<= 1;
        }
-       if(Port31_400LINE || !crtc.skip_line) {
-               char_height >>= 1;
+//     if(Port31_400LINE || !crtc.skip_line) {
+//             char_height >>= 1;
+//     }
+       if(crtc.skip_line) {
+               char_height <<= 1;
        }
-       for(int cy = 0, ytop = 0; cy < crtc.height && ytop < 200; cy++, ytop += char_height) {
+//     for(int cy = 0, ytop = 0; cy < 64 && ytop < 400; cy++, ytop += char_height) {
+       for(int cy = 0, ytop = 0; cy < crtc.height && ytop < 400; cy++, ytop += char_height) {
                for(int x = 0, cx = 0; cx < crtc.width; x += 8, cx++) {
                        if(Port30_40 && (cx & 1)) {
                                continue;
@@ -2062,7 +2086,7 @@ void PC88::draw_text()
                        uint8_t *pattern = ((attrib & 0x10) ? sg_pattern : kanji1 + 0x1000) + code * 8;
 #endif
                        
-                       for(int l = 0, y = ytop; l < char_height && y < 200; l++, y++) {
+                       for(int l = 0, y = ytop; l < char_height / 2 && y < 400; l++, y += 2) {
                                uint8_t pat = (l < 8) ? pattern[l] : 0;
                                if((upper_line && l == 0) || (under_line && l >= 7)) {
                                        pat = 0xff;
@@ -2071,7 +2095,7 @@ void PC88::draw_text()
                                        pat = ~pat;
                                }
                                
-                               uint8_t *dest = &text[y][x];
+                               uint8_t *dest = &text[y >> 1][x];
                                if(Port30_40) {
                                        dest[ 0] = dest[ 1] = (pat & 0x80) ? color : 0;
                                        dest[ 2] = dest[ 3] = (pat & 0x40) ? color : 0;
@@ -2478,16 +2502,19 @@ void pc88_crtc_t::write_cmd(uint8_t data)
        switch(cmd) {
        case 0: // reset
                status &= ~0x16;
+               status |= 0x80; // fix
                cursor.x = cursor.y = -1;
                break;
        case 1: // start display
                reverse = data & 1;
-               status |= 0x10;
+//             status |= 0x10;
+               status |= 0x90; // fix
                status &= ~8;
                break;
        case 2: // set interrupt mask
                if(!(data & 1)) {
-                       status = 0; // from M88
+//                     status = 0; // from M88
+                       status = 0x80; // fix
                }
                intr_mask = data & 3;
                break;
@@ -2551,6 +2578,9 @@ void pc88_crtc_t::write_param(uint8_t data)
                        break;
                }
                break;
+       case 6:
+               status = 0;
+               break;
        }
        cmd_ptr++;
 }
index 111dd11..1de9e38 100644 (file)
@@ -357,6 +357,14 @@ public:
        }
 #endif
        void key_down(int code, bool repeat);
+       bool get_caps_locked()
+       {
+               return (key_caps != 0);
+       }
+       bool get_kana_locked()
+       {
+               return (key_kana != 0);
+       }
        
        void play_tape(const _TCHAR* file_path);
        void rec_tape(const _TCHAR* file_path);
index 68edc2f..cf92588 100644 (file)
@@ -427,6 +427,16 @@ void VM::key_up(int code)
 {
 }
 
+bool VM::get_caps_locked()
+{
+       return pc88->get_caps_locked();
+}
+
+bool VM::get_kana_locked()
+{
+       return pc88->get_kana_locked();
+}
+
 // ----------------------------------------------------------------------------
 // user interface
 // ----------------------------------------------------------------------------
index e6985dd..c170537 100644 (file)
@@ -80,6 +80,7 @@
 #define USE_TAPE1
 #define TAPE_BINARY_ONLY
 #define NOTIFY_KEY_DOWN
+#define USE_KEY_LOCKED
 #define USE_SHIFT_NUMPAD_KEY
 #define USE_ALT_F10_KEY
 #define SUPPORT_ROMA_KANA_CONVERSION
@@ -236,6 +237,8 @@ public:
        // notify key
        void key_down(int code, bool repeat);
        void key_up(int code);
+       bool get_caps_locked();
+       bool get_kana_locked();
        
        // user interface
        void open_floppy_disk(int drv, const _TCHAR* file_path, int bank);
index 24b24d7..b3a0250 100644 (file)
@@ -46,6 +46,14 @@ public:
        }
        void key_down(int code, bool repeat);
        void key_up(int code);
+       bool get_caps_locked()
+       {
+               return caps;
+       }
+       bool get_kana_locked()
+       {
+               return kana;
+       }
 };
 
 #endif
index 51f5953..9890e92 100644 (file)
@@ -1064,6 +1064,26 @@ void VM::key_up(int code)
        keyboard->key_up(code);
 }
 
+bool VM::get_caps_locked()
+{
+#if defined(_PC98DO) || defined(_PC98DOPLUS)
+       if(boot_mode != 0) {
+               return pc88->get_caps_locked();
+       } else
+#endif
+       return keyboard->get_caps_locked();
+}
+
+bool VM::get_kana_locked()
+{
+#if defined(_PC98DO) || defined(_PC98DOPLUS)
+       if(boot_mode != 0) {
+               return pc88->get_kana_locked();
+       } else
+#endif
+       return keyboard->get_kana_locked();
+}
+
 // ----------------------------------------------------------------------------
 // user interface
 // ----------------------------------------------------------------------------
index d69b422..665cfa0 100644 (file)
 #define TAPE_BINARY_ONLY
 #endif
 #define NOTIFY_KEY_DOWN
+#define USE_KEY_LOCKED
 #define USE_SHIFT_NUMPAD_KEY
 #define USE_ALT_F10_KEY
 #if defined(_PC98DO) || defined(_PC98DOPLUS)
@@ -420,6 +421,8 @@ public:
        // notify key
        void key_down(int code, bool repeat);
        void key_up(int code);
+       bool get_caps_locked();
+       bool get_kana_locked();
        
        // user interface
        void open_floppy_disk(int drv, const _TCHAR* file_path, int bank);
index 8025849..864e035 100644 (file)
@@ -45,6 +45,14 @@ public:
        }
        void key_down(int code);
        void key_up(int code);
+       bool get_caps_locked()
+       {
+               return caps;
+       }
+       bool get_kana_locked()
+       {
+               return kana;
+       }
 };
 
 #endif
index 4041c45..c762da6 100644 (file)
@@ -341,6 +341,16 @@ void VM::key_up(int code)
        keyboard->key_up(code);
 }
 
+bool VM::get_caps_locked()
+{
+       return keyboard->get_caps_locked();
+}
+
+bool VM::get_kana_locked()
+{
+       return keyboard->get_kana_locked();
+}
+
 // ----------------------------------------------------------------------------
 // user interface
 // ----------------------------------------------------------------------------
index 40cd861..1e1cad0 100644 (file)
@@ -44,6 +44,8 @@
 // device informations for win32
 #define USE_FD1
 #define NOTIFY_KEY_DOWN
+#define USE_KEY_LOCKED
+#define USE_SHIFT_NUMPAD_KEY
 #define USE_ALT_F10_KEY
 #define USE_AUTO_KEY           5
 #define USE_AUTO_KEY_RELEASE   6
@@ -166,6 +168,8 @@ public:
        // notify key
        void key_down(int code, bool repeat);
        void key_up(int code);
+       bool get_caps_locked();
+       bool get_kana_locked();
        
        // user interface
        void open_floppy_disk(int drv, const _TCHAR* file_path, int bank);
index 37a37d9..05bbedd 100644 (file)
@@ -173,6 +173,14 @@ public:
        }
 #endif
        void key_down_up(int code, bool down);
+       bool get_caps_locked()
+       {
+               return caps;
+       }
+       bool get_kana_locked()
+       {
+               return kana;
+       }
        void draw_screen();
        bool warm_start;
 };
index f186bff..9d0d462 100644 (file)
@@ -264,6 +264,16 @@ void VM::key_up(int code)
        memory->key_down_up(code, false);
 }
 
+bool VM::get_caps_locked()
+{
+       return memory->get_caps_locked();
+}
+
+bool VM::get_kana_locked()
+{
+       return memory->get_kana_locked();
+}
+
 // ----------------------------------------------------------------------------
 // user interface
 // ----------------------------------------------------------------------------
index 5aaaded..9ed24a7 100644 (file)
@@ -45,6 +45,7 @@
 #define USE_TAPE1
 #define USE_TAPE_BUTTON
 #define NOTIFY_KEY_DOWN
+#define USE_KEY_LOCKED
 //#define USE_SHIFT_NUMPAD_KEY
 #define USE_ALT_F10_KEY
 #define USE_AUTO_KEY           8
 static const int vm_auto_key_table_base[][2] = {
        // 0x100: shift
        // 0x200: kana
-       {0xa1,  0x300 | 0xbf},  // ' -> '/'
-       {0xa2,  0x300 | 0xba},  // ' -> ':'
-       {0xa3,  0x300 | 0xdd},  // ' -> ']'
-       {0xa4,  0x300 | 0xbe},  // ' -> '.'
-       {0xa5,  0x300 | 0xe2},  // ' -> '_'
-       {0xa6,  0x200 | 0xbf},  // ' -> '/'
-       {0xa7,  0x300 | 0x31},  // ' -> '1'
-       {0xa8,  0x300 | 0x32},  // ' -> '2'
-       {0xa9,  0x300 | 0x33},  // ' -> '3'
-       {0xaa,  0x300 | 0x34},  // ' -> '4'
-       {0xab,  0x300 | 0x35},  // ' -> '5'
-       {0xac,  0x300 | 0x4e},  // ' -> 'N'
-       {0xad,  0x300 | 0x4d},  // ' -> 'M'
-       {0xae,  0x300 | 0xbc},  // ' -> ','
-       {0xaf,  0x300 | 0x43},  // ' -> 'C'
-       {0xb0,  0x300 | 0xdb},  // ' -> '['
-       {0xb1,  0x200 | 0x31},  // ' -> '1'
-       {0xb2,  0x200 | 0x32},  // ' -> '2'
-       {0xb3,  0x200 | 0x33},  // ' -> '3'
-       {0xb4,  0x200 | 0x34},  // ' -> '4'
-       {0xb5,  0x200 | 0x35},  // ' -> '5'
-       {0xb6,  0x200 | 0x51},  // ' -> 'Q'
-       {0xb7,  0x200 | 0x57},  // ' -> 'W'
-       {0xb8,  0x200 | 0x45},  // ' -> 'E'
-       {0xb9,  0x200 | 0x52},  // ' -> 'R'
-       {0xba,  0x200 | 0x54},  // ' -> 'T'
-       {0xbb,  0x200 | 0x41},  // ' -> 'A'
-       {0xbc,  0x200 | 0x53},  // ' -> 'S'
-       {0xbd,  0x200 | 0x44},  // ' -> 'D'
-       {0xbe,  0x200 | 0x46},  // ' -> 'F'
+       {0xa1,  0x300 | 0xbf},  // '¡' -> '/'
+       {0xa2,  0x300 | 0xba},  // '¢' -> ':'
+       {0xa3,  0x300 | 0xdd},  // '£' -> ']'
+       {0xa4,  0x300 | 0xbe},  // '¤' -> '.'
+       {0xa5,  0x300 | 0xe2},  // '¥' -> '_'
+       {0xa6,  0x200 | 0xbf},  // '¦' -> '/'
+       {0xa7,  0x300 | 0x31},  // '§' -> '1'
+       {0xa8,  0x300 | 0x32},  // '¨' -> '2'
+       {0xa9,  0x300 | 0x33},  // '©' -> '3'
+       {0xaa,  0x300 | 0x34},  // 'ª' -> '4'
+       {0xab,  0x300 | 0x35},  // '«' -> '5'
+       {0xac,  0x300 | 0x4e},  // '¬' -> 'N'
+       {0xad,  0x300 | 0x4d},  // '­' -> 'M'
+       {0xae,  0x300 | 0xbc},  // '®' -> ','
+       {0xaf,  0x300 | 0x43},  // '¯' -> 'C'
+       {0xb0,  0x300 | 0xdb},  // '°' -> '['
+       {0xb1,  0x200 | 0x31},  // '±' -> '1'
+       {0xb2,  0x200 | 0x32},  // '²' -> '2'
+       {0xb3,  0x200 | 0x33},  // '³' -> '3'
+       {0xb4,  0x200 | 0x34},  // '´' -> '4'
+       {0xb5,  0x200 | 0x35},  // 'µ' -> '5'
+       {0xb6,  0x200 | 0x51},  // '¶' -> 'Q'
+       {0xb7,  0x200 | 0x57},  // '·' -> 'W'
+       {0xb8,  0x200 | 0x45},  // '¸' -> 'E'
+       {0xb9,  0x200 | 0x52},  // '¹' -> 'R'
+       {0xba,  0x200 | 0x54},  // 'º' -> 'T'
+       {0xbb,  0x200 | 0x41},  // '»' -> 'A'
+       {0xbc,  0x200 | 0x53},  // '¼' -> 'S'
+       {0xbd,  0x200 | 0x44},  // '½' -> 'D'
+       {0xbe,  0x200 | 0x46},  // '¾' -> 'F'
        {0xbf,  0x200 | 0x47},  // '¿' -> 'G'
        {0xc0,  0x200 | 0x5a},  // 'À' -> 'Z'
        {0xc1,  0x200 | 0x58},  // 'Á' -> 'X'
@@ -220,6 +221,8 @@ public:
        // notify key
        void key_down(int code, bool repeat);
        void key_up(int code);
+       bool get_caps_locked();
+       bool get_kana_locked();
        
        // user interface
        void open_floppy_disk(int drv, const _TCHAR* file_path, int bank);
index d028a5b..1826b9c 100644 (file)
@@ -74,6 +74,19 @@ public:
        }
        void key_down(int code);
        void key_up(int code);
+       bool get_caps_locked()
+       {
+//             return caps_lock;
+               return true;
+       }
+       bool get_kana_locked()
+       {
+#if defined(_TK80BS)
+               return kana_lock;
+#else
+               return false;
+#endif
+       }
 };
 
 #endif
index 15c89ab..ae600b2 100644 (file)
@@ -365,6 +365,16 @@ void VM::key_up(int code)
        keyboard->key_up(code);
 }
 
+bool VM::get_caps_locked()
+{
+       return keyboard->get_caps_locked();
+}
+
+bool VM::get_kana_locked()
+{
+       return keyboard->get_kana_locked();
+}
+
 // ----------------------------------------------------------------------------
 // user interface
 // ----------------------------------------------------------------------------
index 73f2e19..c5059d5 100644 (file)
@@ -70,6 +70,7 @@
 
 #define USE_BINARY_FILE1
 #define NOTIFY_KEY_DOWN
+#define USE_KEY_LOCKED
 #define USE_ALT_F10_KEY
 #define USE_AUTO_KEY           5
 #define USE_AUTO_KEY_RELEASE   6
@@ -277,6 +278,8 @@ public:
        // notify key
        void key_down(int code, bool repeat);
        void key_up(int code);
+       bool get_caps_locked();
+       bool get_kana_locked();
        
        // user interface
        void load_binary(int drv, const _TCHAR* file_path);
index c668140..e034d6c 100644 (file)
@@ -712,7 +712,7 @@ uint8_t UPD765A::get_devstat(int drv)
                return 0x80 | drv;
        }
        // XM8 version 1.20
-       if(!force_ready && !disk[drv]->inserted) {
+       if(force_ready && !disk[drv]->inserted) {
                return drv;
        }
        return 0x28 | drv | (fdc[drv].track ? 0 : 0x10) | ((fdc[drv].track & 1) ? 0x04 : 0) | (disk[drv]->write_protected ? 0x40 : 0);
index e2faf5a..7c1e641 100644 (file)
@@ -130,6 +130,15 @@ public:
        void draw_screen();
        void key_down(int code);
        void key_up(int code);
+       bool get_caps_locked()
+       {
+//             return caps;
+               return true;
+       }
+       bool get_kana_locked()
+       {
+               return kana;
+       }
 };
 
 #endif
index c7692c7..c839105 100644 (file)
@@ -184,6 +184,16 @@ void VM::key_up(int code)
        io->key_up(code);
 }
 
+bool VM::get_caps_locked()
+{
+       return io->get_caps_locked();
+}
+
+bool VM::get_kana_locked()
+{
+       return io->get_kana_locked();
+}
+
 // ----------------------------------------------------------------------------
 // user interface
 // ----------------------------------------------------------------------------
index 06194cb..c6947ac 100644 (file)
@@ -34,6 +34,7 @@
 #define USE_TAPE1
 #define TAPE_BINARY_ONLY
 #define NOTIFY_KEY_DOWN
+#define USE_KEY_LOCKED
 #define USE_ALT_F10_KEY
 #define USE_AUTO_KEY           6
 #define USE_AUTO_KEY_RELEASE   10
@@ -119,6 +120,8 @@ public:
        // notify key
        void key_down(int code, bool repeat);
        void key_up(int code);
+       bool get_caps_locked();
+       bool get_kana_locked();
        
        // user interface
        void play_tape(int drv, const _TCHAR* file_path);
index 47e075e..be823b9 100644 (file)
@@ -44,6 +44,14 @@ public:
                d_cpu = device;
        }
        void key_down(int code, bool repeat);
+       bool get_caps_locked()
+       {
+               return (caps_locked != 0);
+       }
+       bool get_kana_locked()
+       {
+               return (kana_locked != 0);
+       }
 };
 
 #endif
index bbc8c19..475cc64 100644 (file)
@@ -93,6 +93,14 @@ public:
        }
        void key_down(int code, bool repeat);
        void key_up(int code);
+       bool get_caps_locked()
+       {
+               return key_caps_locked;
+       }
+       bool get_kana_locked()
+       {
+               return key_kana_locked;
+       }
        void play_tape(bool value);
        void rec_tape(bool value);
        void close_tape();
index 88fcf91..40205dd 100644 (file)
@@ -649,6 +649,38 @@ void VM::key_up(int code)
 #endif
 }
 
+bool VM::get_caps_locked()
+{
+#ifdef _X1TWIN
+       if(!pce->is_cart_inserted()) {
+#endif
+               if(pseudo_sub_cpu) {
+                       return psub->get_caps_locked();
+               } else {
+                       return kbd->get_caps_locked();
+               }
+#ifdef _X1TWIN
+       }
+       return false;
+#endif
+}
+
+bool VM::get_kana_locked()
+{
+#ifdef _X1TWIN
+       if(!pce->is_cart_inserted()) {
+#endif
+               if(pseudo_sub_cpu) {
+                       return psub->get_kana_locked();
+               } else {
+                       return kbd->get_kana_locked();
+               }
+#ifdef _X1TWIN
+       }
+       return false;
+#endif
+}
+
 // ----------------------------------------------------------------------------
 // user interface
 // ----------------------------------------------------------------------------
index 6e5aa49..eec3eca 100644 (file)
@@ -99,6 +99,7 @@
 #define USE_CART1
 #endif
 #define NOTIFY_KEY_DOWN
+#define USE_KEY_LOCKED
 #define USE_SHIFT_NUMPAD_KEY
 #define USE_ALT_F10_KEY
 #define USE_AUTO_KEY           8
@@ -373,6 +374,8 @@ public:
        // notify key
        void key_down(int code, bool repeat);
        void key_up(int code);
+       bool get_caps_locked();
+       bool get_kana_locked();
        
        // user interface
        void open_floppy_disk(int drv, const _TCHAR* file_path, int bank);
index 59119cc..253b43e 100644 (file)
@@ -46,6 +46,14 @@ public:
                d_cpu = device;
        }
        void key_down(int code);
+       bool get_caps_locked()
+       {
+               return caps_locked;
+       }
+       bool get_kana_locked()
+       {
+               return kana_locked;
+       }
 };
 
 #endif
index e73f7d3..e1b9c0c 100644 (file)
@@ -237,6 +237,16 @@ void VM::key_up(int code)
 {
 }
 
+bool VM::get_caps_locked()
+{
+       return keyboard->get_caps_locked();
+}
+
+bool VM::get_kana_locked()
+{
+       return keyboard->get_kana_locked();
+}
+
 // ----------------------------------------------------------------------------
 // user interface
 // ----------------------------------------------------------------------------
index 18f8b23..5422eb0 100644 (file)
 #define USE_FD1
 #define USE_FD2
 #define NOTIFY_KEY_DOWN
+#define USE_KEY_LOCKED
 #define USE_SHIFT_NUMPAD_KEY
 #define USE_ALT_F10_KEY
 #define USE_AUTO_KEY           5
 #define USE_AUTO_KEY_RELEASE   6
+#define USE_AUTO_KEY_CAPS_LOCK (0xf0 | 0x100)
+#define USE_VM_AUTO_KEY_TABLE
 #define USE_MONITOR_TYPE       3
 #define USE_SCREEN_FILTER
 //#define USE_SCANLINE
 #define USE_DEBUGGER
 #define USE_STATE
 
+static const int vm_auto_key_table_base[][2] = {
+       {0xb0,  0x300 | 0xba},  // '°' -> ':'+SHIFT
+       {0xb9,  0x200 | 0x4c},  // '¹' -> 'L'
+       {0xcd,  0x200 | 0xbd},  // 'Í' -> '-'
+       {0xce,  0x200 | 0xba},  // 'Î' -> ':'
+       {0xd1,  0x200 | 0xbb},  // 'Ñ' -> ';'
+       {0xd8,  0x300 | 0x4b},  // 'Ø' -> 'K'+SHIFT
+       {0xdb,  0x300 | 0xbb},  // 'Û' -> ';'+SHIFT
+       {0xda,  0x300 | 0x4c},  // 'Ú' -> 'L'+SHIFT
+       {0xde,  0x300 | 0x4f},  // 'Þ' -> 'O'+SHIFT
+       {0xdf,  0x300 | 0x50},  // 'ß' -> 'P'+SHIFT
+       {-1,    -1},
+};
+
 #include "../../common.h"
 #include "../../fileio.h"
 
@@ -138,6 +155,8 @@ public:
        // notify key
        void key_down(int code, bool repeat);
        void key_up(int code);
+       bool get_caps_locked();
+       bool get_kana_locked();
        
        // user interface
        void open_floppy_disk(int drv, const _TCHAR* file_path, int bank);
index 1596929..bb740a8 100644 (file)
@@ -677,9 +677,22 @@ void YM2203::set_reg(uint32_t addr, uint32_t data)
 //#ifdef HAS_YM2608
        if(is_ym2608 && _HAS_YM2608) {
                opna->SetReg(addr, data);
-       } else
+       } else {
 //#endif
+               if((addr & 0xf0) == 0x10) {
+                       return;
+               }
+               if(addr == 0x22) {
+                       data = 0x00;
+               } else if(addr == 0x29) {
+                       data = 0x03;
+               } else if(addr >= 0xb4) {
+                       data = 0xc0;
+               }
                opn->SetReg(addr, data);
+//#ifdef HAS_YM2608
+       }
+//#endif
 #ifdef SUPPORT_MAME_FM_DLL
        if(dllchip) {
                fmdll->SetReg(dllchip, addr, data);
@@ -818,6 +831,14 @@ bool YM2203::load_state(FILEIO* state_fio)
                                fmdll->SetReg(dllchip, ch, port_log[ch].data);
                        }
                }
+#ifdef HAS_YM2608
+               if(is_ym2608) {
+                       BYTE *dest = fmdll->GetADPCMBuffer(dllchip);
+                       if(dest != NULL) {
+                               memcpy(dest, opna->GetADPCMBuffer(), 0x40000);
+                       }
+               }
+#endif
        }
 #endif
        decibel_vol = state_fio->FgetInt32();