osd->vm = vm;
# if defined(_USE_QT)
osd->reset_vm_node();
+ osd->update_keyname_table();
# endif
#ifdef USE_AUTO_KEY
initialize_auto_key();
osd->vm = vm;;
#if defined(_USE_QT)
osd->reset_vm_node();
+ osd->update_keyname_table();
#endif
int presented_rate;
int presented_samples;
osd->vm = vm;
# if defined(_USE_QT)
osd->reset_vm_node();
+ osd->update_keyname_table();
# endif
vm->initialize_sound(sound_rate, sound_samples);
#ifdef USE_SOUND_VOLUME
message("* qt/osd")
-SET(THIS_LIB_VERSION 2.20.2)
+SET(THIS_LIB_VERSION 2.21.0)
set(s_qt_osd_headers
osd_base.h
QObject::connect(GuiMain, SIGNAL(lastWindowClosed()),
rMainWindow, SLOT(on_actionExit_triggered()));
+ QObject::connect(emu->get_osd(), SIGNAL(sig_clear_keyname_table()), rMainWindow, SLOT(do_clear_keyname_table()));
+ QObject::connect(emu->get_osd(), SIGNAL(sig_add_keyname_table(uint32_t, QString)), rMainWindow, SLOT(do_add_keyname_table(uint32_t, QString)));
+ emu->get_osd()->update_keyname_table();
+
GuiMain->exec();
return 0;
}
message("* qt/gui")
-set(THIS_LIB_VERSION 2.19.7)
+set(THIS_LIB_VERSION 2.19.8)
#include(cotire)
#include(PrecompiledHeader)
int lim = glv->get_key_table_size();
int i;
int j = 0;
- bool vk_checked[256];
if(lim > KEYDEF_MAXIMUM) lim = KEYDEF_MAXIMUM;
setup_head_label[0] = new QLabel(QString::fromUtf8("<B>VK</B>"));
keycodes_layout->addWidget(setup_head_label[0], 0, 0);
keycodes_layout->addWidget(setup_head_label[1], 0, 1);
- for(i = 0; i < 256; i++) vk_checked[i] = false;
+ for(i = 0; i < 256; i++) {
+ vk_checked[i] = false;
+ }
+ for(i = 0; i < KEYDEF_MAXIMUM; i++) {
+ vk_map[i] = 0x00;
+ setup_combo[i] = NULL;
+ setup_label[i] = NULL;
+ }
for(i = 0; i < lim; i++) {
QString tmps;
const char *p;
connect(setup_combo[j], SIGNAL(sig_selected(uint32_t, uint32_t)),
glv, SLOT(do_update_keyboard_scan_code(uint32_t, uint32_t)));
tmps = QString::fromUtf8("<B>") + QString::fromUtf8(p) + QString::fromUtf8("</B>");
+ vk_map[j] = (uint8_t)i;
setup_label[j] = new QLabel(tmps);
keycodes_layout->addWidget(setup_label[j], j + 1, 0);
keycodes_layout->addWidget(setup_combo[j], j + 1, 1);
{
}
+void CSP_KeySetDialog::do_update_keyname_table(uint32_t vk, QString name)
+{
+ if(p_glv == NULL) return;
+ for(int i = 0; i < KEYDEF_MAXIMUM; i++) {
+ if(setup_combo[i] != NULL) {
+ setup_combo[i]->do_update_scan_name(vk, name);
+ }
+ }
+}
QLabel *setup_head_label[2];
CSP_KeySetupCombo *setup_combo[KEYDEF_MAXIMUM];
QLabel *setup_label[KEYDEF_MAXIMUM];
+ bool vk_checked[256];
+ uint8_t vk_map[KEYDEF_MAXIMUM];
public:
CSP_KeySetDialog(QWidget *parent = NULL, GLDrawClass *glv = NULL);
~CSP_KeySetDialog();
+public slots:
+ void do_update_keyname_table(uint32_t vk, QString name);
};
QT_END_NAMESPACE
int i;
scanname_list.clear();
scancode_list.clear();
+ vkcode_list.clear();
scancode_list.append(0xffffffff);
+ vkcode_list.append(0xffffffff);
scanname_list.append(QApplication::translate("KeySetDialog", "Undefined", 0));
for(i = 0; i < KEYDEF_MAXIMUM; i++) {
if(base_table[i].vk == 0xffffffff) break;
scanname_list.append(QString::fromUtf8(base_table[i].name));
scancode_list.append(base_table[i].scan);
+ vkcode_list.append(base_table[i].vk);
+// printf("%02X %s\n", base_table[i].scan, base_table[i].name);
}
this->addItems(scanname_list);
for(i = 0; i < scancode_list.size(); i++) {
emit sig_selected(vk, scan);
}
+void CSP_KeySetupCombo::do_update_scan_name(uint32_t index, QString name)
+{
+ for(int i = 0; i < scancode_list.size(); i++) {
+ if(vkcode_list.value(i) == index) {
+ this->setItemText(i, name);
+ }
+ }
+}
QStringList scanname_list;
QList<uint32_t> scancode_list;
+ QList<uint32_t> vkcode_list;
public:
CSP_KeySetupCombo(QWidget *parent,
int num,
~CSP_KeySetupCombo();
public slots:
void do_selected(int index);
+ void do_update_scan_name(uint32_t index, QString name);
signals:
int sig_selected(uint32_t, uint32_t);
};
connect(combo, SIGNAL(activated(int)), this, SLOT(do_select(int)));
if((button_num < 16) && (button_num >= 0)) {
for(int i = 0; i < combo->count(); i++) {
- if(p_config->joy_to_key_buttons[button_num] == default_key_table_106_QtScan[i].vk) {
+ if(p_config->joy_to_key_buttons[button_num] == -default_key_table_106_QtScan[i].vk) {
combo->setCurrentIndex(i);
break;
}
#include <QIcon>
#include <QString>
#include <QStringList>
+#include <QMap>
//#include <QMenu>
//#include <QMenuBar>
CSP_Logger *csp_logger;
QMainWindow *MainWindow;
QApplication *CoreApplication;
+ QMap<uint32_t, QString>phys_key_name_map; // VK, NAME
GLDrawClass *graphicsView;
CSP_DockDisks *driveData;
void do_set_state_log_to_syslog(bool f);
void do_set_joy_to_key(bool flag);
void do_select_fixed_cpu(int num);
+ void do_add_keyname_table(uint32_t vk, QString name);
+ void do_clear_keyname_table();
signals:
int message_changed(QString);
int sig_load_state(QString);
int sig_save_state(QString);
int sig_emu_thread_to_fixed_cpu(int);
+ int sig_add_keyname_table(uint32_t, QString);
};
QT_END_NAMESPACE
emit sig_emu_update_config();
}
+void Ui_MainWindowBase::do_clear_keyname_table()
+{
+ phys_key_name_map.clear();
+}
+
+void Ui_MainWindowBase::do_add_keyname_table(uint32_t vk, QString name)
+{
+ phys_key_name_map.insert(vk, name);
+// printf("VK=%02X NAME=%s\n", vk, name.toLocal8Bit().constData());
+}
+
void Ui_MainWindowBase::do_set_screen_rotate(int type)
{
p_config->rotate_type = type;
}
+#include "qt_input.h"
+
void Ui_MainWindowBase::rise_keyboard_dialog(void)
{
if(graphicsView != NULL) {
CSP_KeySetDialog *dlg = new CSP_KeySetDialog(NULL, graphicsView);
dlg->setWindowTitle(QApplication::translate("KeySetDialog", "Configure Keyboard", 0));
+ connect(this, SIGNAL(sig_add_keyname_table(uint32_t, QString)), dlg, SLOT(do_update_keyname_table(uint32_t, QString)));
+ if(!(phys_key_name_map.isEmpty())) {
+ for(auto i = phys_key_name_map.constBegin(); i != phys_key_name_map.constEnd(); ++i)
+ {
+ bool is_set = false;
+ if(!using_flags->is_notify_key_down_lr_shift()) {
+ if(i.key() == VK_SHIFT) {
+ emit sig_add_keyname_table(VK_LSHIFT, i.value());
+ emit sig_add_keyname_table(VK_RSHIFT, i.value());
+ is_set = true;
+ } else if(i.key() == VK_MENU) {
+ emit sig_add_keyname_table(VK_LMENU, i.value());
+ emit sig_add_keyname_table(VK_RMENU, i.value());
+ is_set = true;
+ }
+ }
+ if(i.key() == VK_CONTROL) {
+ emit sig_add_keyname_table(VK_LCONTROL, i.value());
+ emit sig_add_keyname_table(VK_RCONTROL, i.value());
+ is_set = true;
+ }
+ if(p_config->numpad_enter_as_fullkey) {
+ if(i.key() == VK_RETURN) {
+ emit sig_add_keyname_table(VK_OEM_CSP_KPRET, i.value());
+ emit sig_add_keyname_table(VK_RETURN, i.value());
+ is_set = true;
+ }
+ }
+ if(p_config->swap_kanji_pause) {
+ if(i.key() == VK_KANJI) {
+ emit sig_add_keyname_table(VK_PAUSE, i.value());
+ is_set = true;
+ } else if(i.key() == VK_PAUSE) {
+ emit sig_add_keyname_table(VK_KANJI, i.value());
+ is_set = true;
+ }
+ }
+
+ if(!is_set) {
+ emit sig_add_keyname_table(i.key(), i.value());
+ }
+ }
+ }
+
dlg->show();
}
}
virtual int get_vm_node_size();
virtual void set_vm_node_name(int id, const _TCHAR *name);
virtual _TCHAR *get_vm_node_name(int id);
-
+ virtual bool is_support_phy_key_name();
config_t *get_config_ptr(void);
};
{
return -1;
}
+
+bool USING_FLAGS::is_support_phy_key_name()
+{
+ return false;
+}
+
+
max_vm_nodes = 0;
ui_retranslate_completed = false;
//csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "GUI OK");
+ phys_key_name_map.clear();
}
Ui_MainWindowBase::~Ui_MainWindowBase()
{
bitmap_t* pp = (bitmap_t*)p;
if(using_flags->get_osd() == NULL) return;
- QMutexLocker Locker_S(using_flags->get_osd()->screen_mutex);
+ QMutexLocker Locker_S(static_cast<OSD_BASE *>(using_flags->get_osd())->screen_mutex);
if((pp != NULL)) {
if(extfunc != NULL) {
// Will fix at implemenitin PX7.
#ifdef DATAREC_SOUND_RIGHT
add_feature(_T("DATAREC_SOUND_RIGHT"), 1);
#endif
+#ifdef SUPPORT_QUERY_PHY_KEY_NAME
+ add_feature(_T("SUPPORT_QUERY_PHY_KEY_NAME"), 1);
+#endif
}
void OSD::set_features(void)
const _TCHAR *get_lib_common_vm_version();
const _TCHAR *get_lib_common_vm_git_version();
const _TCHAR *get_lib_osd_version();
+ int get_key_name_table_size(void);
+ uint32_t get_scancode_by_vk(uint32_t vk);
+ uint32_t get_vk_by_scancode(uint32_t scancode);
+ const _TCHAR *get_key_name_by_scancode(uint32_t scancode);
+ const _TCHAR *get_key_name_by_vk(uint32_t vk);
// Socket
void initialize_socket();
max_vm_nodes = 0;
p_logger = logger;
debug_mutex = new QMutex(QMutex::Recursive);
+ vm = NULL;
SupportedFeatures.clear();
midi_receivers.clear();
void write_console(const _TCHAR* buffer, unsigned int length);
int read_console_input(_TCHAR* buffer, int length);
bool is_console_key_pressed(uint32_t ch);
+ void update_keyname_table(void);
// common input
void update_input();
virtual const _TCHAR *get_vm_node_name(int id);
virtual int get_vm_node_size(void);
+ virtual int get_key_name_table_size(void);
+ virtual uint32_t get_scancode_by_vk(uint32_t vk);
+ virtual uint32_t get_vk_by_scancode(uint32_t scancode);
+ virtual const _TCHAR *get_key_name_by_scancode(uint32_t scancode);
+ virtual const _TCHAR *get_key_name_by_vk(uint32_t vk);
+
// Get #define S to value.You may use inside of VM/ .
virtual void set_features(void) {}
void add_feature(const _TCHAR *key, double value);
int sig_clear_dbg_completion_list(void);
int sig_add_dbg_completion_list(_TCHAR *);
int sig_apply_dbg_completion_list(void);
+
+ int sig_clear_keyname_table(void);
+ int sig_add_keyname_table(uint32_t, QString);
};
QT_END_NAMESPACE
return mouse_button;
}
+int OSD_BASE::get_key_name_table_size(void)
+{
+ return 0;
+}
+
+void OSD_BASE::update_keyname_table(void)
+{
+ emit sig_clear_keyname_table();
+ const _TCHAR *p = NULL;
+ for(uint32_t i = 0x00; i < get_key_name_table_size(); i++) {
+ p = get_key_name_by_scancode(i);
+ uint32_t vk = get_vk_by_scancode(i);
+ if((p != NULL) && (vk != 0xffffffff)) {
+ QString tmps = QString::fromUtf8(p);
+ emit sig_add_keyname_table(vk, tmps);
+ }
+ }
+}
+
+const _TCHAR *OSD_BASE::get_key_name_by_scancode(uint32_t scancode)
+{
+ return (const _TCHAR *)NULL;
+}
+
+const _TCHAR *OSD_BASE::get_key_name_by_vk(uint32_t vk)
+{
+ return (const _TCHAR *)NULL;
+}
+
+uint32_t OSD_BASE::get_scancode_by_vk(uint32_t vk)
+{
+ return 0xffffffff;
+}
+
+uint32_t OSD_BASE::get_vk_by_scancode(uint32_t scancode)
+{
+ return 0xffffffff;
+}
+
#if !defined(Q_OS_WIN) && !defined(Q_OS_CYGWIN)
uint16_t OSD_BASE::GetAsyncKeyState(uint32_t vk)
{
//#ifdef USE_PRINTER
void OSD_BASE::create_bitmap(bitmap_t *bitmap, int width, int height)
{
- QRect rect;
+// QRect rect;
QColor col = QColor(0, 0, 0, 255);
initialize_screen_buffer(bitmap, width, height, 0); // HALFTONE
bitmap->hPainter.begin(&(bitmap->pImage));
#include "qt_gldraw.h"
#include "csp_logger.h"
+
+int OSD::get_key_name_table_size(void)
+{
+#ifdef SUPPORT_QUERY_PHY_KEY_NAME
+ if(vm != NULL) {
+ return vm->get_key_name_table_size();
+ }
+#endif
+ return 0;
+}
+
+const _TCHAR *OSD::get_key_name_by_scancode(uint32_t scancode)
+{
+#ifdef SUPPORT_QUERY_PHY_KEY_NAME
+ if(vm != NULL) {
+ return vm->get_phy_key_name_by_scancode(scancode);
+ }
+#endif
+ return (const _TCHAR *)NULL;
+}
+
+const _TCHAR *OSD::get_key_name_by_vk(uint32_t vk)
+{
+#ifdef SUPPORT_QUERY_PHY_KEY_NAME
+ if(vm != NULL) {
+ return vm->get_phy_key_name_by_vk(vk);
+ }
+#endif
+ return (const _TCHAR *)NULL;
+}
+
+uint32_t OSD::get_scancode_by_vk(uint32_t vk)
+{
+#ifdef SUPPORT_QUERY_PHY_KEY_NAME
+ if(vm != NULL) {
+ return vm->get_scancode_by_vk(vk);
+ }
+#endif
+ return 0xffffffff;
+}
+
+uint32_t OSD::get_vk_by_scancode(uint32_t scancode)
+{
+#ifdef SUPPORT_QUERY_PHY_KEY_NAME
+ if(vm != NULL) {
+ return vm->get_vk_by_scancode(scancode);
+ }
+#endif
+ return 0xffffffff;
+}
+
const _TCHAR *OSD::get_lib_common_vm_version()
{
if(vm->first_device != NULL) {
message("* vm/common_vm")
-SET(THIS_LIB_VERSION 2.18.4)
+SET(THIS_LIB_VERSION 2.19.0)
#include(cotire)
set(s_vm_common_vm_srcs
//mainio->restore_opn();
return true;
}
+#ifdef SUPPORT_QUERY_PHY_KEY_NAME
+int VM::get_key_name_table_size(void)
+{
+ if(keyboard != NULL) {
+ return keyboard->get_key_name_table_size();
+ }
+ return 0;
+}
+const _TCHAR *VM::get_phy_key_name_by_scancode(uint32_t scancode)
+{
+ if(keyboard != NULL) {
+ return keyboard->get_phy_key_name_by_scancode(scancode);
+ }
+ return (const _TCHAR *)NULL;
+}
+
+const _TCHAR *VM::get_phy_key_name_by_vk(uint32_t vk)
+{
+ if(keyboard != NULL) {
+ return keyboard->get_phy_key_name_by_vk(vk);
+ }
+ return (const _TCHAR *)NULL;
+}
+uint32_t VM::get_scancode_by_vk(uint32_t vk)
+{
+ if(keyboard != NULL) {
+ return keyboard->get_scancode_by_vk(vk);
+ }
+ return 0xffffffff;
+}
+uint32_t VM::get_vk_by_scancode(uint32_t scancode)
+{
+ if(keyboard != NULL) {
+ return keyboard->get_vk_by_scancode(scancode);
+ }
+ return 0xffffffff;
+}
+#endif
#ifdef USE_DIG_RESOLUTION
void VM::get_screen_resolution(int *w, int *h)
#else
#define USE_SOUND_VOLUME 11
#endif
-#define SUPPORT_TV_RENDER
+#define SUPPORT_TV_RENDER
+#define SUPPORT_QUERY_PHY_KEY_NAME
#define IGNORE_DISK_CRC_DEFAULT true
// device informations for virtual machine
{
protected:
// EMU* emu;
-
// devices
// EVENT* event;
void set_sound_device_volume(int ch, int decibel_l, int decibel_r);
#endif
void set_vm_frame_rate(double fps);
-
// notify key
void key_down(int code, bool repeat);
void key_up(int code);
void push_apss_rewind(int drv);
void update_config();
bool process_state(FILEIO* state_fio, bool loading);
+
+#ifdef SUPPORT_QUERY_PHY_KEY_NAME
+ int get_key_name_table_size(void);
+ const _TCHAR *get_phy_key_name_by_scancode(uint32_t scancode);
+ const _TCHAR *get_phy_key_name_by_vk(uint32_t vk);
+ uint32_t get_scancode_by_vk(uint32_t vk);
+ uint32_t get_vk_by_scancode(uint32_t scancode);
+#endif
#if defined(USE_BUBBLE)
void open_bubble_casette(int drv, const _TCHAR *path, int bank);
{
return kana_pressed;
}
+#ifdef SUPPORT_QUERY_PHY_KEY_NAME
+ int get_key_name_table_size(void);
+ const _TCHAR *get_phy_key_name_by_scancode(uint32_t scancode);
+ const _TCHAR *get_phy_key_name_by_vk(uint32_t vk);
+ uint32_t get_scancode_by_vk(uint32_t vk);
+ uint32_t get_vk_by_scancode(uint32_t scancode);
+#endif
void event_callback(int event_id, int err);
void __FASTCALL write_signal(int id, uint32_t data, uint32_t mask);
uint32_t __FASTCALL read_signal(int id);
}
}
+#ifdef SUPPORT_QUERY_PHY_KEY_NAME
+int KEYBOARD::get_key_name_table_size(void)
+{
+ int count = 0;
+ for(int i = 0; i < 256; i++) {
+ count++;
+ if(key_code_name[i].phy >= 0xffff) break;
+ }
+ return count;
+}
+
+const _TCHAR *KEYBOARD::get_phy_key_name_by_scancode(uint32_t scancode)
+{
+ for(int i = 0; i < 256; i++) {
+ if(key_code_name[i].phy >= 0xffff) break;
+ if(key_code_name[i].phy == (uint16_t)scancode) {
+ return (const _TCHAR *)(key_code_name[i].name);
+ }
+ }
+ return (const _TCHAR *)NULL;
+}
+
+const _TCHAR *KEYBOARD::get_phy_key_name_by_vk(uint32_t vk)
+{
+ uint32_t scancode = get_scancode_by_vk(vk);
+ if((scancode == 0) || (scancode >= (sizeof(vk_matrix_106) / sizeof(uint16_t)))) {
+ return (const _TCHAR *)NULL;
+ }
+ return get_phy_key_name_by_scancode(scancode);
+}
+
+uint32_t KEYBOARD::get_scancode_by_vk(uint32_t vk)
+{
+ uint16_t scancode = 0x00;
+ for(int i = 0; i < (sizeof(vk_matrix_106) / sizeof(uint16_t)) ; i++) {
+ if(vk_matrix_106[i] == (const uint16_t)vk) {
+ scancode = vk_matrix_106[i];
+ return (uint32_t)scancode;
+ }
+ }
+ return 0xffffffff;
+}
+
+uint32_t KEYBOARD::get_vk_by_scancode(uint32_t scancode)
+{
+ uint32_t vk;
+ if(scancode < (sizeof(vk_matrix_106) / sizeof(uint16_t))) {
+ vk = vk_matrix_106[scancode];
+ return vk;
+ }
+ return 0xffffffff;
+}
+#endif
+
KEYBOARD::KEYBOARD(VM_TEMPLATE* parent_vm, EMU *parent_emu) : DEVICE(parent_vm, parent_emu)
{
#if defined(_FM77AV_VARIANTS)
delete key_fifo;
}
-
-
KEYBOARD::~KEYBOARD()
{
}
+
#define STATE_VERSION 9
//#if defined(Q_OS_WIN)
//DLL_PREFIX_I struct cur_time_s cur_time;
uint16_t phy;
uint16_t code;
};
+struct key_name_t {
+ uint16_t phy;
+ const _TCHAR *name;
+};
+const key_name_t key_code_name[] = {
+ { 0x01, _T("[ESC]") },
+ { 0x02, _T("1 (FULL KEY)") },
+ { 0x03, _T("2 (FULL KEY)") },
+ { 0x04, _T("3 (FULL KEY)") },
+ { 0x05, _T("4 (FULL KEY)") },
+ { 0x06, _T("5 (FULL KEY)") },
+ { 0x07, _T("6 (FULL KEY)") },
+ { 0x08, _T("7 (FULL KEY)") },
+ { 0x09, _T("8 (FULL KEY)") },
+ { 0x0a, _T("9 (FULL KEY)") },
+ { 0x0b, _T("0 (FULL KEY)") },
+ { 0x0c, _T("- (FULL KEY)") },
+ { 0x0d, _T("^") },
+ { 0x0e, _T("\\|") },
+ { 0x0f, _T("[BS]") },
+ { 0x10, _T("[TAB]") },
+ { 0x11, _T("Q") },
+ { 0x12, _T("W") },
+ { 0x13, _T("E") },
+ { 0x14, _T("R") },
+ { 0x15, _T("T") },
+ { 0x16, _T("Y") },
+ { 0x17, _T("U") },
+ { 0x18, _T("I") },
+ { 0x19, _T("O") },
+ { 0x1a, _T("P") },
+ { 0x1b, _T("@") },
+ { 0x1c, _T("[") },
+ { 0x1d, _T("[RETURN](FULL KEY)") },
+ { 0x1e, _T("A") },
+ { 0x1f, _T("S") },
+ { 0x20, _T("D") },
+ { 0x21, _T("F") },
+ { 0x22, _T("G") },
+ { 0x23, _T("H") },
+ { 0x24, _T("J") },
+ { 0x25, _T("K") },
+ { 0x26, _T("L") },
+ { 0x27, _T(";") },
+ { 0x28, _T(":") },
+ { 0x29, _T("]") },
+ { 0x2a, _T("Z") },
+ { 0x2b, _T("X") },
+ { 0x2c, _T("C") },
+ { 0x2d, _T("V") },
+ { 0x2e, _T("B") },
+ { 0x2f, _T("N") },
+ { 0x30, _T("M") },
+ { 0x31, _T(", [COMMA](FULL KEY)") },
+ { 0x32, _T(". [PERIOD](FULL KEY)") },
+ { 0x33, _T("/ (FULL KEY)") },
+ { 0x34, _T("\\_") },
+ { 0x35, _T("[RIGHT SPACE]") },
+ { 0x36, _T("* (TEN KEY)") },
+ { 0x37, _T("/ (TEN KEY)") },
+ { 0x38, _T("+ (TEN KEY)") },
+ { 0x39, _T("- (TEN KEY)") },
+ { 0x3a, _T("7 (TEN KEY)") },
+ { 0x3b, _T("8 (TEN KEY)") },
+ { 0x3c, _T("9 (TEN KEY)") },
+ { 0x3d, _T("= (TEN KEY)") },
+ { 0x3e, _T("4 (TEN KEY)") },
+ { 0x3f, _T("5 (TEN KEY)") },
+ { 0x40, _T("6 (TEN KEY)") },
+ { 0x41, _T(", [COMMA](TEN KEY)") },
+ { 0x42, _T("1 (TEN KEY)") },
+ { 0x43, _T("2 (FULL KEY)") },
+ { 0x44, _T("3 (TEN KEY)") },
+ { 0x45, _T("[RETURN] (TEN KEY)") },
+ { 0x46, _T("0 (TEN KEY)") },
+ { 0x47, _T(". [PERIOD](TEN KEY)") },
+ { 0x48, _T("[INS]") },
+ { 0x49, _T("[EL]") },
+ { 0x4a, _T("[CLS]") },
+ { 0x4b, _T("[DEL]") },
+ { 0x4c, _T("[DUP]") },
+ { 0x4d, _T("[UP] (CURSOR KEY)") },
+ { 0x4e, _T("[HOME]") },
+ { 0x4f, _T("[LEFT] (CURSOR KEY)") },
+ { 0x50, _T("[DOWN] (CURSOR KEY)") },
+ { 0x51, _T("[RIGHT] (CURSOR KEY)") },
+ { 0x52, _T("[CTRL]") },
+ { 0x53, _T("[LEFT SHIFT]") },
+ { 0x54, _T("[RIGHT SHIFT]") },
+ { 0x55, _T("[CAPS]") },
+ { 0x56, _T("[GRPH]") },
+ { 0x57, _T("[LEFT SPACE]") },
+ { 0x58, _T("[CENTER SPACE]") },
+ { 0x59, _T("*UNKNOWN($59)*") },
+ { 0x5a, _T("[KANA]") },
+ { 0x5b, _T("*UNKNOWN($5B)*") },
+ { 0x5c, _T("[BREAK]") },
+ { 0x5d, _T("[PF1]") },
+ { 0x5e, _T("[PF2]") },
+ { 0x5f, _T("[PF3]") },
+ { 0x60, _T("[PF4]") },
+ { 0x61, _T("[PF5]") },
+ { 0x62, _T("[PF6]") },
+ { 0x63, _T("[PF7]") },
+ { 0x64, _T("[PF8]") },
+ { 0x65, _T("[PF9]") },
+ { 0x66, _T("[PF10]") },
+ { 0xffff, _T("**END**")}
+};
// Key tables value from XM7.
const key_tbl_t standard_key[] = {
{0x01, 0x1b},
virtual const _TCHAR *get_vm_git_version(void) {
return (const _TCHAR *)_git_revision;
}
+ virtual int get_key_name_table_size(void) {
+ return 0;
+ }
+ virtual const _TCHAR *get_phy_key_name_by_scancode(uint32_t scancode) {
+ return (const _TCHAR *)NULL;
+ }
+ virtual const _TCHAR *get_phy_key_name_by_vk(uint32_t vk) {
+ return (const _TCHAR *)NULL;
+ }
+ virtual uint32_t get_scancode_by_vk(uint32_t vk) {
+ return 0xffffffff;
+ }
+ virtual uint32_t get_vk_by_scancode(uint32_t scancode) {
+ return 0xffffffff;
+ }
DEVICE* dummy;
DEVICE* first_device;
DEVICE* last_device;
OSDN Git Service
