bool DonghaiConverter::handleMscInput(struct input_event *input) {
if (!isSpecialKey(input)) {
addOutput(input, false);
return true;
}
return false;
}
void
setKeyModifiers (ScreenKey *key, ScreenKey which) {
if (!isSpecialKey(*key)) {
wchar_t character = *key & SCR_KEY_CHAR_MASK;
ScreenKey modifiers = *key & ~SCR_KEY_CHAR_MASK;
if (which & (SCR_KEY_UPPER | SCR_KEY_SHIFT)) {
if (!(modifiers & (SCR_KEY_UPPER | SCR_KEY_SHIFT))) {
if (iswupper(character)) {
character = towlower(character);
if (which & SCR_KEY_UPPER) {
modifiers |= SCR_KEY_UPPER;
} else {
modifiers |= SCR_KEY_SHIFT;
}
}
}
} else {
if (modifiers & (SCR_KEY_UPPER | SCR_KEY_SHIFT)) {
if (iswalpha(character)) {
character = towupper(character);
modifiers &= ~SCR_KEY_SHIFT;
}
modifiers &= ~SCR_KEY_UPPER;
}
}
if (which & SCR_KEY_CONTROL) {
if (!(modifiers & SCR_KEY_CONTROL)) {
if (character < 0X20) {
character |= 0X60;
modifiers |= SCR_KEY_CONTROL;
}
}
} else {
if (modifiers & SCR_KEY_CONTROL) {
if (iswLatin1(character)) {
if ((character & 0X6F) == 0X2F) {
character |= 0X50;
} else {
character &= 0X9F;
}
}
modifiers &= ~SCR_KEY_CONTROL;
}
}
*key = character | modifiers;
}
}
void AnnotationDialog::CompletableLineEdit::handleSpecialKeysInSearch( QKeyEvent* ev )
{
int cursorPos = cursorPosition();
QString txt;
int additionalLength;
if (! isSpecialKey(ev)) {
txt = text().left(cursorPos) + ev->text() + text().mid(cursorPos);
additionalLength = 0;
} else {
txt = text() + QString::fromUtf8(" %1 ").arg(ev->text());
cursorPos += 2;
additionalLength = 2;
}
setText(txt);
if (! isSpecialKey(ev)) {
//Special handling for ENTER to position the cursor correctly
setText(text().left(text().size() - 1));
cursorPos--;
}
setCursorPosition( cursorPos + ev->text().length() + additionalLength);
deselect();
// Select the item in the listView - not perfect but acceptable for now.
int start = txt.lastIndexOf(QRegExp(QString::fromLatin1("[!&|]")), cursorPosition() - 2) + 1;
if (start > 0) {
start++;
}
QString input = txt.mid(start, cursorPosition() - start);
if (! input.isEmpty()) {
QTreeWidgetItem* item = findItemInListView(input);
if (item) {
item->setCheckState(0, Qt::Checked);
}
}
}
void CInputTranslator::keyDown(const Common::KeyState &keyState) {
if (keyState.ascii > 0 && keyState.ascii <= 127) {
CKeyCharMsg msg(keyState.ascii);
if (_inputHandler->handleMessage(msg))
return;
}
if (CMovementMsg::getMovement(keyState.keycode) != MOVE_NONE) {
CMovementMsg msg(keyState.keycode);
if (_inputHandler->handleMessage(msg))
return;
}
if (isSpecialKey(keyState.keycode)) {
CVirtualKeyCharMsg msg(keyState);
msg._keyState.ascii = 0;
_inputHandler->handleMessage(msg);
}
}
bool DonghaiConverter::handleKeyInput(struct input_event *input) {
if (!isSpecialKey(input)) {
leaveDonghaiMode();
addOutput(input, false);
m_send_syn_event = true;
updateKeyFlags(&m_physic_key_flags, input->code, input->value);
return true;
}
switch (input->code) {
case KEY_CAPSLOCK:
handleCapsLock(input);
break;
case KEY_H:
handleMapKey(input, KEY_LEFT, BIT_H, BIT_LEFT);
break;
case KEY_J:
handleMapKey(input, KEY_DOWN, BIT_J, BIT_DOWN);
break;
case KEY_K:
handleMapKey(input, KEY_UP, BIT_K, BIT_UP);
break;
case KEY_L:
handleMapKey(input, KEY_RIGHT, BIT_L, BIT_RIGHT);
break;
case KEY_I:
handleInsertKey(input);
break;
case KEY_LEFTBRACE:
handleMapKey(input, KEY_ESC, BIT_LEFTBRACE, BIT_ESC);
break;
default:
break;
}
updateKeyFlags(&m_physic_key_flags, input->code, input->value);
return true;
}
static int
insertKey_ScreenScreen (ScreenKey key) {
char *sequence;
char buffer[0X10];
setScreenKeyModifiers(&key, 0);
wchar_t character = key & SCR_KEY_CHAR_MASK;
if (isSpecialKey(key)) {
const unsigned char flags = getAuxiliaryData()[1];
#define KEY(key,string) case (key): sequence = (string); break
#define CURSOR_KEY(key,string1,string2) KEY((key), ((flags & 0X01)? (string1): (string2)))
switch (character) {
KEY(SCR_KEY_ENTER, "\r");
KEY(SCR_KEY_TAB, "\t");
KEY(SCR_KEY_BACKSPACE, "\x7f");
KEY(SCR_KEY_ESCAPE, "\x1b");
CURSOR_KEY(SCR_KEY_CURSOR_LEFT , "\x1bOD", "\x1b[D");
CURSOR_KEY(SCR_KEY_CURSOR_RIGHT, "\x1bOC", "\x1b[C");
CURSOR_KEY(SCR_KEY_CURSOR_UP , "\x1bOA", "\x1b[A");
CURSOR_KEY(SCR_KEY_CURSOR_DOWN , "\x1bOB", "\x1b[B");
KEY(SCR_KEY_PAGE_UP, "\x1b[5~");
KEY(SCR_KEY_PAGE_DOWN, "\x1b[6~");
KEY(SCR_KEY_HOME, "\x1b[1~");
KEY(SCR_KEY_END, "\x1b[4~");
KEY(SCR_KEY_INSERT, "\x1b[2~");
KEY(SCR_KEY_DELETE, "\x1b[3~");
KEY(SCR_KEY_FUNCTION+0, "\x1bOP");
KEY(SCR_KEY_FUNCTION+1, "\x1bOQ");
KEY(SCR_KEY_FUNCTION+2, "\x1bOR");
KEY(SCR_KEY_FUNCTION+3, "\x1bOS");
KEY(SCR_KEY_FUNCTION+4, "\x1b[15~");
KEY(SCR_KEY_FUNCTION+5, "\x1b[17~");
KEY(SCR_KEY_FUNCTION+6, "\x1b[18~");
KEY(SCR_KEY_FUNCTION+7, "\x1b[19~");
KEY(SCR_KEY_FUNCTION+8, "\x1b[20~");
KEY(SCR_KEY_FUNCTION+9, "\x1b[21~");
KEY(SCR_KEY_FUNCTION+10, "\x1b[23~");
KEY(SCR_KEY_FUNCTION+11, "\x1b[24~");
KEY(SCR_KEY_FUNCTION+12, "\x1b[25~");
KEY(SCR_KEY_FUNCTION+13, "\x1b[26~");
KEY(SCR_KEY_FUNCTION+14, "\x1b[28~");
KEY(SCR_KEY_FUNCTION+15, "\x1b[29~");
KEY(SCR_KEY_FUNCTION+16, "\x1b[31~");
KEY(SCR_KEY_FUNCTION+17, "\x1b[32~");
KEY(SCR_KEY_FUNCTION+18, "\x1b[33~");
KEY(SCR_KEY_FUNCTION+19, "\x1b[34~");
default:
logMessage(LOG_WARNING, "unsuported key: %04X", key);
return 0;
}
#undef CURSOR_KEY
#undef KEY
} else {
int byte = convertWcharToChar(character);
if (byte == EOF) {
logMessage(LOG_WARNING, "character not supported in local character set: 0X%04X", key);
return 0;
}
STR_BEGIN(buffer, sizeof(buffer));
if (key & SCR_KEY_ALT_LEFT) STR_PRINTF("%c", ESC);
STR_PRINTF("\\%03o", byte);
STR_END;
sequence = buffer;
}
logBytes(LOG_CATEGORY(SCREEN_DRIVER), "insert bytes", sequence, strlen(sequence));
return doScreenCommand("stuff", sequence, NULL);
}
static int
insertKey_AtSpiScreen (ScreenKey key) {
long keysym;
int modMeta=0, modControl=0;
setKeyModifiers(&key, SCR_KEY_CONTROL);
if (isSpecialKey(key)) {
switch (key & SCR_KEY_CHAR_MASK) {
case SCR_KEY_ENTER: keysym = XK_KP_Enter; break;
case SCR_KEY_TAB: keysym = XK_Tab; break;
case SCR_KEY_BACKSPACE: keysym = XK_BackSpace; break;
case SCR_KEY_ESCAPE: keysym = XK_Escape; break;
case SCR_KEY_CURSOR_LEFT: keysym = XK_Left; break;
case SCR_KEY_CURSOR_RIGHT: keysym = XK_Right; break;
case SCR_KEY_CURSOR_UP: keysym = XK_Up; break;
case SCR_KEY_CURSOR_DOWN: keysym = XK_Down; break;
case SCR_KEY_PAGE_UP: keysym = XK_Page_Up; break;
case SCR_KEY_PAGE_DOWN: keysym = XK_Page_Down; break;
case SCR_KEY_HOME: keysym = XK_Home; break;
case SCR_KEY_END: keysym = XK_End; break;
case SCR_KEY_INSERT: keysym = XK_Insert; break;
case SCR_KEY_DELETE: keysym = XK_Delete; break;
case SCR_KEY_FUNCTION + 0: keysym = XK_F1; break;
case SCR_KEY_FUNCTION + 1: keysym = XK_F2; break;
case SCR_KEY_FUNCTION + 2: keysym = XK_F3; break;
case SCR_KEY_FUNCTION + 3: keysym = XK_F4; break;
case SCR_KEY_FUNCTION + 4: keysym = XK_F5; break;
case SCR_KEY_FUNCTION + 5: keysym = XK_F6; break;
case SCR_KEY_FUNCTION + 6: keysym = XK_F7; break;
case SCR_KEY_FUNCTION + 7: keysym = XK_F8; break;
case SCR_KEY_FUNCTION + 8: keysym = XK_F9; break;
case SCR_KEY_FUNCTION + 9: keysym = XK_F10; break;
case SCR_KEY_FUNCTION + 10: keysym = XK_F11; break;
case SCR_KEY_FUNCTION + 11: keysym = XK_F12; break;
case SCR_KEY_FUNCTION + 12: keysym = XK_F13; break;
case SCR_KEY_FUNCTION + 13: keysym = XK_F14; break;
case SCR_KEY_FUNCTION + 14: keysym = XK_F15; break;
case SCR_KEY_FUNCTION + 15: keysym = XK_F16; break;
case SCR_KEY_FUNCTION + 16: keysym = XK_F17; break;
case SCR_KEY_FUNCTION + 17: keysym = XK_F18; break;
case SCR_KEY_FUNCTION + 18: keysym = XK_F19; break;
case SCR_KEY_FUNCTION + 19: keysym = XK_F20; break;
case SCR_KEY_FUNCTION + 20: keysym = XK_F21; break;
case SCR_KEY_FUNCTION + 21: keysym = XK_F22; break;
case SCR_KEY_FUNCTION + 22: keysym = XK_F23; break;
case SCR_KEY_FUNCTION + 23: keysym = XK_F24; break;
case SCR_KEY_FUNCTION + 24: keysym = XK_F25; break;
case SCR_KEY_FUNCTION + 25: keysym = XK_F26; break;
case SCR_KEY_FUNCTION + 26: keysym = XK_F27; break;
case SCR_KEY_FUNCTION + 27: keysym = XK_F28; break;
case SCR_KEY_FUNCTION + 28: keysym = XK_F29; break;
case SCR_KEY_FUNCTION + 29: keysym = XK_F30; break;
case SCR_KEY_FUNCTION + 30: keysym = XK_F31; break;
case SCR_KEY_FUNCTION + 31: keysym = XK_F32; break;
case SCR_KEY_FUNCTION + 32: keysym = XK_F33; break;
case SCR_KEY_FUNCTION + 33: keysym = XK_F34; break;
case SCR_KEY_FUNCTION + 34: keysym = XK_F35; break;
default: logMessage(LOG_WARNING, "key not insertable: %04X", key); return 0;
}
} else {
wchar_t wc;
if (key & SCR_KEY_ALT_LEFT) {
key &= ~SCR_KEY_ALT_LEFT;
modMeta = 1;
}
if (key & SCR_KEY_CONTROL) {
key &= ~SCR_KEY_CONTROL;
modControl = 1;
}
wc = key & SCR_KEY_CHAR_MASK;
if (wc < 0x100)
keysym = wc; /* latin1 character */
else
keysym = 0x1000000 | wc;
}
logMessage(LOG_DEBUG, "inserting key: %04X -> %s%s%ld",
key,
(modMeta? "meta ": ""),
(modControl? "control ": ""),
keysym);
{
int ok = 0;
if (!modMeta || SPI_generateKeyboardEvent(XK_Meta_L,NULL,SPI_KEY_PRESS)) {
if (!modControl || SPI_generateKeyboardEvent(XK_Control_L,NULL,SPI_KEY_PRESS)) {
if (SPI_generateKeyboardEvent(keysym,NULL,SPI_KEY_SYM)) {
ok = 1;
} else {
logMessage(LOG_WARNING, "key insertion failed.");
}
if (modControl && !SPI_generateKeyboardEvent(XK_Control_L,NULL,SPI_KEY_RELEASE)) {
logMessage(LOG_WARNING, "control release failed.");
ok = 0;
}
} else {
logMessage(LOG_WARNING, "control press failed.");
}
if (modMeta && !SPI_generateKeyboardEvent(XK_Meta_L,NULL,SPI_KEY_RELEASE)) {
logMessage(LOG_WARNING, "meta release failed.");
ok = 0;
}
} else {
logMessage(LOG_WARNING, "meta press failed.");
}
return ok;
}
}
void AnnotationDialog::CompletableLineEdit::keyPressEvent( QKeyEvent* ev )
{
if ( ev->key() == Qt::Key_Down || ev->key() == Qt::Key_Up ) {
selectPrevNextMatch( ev->key() == Qt::Key_Down );
return;
}
if ( m_mode == SearchMode && ( ev->key() == Qt::Key_Return || ev->key() == Qt::Key_Enter) ) { //Confirm autocomplete, deselect all text
handleSpecialKeysInSearch( ev );
m_listSelect->showOnlyItemsMatching( QString() ); // Show all again after confirming autocomplete suggestion.
return;
}
if ( m_mode != SearchMode && isSpecialKey( ev ) )
return; // Don't insert the special character.
if ( ev->key() == Qt::Key_Space && ev->modifiers() & Qt::ControlModifier ) {
mergePreviousImageSelection();
return;
}
QString prevContent = text();
if ( ev->text().isEmpty() || !ev->text()[0].isPrint() ) {
// If final Return is handled by the default implementation,
// it can "leak" to other widgets. So we swallow it here:
if ( ev->key() == Qt::Key_Return || ev->key() == Qt::Key_Enter )
emit KLineEdit::returnPressed( text() );
else
KLineEdit::keyPressEvent( ev );
if ( prevContent != text() )
m_listSelect->showOnlyItemsMatching( text() );
return;
}
// &,|, or ! should result in the current item being inserted
if ( m_mode == SearchMode && isSpecialKey( ev ) ) {
handleSpecialKeysInSearch( ev );
m_listSelect->showOnlyItemsMatching( QString() ); // Show all again after a special caracter.
return;
}
int cursorPos = cursorPosition();
int selStart = selectionStart();
KLineEdit::keyPressEvent( ev );
// Find the text of the current item
int itemStart = 0;
QString input = text();
if ( m_mode == SearchMode ) {
input = input.left( cursorPosition() );
itemStart = input.lastIndexOf(QRegExp(QString::fromLatin1("[!&|]"))) + 1;
if (itemStart > 0) {
itemStart++;
}
input = input.mid( itemStart );
}
// Find the text in the listView
QTreeWidgetItem* item = findItemInListView( input );
if ( !item && m_mode == SearchMode ) {
// revert
setText( prevContent );
setCursorPosition( cursorPos );
item = findItemInListView( input );
if(selStart>=0)
setSelection( selStart, prevContent.length() ); // Reset previous selection.
}
if ( item ) {
selectItemAndUpdateLineEdit( item, itemStart, input );
m_listSelect->showOnlyItemsMatching( input );
}
else if (m_mode != SearchMode )
m_listSelect->showOnlyItemsMatching( input );
}
int main(int argc, char * argv[])
{
int ch, opt;
int errflag;
char *optargTrainingSet=NULL, optargSep=',';
std::vector<char> trainingSet;
while ((opt = getopt(argc, argv, ":hc:s:")) != -1)
{
switch (opt)
{
case 'h':
errflag++;
break;
case 'c':
optargTrainingSet = optarg;
break;
case 's':
sscanf(optarg, "%c", &optargSep);
break;
case ':':
std::cerr << "option -" << optopt << "requires an operand" << std::endl;
errflag++;
break;
case '?':
std::cerr << "unrecognized option:-" << optopt << std::endl;
errflag++;
break;
}
}
if (errflag || (optargTrainingSet == NULL))
{
printCLHelp(argv[0]);
return EXIT_FAILURE;
}
if (splitStringToChar(optargTrainingSet, trainingSet, optargSep) != 0)
{
return EXIT_FAILURE;
}
// Initialize app
initTT();
//char a[] = {'a', 's', 'd', 'f', ' '};
charsRefer = generateString(trainingSet.data(), (int)trainingSet.size(), buffersize);
charsTyped.resize(buffersize);
charsTyped.clear();
setupScreen();
updateReferLine(charsRefer);
updateActionLine(charsTyped, charsRefer);
updateInfoLine();
updateCursorPosition(charsTyped);
ch = getch();
while (ch != ASCII_CTRL_C)
{
if (!isPrintableKey(ch) && !isSpecialKey(ch))
{
ch = getch();
continue;
}
switch (ch)
{
case ASCII_BACKSPACE:
case ASCII_DELETE:
std::cout << (char) ASCII_CTRL_G; // sound the bell
refresh();
break;
case ASCII_CTRL_R:
resetStatistics();
case ASCII_NEWLINE:
case ASCII_CRETURN:
if (isEOL(charsTyped) || (ch == ASCII_CTRL_R))
{
charsRefer = generateString(trainingSet.data(), (int)trainingSet.size(), buffersize);
updateReferLine(charsRefer);
clearActionLine();
clearBuffer(charsTyped);
}
break;
default:
if (addChar(charsTyped, ch))
{
updateActionLine(charsTyped, charsRefer);
}
updateInfoLine();
updateCursorPosition(charsTyped);
}
ch = getch();
}
refresh();
endwin();
/*
std::cout << "buffersize= " << buffersize << std::endl;
std::cout << "reference = " << charsRefer.size() << std::endl;
std::cout << "capacity = " << charsTyped.capacity() << std::endl;
std::cout << "typed_in = " << charsTyped.size() << std::endl;
*/
printf("Goodbye!\n");
return 0;
}
static int
insertMapped (ScreenKey key) {
char buffer[2];
char *sequence;
char *end;
if (isSpecialKey(key)) {
switch (key & SCR_KEY_CHAR_MASK) {
case SCR_KEY_ENTER:
sequence = "\r";
break;
case SCR_KEY_TAB:
sequence = "\t";
break;
case SCR_KEY_BACKSPACE:
sequence = "\x08";
break;
case SCR_KEY_ESCAPE:
sequence = "\x1b";
break;
case SCR_KEY_CURSOR_LEFT:
return(simulateKey(105, 0));
case SCR_KEY_CURSOR_RIGHT:
return(simulateKey(106, 0));
case SCR_KEY_CURSOR_UP:
return(simulateKey(103, 0));
case SCR_KEY_CURSOR_DOWN:
return(simulateKey(108, 0));
case SCR_KEY_PAGE_UP:
return(simulateKey(104, 0));
case SCR_KEY_PAGE_DOWN:
return(simulateKey(109, 0));
case SCR_KEY_HOME:
return(simulateKey(102, 0));
case SCR_KEY_END:
return(simulateKey(107, 0));
case SCR_KEY_INSERT:
return(simulateKey(110, 0));
case SCR_KEY_DELETE:
return(simulateKey(111, 0));
case SCR_KEY_FUNCTION + 0:
case SCR_KEY_FUNCTION + 1:
case SCR_KEY_FUNCTION + 2:
case SCR_KEY_FUNCTION + 3:
case SCR_KEY_FUNCTION + 4:
case SCR_KEY_FUNCTION + 5:
case SCR_KEY_FUNCTION + 6:
case SCR_KEY_FUNCTION + 7:
case SCR_KEY_FUNCTION + 8:
case SCR_KEY_FUNCTION + 9:
case SCR_KEY_FUNCTION + 10:
return(simulateKey(key - SCR_KEY_FUNCTION + 59, 0));
case SCR_KEY_FUNCTION + 11:
return(simulateKey(87, 0));
case SCR_KEY_FUNCTION + 12:
return(simulateKey(88, 0));
default:
logMessage(LOG_WARNING, "Key %4.4X not suported.", key);
return 0;
}
end = sequence + strlen(sequence);
} else {
int character = key & SCR_KEY_CHAR_MASK;
int c = convertWcharToChar(character);
if (c== EOF) {
logMessage(LOG_WARNING, "Character %d not supported", character);
return 0;
}
sequence = end = buffer + ARRAY_COUNT(buffer);
*--sequence = key & SCR_KEY_CHAR_MASK;
if (key & SCR_KEY_ALT_LEFT)
*--sequence = 0X1B;
}
while (sequence != end)
if (simulateKey(0, *sequence++))
return 0;
return 1;
}
void keyboard_handler ( registers_t *regs ) {
u8int scancode = inb ( 0x60 );
u8int specialKey = 0;
specialKey = isSpecialKey ( scancode );
currentKey = 0;
if ( scancode & 0x80 ) {
scancode = scancode - 0x80;
if ( scancode == 42 || scancode - 0x80 == 54 ) {
shift_flag = 0;
}
} else {
if ( scancode == 42 || scancode - 0x80 == 54 ) {
shift_flag = 1;
}
if ( scancode == 0x3A ) {
CapsOn = !CapsOn;
i8042_Caps(CapsOn, 0, 0);
}
if ( shift_flag == 0 && CapsOn == 0 ) {
//monitor_put ( lowerCaseKbdus[scancode] );
setKey ( lowerCaseKbdus[scancode] ); //set Current Key for key logger.
}
if ( shift_flag == 1 || CapsOn == 1 ) {
//monitor_put ( upperCaseKbdus[scancode] );
setKey ( upperCaseKbdus[scancode] ); //set Current Key for key logger.
}
//monitor_put(currentKey); //standard print keys to screen
if ( specialKey != 0 ) {
switch ( specialKey ) {
case 1:
monitor_command ( "cursor", "left" );
break;
case 2:
monitor_command ( "cursor", "right" );
break;
case 3:
monitor_command ( "cursor", "up" );
break;
case 4:
monitor_command ( "cursor", "down" );
break;
case 5:
monitor_put ( '\r' );
setKey ( '\r' );
break;
default:
break;
}
}
}
//i8042_Caps(CapsOn, 0, 0);
}
