home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1997 March / VPR9703A.ISO / OLS / Winnt / HCAPS32 / HCAPS32.LZH / HCAPS32S.C < prev    next >
C/C++ Source or Header  |  1995-07-06  |  12KB  |  401 lines
  1. #include <windows.h>
  2. #include <ime.h>
  3. #include <winnls.h>
  4. #include <winnls32.h>
  5. #include "hcaps32.h"
  6. #include "hcaps32s.h"
  7.  
  8. static UINT    afConfig;
  9. static UINT    timeDelay;
  10. static UINT    timeInterval;
  11. static HWND    hwndClient;
  12. static HWND    hwndKeyRepeat;
  13.  
  14. static BYTE    ab[256];
  15.  
  16. #ifndef VK_KANA
  17. #define VK_KANA        0x15
  18. #define VK_KANJI    0x19
  19. #endif
  20.  
  21. static HHOOK    hhook;
  22. static WPARAM wParamRepeat;
  23. static LPARAM lParamRepeat;
  24. static BOOL    fRepeating;
  25. static HINSTANCE    hInstDLL;
  26. static DWORD    idThread;
  27. static HANDLE    hThread;
  28. static UINT        idTimer;
  29. static UINT        idTimerKeyUp;
  30.  
  31. void SetConfig( UINT afConfigNew, UINT timeDelayNew, UINT timeIntervalNew ) {
  32.     afConfig = afConfigNew;
  33.     timeDelay = timeDelayNew;
  34.     timeInterval = timeIntervalNew;
  35.     if( timeInterval < 5 ) timeInterval = 5;
  36.     if( hhook != NULL ) {
  37.         ReleaseHook();
  38.         SetHook( hwndClient );
  39.     }
  40. }
  41.  
  42. BOOL WINAPI DllMain( HINSTANCE hInstDLLIn, DWORD fdwReason, LPVOID lpvReserved ) {
  43.     hInstDLL = hInstDLLIn;
  44.     return TRUE;
  45. }
  46.  
  47. static HWND GetFocus2( void ) {
  48.     HWND    hwnd = GetFocus();
  49.     if( hwnd == NULL ) hwnd = GetDesktopWindow();
  50.     return hwnd;
  51. }
  52.  
  53. static void near ImeConnectToKana( BYTE bKana ) {
  54.     if( WINNLSGetEnableStatus( NULL ) ) {
  55.         BOOL    fOpen;
  56.         IMESTRUCT FAR*    pime;
  57.         HANDLE    hmem;
  58.         WORD    mode;
  59.         HWND    hwndFocus = GetFocus2();
  60.         hmem = GlobalAlloc( GMEM_SHARE | GMEM_MOVEABLE, sizeof(IMESTRUCT) );
  61.         pime = (IMESTRUCT FAR*)GlobalLock( hmem );
  62.         pime->fnc = IME_GETOPEN;
  63.         fOpen = (BOOL)SendIMEMessageEx( hwndFocus, (LPARAM)hmem );
  64.         if( fOpen ) {
  65.             pime->fnc = IME_GETCONVERSIONMODE;
  66.             mode = (WORD)SendIMEMessageEx( hwndFocus, (LPARAM)hmem );
  67.             if( (mode & IME_MODE_ALPHANUMERIC) != 0 && (bKana & 0x80) != 0 ) {
  68.                 pime->fnc = IME_SETCONVERSIONMODE;
  69.                 pime->wParam = IME_MODE_HIRAGANA;
  70.                 SendIMEMessageEx( hwndFocus, (LPARAM)hmem );
  71.             } else if( (mode & (IME_MODE_HIRAGANA | IME_MODE_KATAKANA)) != 0 && (bKana & 0x80) == 0 ) {
  72.                 pime->fnc = IME_SETCONVERSIONMODE;
  73.                 pime->wParam = IME_MODE_ALPHANUMERIC;
  74.                 SendIMEMessageEx( hwndFocus, (LPARAM)hmem );
  75.             }
  76.         }
  77.         GlobalUnlock( hmem );
  78.         GlobalFree( hmem );
  79.     }
  80. }
  81.  
  82.  
  83. static BYTE    bKana;
  84.  
  85. static void near SwitchKanaMode( HWND hwndFocus, int action ) {
  86.     // action == 0 ... 切り替え
  87.     // action == 1 ... on
  88.     // action == 2 ... off
  89.     GetKeyboardState( (BYTE FAR*)ab );
  90.     bKana = ab[VK_KANA];
  91.     if( action == 2
  92.      || (action == 0 && (ab[VK_KANA] & 0x80)) ) {
  93.         if( (bKana & 0x80) == 0 ) {
  94.             return;
  95.         }
  96.         bKana &= 0x7F;
  97.     } else {
  98.         if( bKana == 0 ) {
  99.             bKana = 0x81;
  100.         } else if( bKana == 1 ) {
  101.             bKana = 0x80;
  102.         } else {
  103.             return;
  104.         }
  105.     }
  106.     ab[VK_KANA] = bKana;
  107.     SetKeyboardState( (BYTE FAR*)ab );
  108.     if( bKana & 0x80 ) {
  109.         PostMessage( hwndFocus, WM_KEYDOWN, VK_KANA, 0x80700001L );
  110.     } else {
  111.         PostMessage( hwndFocus, WM_KEYUP, VK_KANA, 0x00700001L );
  112.     }
  113. }
  114.  
  115. static void near KanaConnectToIme( void ) {
  116.     GetKeyboardState( (BYTE FAR*)ab );
  117.     if( WINNLSGetEnableStatus( NULL ) ) {
  118.         BOOL    fOpen;
  119.         IMESTRUCT FAR*    pime;
  120.         HANDLE    hmem;
  121.         WORD    mode;
  122.         HWND    hwndFocus = GetFocus2();
  123.         hmem = GlobalAlloc( GMEM_SHARE | GMEM_MOVEABLE, sizeof(IMESTRUCT) );
  124.         pime = (IMESTRUCT FAR*)GlobalLock( hmem );
  125.         pime->fnc = IME_GETOPEN;
  126.         fOpen = (BOOL)SendIMEMessageEx( hwndFocus, (LPARAM)hmem );
  127.         if( fOpen ) {
  128.             pime->fnc = IME_GETCONVERSIONMODE;
  129.             mode = (WORD)SendIMEMessageEx( hwndFocus, (LPARAM)hmem );
  130.             if( (mode & IME_MODE_ALPHANUMERIC) != 0 && (ab[VK_KANA] & 0x80) != 0 ) {
  131.                 SwitchKanaMode( hwndFocus, 2 );
  132.             } else if( (mode & (IME_MODE_HIRAGANA | IME_MODE_KATAKANA)) != 0 && (ab[VK_KANA] & 0x80) == 0 ) {
  133.                 SwitchKanaMode( hwndFocus, 1 );
  134.             }
  135.         }
  136.         GlobalUnlock( hmem );
  137.         GlobalFree( hmem );
  138.     }
  139. }
  140.  
  141. static void near SwitchIME( void ) {
  142.     if( WINNLSGetEnableStatus( NULL ) ) {
  143.         BOOL    fOpen;
  144.         IMESTRUCT FAR*    pime;
  145.         HANDLE    hmem;
  146.         HWND    hwndFocus = GetFocus2();
  147.         hmem = GlobalAlloc( GMEM_SHARE | GMEM_MOVEABLE, sizeof(IMESTRUCT) );
  148.         pime = (IMESTRUCT FAR*)GlobalLock( hmem );
  149.         pime->fnc = IME_GETOPEN;
  150.         fOpen = (BOOL)SendIMEMessageEx( hwndFocus, (LPARAM)hmem );
  151.         if( fOpen ) {
  152.             if( pime->wCount != 0 ) {
  153.                 pime->fnc = IME_SENDVKEY;
  154.                 pime->wParam = VK_DBE_DETERMINESTRING;
  155.                 SendIMEMessageEx( hwndFocus, (LPARAM)hmem );
  156.             }
  157.         }
  158.         pime->fnc = IME_SETOPEN;
  159.         pime->wParam = !fOpen;
  160.         SendIMEMessageEx( hwndFocus, (LPARAM)hmem );
  161.         if( afConfig & FLAG_KANA_SWITCH ) {
  162.             SwitchKanaMode( hwndFocus, fOpen + 1 );
  163.         }
  164.         GlobalUnlock( hmem );
  165.         GlobalFree( hmem );
  166.     }
  167. }
  168.  
  169. static BOOL    fDelay;
  170.  
  171. void CALLBACK KeyUpTimerProc( HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime ) {
  172.     KillTimer( NULL, idTimerKeyUp );
  173.     idTimerKeyUp = 0;
  174.     PostMessage( hwndKeyRepeat, WM_KEYUP, wParamRepeat, 0xC0000001L );
  175. }
  176.  
  177.  
  178. void CALLBACK TimerProc( HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime ) {
  179.     if( fDelay ) {
  180.         fDelay = FALSE;
  181.         KillTimer( NULL, idTimer );
  182.         idTimer = SetTimer( NULL, 0, timeInterval, (TIMERPROC)TimerProc );
  183.     } else {
  184.         if( fRepeating ) {
  185.             if( IsWindow( hwndKeyRepeat )
  186.              && (GetKeyState( wParamRepeat ) & 0x8000) != 0 ) {
  187.                 PostMessage( hwndKeyRepeat, WM_KEYDOWN, wParamRepeat, lParamRepeat );
  188.             }
  189.         }
  190.     }
  191. }
  192.  
  193. LRESULT CALLBACK JournalRecordProc( int nCode, WPARAM wParam, LPARAM lParam ) {
  194.     IMESTRUCT FAR*    pime;
  195.     HANDLE    hmem;
  196.     HWND    hwndFocus;
  197.     static BYTE    bKanaPrev;
  198.     if( nCode == HC_ACTION ) {
  199.         if( ((EVENTMSG*)lParam)->message == WM_KEYDOWN ) {
  200.             UINT    param1 = ((EVENTMSG*)lParam)->paramL & 0xFF;
  201.             UINT    param2 = ((EVENTMSG*)lParam)->paramH;
  202.             if( (afConfig & FLAG_REPEAT_HOOK) != 0 ) {
  203.                 if( param1 >= 0x25 && param1 <= 0x28 ) {
  204.                     if( !fRepeating ) {
  205.                         hwndKeyRepeat = GetFocus();
  206.                         if( hwndKeyRepeat != NULL ) {
  207.                             fRepeating = TRUE;
  208.                             wParamRepeat = param1;
  209.                             lParamRepeat = 0x40000001L;
  210.                             fDelay = TRUE;
  211.                             idTimer = SetTimer( NULL, 0, timeDelay - timeInterval, (TIMERPROC)TimerProc );
  212. //                            hThread = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)KeyRepeatThread
  213. //                                        , NULL, 0, &idThread );
  214.                         }
  215.                     }
  216.                 } else {
  217.                     if( fRepeating ) {
  218.                         KillTimer( NULL, idTimer );
  219.                         if( idTimerKeyUp == 0 ) {
  220.                             idTimerKeyUp = SetTimer( NULL, 0, 100, (TIMERPROC)KeyUpTimerProc );
  221.                         }
  222. //                        TerminateThread( hThread, 0 );
  223.                         fRepeating = FALSE;
  224.                     }
  225.                 }
  226.             }
  227.             if( param1 == 0x11 && param2 == 0x8000 ) {
  228.                 // 右Ctrlキー
  229.                 if( (afConfig & FLAG_RIGHTCTRL_HOOK) != 0 ) {
  230.                     SwitchKanaMode( GetFocus2(), 0 );
  231.                 }
  232.             } else if( param1 == 0xF1 || param1 == 0xF2 ) {
  233.                 // ひらがな／カタカナキー
  234.                 if( (afConfig & FLAG_HIRAGANA_HOOK) != 0 ) {
  235.                     SwitchIME();
  236.                 }
  237.             } else if( param1 == 0xF3 || param1 == 0xF4 ) {
  238.                 // 半角／全角
  239.                 if( (afConfig & FLAG_HANKAKU_HOOK) != 0 ) {
  240.                     if( (GetKeyState( VK_CONTROL ) & 0x8000) != 0 ) {
  241.                         PostMessage( GetActiveWindow(), WM_SYSCOMMAND, SC_TASKLIST, 0L );
  242.                     } else {
  243.                         hwndFocus = GetFocus2();
  244.                         hmem = GlobalAlloc( GMEM_SHARE | GMEM_MOVEABLE, sizeof(IMESTRUCT) );
  245.                         pime = (IMESTRUCT FAR*)GlobalLock( hmem );
  246.                         pime->fnc = IME_GETOPEN;
  247.                         if( SendIMEMessageEx( hwndFocus, (LPARAM)hmem ) == 0
  248.                          || pime->wCount == 0 ) {
  249.                             PostMessage( hwndFocus, WM_KEYDOWN, VK_ESCAPE, 0x00010001L );
  250.                             PostMessage( hwndFocus, WM_KEYUP, VK_ESCAPE, 0x80010001L );
  251.                         } else {
  252.                             pime->fnc = IME_SENDVKEY;
  253.                             pime->wParam = VK_DBE_FLUSHSTRING;
  254.                             SendIMEMessageEx( hwndFocus, (LPARAM)hmem );
  255.                         }
  256.                         GlobalUnlock( hmem );
  257.                         GlobalFree( hmem );
  258.                     }
  259.                 }
  260.             } else if( param1 == 0x1C ) {
  261.                 if( (afConfig & FLAG_HENKAN_HOOK) != 0 ) {
  262.                     BOOL    fOpen;
  263.                     hwndFocus = GetFocus2();
  264.                     if( GetKeyState( VK_MENU ) & 0x8000 ) {
  265.                         PostMessage( hwndFocus, WM_SYSCHAR, ' ', 0x20390001L );
  266.                     } else {
  267.                         WORD    wCount;
  268.                         hmem = GlobalAlloc( GMEM_SHARE | GMEM_MOVEABLE, sizeof(IMESTRUCT) );
  269.                         pime = (IMESTRUCT FAR*)GlobalLock( hmem );
  270.                         pime->fnc = IME_GETOPEN;
  271.                         fOpen = (BOOL)SendIMEMessageEx( hwndFocus, (LPARAM)hmem );
  272.                         wCount = pime->wCount;
  273.                         GlobalUnlock( hmem );
  274.                         GlobalFree( hmem );
  275.                         if( fOpen ) {
  276.                             IMEPRO    imepro;
  277.                             if( wCount != 0 ) {
  278.                                 return CallNextHookEx( hhook, nCode, wParam, lParam);
  279.                             }
  280.                             IMPGetIME( NULL, &imepro );
  281.                             SendMessage( imepro.hWnd, WM_CHAR, ' ', 1L );
  282.                         } else {
  283.                             PostMessage( hwndFocus, WM_KEYDOWN, VK_SPACE, 0x00390001L );
  284.                             PostMessage( hwndFocus, WM_KEYUP, VK_SPACE, 0x80390001L );
  285.                         }
  286.                     }
  287.                 }
  288.             } else if( param1 == 0x1D ) {
  289.                 // 無変換キー
  290.                 if( (afConfig & FLAG_MUHENKAN_HOOK) != 0 ) {
  291.                     SwitchKanaMode( GetFocus2(), 0 );
  292.                 }
  293.             } else if( param1 == 0xF0 ) {
  294.                 // 英数キー
  295.                 if( (afConfig & FLAG_EISUU_KANAOFF) != 0 ) {
  296.                     SwitchKanaMode( GetFocus2(), 2 );
  297.                 }
  298.                 if( (afConfig & FLAG_EISUU_HOOK) != 0 ) {
  299.                     hwndFocus = GetFocus2();
  300.                     GetKeyboardState( ab );
  301.                     ab[ VK_CAPITAL ] ^= 1;
  302.                     SetKeyboardState( ab );
  303.                     if( hwndFocus != NULL ) {
  304.                         PostMessage( hwndFocus, WM_KEYDOWN, VK_CAPITAL, 0x803A0001L );
  305.                         PostMessage( hwndFocus, WM_KEYUP, VK_CAPITAL, 0x003A0001L );
  306.                     }
  307.                 }
  308.             }
  309.         } else if( ((EVENTMSG*)lParam)->message == WM_KEYUP
  310.                 && (afConfig & FLAG_REPEAT_HOOK) != 0 ) {
  311.             if( fRepeating ) {
  312.                 KillTimer( NULL, idTimer );
  313.                 if( idTimerKeyUp == 0 ) {
  314.                     idTimerKeyUp = SetTimer( NULL, 0, 100, (TIMERPROC)KeyUpTimerProc );
  315.                 }
  316. //                TerminateThread( hThread, 0 );
  317.                 fRepeating = FALSE;
  318.             }
  319.         }
  320.     }
  321.     return CallNextHookEx( hhook, nCode, wParam, lParam);
  322. }
  323.  
  324.  
  325. LRESULT GetMsgProc( int nCode, WPARAM param1, LPARAM param2 ) {
  326.     HWND    hwndFocus;
  327.     static BYTE    bKanaPrev;
  328.     if( nCode == HC_ACTION ) {
  329.         WPARAM    wParam = ((MSG*)param2)->wParam;
  330.         LPARAM    lParam = ((MSG*)param2)->lParam;
  331.         if( ((MSG*)param2)->message == WM_KEYDOWN
  332.          || ((MSG*)param2)->message == WM_SYSKEYDOWN ) {
  333.             if( (afConfig & FLAG_REPEAT_HOOK) != 0 ) {
  334.                 if( wParam >= 0x25 && wParam <= 0x28 ) {
  335.                     if( !fRepeating ) {
  336.                         hwndKeyRepeat = GetFocus();
  337.                         if( hwndKeyRepeat != NULL ) {
  338.                             fRepeating = TRUE;
  339.                             wParamRepeat = wParam;
  340.                             lParamRepeat = 0x40000001L;
  341.                             fDelay = TRUE;
  342.                             idTimer = SetTimer( NULL, 0, timeDelay - timeInterval, (TIMERPROC)TimerProc );
  343.                         }
  344.                     }
  345.                 } else {
  346.                     if( fRepeating ) {
  347.                         KillTimer( NULL, idTimer );
  348.                         if( idTimerKeyUp == 0 ) {
  349.                             idTimerKeyUp = SetTimer( NULL, 0, 100, (TIMERPROC)KeyUpTimerProc );
  350.                         }
  351.                         fRepeating = FALSE;
  352.                     }
  353.                 }
  354.             }
  355.             if( wParam == 0xF0 ) {
  356.                 // 英数キー
  357.                 if( (afConfig & FLAG_EISUU_KANAOFF) != 0 ) {
  358.                     SwitchKanaMode( GetFocus2(), 2 );
  359.                 }
  360.                 if( (afConfig & FLAG_EISUU_HOOK) != 0 ) {
  361.                     hwndFocus = GetFocus2();
  362.                     GetKeyboardState( ab );
  363.                     ab[ VK_CAPITAL ] ^= 1;
  364.                     SetKeyboardState( ab );
  365.                     if( hwndFocus != NULL ) {
  366.                         PostMessage( hwndFocus, WM_KEYDOWN, VK_CAPITAL, 0x803A0001L );
  367.                         PostMessage( hwndFocus, WM_KEYUP, VK_CAPITAL, 0x003A0001L );
  368.                     }
  369.                 }
  370.             }
  371.         } else if( ( ((MSG*)param2)->message == WM_KEYUP || ((MSG*)param2)->message == WM_SYSKEYUP)
  372.                 && (afConfig & FLAG_REPEAT_HOOK) != 0 ) {
  373.             if( fRepeating ) {
  374.                 KillTimer( NULL, idTimer );
  375.                 if( idTimerKeyUp == 0 ) {
  376.                     idTimerKeyUp = SetTimer( NULL, 0, 100, (TIMERPROC)KeyUpTimerProc );
  377.                 }
  378.                 fRepeating = FALSE;
  379.             }
  380.         }
  381.     }
  382.     return CallNextHookEx( hhook, nCode, param1, param2 );
  383. }
  384.  
  385.  
  386. void SetHook( HWND hwnd ) {
  387.     hwndClient = hwnd;
  388.     GetKeyboardState( (BYTE FAR*)ab );
  389.     bKana = ab[VK_KANA];
  390.     if( afConfig & FLAG_JOURNAL_HOOK ) {
  391.         hhook = SetWindowsHookEx( WH_JOURNALRECORD, (HOOKPROC)JournalRecordProc, hInstDLL, 0L );
  392.     } else {
  393.         hhook = SetWindowsHookEx( WH_GETMESSAGE, (HOOKPROC)GetMsgProc, hInstDLL, 0L );
  394.     }
  395. }
  396.  
  397. void ReleaseHook( void ) {
  398.     UnhookWindowsHookEx( hhook );
  399. }
  400.  
  401.