[UI][Qt] Update to upstream 2017-06-22.Some parts are temporally.

diff --git a/source/history.txt b/source/history.txt
index 8d9983d..7e2eca6 100644 (file)
--- a/source/history.txt
+++ b/source/history.txt
@@ -1,3 +1,18 @@
+6/22/2017
+
+[EMU] move auto key codes from winmain to emu class
+[EMU] support to convert roman letters to kana letters
+[WINMAIN] support APPLICATION accelerator to enable/disable roman to kana
+[WINMAIN] support CTRL+ALT+ENTER accelerator to enable/disable full speed
+
+[VM/I386] improve i86/i286 core based on MAME 0.185
+[VM/UPD765A] fix device status (thanks annonymus guy)
+[VM/YM2203] fix to mask YM2608 ports in YM2203 case (thanks annonymus guy)
+
+[PC8801/PC88] fix bank switch of extend ram (thanks annonymus guy)
+[PC8801/PC88] fix crtc for dma underrun case (thanks annonymus guy)
+
+
 5/28/2017
 
 [WINMAIN] support to run simulation at full speed

diff --git a/source/src/qt/CMakeLists.txt b/source/src/qt/CMakeLists.txt
index 160bff5..65479bc 100644 (file)
--- a/source/src/qt/CMakeLists.txt
+++ b/source/src/qt/CMakeLists.txt
@@ -47,8 +47,8 @@ generate_export_header(CSPosd
        STATIC_DEFINE CSPgosd_BUILT_AS_STATIC
 )
   set_target_properties(CSPosd PROPERTIES 
-     SOVERSION 2.9.3
-     VERSION 2.9.3
+     SOVERSION 2.9.4
+     VERSION 2.9.4
   )
 
 else()
@@ -64,8 +64,8 @@ target_link_libraries(CSPosd PUBLIC
          )
   
   set_target_properties(CSPosd PROPERTIES 
-     SOVERSION 2.9.3
-     VERSION 2.9.3
+     SOVERSION 2.9.4
+     VERSION 2.9.4
   )
   INSTALL(TARGETS CSPosd DESTINATION ${LIBCSP_INSTALL_DIR})
 endif()

diff --git a/source/src/qt/common/emu_thread.cpp b/source/src/qt/common/emu_thread.cpp
index a1eaf89..23eb14e 100644 (file)
--- a/source/src/qt/common/emu_thread.cpp
+++ b/source/src/qt/common/emu_thread.cpp
@@ -43,6 +43,15 @@ EmuThreadClass::~EmuThreadClass()
 {
 }
 
+void EmuThreadClass::set_romakana(void)
+{
+       romakana_conversion_mode = !romakana_conversion_mode;
+       p_config->romaji_to_kana = !p_config->romaji_to_kana;
+#if defined(USE_AUTO_KEY)
+       p_emu->set_auto_key_char(romakana_conversion_mode ? 1 : 0);
+#endif
+}
+
 int EmuThreadClass::get_interval(void)
 {
        static int accum = 0;
@@ -382,7 +391,16 @@ void EmuThreadClass::doWork(const QString &params)
                                }
                        }
 #endif
-                       if(roma_kana_conv) {
+                       if(p_config->romaji_to_kana) {
+                               //FIFO *dmy = p_emu->get_auto_key_buffer();
+                               //if(dmy != NULL) {
+                               //      if(!dmy->empty()) {
+                               //              p_emu->stop_auto_key();         
+                               //              p_emu->start_auto_key();
+                               //      }
+                               //}
+                          
+#if 0
                                if(!roma_kana_queue.isEmpty()) {
 #if defined(USE_AUTO_KEY)
                                        FIFO *dmy = emu->get_auto_key_buffer();
@@ -399,6 +417,7 @@ void EmuThreadClass::doWork(const QString &params)
                                if(roma_kana_queue.isEmpty()) {
                                        roma_kana_conv = false;
                                }
+#endif
                        }
                        // else
                        {
@@ -406,14 +425,21 @@ void EmuThreadClass::doWork(const QString &params)
                                        key_queue_t sp;
                                        dequeue_key_up(&sp);
                                        key_mod = sp.mod;
-                                       p_emu->key_modifiers(sp.mod);
-                                       p_emu->key_up(sp.code);
+                                       {
+                                               p_emu->key_modifiers(sp.mod);
+                                               p_emu->key_up(sp.code, true); // need decicion of extend.
+                                       }
                                }
                                while(!is_empty_key_down()) {
                                        key_queue_t sp;
                                        dequeue_key_down(&sp);
-                                       p_emu->key_modifiers(sp.mod);
-                                       p_emu->key_down(sp.code, sp.repeat);
+                                       if(p_config->romaji_to_kana) {
+                                               p_emu->key_modifiers(sp.mod);
+                                               p_emu->key_char(sp.code);
+                                       } else {
+                                               p_emu->key_modifiers(sp.mod);
+                                               p_emu->key_down(sp.code, true, sp.repeat);
+                                       }
                                }
                        }
                        run_frames = p_emu->run();

diff --git a/source/src/qt/common/emu_thread.h b/source/src/qt/common/emu_thread.h
index 7fdc8bf..e63b7f5 100644 (file)
--- a/source/src/qt/common/emu_thread.h
+++ b/source/src/qt/common/emu_thread.h
@@ -53,6 +53,7 @@ protected:
        void get_cd_string(void);
        void get_bubble_string(void);
 
+       void set_romakana(void) override;
 public:
        EmuThreadClass(META_MainWindow *rootWindow, USING_FLAGS *p, QObject *parent = 0);
        ~EmuThreadClass();

diff --git a/source/src/qt/gui/CMakeLists.txt b/source/src/qt/gui/CMakeLists.txt
index 866cf0f..4b30d4d 100644 (file)
--- a/source/src/qt/gui/CMakeLists.txt
+++ b/source/src/qt/gui/CMakeLists.txt
@@ -102,7 +102,7 @@ set(s_qt_gui_srcs
          emu_thread_tmpl.cpp
          qt_debugger_tmpl.cpp
 
-         ../../romakana.cpp
+#        ../../romakana.cpp
          menu_flags_tmpl.cpp
          csp_logger.cpp
          qt_main.cpp
@@ -176,8 +176,8 @@ target_link_libraries(CSPgui PUBLIC
          )
 
 set_target_properties(CSPgui PROPERTIES 
-                            SOVERSION 2.9.4
-                            VERSION 2.9.4
+                            SOVERSION 2.9.5
+                            VERSION 2.9.5
                             )
 INSTALL(TARGETS CSPgui DESTINATION ${LIBCSP_INSTALL_DIR})
 endif()

diff --git a/source/src/qt/gui/emu_thread_tmpl.cpp b/source/src/qt/gui/emu_thread_tmpl.cpp
index 4d8c72f..b4ae64e 100644 (file)
--- a/source/src/qt/gui/emu_thread_tmpl.cpp
+++ b/source/src/qt/gui/emu_thread_tmpl.cpp
@@ -17,7 +17,7 @@
 #include "emu_thread_tmpl.h"
 
 #include "qt_gldraw.h"
-#include "../../romakana.h"
+//#include "../../romakana.h"
 
 //#include "csp_logger.h"
 #include "menu_flags.h"
@@ -199,6 +199,7 @@ void EmuThreadClassBase::do_key_down(uint32_t vk, uint32_t mod, bool repeat)
        sp.repeat = repeat;
        //key_changed = true;
        if(using_flags->is_use_roma_kana_conversion()) {
+#if 0
                if(p_config->roma_kana_conversion) {
                        if((vk == VK_F12)) {
                                romakana_conversion_mode = !romakana_conversion_mode;
@@ -214,6 +215,12 @@ void EmuThreadClassBase::do_key_down(uint32_t vk, uint32_t mod, bool repeat)
                                return;
                        }
                }
+#else
+       if(vk == VK_F12) {
+               set_romakana();
+               return;
+       }
+#endif
        }
        enqueue_key_down(sp);
        key_mod = mod;
@@ -225,7 +232,7 @@ void EmuThreadClassBase::do_key_up(uint32_t vk, uint32_t mod)
        sp.code = vk;
        sp.mod = mod;
        sp.repeat = false;
-
+#if 0
        if(using_flags->is_use_roma_kana_conversion()) {
                if(p_config->roma_kana_conversion && romakana_conversion_mode) {
                        if(roma_kana_ptr < (int)(sizeof(roma_kana_buffer) / sizeof(_TCHAR)) &&
@@ -288,6 +295,7 @@ void EmuThreadClassBase::do_key_up(uint32_t vk, uint32_t mod)
                        }
                }
        }
+#endif
        enqueue_key_up(sp);
        key_mod = mod;
 }

diff --git a/source/src/qt/gui/emu_thread_tmpl.h b/source/src/qt/gui/emu_thread_tmpl.h
index f3348ed..081cb2a 100644 (file)
--- a/source/src/qt/gui/emu_thread_tmpl.h
+++ b/source/src/qt/gui/emu_thread_tmpl.h
@@ -32,7 +32,7 @@ class QWaitCondition;
 class USING_FLAGS;
 
 QT_BEGIN_NAMESPACE
-#include "../../romakana.h"
+//#include "../../romakana.h"
 
 typedef struct {
        uint32_t code;
@@ -168,7 +168,8 @@ protected:
                key_down_code_fifo->clear();
                key_down_mod_fifo->clear();
                key_down_repeat_fifo->clear();
-       };              
+       };
+       virtual void set_romakana(void) { };
 public:
        EmuThreadClassBase(META_MainWindow *rootWindow, USING_FLAGS *p, QObject *parent = 0);
        ~EmuThreadClassBase();

diff --git a/source/src/qt/osd.cpp b/source/src/qt/osd.cpp
index d45706b..6bd4962 100644 (file)
--- a/source/src/qt/osd.cpp
+++ b/source/src/qt/osd.cpp
@@ -1052,6 +1052,15 @@ void OSD::set_features(void)
        set_features_vm();
        set_features_misc();
        set_features_debug();
+
+       __USE_AUTO_KEY = false;
+       __USE_SHIFT_NUMPAD_KEY = false;
+#ifdef USE_AUTO_KEY
+       __USE_AUTO_KEY = true;
+#endif
+#ifdef USE_SHIFT_NUMPAD_KEY
+       __USE_SHIFT_NUMPAD_KEY = true;
+#endif
 }
 
 extern std::string cpp_homedir;

diff --git a/source/src/qt/osd_base.h b/source/src/qt/osd_base.h
index ec6f26d..7b63c3b 100644 (file)
--- a/source/src/qt/osd_base.h
+++ b/source/src/qt/osd_base.h
@@ -96,6 +96,9 @@ protected:
 
        QList<supportedlist_t> SupportedFeatures;
        
+       bool __USE_AUTO_KEY;
+       bool __USE_SHIFT_NUMPAD_KEY;
+   
        _TCHAR app_path[_MAX_PATH];
        QElapsedTimer osd_timer;
        bool locked_vm;
@@ -301,8 +304,8 @@ public:
        
        // common input
        void update_input();
-       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_down_native(int code, bool repeat);
        void key_up_native(int code);
        void key_lost_focus();

diff --git a/source/src/qt/osd_input.cpp b/source/src/qt/osd_input.cpp
index dabd12b..0f79c26 100644 (file)
--- a/source/src/qt/osd_input.cpp
+++ b/source/src/qt/osd_input.cpp
@@ -176,9 +176,123 @@ void OSD_BASE::update_input()
        }
 }
 
-void OSD_BASE::key_down(int code, bool repeat)
+void OSD_BASE::key_down(int code, bool extended, bool repeat)
 {
        if((code >= 256) || (code < 0)) return; // WORKAROUND
+//#ifdef USE_AUTO_KEY
+       if(!__USE_AUTO_KEY || (!now_auto_key && !p_config->romaji_to_kana)) {
+//#endif
+               //if(!dinput_key_available) {
+                       if(code == VK_SHIFT) {
+                               if(!(key_status[VK_LSHIFT] & 0x80) && (GetAsyncKeyState(VK_LSHIFT) & 0x8000)) {
+                                       code = VK_LSHIFT;
+                               } else if(!(key_status[VK_RSHIFT] & 0x80) && (GetAsyncKeyState(VK_RSHIFT) & 0x8000)) {
+                                       code = VK_RSHIFT;
+                               } else {
+                                       return;
+                               }
+                       } else if(code == VK_CONTROL) {
+                               if(!(key_status[VK_LCONTROL] & 0x80) && (GetAsyncKeyState(VK_LCONTROL) & 0x8000)) {
+                                       code = VK_LCONTROL;
+                               } else if(!(key_status[VK_RCONTROL] & 0x80) && (GetAsyncKeyState(VK_RCONTROL) & 0x8000)) {
+                                       code = VK_RCONTROL;
+                               } else {
+                                       return;
+                               }
+                       } else if(code == VK_MENU) {
+                               if(!(key_status[VK_LMENU] & 0x80) && (GetAsyncKeyState(VK_LMENU) & 0x8000)) {
+                                       code = VK_LMENU;
+                               } else if(!(key_status[VK_RMENU] & 0x80) && (GetAsyncKeyState(VK_RMENU) & 0x8000)) {
+                                       code = VK_RMENU;
+                               } else {
+                                       return;
+                               }
+                       }
+                  
+//#ifdef USE_SHIFT_NUMPAD_KEY
+                       if(__USE_SHIFT_NUMPAD_KEY) {
+//                     if(code == VK_LSHIFT || code == VK_RSHIFT) {
+                       if(code == VK_LSHIFT) {
+                               key_shift_pressed = true;
+                               return;
+                       }
+                       if(!extended) {
+                               switch(code) {
+                               case VK_INSERT:
+                                       if(key_shift_pressed || key_shift_released || key_status[VK_NUMPAD0]) {
+                                               code = VK_NUMPAD0;
+                                               key_shift_pressed = true;
+                                       }
+                                       break;
+                               case VK_END:
+                                       if(key_shift_pressed || key_shift_released || key_status[VK_NUMPAD1]) {
+                                               code = VK_NUMPAD1;
+                                               key_shift_pressed = true;
+                                       }
+                                       break;
+                               case VK_DOWN:
+                                       if(key_shift_pressed || key_shift_released || key_status[VK_NUMPAD2]) {
+                                               code = VK_NUMPAD2;
+                                               key_shift_pressed = true;
+                                       }
+                                       break;
+                               case VK_NEXT:
+                                       if(key_shift_pressed || key_shift_released || key_status[VK_NUMPAD3]) {
+                                               code = VK_NUMPAD3;
+                                               key_shift_pressed = true;
+                                       }
+                                       break;
+                               case VK_LEFT:
+                                       if(key_shift_pressed || key_shift_released || key_status[VK_NUMPAD4]) {
+                                               code = VK_NUMPAD4;
+                                               key_shift_pressed = true;
+                                       }
+                                       break;
+                               case VK_CLEAR:
+                                       if(key_shift_pressed || key_shift_released || key_status[VK_NUMPAD5]) {
+                                               code = VK_NUMPAD5;
+                                               key_shift_pressed = true;
+                                       }
+                                       break;
+                               case VK_RIGHT:
+                                       if(key_shift_pressed || key_shift_released || key_status[VK_NUMPAD6]) {
+                                               code = VK_NUMPAD6;
+                                               key_shift_pressed = true;
+                                       }
+                                       break;
+                               case VK_HOME:
+                                       if(key_shift_pressed || key_shift_released || key_status[VK_NUMPAD7]) {
+                                               code = VK_NUMPAD7;
+                                               key_shift_pressed = true;
+                                       }
+                                       break;
+                               case VK_UP:
+                                       if(key_shift_pressed || key_shift_released || key_status[VK_NUMPAD8]) {
+                                               code = VK_NUMPAD8;
+                                               key_shift_pressed = true;
+                                       }
+                                       break;
+                               case VK_PRIOR:
+                                       if(key_shift_pressed || key_shift_released || key_status[VK_NUMPAD9]) {
+                                               code = VK_NUMPAD9;
+                                               key_shift_pressed = true;
+                                       }
+                                       break;
+                               }
+                       }
+                  }
+                  
+//#endif
+                       key_down_native(code, repeat);
+               //} else {
+               //      if(repeat || code == 0xf0 || code == 0xf1 || code == 0xf2 || code == 0xf3 || code == 0xf4) {
+               //              key_down_native(code, repeat);
+               //      }
+               //}
+//#ifdef USE_AUTO_KEY
+       }
+//#endif
+#if 0
        if(code == VK_SHIFT) {
                if(!(key_status[VK_LSHIFT] & 0x80) && (GetAsyncKeyState(VK_LSHIFT) & 0x8000)) {
                        code = VK_LSHIFT;
@@ -217,11 +331,102 @@ void OSD_BASE::key_down(int code, bool repeat)
                }
        }
        key_down_native(code, repeat);
+#endif
 }
 
-void OSD_BASE::key_up(int code)
+void OSD_BASE::key_up(int code, bool extended)
 {
        if((code >= 256) || (code < 0)) return; // WORKAROUND
+//#ifdef USE_AUTO_KEY
+       if(!__USE_AUTO_KEY || (!now_auto_key && !p_config->romaji_to_kana)) {
+//#endif
+               //if(!dinput_key_available) {
+                       if(code == VK_SHIFT) {
+                               if((key_status[VK_LSHIFT] & 0x80) && !(GetAsyncKeyState(VK_LSHIFT) & 0x8000)) {
+                                       code = VK_LSHIFT;
+                               } else if((key_status[VK_RSHIFT] & 0x80) && !(GetAsyncKeyState(VK_RSHIFT) & 0x8000)) {
+                                       code = VK_RSHIFT;
+                               } else {
+                                       return;
+                               }
+                       } else if(code == VK_CONTROL) {
+                               if((key_status[VK_LCONTROL] & 0x80) && !(GetAsyncKeyState(VK_LCONTROL) & 0x8000)) {
+                                       code = VK_LCONTROL;
+                               } else if((key_status[VK_RCONTROL] & 0x80) && !(GetAsyncKeyState(VK_RCONTROL) & 0x8000)) {
+                                       code = VK_RCONTROL;
+                               } else {
+                                       return;
+                               }
+                       } else if(code == VK_MENU) {
+                               if((key_status[VK_LMENU] & 0x80) && !(GetAsyncKeyState(VK_LMENU) & 0x8000)) {
+                                       code = VK_LMENU;
+                               } else if((key_status[VK_RMENU] & 0x80) && !(GetAsyncKeyState(VK_RMENU) & 0x8000)) {
+                                       code = VK_RMENU;
+                               } else {
+                                       return;
+                               }
+                       }
+//#ifdef USE_SHIFT_NUMPAD_KEY
+                       if(__USE_SHIFT_NUMPAD_KEY) {
+                       
+//                     if(code == VK_LSHIFT || code == VK_RSHIFT) {
+                       if(code == VK_LSHIFT) {
+                               key_shift_pressed = false;
+                               key_shift_released = true;
+                               return;
+                       }
+                       if(!extended) {
+                               switch(code) {
+                               case VK_NUMPAD0: case VK_INSERT:
+                                       key_up_native(VK_NUMPAD0);
+                                       key_up_native(VK_INSERT);
+                                       return;
+                               case VK_NUMPAD1: case VK_END:
+                                       key_up_native(VK_NUMPAD1);
+                                       key_up_native(VK_END);
+                                       return;
+                               case VK_NUMPAD2: case VK_DOWN:
+                                       key_up_native(VK_NUMPAD2);
+                                       key_up_native(VK_DOWN);
+                                       return;
+                               case VK_NUMPAD3: case VK_NEXT:
+                                       key_up_native(VK_NUMPAD3);
+                                       key_up_native(VK_NEXT);
+                                       return;
+                               case VK_NUMPAD4: case VK_LEFT:
+                                       key_up_native(VK_NUMPAD4);
+                                       key_up_native(VK_LEFT);
+                                       return;
+                               case VK_NUMPAD5: case VK_CLEAR:
+                                       key_up_native(VK_NUMPAD5);
+                                       key_up_native(VK_CLEAR);
+                                       return;
+                               case VK_NUMPAD6: case VK_RIGHT:
+                                       key_up_native(VK_NUMPAD6);
+                                       key_up_native(VK_RIGHT);
+                                       return;
+                               case VK_NUMPAD7: case VK_HOME:
+                                       key_up_native(VK_NUMPAD7);
+                                       key_up_native(VK_HOME);
+                                       return;
+                               case VK_NUMPAD8: case VK_UP:
+                                       key_up_native(VK_NUMPAD8);
+                                       key_up_native(VK_UP);
+                                       return;
+                               case VK_NUMPAD9: case VK_PRIOR:
+                                       key_up_native(VK_NUMPAD9);
+                                       key_up_native(VK_PRIOR);
+                                       return;
+                               }
+                       }
+                       }
+//#endif
+                       key_up_native(code);
+               }
+//#ifdef USE_AUTO_KEY
+//}
+//#endif
+#if 0
        if(code == VK_SHIFT) {
                if((key_status[VK_LSHIFT] & 0x80) && !(GetAsyncKeyState(VK_LSHIFT) & 0x8000)) {
                        code = VK_LSHIFT;
@@ -258,6 +463,7 @@ void OSD_BASE::key_up(int code)
                }
        }
        key_up_native(code);
+#endif
 }