Changeset 2769


Ignore:
Timestamp:
Aug 20, 2006, 8:12:13 AM (19 years ago)
Author:
bird
Message:

messing about.

Location:
trunk/synergy/birdhacks
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/synergy/birdhacks/dumpchars.c

    r2767 r2769  
    1919#include <stdio.h>
    2020#include <string.h>
     21#include <ctype.h>
    2122
    2223
    … …  
    7071
    7172
     73/**
     74 * Get the name of a virtual key.
     75 * @returns the key name (readonly).
     76 * @param   ulVirtualKey    The virtual key.
     77 */
     78const char *GetVirtualKeyName(ULONG ulVirtualKey)
     79{
     80    switch (ulVirtualKey) {
     81#define CASE(vk) case vk: return #vk
     82        CASE(VK_BUTTON1);
     83        CASE(VK_BUTTON2);
     84        CASE(VK_BUTTON3);
     85        CASE(VK_BREAK);
     86        CASE(VK_BACKSPACE);
     87        CASE(VK_TAB);
     88        CASE(VK_BACKTAB);
     89        CASE(VK_NEWLINE);
     90        CASE(VK_SHIFT);
     91        CASE(VK_CTRL);
     92        CASE(VK_ALT);
     93        CASE(VK_ALTGRAF);
     94        CASE(VK_PAUSE);
     95        CASE(VK_CAPSLOCK);
     96        CASE(VK_ESC);
     97        CASE(VK_SPACE);
     98        CASE(VK_PAGEUP);
     99        CASE(VK_PAGEDOWN);
     100        CASE(VK_END);
     101        CASE(VK_HOME);
     102        CASE(VK_LEFT);
     103        CASE(VK_UP);
     104        CASE(VK_RIGHT);
     105        CASE(VK_DOWN);
     106        CASE(VK_PRINTSCRN);
     107        CASE(VK_INSERT);
     108        CASE(VK_DELETE);
     109        CASE(VK_SCRLLOCK);
     110        CASE(VK_NUMLOCK);
     111        CASE(VK_ENTER);
     112        CASE(VK_SYSRQ);
     113        CASE(VK_F1);
     114        CASE(VK_F2);
     115        CASE(VK_F3);
     116        CASE(VK_F4);
     117        CASE(VK_F5);
     118        CASE(VK_F6);
     119        CASE(VK_F7);
     120        CASE(VK_F8);
     121        CASE(VK_F9);
     122        CASE(VK_F10);
     123        CASE(VK_F11);
     124        CASE(VK_F12);
     125        CASE(VK_F13);
     126        CASE(VK_F14);
     127        CASE(VK_F15);
     128        CASE(VK_F16);
     129        CASE(VK_F17);
     130        CASE(VK_F18);
     131        CASE(VK_F19);
     132        CASE(VK_F20);
     133        CASE(VK_F21);
     134        CASE(VK_F22);
     135        CASE(VK_F23);
     136        CASE(VK_F24);
     137        CASE(VK_ENDDRAG);
     138        CASE(VK_CLEAR);
     139        CASE(VK_EREOF);
     140        CASE(VK_PA1);
     141        CASE(VK_ATTN);
     142        CASE(VK_CRSEL);
     143        CASE(VK_EXSEL);
     144        CASE(VK_COPY);
     145        CASE(VK_BLK1);
     146        CASE(VK_BLK2);
     147#undef CASE
     148        default:
     149            return "";
     150    }
     151}
     152
     153char GetChar(unsigned ch)
     154{
     155    if (ch < 128 && isprint(ch)) {
     156        return ch;
     157    }
     158    return '.';
     159}
     160
    72161int main()
    73162{
    … …  
    97186            USHORT fVirtualKeyShiftState = fScanCodeShiftState;
    98187            USHORT fVirtualKeyRc = WinTranslateChar2(0, &usVirtualKey, &ulVirtualKeyDeadKeyInfo, TC_SCANCODETOVIRTUALKEY, &fVirtualKeyShiftState);
    99             printf("%d/%#x: %04x %lx %04x %04x | %04x %lx %04x %04x\n",
    100                    iChar, iChar,
     188            printf("%d/%#x/[%c]: %04x %lx %04x %04x | %04x %lx %04x %04x (%s)\n",
     189                   iChar, iChar, GetChar(iChar),
    101190                   usScanCode, ulScanCodeDeadKeyInfo, fScanCodeShiftState, fScanCodeRc,
    102                    usVirtualKey, ulVirtualKeyDeadKeyInfo, fVirtualKeyShiftState, fVirtualKeyRc);
    103         }
    104     }
    105 
    106     /*
    107      * scancode to char and virtual key.
    108      */
    109     printf("\n"
    110            "\n"
    111            "\n"
    112            "scancode -> char + virtual key \n");
    113     for (unsigned iScanCode = 0; iScanCode < 256; iScanCode++) {
    114         for (unsigned fShiftState = 0; fShiftState < (1 << TCF_MAX_BITS); fShiftState++) {
    115             /* to char */
    116             USHORT usChar = iScanCode;
    117             ULONG  ulCharDeadKeyInfo = 0;
    118             USHORT fCharShiftState = fShiftState;
    119             USHORT fCharRc = WinTranslateChar2(0, &usChar, &ulCharDeadKeyInfo, TC_SCANCODETOCHAR, &fCharShiftState);
    120 
    121             /* to virtual key */
    122             USHORT usVirtualKey = iScanCode;
    123             ULONG  ulVirtualKeyDeadKeyInfo = 0;
    124             USHORT fVirtualKeyShiftState = fShiftState;
    125             USHORT fVirtualKeyRc = WinTranslateChar2(0, &usVirtualKey, &ulVirtualKeyDeadKeyInfo, TC_SCANCODETOVIRTUALKEY, &fVirtualKeyShiftState);
    126             if (usChar && usVirtualKey) {
    127                 printf("%3d/%#04x+%02x: %04x %lx %04x %04x | %04x %lx %04x %04x\n",
    128                        iScanCode, iScanCode, fShiftState,
    129                        usChar, ulCharDeadKeyInfo, fCharShiftState, fCharRc,
    130                        usVirtualKey, ulVirtualKeyDeadKeyInfo, fVirtualKeyShiftState, fVirtualKeyRc);
    131             } else if (usChar) {
    132                 printf("%3d/%#04x+%02x: %04x %lx %04x %04x\n",
    133                        iScanCode, iScanCode, fShiftState,
    134                        usChar, ulCharDeadKeyInfo, fCharShiftState, fCharRc);
    135             } else if (usVirtualKey) {
    136                 printf("%3d/%#04x+%02x:                  | %04x %lx %04x %04x\n",
    137                        iScanCode, iScanCode, fShiftState,
    138                        usVirtualKey, ulVirtualKeyDeadKeyInfo, fVirtualKeyShiftState, fVirtualKeyRc);
    139             }
     191                   usVirtualKey, ulVirtualKeyDeadKeyInfo, fVirtualKeyShiftState, fVirtualKeyRc, GetVirtualKeyName(usVirtualKey));
    140192        }
    141193    }
    … …  
    147199           "\n"
    148200           "\n"
    149            "virtual key -> scancode + char\n");
     201           "virtual key -> scancode -> char\n");
    150202    for (unsigned iVirtualKey = 0; iVirtualKey < 512; iVirtualKey++) {
    151203        /* to scancode */
    … …  
    156208        if (usScanCode) {
    157209            /* to char */
    158             USHORT usChar = iVirtualKey;
     210            USHORT usChar = usScanCode;
    159211            ULONG  ulCharDeadKeyInfo = 0;
    160             USHORT fCharShiftState = 0;
     212            USHORT fCharShiftState = fScanCodeShiftState;
    161213            USHORT fCharRc = WinTranslateChar2(0, &usChar, &ulCharDeadKeyInfo, TC_SCANCODETOCHAR, &fCharShiftState);
    162214            if (usChar) {
    163                 printf("%3d/%#04x: %04x %lx %04x %04x | %04x %lx %04x %04x\n",
     215                printf("%3d/%#04x: %04x %lx %04x %04x | %04x[%c] %lx %04x %04x [%s]\n",
    164216                       iVirtualKey, iVirtualKey,
    165217                       usScanCode, ulScanCodeDeadKeyInfo, fScanCodeShiftState, fScanCodeRc,
    166                        usChar, ulCharDeadKeyInfo, fCharShiftState, fCharRc);
     218                       usChar, GetChar(usChar), ulCharDeadKeyInfo, fCharShiftState, fCharRc,
     219                       GetVirtualKeyName(iVirtualKey));
    167220            } else {
    168                 printf("%3d/%#04x: %04x %lx %04x %04x\n",
     221                printf("%3d/%#04x: %04x %lx %04x %04x [%s]\n",
    169222                       iVirtualKey, iVirtualKey,
    170                        usScanCode, ulScanCodeDeadKeyInfo, fScanCodeShiftState, fScanCodeRc);
     223                       usScanCode, ulScanCodeDeadKeyInfo, fScanCodeShiftState, fScanCodeRc,
     224                       GetVirtualKeyName(iVirtualKey));
    171225            }
    172226        }
    … …  
    176230           "\n"
    177231           "\n"
    178            "scan code -> oem scan code\n");
     232           "scan code -> oem scan code -> scan code\n");
    179233    for (unsigned iScanCode = 0; iScanCode < 256; iScanCode++) {
    180234        USHORT usOemScanCode = iScanCode;
    … …  
    183237        USHORT fOemScanCodeRc = WinTranslateChar2(0, &usOemScanCode, &ulOemScanCodeDeadKeyInfo, TC_SCANTOOEMSCAN, &fOemScanCodeShiftState);
    184238        if (usOemScanCode) {
    185             printf("%3d/%#04x: %04x %lx %04x %04x\n",
     239            printf("%3d/%#04x: %04x %lx %04x %04x",
    186240                   iScanCode, iScanCode,
    187241                   usOemScanCode, ulOemScanCodeDeadKeyInfo, fOemScanCodeShiftState, fOemScanCodeRc);
     242            /* the other way */
     243            fOemScanCodeRc = WinTranslateChar2(0, &usOemScanCode, &ulOemScanCodeDeadKeyInfo, TC_SCANTOOEMSCAN, &fOemScanCodeShiftState);
     244            printf(" -> %04x %lx %04x %04x%s\n",
     245                   usOemScanCode, ulOemScanCodeDeadKeyInfo, fOemScanCodeShiftState, fOemScanCodeRc,
     246                   usOemScanCode != iScanCode ? " *" :"");
    188247        }
    189248    }
    … …  
    193252       "\n"
    194253       "oem scan code -> scan code\n");
    195     for (unsigned iOemScanCode = 0; iOemScanCode < 256; iOemScanCode++) {
     254    for (unsigned iOemScanCode = 0; iOemScanCode < 128; iOemScanCode++) {
    196255        USHORT usScanCode = iOemScanCode;
    197256        ULONG  ulScanCodeDeadKeyInfo = 0;
    … …  
    205264    }
    206265
     266    printf("\n"
     267           "\n"
     268           "\n"
     269           "scan code -> extended oem scan code -> scan code\n");
     270    for (unsigned iScanCode = 0; iScanCode < 256; iScanCode++) {
     271        USHORT usOemScanCode = iScanCode;
     272        ULONG  ulOemScanCodeDeadKeyInfo = 0;
     273        USHORT fOemScanCodeShiftState = TCF_EXTENDEDKEY;
     274        USHORT fOemScanCodeRc = WinTranslateChar2(0, &usOemScanCode, &ulOemScanCodeDeadKeyInfo, TC_SCANTOOEMSCAN, &fOemScanCodeShiftState);
     275        if (usOemScanCode) {
     276            printf("%3d/%#04x: %04x %lx %04x %04x",
     277                   iScanCode, iScanCode,
     278                   usOemScanCode, ulOemScanCodeDeadKeyInfo, fOemScanCodeShiftState, fOemScanCodeRc);
     279            /* the other way */
     280            fOemScanCodeRc = WinTranslateChar2(0, &usOemScanCode, &ulOemScanCodeDeadKeyInfo, TC_SCANTOOEMSCAN, &fOemScanCodeShiftState);
     281            printf(" -> %04x %lx %04x %04x%s\n",
     282                   usOemScanCode, ulOemScanCodeDeadKeyInfo, fOemScanCodeShiftState, fOemScanCodeRc,
     283                   usOemScanCode != iScanCode ? " *" :"");
     284        }
     285    }
     286
     287    printf("\n"
     288       "\n"
     289       "\n"
     290       "extended oem scan code -> scan code\n");
     291    for (unsigned iOemScanCode = 0; iOemScanCode < 128; iOemScanCode++) {
     292        USHORT usScanCode = iOemScanCode;
     293        ULONG  ulScanCodeDeadKeyInfo = 0;
     294        USHORT fScanCodeShiftState = TCF_EXTENDEDKEY;
     295        USHORT fScanCodeRc = WinTranslateChar2(0, &usScanCode, &ulScanCodeDeadKeyInfo, TC_OEMSCANTOSCAN, &fScanCodeShiftState);
     296        if (usScanCode) {
     297            printf("%3d/%#04x: %04x %lx %04x %04x\n",
     298                   iOemScanCode, iOemScanCode,
     299                   usScanCode, ulScanCodeDeadKeyInfo, fScanCodeShiftState, fScanCodeRc);
     300        }
     301    }
     302
     303
     304    /*
     305     * scancode to char and virtual key.
     306     */
     307    printf("\n"
     308           "\n"
     309           "\n"
     310           "scancode -> char + virtual key \n");
     311    for (unsigned iScanCode = 0; iScanCode < 256; iScanCode++) {
     312        struct {
     313            USHORT usVirtualKey;
     314            USHORT usChar;
     315            USHORT fCharRc;
     316        } aCombinations[1 << TCF_MAX_BITS];
     317        for (unsigned fShiftState = 0; fShiftState < (1 << TCF_MAX_BITS); fShiftState++) {
     318            /* to char */
     319            USHORT usChar = iScanCode;
     320            ULONG  ulCharDeadKeyInfo = 0;
     321            USHORT fCharShiftState = fShiftState;
     322            USHORT fCharRc = WinTranslateChar2(0, &usChar, &ulCharDeadKeyInfo, TC_SCANCODETOCHAR, &fCharShiftState);
     323            aCombinations[fShiftState].usChar = usChar;
     324            aCombinations[fShiftState].fCharRc = fCharRc;
     325
     326            /* to virtual key */
     327            USHORT usVirtualKey = iScanCode;
     328            ULONG  ulVirtualKeyDeadKeyInfo = 0;
     329            USHORT fVirtualKeyShiftState = fShiftState;
     330            USHORT fVirtualKeyRc = WinTranslateChar2(0, &usVirtualKey, &ulVirtualKeyDeadKeyInfo, TC_SCANCODETOVIRTUALKEY, &fVirtualKeyShiftState);
     331            aCombinations[fShiftState].usVirtualKey = usVirtualKey;
     332
     333            /* display the result */
     334            printf(" %3d/%#04x+%02x[%c%c%c%c%c%c%c%c]: ",
     335                   iScanCode, iScanCode, fShiftState,
     336                   fShiftState & TCF_LSHIFT ? 'L' : '-',
     337                   fShiftState & TCF_RSHIFT ? 'R' : '-',
     338                   fShiftState & TCF_LCONTROL ? 'l' : '-',
     339                   fShiftState & TCF_RCONTROL ? 'r' : '-',
     340                   fShiftState & TCF_ALT ? 'A' : '-',
     341                   fShiftState & TCF_ALTGR ? 'G' : '-',
     342                   fShiftState & TCF_CAPSLOCK ? 'C' : '-',
     343                   fShiftState & TCF_NUMLOCK ? 'N' : '-');
     344            if (usChar && usVirtualKey) {
     345                printf("%04x[%c] %lx %04x %04x | %04x %lx %04x %04x (%s)\n",
     346                       usChar, GetChar(usChar), ulCharDeadKeyInfo, fCharShiftState, fCharRc,
     347                       usVirtualKey, ulVirtualKeyDeadKeyInfo, fVirtualKeyShiftState, fVirtualKeyRc, GetVirtualKeyName(usVirtualKey));
     348            } else if (usChar) {
     349                printf("%04x[%c] %lx %04x %04x\n",
     350                       usChar, GetChar(usChar), ulCharDeadKeyInfo, fCharShiftState, fCharRc);
     351            } else if (usVirtualKey) {
     352                printf("                 | %04x %lx %04x %04x (%s)\n",
     353                       usVirtualKey, ulVirtualKeyDeadKeyInfo, fVirtualKeyShiftState, fVirtualKeyRc, GetVirtualKeyName(usVirtualKey));
     354            } else {
     355                printf("\n");
     356            }
     357        }
     358#if 0
     359        /* 2. Eliminate duplicates. */
     360        for (unsigned j = 0; j < sizeof(aCombinations) / sizeof(aCombinations[0]); j++) {
     361            unsigned iBest = j;
     362            for (unsigned k = j + 1; k < sizeof(aCombinations) / sizeof(aCombinations[0]); k++) {
     363                if (    aCombinations[iBest].usChar       == aCombinations[k].usChar
     364                    &&  aCombinations[iBest].usVirtualKey == aCombinations[k].usVirtualKey) {
     365                    // check if one of these is a subset of the other.
     366                    if ((iBest & k) == k) {
     367                        aCombinations[iBest].usChar = aCombinations[iBest].usVirtualKey = 0;
     368                        iBest = k;
     369                    } else if (     (iBest & k) == iBest
     370                               /*||   iBest == k - when we can ignore L/R keys */) {
     371                        aCombinations[k].usChar = aCombinations[k].usVirtualKey = 0;
     372                    }
     373                }
     374            }
     375        }
     376
     377        // 3. Print the remainders.
     378        for (unsigned fShiftState = 0; fShiftState < sizeof(aCombinations) / sizeof(aCombinations[0]); fShiftState++) {
     379            if (aCombinations[fShiftState].usChar || aCombinations[fShiftState].usVirtualKey) {
     380                const USHORT usChar = aCombinations[fShiftState].usChar;
     381                const USHORT fCharRc = aCombinations[fShiftState].fCharRc;
     382                const USHORT usVirtualKey = aCombinations[fShiftState].usVirtualKey;
     383
     384                printf("*%3d/%#04x+%02x[%c%c%c%c%c%c%c%c]: ",
     385                       iScanCode, iScanCode, fShiftState,
     386                       fShiftState & TCF_LSHIFT ? 'L' : '-',
     387                       fShiftState & TCF_RSHIFT ? 'R' : '-',
     388                       fShiftState & TCF_LCONTROL ? 'l' : '-',
     389                       fShiftState & TCF_RCONTROL ? 'r' : '-',
     390                       fShiftState & TCF_ALT ? 'A' : '-',
     391                       fShiftState & TCF_ALTGR ? 'G' : '-',
     392                       fShiftState & TCF_CAPSLOCK ? 'C' : '-',
     393                       fShiftState & TCF_NUMLOCK ? 'N' : '-');
     394                if (usChar && usVirtualKey) {
     395                    printf("%04x[%c] %04x | %04x (%s)\n", usChar, GetChar(usChar), fCharRc, usVirtualKey, GetVirtualKeyName(usVirtualKey));
     396                } else if (usChar) {
     397                    printf("%04x[%c] %04x \n",       usChar, GetChar(usChar), fCharRc);
     398                } else if (usVirtualKey) {
     399                    printf("             | %04x (%s)\n", usVirtualKey, GetVirtualKeyName(usVirtualKey));
     400                } else {
     401                    printf("\n");
     402                }
     403            }
     404        }
     405#endif
     406    }
     407
    207408    return 0;
    208409}

  • trunk/synergy/birdhacks/getkey.c

    r2767 r2769  
    2121        int cch = read(0, &ch, 1);
    2222        printf("ch=%02x (%03d) cch=%d\n", ch, ch, cch);
     23        fflush(stdout);
    2324    }
    2425}

  • trunk/synergy/birdhacks/spy1.c

    r2766 r2769  
    190190    switch (pQmsg->msg) {
    191191        case WM_VIOCHAR:
     192#if 1
     193            if (SHORT1FROMMP(pQmsg->mp1) & KC_PREVDOWN) {
     194                break;
     195            }
     196#endif
     197            printf("%09ld: ", pQmsg->time);
    192198            printf("WM_VIOCHAR: fKC=%04x rep=%02x scan=%02x ",
    193199                   SHORT1FROMMP(pQmsg->mp1), CHAR3FROMMP(pQmsg->mp1), CHAR4FROMMP(pQmsg->mp1));
    194             printf("xlch=%02x(%c) xlscan=%02x fKDD=%04x ",
     200            printf("xlch=%02x(%c) xlscan=%02x fKDD=%04x",
    195201                   CHAR1FROMMP(pQmsg->mp2), isprint(CHAR1FROMMP(pQmsg->mp2)) ? CHAR1FROMMP(pQmsg->mp2) : '.',
    196202                   CHAR2FROMMP(pQmsg->mp2), SHORT2FROMMP(pQmsg->mp2));
    … …  
    201207
    202208        case WM_CHAR:
     209#if 1
     210            if (SHORT1FROMMP(pQmsg->mp1) & KC_PREVDOWN) {
     211                break;
     212            }
     213#endif
     214            printf("%09ld: ", pQmsg->time);
    203215            printf("   WM_CHAR: fKC=%04x rep=%02x scan=%02x ",
    204216                   SHORT1FROMMP(pQmsg->mp1), CHAR3FROMMP(pQmsg->mp1), CHAR4FROMMP(pQmsg->mp1));
    205             printf("ch=%04x(%c) vk=%04x(%s) ",
    206                    SHORT1FROMMP(pQmsg->mp2), isprint(SHORT1FROMMP(pQmsg->mp2)) ? SHORT1FROMMP(pQmsg->mp2) : '.',
    207                    SHORT2FROMMP(pQmsg->mp2), GetVirtualKeyName(SHORT2FROMMP(pQmsg->mp2)));
     217            printf("ch=%04x(%c)             vk=%04x",
     218                   SHORT1FROMMP(pQmsg->mp2), isprint(SHORT1FROMMP(pQmsg->mp2)) && (SHORT1FROMMP(pQmsg->mp1) & KC_CHAR) ? SHORT1FROMMP(pQmsg->mp2) : '.',
     219                   SHORT2FROMMP(pQmsg->mp2));
     220            if (SHORT1FROMMP(pQmsg->mp1) & KC_VIRTUALKEY) {
     221                printf("(%s)", GetVirtualKeyName(SHORT2FROMMP(pQmsg->mp2)));
     222            }
    208223            PrintKC(SHORT1FROMMP(pQmsg->mp1));
    209224            printf("\n");
    … …  
    219234void PrintEvent(PSPY1EVENT pEvent)
    220235{
     236#if 0
    221237    /* first line, raw data */
    222238    printf("p%04lx t%02lx", pEvent->pid, pEvent->tid);
    … …  
    231247        default:                        printf(" invalid msg (%d)\n", pEvent->enmType); return;
    232248    }
     249#endif
    233250    switch (pEvent->enmType) {
    234251        case SPY1EVENTTYPE_MSG_REMOVED:
     252#if 0
    235253        case SPY1EVENTTYPE_MSG_PEEK:
    236254            printf(" time=%08lx hwnd=%08lx msg=%04lx mp1=%08x mp2=%08x (%ld,%ld)\n",
    … …  
    242260                   pEvent->u.Msg.ptl.x,
    243261                   pEvent->u.Msg.ptl.y);
     262#endif
    244263            PrintMsg(&pEvent->u.Msg);
    245264            break;
Note: See TracChangeset for help on using the changeset viewer.