home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1996 November / VPR9611A.ISO / ols / win31 / hmize120 / hmize120.lzh / SOURCE.LZH / EDITHOOK.CPP < prev    next >
C/C++ Source or Header  |  1995-03-15  |  17KB  |  667 lines
  1. #include <windows.h>
  2. extern "C" {
  3. #include <ime.h>
  4. }
  5. #include <stdlib.h>
  6. #include <string.h>
  7. #include "global.h"
  8. #include "edithook.h"
  9. #include "editedit.h"
  10. #include "listhook.h"
  11. #include "..\hidemaru\menu.h"
  12.  
  13. BOOL    fSelecting;
  14. BOOL    fMenuFilterInstalled;
  15. static DWORD    dw;
  16.  
  17. void SendVKey( int vkey ) {
  18.     BYTE    bCtrl = abKeyState[ VK_CONTROL ];
  19.     abKeyState[ VK_CONTROL ] = 0;
  20.     SetKeyboardState( (BYTE FAR*)abKeyState );
  21.     SendMessage( hwndTarget, WM_KEYDOWN, vkey, 1L );
  22.     abKeyState[ VK_CONTROL ] = bCtrl;
  23.     SetKeyboardState( (BYTE FAR*)abKeyState );
  24. }
  25.  
  26. void SendChar( int ch ) {
  27.     BYTE    bCtrl = abKeyState[ VK_CONTROL ];
  28.     abKeyState[ VK_CONTROL ] = 0;
  29.     SetKeyboardState( (BYTE FAR*)abKeyState );
  30.     SendMessage( hwndTarget, WM_CHAR, ch, 1L );
  31.     abKeyState[ VK_CONTROL ] = bCtrl;
  32.     SetKeyboardState( (BYTE FAR*)abKeyState );
  33. }
  34.  
  35. void SendCtrlVKey( int vkey ) {
  36.     BYTE    bCtrl = abKeyState[ VK_CONTROL ];
  37.     abKeyState[ VK_CONTROL ] = 0x80;
  38.     SetKeyboardState( (BYTE FAR*)abKeyState );
  39.     SendMessage( hwndTarget, WM_KEYDOWN, vkey, 1L );
  40.     abKeyState[ VK_CONTROL ] = bCtrl;
  41.     SetKeyboardState( (BYTE FAR*)abKeyState );
  42. }
  43.  
  44. void SendCtrlShiftVKey( int vkey ) {
  45.     BYTE    bCtrl = abKeyState[ VK_CONTROL ];
  46.     BYTE    bShift = abKeyState[ VK_SHIFT ];
  47.     abKeyState[ VK_CONTROL ] = 0x80;
  48.     abKeyState[ VK_SHIFT ] = 0x80;
  49.     SetKeyboardState( (BYTE FAR*)abKeyState );
  50.     SendMessage( hwndTarget, WM_KEYDOWN, vkey, 1L );
  51.     abKeyState[ VK_CONTROL ] = bCtrl;
  52.     abKeyState[ VK_SHIFT ] = bShift;
  53.     SetKeyboardState( (BYTE FAR*)abKeyState );
  54. }
  55.  
  56. void SendShiftVKey( int vkey ) {
  57.     BYTE    bShift = abKeyState[ VK_SHIFT ];
  58.     BYTE    bCtrl = abKeyState[ VK_CONTROL ];
  59.     abKeyState[ VK_CONTROL ] = 0;
  60.     abKeyState[ VK_SHIFT ] = 0x80;
  61.     SetKeyboardState( (BYTE FAR*)abKeyState );
  62.     SendMessage( hwndTarget, WM_KEYDOWN, vkey, 1L );
  63.     abKeyState[ VK_SHIFT ] = bShift;
  64.     abKeyState[ VK_CONTROL ] = bCtrl;
  65.     SetKeyboardState( (BYTE FAR*)abKeyState );
  66. }
  67.  
  68. void SendSelectingVKey( int vkey ) {
  69.     if( fSelecting ) {
  70.         SendShiftVKey( vkey );
  71.     } else {
  72.         SendVKey( vkey );
  73.     }
  74. }
  75.  
  76. void SendSelectingCtrlVKey( int vkey ) {
  77.     BYTE    bCtrl = abKeyState[ VK_CONTROL ];
  78.     BYTE    bShift = abKeyState[ VK_SHIFT ];
  79.     abKeyState[ VK_CONTROL ] = 0x80;
  80.     if( fSelecting ) {
  81.         abKeyState[VK_SHIFT] = 0x80;
  82.     }
  83.     SetKeyboardState( (BYTE FAR*)abKeyState );
  84.     SendMessage( hwndTarget, WM_KEYDOWN, vkey, 1L );
  85.     abKeyState[ VK_CONTROL ] = bCtrl;
  86.     abKeyState[ VK_SHIFT ] = bShift;
  87.     SetKeyboardState( (BYTE FAR*)abKeyState );
  88. }
  89.  
  90. static void EndSelection( void ) {
  91.     fSelecting = FALSE;
  92.     dw = SendMessage( hwndTarget, EM_GETSEL, 0, 0L );
  93.     if( HIWORD(dw) != LOWORD(dw) ) {
  94.         SendMessage( hwndTarget, EM_SETSEL, TRUE, MAKELONG( LOWORD(dw), LOWORD(dw) ) );
  95.     }
  96. }
  97.  
  98. /************************************************************/
  99. static char szCollon[] = ":";
  100.  
  101. char* GetCommandString( int cmd ) {
  102.     static char    szResult[100];
  103.     LoadString( hInstance, cmd, szResult, sizeof(szResult) );
  104.     if( cmd >= CMD_MENU_1 && cmd <= CMD_MENU_8 ) {
  105.         if( pshare->key.aszMenuTitle[cmd - CMD_MENU_1][0] != '\0' ) {
  106.             lstrcat( szResult, szCollon );
  107.             lstrcat( szResult, pshare->key.aszMenuTitle[cmd - CMD_MENU_1] );
  108.         }
  109.     } else if( (cmd >= CMD_MACRO_1 && cmd <= CMD_MACRO_15)
  110.             || (cmd >= CMD_MACRO_16 && cmd <= CMD_MACRO_30) ) {
  111.         LPSTR    pszTitle;
  112.         if( cmd < CMD_MACRO_16 ) {
  113.             pszTitle = pshare->amacro[cmd - CMD_MACRO_1].szTitle;
  114.         } else {
  115.             pszTitle = pshare->amacro2[cmd - CMD_MACRO_16].szTitle;
  116.         }
  117.         if( pszTitle[0] != '\0' ) {
  118.             lstrcat( szResult, szCollon );
  119.             lstrcat( szResult, pszTitle );
  120.         }
  121.     }
  122.     return szResult;
  123. }
  124.  
  125. static KEYMENU FAR*    pKeyMenu;
  126. static int    cMenuItem;
  127.  
  128. static FARPROC    pfnOldHook;
  129. static DWORD    timeButtonDown;
  130.  
  131. extern "C" void FAR PASCAL _export MenuFilter( int nCode, WPARAM wParam, LPARAM lParam ) {
  132.     if( nCode >= 0 ) {
  133.         MSG FAR*    pmsg = (MSG FAR*)lParam;
  134.         if( pmsg->message == WM_RBUTTONUP ) {
  135.             if( GetCurrentTime() - timeButtonDown <= 350 ) {
  136.                 pmsg->message = WM_MOUSEMOVE;
  137.             }
  138.         } else if( pmsg->message == WM_CHAR ) {
  139.             if( pmsg->wParam <= 0x1A ) {
  140.                 pmsg->wParam += '@';
  141.             }
  142.         }
  143.     } else {
  144.         DefHookProc( nCode, wParam, lParam, &pfnOldHook );
  145.     }
  146. }
  147.  
  148. static BOOL    fRightButton;
  149.  
  150. static void near CheckMacroTitle( char* psz, int cmd ) {
  151.     if( cmd >= CMD_MACRO_1 && cmd <= CMD_MACRO_15 ) {
  152.         lstrcpy( psz + 3, pshare->amacro[cmd - CMD_MACRO_1].szTitle );
  153.     } else if( cmd >= CMD_MACRO_16 && cmd <= CMD_MACRO_30 ) {
  154.         lstrcpy( psz + 3, pshare->amacro2[cmd - CMD_MACRO_16].szTitle );
  155.     }
  156. }
  157.  
  158. static HMENU near CreatePopupSub( int cmd ) {
  159.     HMENU    hPopup = CreatePopupMenu();
  160.     KEYMENU FAR*    pKeyMenu = & pshare->key.amenu[ cmd - CMD_MENU_1 ];
  161.     int                cMenuItem = 0;
  162.     while( pKeyMenu->acmd[ cMenuItem ] != 0 ) {
  163.         cMenuItem ++;
  164.         if( cMenuItem >= KEYMENU_NUM ) {
  165.             break;
  166.         }
  167.     }
  168.     char    sz[50];
  169.     sz[0] = '&';
  170.     sz[2] = '\t';
  171.     for( int i = 0; i < cMenuItem; i++ ) {
  172.         if( pKeyMenu->avkey[i] == (BYTE)-1 ) {
  173.             AppendMenu( hPopup, MF_SEPARATOR, 0, NULL );
  174.         } else {
  175.             sz[1] = pKeyMenu->avkey[i];
  176.             strcpy( sz + 3, GetCommandString( pKeyMenu->acmd[i] ) );
  177.             if( pKeyMenu->acmd[i] >= CMD_MENU_1 && pKeyMenu->acmd[i] <= CMD_MENU_8 ) {
  178.                 if( pKeyMenu->acmd[i] != cmd ) {
  179.                     AppendMenu( hPopup, MF_POPUP
  180.                         , CreatePopupSub( pKeyMenu->acmd[i] )
  181.                         , sz + fRightButton * 3 );
  182.                 }
  183.             } else {
  184.                 CheckMacroTitle( sz, pKeyMenu->acmd[i] );
  185.                 AppendMenu( hPopup, MF_BYCOMMAND | MF_ENABLED | MF_STRING
  186.                     , pKeyMenu->acmd[i]
  187.                     , sz + fRightButton * 3 );
  188.             }
  189.         }
  190.     }
  191.     return hPopup;
  192. }
  193.  
  194. static WPARAM ConvertWParam( WPARAM wParam ) {
  195.     if( wParam <= 'Z' - '@' + 1 + 5 ) {
  196.         wParam += '@';
  197.     } else if( wParam >= 'a' && wParam <= 'z' ) {
  198.         wParam = wParam - 'a' + 'A';
  199.     }
  200.     return wParam;
  201. }
  202.  
  203. static void ProcessCommand( int cmd ) {
  204.     GetKeyboardState( (BYTE FAR*)abKeyState );
  205.     if( wndclass == CLASS_EDIT ) {
  206.         DebugOut( "EditCommand\x0d\x0a" );
  207.         ProcessEditCommand( cmd );
  208.     } else {
  209.         DebugOut( "ListBoxCommand\x0d\x0a" );
  210.         ProcessListBoxCommand( cmd );
  211.     }
  212. }
  213.  
  214. #ifndef VK_KANA
  215. #define VK_KANA    0x15
  216. #endif
  217.  
  218. void CommandKeyMenu( WORD cmd ) {
  219.     pKeyMenu = & pshare->key.amenu[ cmd - CMD_MENU_1 ];
  220.     cMenuItem = 0;
  221.     while( pKeyMenu->acmd[ cMenuItem ] != 0 ) {
  222.         cMenuItem ++;
  223.         if( cMenuItem >= KEYMENU_NUM ) {
  224.             break;
  225.         }
  226.     }
  227.     timeButtonDown = GetCurrentTime();
  228.     fRightButton = (GetKeyState( VK_RBUTTON ) & 0x8000) != 0;
  229.     BOOL    fClipbrdMenu;
  230.     if( wndclass == CLASS_EDIT ) {
  231.         dw = SendMessage( hwndTarget, EM_GETSEL, 0, 0L );
  232.         fClipbrdMenu = fRightButton && (HIWORD(dw) != LOWORD(dw));
  233.     } else {
  234.         fClipbrdMenu = FALSE;
  235.     }
  236.     if( cMenuItem == 0 && !fRightButton ) {
  237.         MessageBeep(0);
  238.         return;
  239.     }
  240.     {
  241.         MSG    msg;
  242.         PeekMessage( &msg, NULL, WM_CHAR, WM_CHAR, PM_REMOVE );
  243.     }
  244.     HMENU    hPopup = CreatePopupMenu();
  245.     int        cyMenu = GetSystemMetrics( SM_CYMENU );
  246.     int        cySeparator = cyMenu / 2 - 2;
  247.     int        cyPopup = cyMenu / 4;
  248.     int        cyMenuUp = 0;
  249.     int        i;
  250.     cyMenu += 1;
  251.     if( fClipbrdMenu ) {
  252.         BOOL    fLastSeparator = FALSE;
  253.         int        cMenu = 0;
  254.         for( i = 0; i < KEYMENU_NUM; i++ ) {
  255.             if( pshare->menuRightButton.acmd[i] == 0 ) {
  256.                 break;
  257.             }
  258.             if( pshare->menuRightButton.avkey[i] == (BYTE)-1 ) {
  259.                 fLastSeparator = TRUE;
  260.                 AppendMenu( hPopup, MF_SEPARATOR, 0, NULL );
  261.                 cyPopup += cySeparator;
  262.                 cMenu ++;
  263.             } else {
  264.                 int    cmd = pshare->menuRightButton.acmd[i];
  265.                 fLastSeparator = FALSE;
  266.                 AppendMenu( hPopup, MF_BYCOMMAND | MF_ENABLED | MF_STRING
  267.                     , cmd
  268.                     , GetCommandString( pshare->menuRightButton.acmd[i] ) );
  269.                 cyPopup += cyMenu;
  270.                 if( cmd == CMD_COPY ) {
  271.                     cyMenuUp = cyPopup - cyMenu;
  272.                 }
  273.                 cMenu ++;
  274.             }
  275.         }
  276.         if( fLastSeparator ) {
  277.             DeleteMenu( hPopup, cMenu - 1, MF_BYPOSITION );
  278.             cyPopup -= cySeparator;
  279.         }
  280.     } else {
  281.         char    sz[50];
  282.         if( pshare->key.fTitledMenu ) {
  283.             sz[0] = '\t';
  284.             if( pshare->key.aszMenuTitle[cmd - CMD_MENU_1][0] == '\0' ) {
  285.                 LoadString( hInstance, cmd, sz + 1, sizeof(sz) - 1 );
  286.             } else {
  287.                 lstrcpy( sz + 1, pshare->key.aszMenuTitle[cmd - CMD_MENU_1] );
  288.             }
  289.             AppendMenu( hPopup, MF_BYCOMMAND | MF_ENABLED | MF_STRING
  290.                 , 0, sz + fRightButton );
  291.             AppendMenu( hPopup, MF_SEPARATOR, 0, NULL );
  292.             cyPopup += cyMenu + cySeparator;
  293.         }
  294.         sz[0] = '&';
  295.         sz[2] = '\t';
  296.         for( int i = 0; i < cMenuItem; i++ ) {
  297.             if( pKeyMenu->avkey[i] == (BYTE)-1 ) {
  298.                 AppendMenu( hPopup, MF_SEPARATOR, 0, NULL );
  299.                 cyPopup += cySeparator;
  300.             } else {
  301.                 sz[1] = pKeyMenu->avkey[i];
  302.                 strcpy( sz + 3, GetCommandString( pKeyMenu->acmd[i] ) );
  303.                 if( pKeyMenu->acmd[i] >= CMD_MENU_1 && pKeyMenu->acmd[i] <= CMD_MENU_8 ) {
  304.                     AppendMenu( hPopup, MF_POPUP
  305.                         , CreatePopupSub( pKeyMenu->acmd[i] )
  306.                         , sz + fRightButton * 3 );
  307.                 } else {
  308.                     CheckMacroTitle( sz, pKeyMenu->acmd[i] );
  309.                     AppendMenu( hPopup, MF_BYCOMMAND | MF_ENABLED | MF_STRING
  310.                         , pKeyMenu->acmd[i]
  311.                         , sz + fRightButton * 3 );
  312.                 }
  313.                 cyPopup += cyMenu;
  314.             }
  315.         }
  316.     }
  317.     int    x,y;
  318.     BOOL    fDelay = FALSE;
  319.     if( fRightButton ) {
  320.         POINT    pt;
  321.         GetCursorPos( &pt );
  322.         x = pt.x;
  323.         y = pt.y;
  324.         y -= cyMenuUp;
  325.     } else {
  326.         RECT    rc;
  327.         GetWindowRect( hwndTarget, &rc );
  328.         x = rc.left;
  329.         y = rc.top;
  330.         if( GetKeyState( VK_CONTROL ) & 0x8000 ) fDelay = TRUE;
  331.     }
  332.     {
  333.         int    cyScreen = GetSystemMetrics( SM_CYSCREEN );
  334.         if( y + cyPopup > cyScreen ) {
  335.             y = cyScreen - cyPopup;
  336.         }
  337.     }
  338.     MSG    msg;
  339.     if( fDelay && pshare->key.adelay[ cmd - CMD_MENU_1 ] != 0 ) {
  340. //        ImeSaveMode();
  341.         DWORD    timeStart = GetCurrentTime();
  342.         while( GetCurrentTime() - timeStart < (WORD)pshare->key.adelay[ cmd - CMD_MENU_1 ] * 100 ) {
  343.             if( PeekMessage( &msg, NULL, NULL, NULL, PM_REMOVE ) ) {
  344.                 TranslateMessage( &msg );
  345.                 if( msg.message == WM_KEYUP
  346.                  || msg.message == WM_COMMAND ) {
  347.                     // nothing to do
  348.                 } else if( msg.message == WM_KEYDOWN
  349.                         || msg.message == WM_CHAR ) {
  350.                     if( msg.wParam == VK_ESCAPE ) {
  351.                         PeekMessage( &msg, NULL, WM_CHAR, WM_CHAR, PM_REMOVE );
  352.                         DestroyMenu( hPopup );
  353.                         return;
  354.                     }
  355.                     msg.wParam = ConvertWParam( msg.wParam );
  356.                     for( int i = 0; i < cMenuItem; i++ ) {
  357.                         if( pKeyMenu->avkey[i] == msg.wParam ) {
  358.                             PeekMessage( &msg, NULL, WM_CHAR, WM_CHAR, PM_REMOVE );
  359.                             ProcessCommand( pKeyMenu->acmd[i] );
  360.                             DestroyMenu( hPopup );
  361.                             return;
  362.                         }
  363.                     }
  364.                 } else {
  365.                     DispatchMessage( &msg );
  366.                 }
  367.             }
  368.         }
  369.     }
  370.     pfnOldHook = SetWindowsHook( WH_GETMESSAGE, (FARPROC)MenuFilter );
  371.     HWND    hwndMenuParent = CreateWindow( "Edit", "", WS_CHILD, 0, 0, 0, 0
  372.                         , hwndTarget, 1, hInstance, NULL );
  373.     if( hwndMenuParent == NULL ) {
  374.         DebugOut( "MenuParent creation failed.\x0d\x0a" );
  375.     }
  376.     TrackPopupMenu( hPopup, TPM_LEFTALIGN | (fRightButton ? TPM_RIGHTBUTTON : TPM_LEFTBUTTON), x, y, 0, hwndMenuParent, NULL );
  377.     UnhookWindowsHook( WH_GETMESSAGE, (FARPROC)MenuFilter );
  378.     DestroyMenu( hPopup );
  379.     if( PeekMessage( &msg, hwndMenuParent, WM_COMMAND, WM_COMMAND, PM_REMOVE ) ) {
  380.         ProcessCommand( msg.wParam );
  381.     } else {
  382.         DebugOut( "WM_COMMAND not found after TrackPopupMenu\x0d\x0a" );
  383.     }
  384.     DestroyWindow( hwndMenuParent );
  385. }
  386. /*********************/
  387.  
  388. static int    xInput;
  389.  
  390. BOOL ProcessEditCommand( int cmd ) {
  391.     switch( cmd ) {
  392.         case CMD_CURSOR_UP:
  393.         case CMD_FAST_UP:
  394.             SendSelectingVKey( VK_UP );
  395.             break;
  396.  
  397.         case CMD_CURSOR_DOWN:
  398.         case CMD_FAST_DOWN:
  399.             SendSelectingVKey( VK_DOWN );
  400.             break;
  401.  
  402.         case CMD_CURSOR_RIGHT:
  403.             SendSelectingVKey( VK_RIGHT );
  404.             break;
  405.  
  406.         case CMD_CURSOR_LEFT:
  407.             SendSelectingVKey( VK_LEFT );
  408.             break;
  409.  
  410.         case CMD_WORD_RIGHT:
  411.             SendSelectingCtrlVKey( VK_RIGHT );
  412.             break;
  413.  
  414.         case CMD_WORD_LEFT:
  415.             SendSelectingCtrlVKey( VK_LEFT );
  416.             break;
  417.  
  418.         case CMD_GO_LINE_TOP:
  419.         case CMD_GO_LINE_TOP2:
  420.             SendSelectingVKey( VK_HOME );
  421.             break;
  422.  
  423.         case CMD_GO_LINE_END:
  424.         case CMD_GO_LINE_END2:
  425.             SendSelectingVKey( VK_END );
  426.             break;
  427.  
  428.         case CMD_GO_FILE_TOP:
  429.             SendSelectingCtrlVKey( VK_HOME );
  430.             break;
  431.  
  432.         case CMD_GO_FILE_END:
  433.             SendSelectingCtrlVKey( VK_END );
  434.             break;
  435.  
  436.         case CMD_NEXT_PAGE:
  437.         case CMD_HALF_NEXT_PAGE:
  438.             SendSelectingVKey( VK_NEXT );
  439.             break;
  440.  
  441.         case CMD_PREV_PAGE:
  442.         case CMD_HALF_PREV_PAGE:
  443.             SendSelectingVKey( VK_PRIOR );
  444.             break;
  445.  
  446.         case CMD_BEGINSELECTION:
  447.             fSelecting = TRUE;
  448.             break;
  449.  
  450.         case CMD_COPY:
  451.             DebugOut( "CMD_COPY\x0d\x0a" );
  452.             SendMessage( hwndTarget, WM_COPY, 0, 0L );
  453.             EndSelection();
  454.             break;
  455.  
  456.         case CMD_PASTE:
  457.             SendMessage( hwndTarget, WM_PASTE, 0, 0L );
  458.             fSelecting = FALSE;
  459.             break;
  460.  
  461.         case CMD_CUT:
  462.             DebugOut( "CMD_CUT\x0d\x0a" );
  463.             SendMessage( hwndTarget, WM_CUT, 0, 0L );
  464.             fSelecting = FALSE;
  465.             break;
  466.  
  467.         case CMD_DELETE:
  468.             SendVKey( VK_DELETE );
  469.             fSelecting = FALSE;
  470.             break;
  471.  
  472.         case CMD_DELETE_WORD:
  473.             SendCtrlShiftVKey( VK_RIGHT );
  474.             SendVKey( VK_DELETE );
  475.             break;
  476.  
  477.         case CMD_DELETE_WORD_ALL:
  478.             SendCtrlVKey( VK_LEFT );
  479.             SendCtrlShiftVKey( VK_RIGHT );
  480.             SendVKey( VK_DELETE );
  481.             break;
  482.  
  483.         case CMD_DELETE_WORD_FRONT:
  484.             SendCtrlShiftVKey( VK_RIGHT );
  485.             SendVKey( VK_DELETE );
  486.             break;
  487.  
  488.         case CMD_DELETE_LINE:
  489.             SendVKey( VK_HOME );
  490.             SendShiftVKey( VK_DOWN );
  491.             SendVKey( VK_DELETE );
  492.             break;
  493.  
  494.         case CMD_DELETE_AFTER:
  495.             SendShiftVKey( VK_END );
  496.             SendVKey( VK_DELETE );
  497.             break;
  498.  
  499.         case CMD_DELETE_BEFORE:
  500.             SendShiftVKey( VK_HOME );
  501.             SendVKey( VK_DELETE );
  502.             break;
  503.  
  504.         case CMD_RETURN:
  505.             SendVKey( VK_RETURN );
  506.             break;
  507.  
  508.         case CMD_TAB:
  509.             SendVKey( VK_TAB );
  510.             break;
  511.  
  512.         case CMD_BACKSPACE:
  513.             SendChar( VK_BACK );
  514.             break;
  515.  
  516.         case CMD_UNDO:
  517.             SendMessage( hwndTarget, WM_UNDO, 0, 0L );
  518.             break;
  519.  
  520.         case CMD_TOUPPER:
  521.             ToUpper();
  522.             break;
  523.  
  524.         case CMD_TOLOWER:
  525.             ToLower();
  526.             break;
  527.  
  528.         case CMD_TOHANKAKU:
  529.             ToHankaku();
  530.             break;
  531.  
  532.         case CMD_TOZENKAKUHIRA:
  533.             ToZenkakuHira();
  534.             break;
  535.  
  536.         case CMD_TOZENKAKUKATA:
  537.             ToZenkakuKata();
  538.             break;
  539.  
  540.         case CMD_CASE_CHANGE:
  541.             CaseChange();
  542.             break;
  543.  
  544.         case CMD_SELECT_ALL:
  545.             SendMessage( hwndTarget, EM_SETSEL, TRUE, MAKELONG( 0, -1 ) );
  546.             break;
  547.  
  548.         case CMD_CAPSLOCK_FORGOT:
  549.             GetKeyboardState( (BYTE FAR*)abKeyState );
  550.             abKeyState[ VK_CAPITAL ] ^= 1;
  551.             SetKeyboardState( (BYTE FAR*)abKeyState );
  552.             if( xInput != -1 ) {
  553.                 CapsLockForget( xInput );
  554.                 xInput = -1;
  555.                 DebugOut( "xInput reset\x0d\x0a" );
  556.             }
  557.             break;
  558.  
  559.         default:
  560.             if( cmd >= CMD_MENU_1 && cmd <= CMD_MENU_8 ) {
  561.                 CommandKeyMenu( cmd );
  562.                 break;
  563.             }
  564.             MessageBeep(0);
  565.             return FALSE;
  566.     }
  567.     return TRUE;
  568. }
  569.  
  570. BOOL EditHookProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam ) {
  571.     static int    cmd;
  572.     switch( message ) {
  573.         case WM_KEYDOWN:
  574.             DebugOut( "WM_KEYDOWN " );
  575.             {
  576.                 static char    sz[20];
  577.                 itoa( wParam, sz, 10 );
  578.                 DebugOut( sz );
  579.                 DebugOut( "\x0d\x0a" );
  580.             }
  581.             if( wParam == VK_DELETE ) {
  582.                 fSelecting = FALSE;
  583.             } else if( wParam >= VK_PRIOR && wParam <= VK_DOWN ) {
  584.                 if( fSelecting ) {
  585.                     SendSelectingVKey( wParam );
  586.                     xInput = -1;
  587.                     DebugOut( "xInput reset\x0d\x0a" );
  588.                     return TRUE;
  589.                 }
  590.             } else if( wParam >= VK_F1 ) {
  591.                 cmd = GetCommand( wParam );
  592.                 if( cmd != 0 ) {
  593.                     if( ProcessEditCommand( cmd ) ) {
  594.                         return TRUE;
  595.                     }
  596.                 }
  597.             }
  598.             if( wParam == VK_BACK
  599.              || (wParam >= VK_CAPITAL && wParam <= VK_HELP)
  600.              || wParam >= VK_F1 && wParam <= VK_F24 ) {
  601.                 xInput = -1;
  602.                 DebugOut( "xInput reset\x0d\x0a" );
  603.             }
  604.             break;
  605.  
  606.         case WM_CHAR:
  607.             DebugOut( "WM_CHAR " );
  608.             {
  609.                 static char    sz[20];
  610.                 itoa( wParam, sz, 10 );
  611.                 DebugOut( sz );
  612.                 DebugOut( "\x0d\x0a" );
  613.             }
  614.             if( wParam < ' ' ) {
  615.                 if( (afConfig & FLAG_HOOK_CTRL_XCV) == 0 ) {
  616.                     if( wParam == 'X' - '@'
  617.                      || wParam == 'C' - '@'
  618.                      || wParam == 'V' - '@' ) {
  619.                         break;
  620.                     }
  621.                 }
  622.                 cmd = GetCommand( wParam + '@' );
  623.                 if( cmd != 0 ) {
  624.                     if( ProcessEditCommand( cmd ) ) {
  625.                         return TRUE;
  626.                     }
  627.                 }
  628.                 xInput = -1;
  629.                 DebugOut( "xInput reset\x0d\x0a" );
  630.             } else {
  631.                 if( xInput == -1 ) {
  632.                     dw = SendMessage( hwnd, EM_GETSEL, 0, 0L );
  633.                     xInput = (int)(WORD)dw;
  634.                     DebugOut( "xInput set\x0d\x0a" );
  635.                 }
  636.             }
  637.             fSelecting = FALSE;
  638.             break;
  639.  
  640.         case WM_RBUTTONDOWN:
  641.             if( GetFocus() == hwnd ) {
  642.                 PostMessage( hwndClient, WM_USER, (WPARAM)hwnd, 0 );
  643.             }
  644.             break;
  645.  
  646.         case WM_LBUTTONDOWN:
  647.             xInput = -1;
  648.             break;
  649.  
  650.     }
  651.     return FALSE;
  652. }
  653.  
  654. void EditHookRButtonDown( HWND hwnd ) {
  655.     if( GetFocus() == hwnd ) {
  656.         if( afConfig & FLAG_HOOK_RBUTTON ) {
  657.             GetKeyboardState( (BYTE FAR*)abKeyState );
  658.             dw = SendMessage( hwnd, EM_GETSEL, 0, 0L );
  659.             if( HIWORD(dw) != LOWORD(dw) ) {
  660.                 CommandKeyMenu( CMD_MENU_1 );
  661.             } else {
  662.                 ProcessEditCommand( pshare->key.mouse[1] );
  663.             }
  664.         }
  665.     }
  666. }
  667.