test: ntcon/conime/conime.c File Reference

Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

# conime.c File Reference

`#include "precomp.h"`

Go to the source code of this file.

## Defines

#define | LockConsoleTable() RtlEnterCriticalSection(&ConsoleTableLock)
#define | UnlockConsoleTable() RtlLeaveCriticalSection(&ConsoleTableLock)
#define | InputExceptionFilter(pexi) EXCEPTION_EXECUTE_HANDLER

## Functions

int APIENTRY | WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
BOOL | InitConsoleIME (HINSTANCE hInstance)
LRESULT FAR PASCAL | WndProc (HWND hWnd, UINT Message, WPARAM wParam, LPARAM lParam)
VOID | ExitList (HWND hWnd)
BOOL | InsertConsole (HWND hWnd, HANDLE hConsole, HWND hWndConsole)
BOOL | GrowConsoleTable (VOID)
PCONSOLE_TABLE | SearchConsole (HANDLE hConsole)
BOOL | RemoveConsole (HWND hwnd, HANDLE hConsole)
BOOL | RemoveConsoleWorker (HWND hwnd, PCONSOLE_TABLE ConTbl)
BOOL | InsertNewConsole (HWND hWnd, HANDLE hConsole, HWND hWndConsole)
BOOL | ConsoleSetFocus (HWND hWnd, HANDLE hConsole, HKL hKL)
BOOL | ConsoleKillFocus (HWND hWnd, HANDLE hConsole)
BOOL | ConsoleScreenBufferSize (HWND hWnd, HANDLE hConsole, COORD ScreenBufferSize)
BOOL | ConImeInputLangchangeRequest (HWND hWnd, HANDLE hConsole, HKL hkl, int Direction)
BOOL | ConImeInputLangchange (HWND hWnd, HANDLE hConsole, HKL hkl)
BOOL | InputLangchange (HWND hWnd, DWORD CharSet, HKL hkl)
LRESULT | ConsoleImeSendMessage (HWND hWndConsoleIME, WPARAM wParam, LPARAM lParam)

## Variables

HANDLE | LastConsole
HIMC | ghDefaultIMC
PCONSOLE_TABLE * | ConsoleTable
ULONG | NumberOfConsoleTable
CRITICAL_SECTION | ConsoleTableLock
BOOL | gfDoNotKillFocus
DWORD | dwConsoleThreadId

## Define Documentation

#define InputExceptionFilter | ( | pexi |  | ) | EXCEPTION_EXECUTE_HANDLER

| Definition at line 56 of file ntcon/conime/conime.c. Referenced by ConsoleInputThread(), WinMain(), and WndProc().

#define LockConsoleTable | (

)

RtlEnterCriticalSection(&ConsoleTableLock)

| Definition at line 33 of file ntcon/conime/conime.c. Referenced by ExitList(), InsertNewConsole(), RemoveConsole(), SearchConsole(), and WndProc().

#define UnlockConsoleTable | (

)

RtlLeaveCriticalSection(&ConsoleTableLock)

| Definition at line 34 of file ntcon/conime/conime.c. Referenced by ExitList(), InsertNewConsole(), RemoveConsole(), SearchConsole(), and WndProc().

## Function Documentation

BOOL ConImeInputLangchange | ( | HWND | hWnd,
|  | HANDLE | hConsole,
|  | HKL | hkl
| ) |

Definition at line 1094 of file ntcon/conime/conime.c.

References ActivateKeyboardLayout, ASSERT, CI_CONIMEMODEINFO, CONIME_UIMODEINFO, ConsoleImeSendMessage(), DBGPRINT, _HKL_TABLE::dwConversion, _CONSOLE_TABLE::dwConversion, FALSE, _CONSOLE_TABLE::fOpen, GetIMEName(), _HKL_TABLE::hkl, HKL_TABLE, HKL_TABLE_INCREMENT, _CONSOLE_TABLE::hklActive, _CONSOLE_TABLE::hklListMax, hWnd, _CONSOLE_TABLE::hWndCon, IME_CMODE_OPEN, ImeUIMakeInfoString(), ImeUIOpenStatusWindow(), _CONSOLE_TABLE::ImmGetProperty, ImmGetProperty(), INT, IS_IME_KBDLAYOUT, LastConsole, LPCONIME_UIMODEINFO, _CONSOLE_TABLE::lphklList, _CONIME_UIMODEINFO::ModeStringLen, NULL, _CONIME_UIMODEINFO::Position, SearchConsole(), SetNLSMode(), TRUE, and VIEW_RIGHT.

Referenced by WndProc().

    01099 {
    01100     PCONSOLE_TABLE ConTbl;
    01101     LPCONIME_UIMODEINFO lpModeInfo;
    01102     COPYDATASTRUCT CopyData;
    01103     INT counter ;
    01104     LPHKL_TABLE lphklListNew ;
    01105
    01106     ConTbl = SearchConsole(hConsole);
    01107     if (ConTbl == NULL) {
    01108         // cannot find specified console.
    01109         // It might be last console lost focus.
    01110         // try Last Console.
    01111         ConTbl = SearchConsole(LastConsole);
    01112         if (ConTbl == NULL) {
    01113             DBGPRINT(("CONIME: Error! Cannot found registed Console\n"));
    01114             return FALSE;
    01115         }
    01116     }
    01117
    01118     if (ConTbl->lphklList == NULL) {
    01119         return FALSE;
    01120     }
    01121
    01122     if (IS_IME_KBDLAYOUT(ConTbl->hklActive)) {
    01123         for (counter = 0 ; counter < ConTbl->hklListMax ;counter ++)
    01124         {
    01125             if (ConTbl->lphklList[counter].hkl == 0 || ConTbl->lphklList[counter].hkl == ConTbl->hklActive) {
    01126                 break;
    01127             }
    01128         }
    01129
    01130         if (counter >= ConTbl->hklListMax)
    01131         {
    01132             ASSERT(counter == ConTbl->hklListMax);
    01133             // reallocation
    01134             lphklListNew = LocalAlloc(LPTR, sizeof(HKL_TABLE) * (ConTbl->hklListMax + HKL_TABLE_INCREMENT) ) ;
    01135             if (lphklListNew != NULL)
    01136             {
    01137                 CopyMemory(lphklListNew , ConTbl->lphklList , sizeof(HKL_TABLE) * ConTbl->hklListMax) ;
    01138                 ConTbl->hklListMax += HKL_TABLE_INCREMENT ;
    01139                 LocalFree(ConTbl->lphklList);
    01140                 ConTbl->lphklList = lphklListNew;
    01141             }
    01142             else {
    01143                 return FALSE ;
    01144             }
    01145         }
    01146         ASSERT(ConTbl->lphklList != NULL);
    01147         ConTbl->lphklList[counter].hkl = ConTbl->hklActive;
    01148         ConTbl->lphklList[counter].dwConversion = ConTbl->dwConversion | (ConTbl->fOpen ? IME_CMODE_OPEN : 0)  ;
    01149     }
    01150
    01151     ActivateKeyboardLayout(hkl, 0);
    01152     ConTbl->hklActive = hkl;
    01153     GetIMEName( ConTbl );
    01154     ImeUIOpenStatusWindow(hWnd);
    01155     ConTbl->ImmGetProperty = ImmGetProperty(ConTbl->hklActive , IGP_PROPERTY);
    01156
    01157     lpModeInfo = (LPCONIME_UIMODEINFO)LocalAlloc( LPTR, sizeof(CONIME_UIMODEINFO) ) ;
    01158     if ( lpModeInfo == NULL) {
    01159         return FALSE;
    01160     }
    01161     CopyData.dwData = CI_CONIMEMODEINFO ;
    01162     CopyData.cbData = sizeof(CONIME_UIMODEINFO) ;
    01163     CopyData.lpData = lpModeInfo ;
    01164
    01165     if (IS_IME_KBDLAYOUT(hkl)) {
    01166
    01167         for (counter=0; counter < ConTbl->hklListMax ; counter++)
    01168         {
    01169             if (ConTbl->lphklList[counter].hkl == hkl)
    01170             {
    01171                 SetNLSMode(hWnd, hConsole,ConTbl->lphklList[counter].dwConversion ) ;
    01172                 ImeUIOpenStatusWindow(hWnd) ;
    01173                 if (ImeUIMakeInfoString(ConTbl,
    01174                                         lpModeInfo))
    01175                 {
    01176                     ConsoleImeSendMessage( ConTbl->hWndCon,
    01177                                            (WPARAM)hWnd,
    01178                                            (LPARAM)&CopyData
    01179                                          ) ;
    01180                 }
    01181             }
    01182         }
    01183     }
    01184     else
    01185     {
    01186
    01187         SetNLSMode(hWnd, hConsole,ConTbl->dwConversion & ~IME_CMODE_OPEN ) ;
    01188         lpModeInfo->ModeStringLen = 0 ;
    01189         lpModeInfo->Position = VIEW_RIGHT ;
    01190         ConsoleImeSendMessage( ConTbl->hWndCon,
    01191                                (WPARAM)hWnd,
    01192                                (LPARAM)&CopyData
    01193                               ) ;
    01194     }
    01195
    01196     LocalFree( lpModeInfo );
    01197
    01198     return TRUE;
    01199 }

BOOL ConImeInputLangchangeRequest | ( | HWND | hWnd,
|  | HANDLE | hConsole,
|  | HKL | hkl,
|  | int | Direction
| ) |

Definition at line 1000 of file ntcon/conime/conime.c.

References CM_CONIME_KL_ACTIVATE, CONIME_DIRECT, _CONSOLE_TABLE::ConsoleOutputCP, DBGPRINT, DWORD, FALSE, HKL_TO_LANGID, _CONSOLE_TABLE::hklActive, _CONSOLE_TABLE::hWndCon, IS_IME_KBDLAYOUT, JAPAN_CODEPAGE, KOREA_CODEPAGE, LANG_ID_JAPAN, LANG_ID_KOREA, LANG_ID_PRC, LANG_ID_TAIWAN, NULL, PostMessage(), PRC_CODEPAGE, SearchConsole(), TAIWAN_CODEPAGE, and TRUE.

Referenced by WndProc().

    01006 {
    01007     PCONSOLE_TABLE ConTbl;
    01008     int nLayouts;
    01009     LPHKL lphkl;
    01010     DWORD RequiredLID = 0;
    01011     int StartPos;
    01012     int CurrentHklPos;
    01013     int i;
    01014
    01015     ConTbl = SearchConsole(hConsole);
    01016     if (ConTbl == NULL) {
    01017         DBGPRINT(("CONIME: cannot find registered Console\n"));
    01018         return FALSE;
    01019     }
    01020
    01021     switch (ConTbl->ConsoleOutputCP) {
    01022         case JAPAN_CODEPAGE:
    01023             RequiredLID = LANG_ID_JAPAN;
    01024             break;
    01025         case PRC_CODEPAGE:
    01026             RequiredLID = LANG_ID_PRC;
    01027             break;
    01028         case KOREA_CODEPAGE:
    01029             RequiredLID = LANG_ID_KOREA;
    01030             break;
    01031         case TAIWAN_CODEPAGE:
    01032             RequiredLID = LANG_ID_TAIWAN;
    01033             break;
    01034         default:
    01035             break;
    01036     }
    01037
    01038     if ( !IS_IME_KBDLAYOUT(hkl) ||
    01039         ( HKL_TO_LANGID(hkl) == RequiredLID)) {
    01040         return TRUE;
    01041     }
    01042     if (Direction == CONIME_DIRECT) {
    01043         return FALSE;
    01044     }
    01045
    01046     nLayouts = GetKeyboardLayoutList(0, NULL);
    01047     if (nLayouts == 0) {
    01048         return FALSE;
    01049     }
    01050     lphkl = LocalAlloc(LPTR, nLayouts * sizeof(HKL));
    01051     if (lphkl == NULL) {
    01052         return FALSE;
    01053     }
    01054     GetKeyboardLayoutList(nLayouts, lphkl);
    01055
    01056     for (CurrentHklPos = 0; CurrentHklPos < nLayouts; CurrentHklPos++) {
    01057         if (ConTbl->hklActive == lphkl[CurrentHklPos] ) {
    01058             break;
    01059         }
    01060     }
    01061     if (CurrentHklPos >= nLayouts) {
    01062         LocalFree(lphkl);
    01063         return FALSE;
    01064     }
    01065
    01066     StartPos = CurrentHklPos;
    01067
    01068     for (i = 0; i < nLayouts; i++) {
    01069         StartPos+=Direction;
    01070         if (StartPos < 0) {
    01071             StartPos = nLayouts-1;
    01072         }
    01073         else if (StartPos >= nLayouts) {
    01074             StartPos = 0;
    01075         }
    01076
    01077         if ((( HandleToUlong(lphkl[StartPos]) & 0xf0000000) == 0x00000000) ||
    01078             (( HandleToUlong(lphkl[StartPos]) & 0x0000ffff) == RequiredLID)) {
    01079             PostMessage( ConTbl->hWndCon,
    01080                          CM_CONIME_KL_ACTIVATE,
    01081                           HandleToUlong(lphkl[StartPos]),
    01082                          0);
    01083             LocalFree(lphkl);
    01084             return FALSE;
    01085         }
    01086     }
    01087
    01088     LocalFree(lphkl);
    01089     return FALSE;
    01090
    01091 }

LRESULT ConsoleImeSendMessage | ( | HWND | hWndConsoleIME,
|  | WPARAM | wParam,
|  | LPARAM | lParam
| ) |

Definition at line 1227 of file ntcon/conime/conime.c.

References CONIME_SENDMSG_TIMEOUT, FALSE, NULL, SendMessageTimeout(), and TRUE.

Referenced by CloseCandidateJapan(), CloseCandidateKorea(), CloseCandidatePRC(), CloseCandidateTaiwan(), ConImeInputLangchange(), GetCompStrJapan(), GetCompStrKorea(), GetCompStrPRC(), GetCompStrTaiwan(), ImeSysPropertyWindow(), ImeUIGuideLine(), ImeUIOpenStatusWindow(), ImeUISetConversionMode(), ImeUISetOpenStatus(), OpenCandidateJapan(), OpenCandidateKorea(), OpenCandidatePRC(), OpenCandidateTaiwan(), ReDisplayCompStrJapan(), ReDisplayCompStrKorea(), ReDisplayCompStrPRC(), and ReDisplayCompStrTaiwan().

    01232 {
    01233     LRESULT lResult;
    01234     LRESULT fNoTimeout;
    01235
    01236     if (hWndConsoleIME == NULL)
    01237     {
    01238         return FALSE;
    01239     }
    01240
    01241     fNoTimeout = SendMessageTimeout(hWndConsoleIME,
    01242                                     WM_COPYDATA,
    01243                                     wParam,
    01244                                     lParam,
    01245                                     SMTO_ABORTIFHUNG | SMTO_NORMAL,
    01246                                     CONIME_SENDMSG_TIMEOUT,
    01247                                     &lResult);
    01248
    01249     if (fNoTimeout)
    01250     {
    01251         return TRUE;
    01252     }
    01253
    01254
    01255     /*
    01256      * ConsoleImeMessagePump give up SendMessage to conime.
    01257      * CONIME is hung up.
    01258      * probably, consrv also hung up.
    01259      */
    01260     KdPrint(("ConsoleImeSendMessage: CONIME_SENDMSG_COUNT is hung up\n"));
    01261
    01262     return FALSE;
    01263
    01264 }

BOOL ConsoleKillFocus | ( | HWND | hWnd,
|  | HANDLE | hConsole
| ) |

Definition at line 950 of file ntcon/conime/conime.c.

References DBGPRINT, FALSE, gfDoNotKillFocus, ghDefaultIMC, hWnd, ImmAssociateContext(), ImmSetActiveContextConsoleIME(), NULL, SearchConsole(), and TRUE.

Referenced by WndProc().

    00954 {
    00955     PCONSOLE_TABLE ConTbl;
    00956
    00957     ConTbl = SearchConsole(hConsole);
    00958     if (ConTbl == NULL) {
    00959         DBGPRINT(("CONIME: Error! Cannot found registed Console\n"));
    00960         return FALSE;
    00961     }
    00962
    00963     if ( gfDoNotKillFocus ){
    00964         gfDoNotKillFocus = FALSE;
    00965     }
    00966     else{
    00967 //v-hirshi Jun.13.1996 #if defined(LATER_DBCS)  // kazum
    00968         ImmSetActiveContextConsoleIME(hWnd, FALSE);
    00969 //v-hirshi Jun.13.1996 #endif
    00970         ImmAssociateContext(hWnd, ghDefaultIMC);
    00971     }
    00972
    00973 #ifdef DEBUG_MODE
    00974     DisplayInformation(hWnd, hConsole);
    00975 #endif
    00976
    00977     return TRUE;
    00978 }

BOOL ConsoleScreenBufferSize | ( | HWND | hWnd,
|  | HANDLE | hConsole,
|  | COORD | ScreenBufferSize
| ) |

Definition at line 981 of file ntcon/conime/conime.c.

References DBGPRINT, FALSE, NULL, _CONSOLE_TABLE::ScreenBufferSize, SearchConsole(), and TRUE.

Referenced by WndProc().

    00986 {
    00987     PCONSOLE_TABLE ConTbl;
    00988
    00989     ConTbl = SearchConsole(hConsole);
    00990     if (ConTbl == NULL) {
    00991         DBGPRINT(("CONIME: Error! Cannot found registed Console\n"));
    00992         return FALSE;
    00993     }
    00994
    00995     ConTbl->ScreenBufferSize = ScreenBufferSize;
    00996     return TRUE;
    00997 }

BOOL ConsoleSetFocus | ( | HWND | hWnd,
|  | HANDLE | hConsole,
|  | HKL | hKL
| ) |

Definition at line 903 of file ntcon/conime/conime.c.

References ActivateKeyboardLayout, DBGPRINT, FALSE, GetIMEName(), gfDoNotKillFocus, _CONSOLE_TABLE::hIMC_Current, _CONSOLE_TABLE::hklActive, hWnd, ImeUISetOpenStatus(), ImmAssociateContext(), _CONSOLE_TABLE::ImmGetProperty, ImmGetProperty(), ImmSetActiveContextConsoleIME(), LastConsole, _CONSOLE_TABLE::lpCompStrMem, NULL, ReDisplayCompositionStr(), SearchConsole(), and TRUE.

Referenced by WndProc().

    00908 {
    00909     PCONSOLE_TABLE ConTbl;
    00910     HKL OldhKL;
    00911
    00912     ConTbl = SearchConsole(hConsole);
    00913     if (ConTbl == NULL) {
    00914         DBGPRINT(("CONIME: Error! Cannot found registed Console\n"));
    00915         return FALSE;
    00916     }
    00917
    00918     if ( gfDoNotKillFocus ){
    00919         gfDoNotKillFocus = FALSE;
    00920     }
    00921
    00922     OldhKL = ConTbl->hklActive ;
    00923     ConTbl->hklActive = hKL;
    00924     ActivateKeyboardLayout(ConTbl->hklActive, 0);
    00925     ImmAssociateContext(hWnd, ConTbl->hIMC_Current);
    00926
    00927     if (OldhKL == 0) {
    00928         GetIMEName( ConTbl );
    00929         ConTbl->ImmGetProperty = ImmGetProperty(ConTbl->hklActive , IGP_PROPERTY);
    00930     }
    00931
    00932 //v-hirshi Jun.13.1996 #if defined(LATER_DBCS)  // kazum
    00933     ImmSetActiveContextConsoleIME(hWnd, TRUE);
    00934 //v-hirshi Jun.13.1996 #endif
    00935
    00936     LastConsole = hConsole;
    00937
    00938 #ifdef DEBUG_MODE
    00939     DisplayInformation(hWnd, hConsole);
    00940 #endif
    00941
    00942     ImeUISetOpenStatus( hWnd );
    00943     if (ConTbl->lpCompStrMem != NULL)
    00944         ReDisplayCompositionStr( hWnd );
    00945
    00946     return TRUE;
    00947 }

VOID ExitList | ( | HWND | hWnd | ) |

Definition at line 611 of file ntcon/conime/conime.c.

References _CONSOLE_TABLE::CandListMemAllocSize, _CONSOLE_TABLE::CandSep, _CONSOLE_TABLE::CandSepAllocSize, ConsoleTable, DBGPRINT, dwConsoleThreadId, _CONSOLE_TABLE::Enable, FALSE, ghDefaultIMC, _CONSOLE_TABLE::hConsole, _CONSOLE_TABLE::hIMC_Original, hWnd, ImmAssociateContext(), ImmDestroyContext(), _CONSOLE_TABLE::LateRemove, LockConsoleTable, _CONSOLE_TABLE::lpCandListMem, _CONSOLE_TABLE::lpCompStrMem, MAX_LISTCAND, NULL, NumberOfConsoleTable, TRUE, and UnlockConsoleTable.

Referenced by WndProc().

    00614 {
    00615     ULONG i ,j;
    00616     PCONSOLE_TABLE FocusedConsole;
    00617
    00618     DBGPRINT(("CONIME:ExitList Processing\n"));
    00619     ImmAssociateContext(hWnd,ghDefaultIMC);
    00620
    00621     LockConsoleTable();
    00622
    00623     for (i = 1; i < NumberOfConsoleTable; i++) {
    00624         FocusedConsole = ConsoleTable[i];
    00625         if (FocusedConsole != NULL)
    00626         {
    00627             if (FocusedConsole->hConsole != NULL) {
    00628                 if (FocusedConsole->Enable) {
    00629                     ImmDestroyContext(FocusedConsole->hIMC_Original);
    00630                     if ( FocusedConsole->lpCompStrMem != NULL) {
    00631                         LocalFree( FocusedConsole->lpCompStrMem );
    00632                         FocusedConsole->lpCompStrMem = NULL;
    00633                     }
    00634                     for (j = 0; j < MAX_LISTCAND; j++){
    00635                         if (FocusedConsole->lpCandListMem[j] != NULL) {
    00636                             LocalFree(FocusedConsole->lpCandListMem[j]);
    00637                             FocusedConsole->lpCandListMem[j] = NULL;
    00638                             FocusedConsole->CandListMemAllocSize[j] = 0;
    00639                         }
    00640                     }
    00641                     if (FocusedConsole->CandSep != NULL) {
    00642                         LocalFree(FocusedConsole->CandSep);
    00643                         FocusedConsole->CandSepAllocSize = 0;
    00644                     }
    00645                     FocusedConsole->Enable = FALSE;
    00646                 }
    00647                 else
    00648                     FocusedConsole->LateRemove = TRUE;
    00649             }
    00650         }
    00651     }
    00652     LocalFree( ConsoleTable );
    00653     UnlockConsoleTable();
    00654
    00655     if (dwConsoleThreadId)
    00656     {
    00657         AttachThreadInput(GetCurrentThreadId(), dwConsoleThreadId, FALSE);
    00658         UnregisterConsoleIME();
    00659         dwConsoleThreadId = 0;
    00660     }
    00661 }

BOOL GrowConsoleTable | ( | VOID |  | ) |

Definition at line 742 of file ntcon/conime/conime.c.

References CONSOLE_CONSOLE_TABLE_INCREMENT, ConsoleTable, FALSE, NULL, NumberOfConsoleTable, PCONSOLE_TABLE, and TRUE.

Referenced by InsertConsole().

    00745 {
    00746     PCONSOLE_TABLE *NewTable;
    00747     PCONSOLE_TABLE *OldTable;
    00748     ULONG MaxConsoleTable;
    00749
    00750     MaxConsoleTable = NumberOfConsoleTable + CONSOLE_CONSOLE_TABLE_INCREMENT;
    00751     NewTable = (PCONSOLE_TABLE *)LocalAlloc(LPTR, MaxConsoleTable * sizeof(PCONSOLE_TABLE));
    00752     if (NewTable == NULL) {
    00753         return FALSE;
    00754     }
    00755     CopyMemory(NewTable, ConsoleTable, NumberOfConsoleTable * sizeof(PCONSOLE_TABLE));
    00756
    00757     OldTable = ConsoleTable;
    00758     ConsoleTable = NewTable;
    00759     NumberOfConsoleTable = MaxConsoleTable;
    00760
    00761     LocalFree(OldTable);
    00762
    00763     return TRUE;
    00764 }

BOOL InitConsoleIME | ( | HINSTANCE | hInstance | ) |

Definition at line 109 of file ntcon/conime/conime.c.

References CONSOLE_INITIAL_TABLE, CONSOLEIME_EVENT, ConsoleTable, ConsoleTableLock, CVMAX, DBGPRINT, DestroyWindow, dwConsoleThreadId, ErrorExit(), FALSE, GetSystemMetrics(), hWnd, ID_CONSOLEIME_ICON, IDS_APPNAME, IDS_CLASSNAME, IDS_MENUNAME, IDS_TITLE, L, LPVOID, NULL, NumberOfConsoleTable, PCONSOLE_TABLE, RegisterClass, RtlInitializeCriticalSection(), SetWindowText(), ShowWindow, szTitle, TRUE, UNICODE_SPACE, UnregisterClass(), UpdateWindow(), and WndProc().

Referenced by WinMain().

    00112 {
    00113     HANDLE   hEvent;
    00114     ATOM     atom;
    00115     HWND     hWnd;
    00116     WNDCLASS ConsoleIMEClass;
    00117     int      cxExecStart;
    00118     int      cyExecStart;
    00119     WCHAR    szMenuName[16];                 // The name of Menu
    00120     WCHAR    szClassName[16];                // The class name of this application
    00121     WCHAR    szTitle[16];                    // The title bar text
    00122
    00123 #ifdef DEBUG_MODE
    00124     WCHAR    szAppName[16];                  // The name of this application
    00125
    00126     LoadString(hInstance, IDS_TITLE,     szTitle,     sizeof(szTitle));
    00127 #else
    00128     szTitle[0] = L'\0';
    00129 #endif
    00130
    00131     DBGPRINT(("CONIME: Enter InitConsoleIMEl!\n"));
    00132
    00133     RtlInitializeCriticalSection(&ConsoleTableLock);
    00134
    00135     ConsoleTable = (PCONSOLE_TABLE *)LocalAlloc(LPTR, CONSOLE_INITIAL_TABLE * sizeof(PCONSOLE_TABLE));
    00136     if (ConsoleTable == NULL) {
    00137         return FALSE;
    00138     }
    00139     RtlZeroMemory(ConsoleTable, CONSOLE_INITIAL_TABLE * sizeof(PCONSOLE_TABLE));
    00140     NumberOfConsoleTable = CONSOLE_INITIAL_TABLE;
    00141
    00142     // Load the application name and description strings.
    00143     LoadString(hInstance, IDS_MENUNAME,  szMenuName,  sizeof(szMenuName));
    00144     LoadString(hInstance, IDS_CLASSNAME, szClassName, sizeof(szClassName));
    00145
    00146     hEvent = OpenEvent(EVENT_MODIFY_STATE,    // Access flag
    00147                        FALSE,                 // Inherit
    00148                        CONSOLEIME_EVENT);     // Event object name
    00149     if (hEvent == NULL)
    00150     {
    00151         DBGPRINT(("CONIME: OpenEvent failure! %d\n",GetLastError()));
    00152         goto ErrorExit;
    00153     }
    00154
    00155     // Fill in window class structure with parameters that describe the
    00156     // main window.
    00157
    00158     ConsoleIMEClass.style         = 0;                       // Class style(s).
    00159     ConsoleIMEClass.lpfnWndProc   = WndProc;                 // Window Procedure
    00160     ConsoleIMEClass.cbClsExtra    = 0;                       // No per-class extra data.
    00161     ConsoleIMEClass.cbWndExtra    = 0;                       // No per-window extra data.
    00162     ConsoleIMEClass.hInstance     = hInstance;               // Owner of this class
    00163     ConsoleIMEClass.hIcon         = LoadIcon(hInstance, MAKEINTRESOURCE(ID_CONSOLEIME_ICON));
    00164     ConsoleIMEClass.hCursor       = LoadCursor(NULL, IDC_ARROW); // Cursor
    00165     ConsoleIMEClass.hbrBackground = GetStockObject(WHITE_BRUSH); // Default color
    00166     ConsoleIMEClass.lpszMenuName  = szMenuName;              // Menu name from .RC
    00167     ConsoleIMEClass.lpszClassName = szClassName;             // Class Name
    00168
    00169     // Register the window class and return FALSE if unsuccesful.
    00170
    00171     atom = RegisterClass(&ConsoleIMEClass);
    00172     if (atom == 0)
    00173     {
    00174         DBGPRINT(("CONIME: RegisterClass failure! %d\n",GetLastError()));
    00175         goto ErrorExit;
    00176     }
    00177     else {
    00178         DBGPRINT(("CONIME: RegisterClass Successful!\n"));
    00179     }
    00180
    00181     // Guess size for now.
    00182     cxExecStart = GetSystemMetrics(SM_CXSCREEN);
    00183     cyExecStart = GetSystemMetrics(SM_CYMENU);
    00184
    00185     // Create a main window for this application instance.
    00186     hWnd = CreateWindow(szClassName,                 // See RegisterClass() call.
    00187                         szTitle,                     // Text for window title bar.
    00188                         WS_OVERLAPPEDWINDOW,
    00189                         cxExecStart - (cxExecStart / 3) ,
    00190                         cyExecStart ,
    00191                         cxExecStart / 3 ,
    00192                         cyExecStart * 10 ,
    00193                         NULL,                        // Overlapped has no parent.
    00194                         NULL,                        // Use the window class menu.
    00195                         hInstance,
    00196                         (LPVOID)NULL);
    00197
    00198     // If window could not be created, return "failure"
    00199     if (hWnd == NULL) {
    00200         DBGPRINT(("CONIME: CreateWindow failured! %d\n",GetLastError()));
    00201         goto ErrorExit;
    00202     }
    00203     else{
    00204         DBGPRINT(("CONIME: CreateWindow Successful!\n"));
    00205     }
    00206
    00207     if (! RegisterConsoleIME(hWnd, &dwConsoleThreadId))
    00208     {
    00209         DBGPRINT(("CONIME: RegisterConsoleIME failured! %d\n",GetLastError()));
    00210         goto ErrorExit;
    00211     }
    00212
    00213     if (! AttachThreadInput(GetCurrentThreadId(), dwConsoleThreadId, TRUE))
    00214     {
    00215         DBGPRINT(("CONIME: AttachThreadInput failured! %d\n",GetLastError()));
    00216         goto ErrorExit;
    00217     }
    00218
    00219     /*
    00220      * dwConsoleThreadId is locked until event sets of hEvent
    00221      */
    00222     SetEvent(hEvent);
    00223     CloseHandle(hEvent);
    00224
    00225 #ifdef DEBUG_MODE
    00226     LoadString(hInstance, IDS_APPNAME,   szAppName,   sizeof(szAppName));
    00227
    00228     // Make the window visible; update its client area; and return "success"
    00229     ShowWindow(hWnd, SW_MINIMIZE); // Show the window
    00230     SetWindowText(hWnd, szAppName);
    00231     UpdateWindow(hWnd);         // Sends WM_PAINT message
    00232
    00233     {
    00234         int i;
    00235
    00236         for (i = 0; i < CVMAX; i++) {
    00237             ConvertLine[i] = UNICODE_SPACE;
    00238             ConvertLineAtr[i] = 0;
    00239         }
    00240         xPos = 0;
    00241         xPosLast = 0;
    00242     }
    00243
    00244 #endif
    00245
    00246     return TRUE;                // We succeeded...
    00247
    00248 ErrorExit:
    00249     if (dwConsoleThreadId)
    00250         UnregisterConsoleIME();
    00251     if (hWnd)
    00252         DestroyWindow(hWnd);
    00253     if (atom)
    00254         UnregisterClass(szClassName,hInstance);
    00255     if (hEvent)
    00256     {
    00257         SetEvent(hEvent);
    00258         CloseHandle(hEvent);
    00259     }
    00260     return FALSE;
    00261 }

BOOL InputLangchange | ( | HWND | hWnd,
|  | DWORD | CharSet,
|  | HKL | hkl
| ) |

Definition at line 1202 of file ntcon/conime/conime.c.

References ActivateKeyboardLayout, DBGPRINT, FALSE, GetIMEName(), _CONSOLE_TABLE::hklActive, hWnd, ImeUIOpenStatusWindow(), LastConsole, NULL, SearchConsole(), and TRUE.

Referenced by WndProc().

    01207 {
    01208     PCONSOLE_TABLE ConTbl;
    01209
    01210     ConTbl = SearchConsole(LastConsole);
    01211     if (ConTbl == NULL) {
    01212         DBGPRINT(("CONIME: Error! Cannot found registed Console\n"));
    01213         return FALSE;
    01214     }
    01215
    01216     ConTbl->hklActive = hkl;
    01217     ActivateKeyboardLayout(ConTbl->hklActive, 0);
    01218     GetIMEName( ConTbl );
    01219     ImeUIOpenStatusWindow(hWnd);
    01220     return TRUE;
    01221 }

BOOL InsertConsole | ( | HWND | hWnd,
|  | HANDLE | hConsole,
|  | HWND | hWndConsole
| ) |

Definition at line 664 of file ntcon/conime/conime.c.

References _CONSOLE_TABLE::CompAttrColor, CONSOLE_TABLE, ConsoleTable, DBGPRINT, DEFAULT_COMP_ALREADY_CONVERTED, DEFAULT_COMP_CONVERSION, DEFAULT_COMP_ENTERED, DEFAULT_COMP_INPUT_ERROR, DEFAULT_COMP_YET_CONVERTED, DEFAULT_TEMP_WIDTH, _CONSOLE_TABLE::Enable, FALSE, GetIMEName(), GrowConsoleTable(), _CONSOLE_TABLE::hConsole, _CONSOLE_TABLE::hIMC_Current, _CONSOLE_TABLE::hIMC_Original, HKL_INITIAL_TABLE, HKL_TABLE, _CONSOLE_TABLE::hklListMax, hWnd, _CONSOLE_TABLE::hWndCon, ImmCreateContext(), _CONSOLE_TABLE::LateRemove, _CONSOLE_TABLE::lphklList, NULL, NumberOfConsoleTable, RemoveConsoleWorker(), _CONSOLE_TABLE::ScreenBufferSize, and TRUE.

Referenced by InsertNewConsole().

    00669 {
    00670     ULONG i;
    00671     PCONSOLE_TABLE FocusedConsole;
    00672
    00673     i = 1;
    00674
    00675     do {
    00676         for (; i < NumberOfConsoleTable; i++) {
    00677             FocusedConsole = ConsoleTable[i];
    00678
    00679             if (FocusedConsole == NULL)
    00680             {
    00681                 FocusedConsole = LocalAlloc(LPTR, sizeof(CONSOLE_TABLE));
    00682                 if (FocusedConsole == NULL)
    00683                     return FALSE;
    00684                 ConsoleTable[i] = FocusedConsole;
    00685             }
    00686
    00687             if ((FocusedConsole->hConsole != NULL) &&
    00688                 (FocusedConsole->LateRemove)&&
    00689                 (FocusedConsole->Enable)) {
    00690                 RemoveConsoleWorker(hWnd, FocusedConsole);
    00691             }
    00692
    00693             if (FocusedConsole->hConsole == NULL) {
    00694                 RtlZeroMemory(FocusedConsole, sizeof(CONSOLE_TABLE));
    00695                 FocusedConsole->lphklList = LocalAlloc(LPTR, sizeof(HKL_TABLE)*HKL_INITIAL_TABLE);
    00696                 if (FocusedConsole->lphklList == NULL)
    00697                 {
    00698                     return FALSE;
    00699                 }
    00700                 RtlZeroMemory(FocusedConsole->lphklList, sizeof(HKL_TABLE)*HKL_INITIAL_TABLE);
    00701                 FocusedConsole->hklListMax = HKL_INITIAL_TABLE ;
    00702
    00703                 FocusedConsole->hIMC_Current = ImmCreateContext();
    00704                 if (FocusedConsole->hIMC_Current == (HIMC)NULL) {
    00705                     LocalFree(FocusedConsole);
    00706                     FocusedConsole = NULL;
    00707                     return FALSE;
    00708                 }
    00709
    00710                 FocusedConsole->hIMC_Original = FocusedConsole->hIMC_Current;
    00711                 FocusedConsole->hConsole      = hConsole;
    00712                 FocusedConsole->hWndCon       = hWndConsole;
    00713 //                FocusedConsole->hklActive     = NULL;
    00714                 FocusedConsole->Enable        = TRUE;
    00715 //                FocusedConsole->LateRemove    = FALSE;
    00716 //                FocusedConsole->fNestCandidate = FALSE;
    00717 //                FocusedConsole->fInComposition = FALSE;
    00718 //                FocusedConsole->fInCandidate = FALSE;
    00719                 FocusedConsole->ScreenBufferSize.X = DEFAULT_TEMP_WIDTH;
    00720
    00721                 FocusedConsole->CompAttrColor[0] = DEFAULT_COMP_ENTERED;
    00722                 FocusedConsole->CompAttrColor[1] = DEFAULT_COMP_ALREADY_CONVERTED;
    00723                 FocusedConsole->CompAttrColor[2] = DEFAULT_COMP_CONVERSION;
    00724                 FocusedConsole->CompAttrColor[3] = DEFAULT_COMP_YET_CONVERTED;
    00725                 FocusedConsole->CompAttrColor[4] = DEFAULT_COMP_INPUT_ERROR;
    00726                 FocusedConsole->CompAttrColor[5] = DEFAULT_COMP_INPUT_ERROR;
    00727                 FocusedConsole->CompAttrColor[6] = DEFAULT_COMP_INPUT_ERROR;
    00728                 FocusedConsole->CompAttrColor[7] = DEFAULT_COMP_INPUT_ERROR;
    00729
    00730                 GetIMEName(FocusedConsole);
    00731
    00732                 return TRUE;
    00733             }
    00734         }
    00735     } while (GrowConsoleTable());
    00736
    00737     DBGPRINT(("CONIME: Cannot grow Console Table\n"));
    00738     return FALSE;
    00739 }

BOOL InsertNewConsole | ( | HWND | hWnd,
|  | HANDLE | hConsole,
|  | HWND | hWndConsole
| ) |

Definition at line 869 of file ntcon/conime/conime.c.

References FALSE, hWnd, ImeUISetOpenStatus(), InsertConsole(), LockConsoleTable, NULL, SearchConsole(), TRUE, and UnlockConsoleTable.

Referenced by WndProc().

    00874 {
    00875     // conime receive ime message from console before 1st console registered.
    00876     // this will happen after restart conime when conime dead by bogus ime's AV or
    00877     // other problem
    00878     // so this fail safe code is  necessary to protect consrv.
    00879     if (SearchConsole(hConsole) != NULL) {
    00880         return TRUE;
    00881     }
    00882
    00883     LockConsoleTable();
    00884
    00885     if (!InsertConsole(hWnd, hConsole, hWndConsole)) {
    00886         UnlockConsoleTable();
    00887         return FALSE;
    00888     }
    00889
    00890 #ifdef DEBUG_MODE
    00891     DisplayInformation(hWnd, hConsole);
    00892 #endif
    00893
    00894     ImeUISetOpenStatus( hWndConsole );
    00895
    00896     UnlockConsoleTable();
    00897
    00898     return TRUE;
    00899 }

BOOL RemoveConsole | ( | HWND | hwnd,
|  | HANDLE | hConsole
| ) |

Definition at line 801 of file ntcon/conime/conime.c.

    00805 {
    00806     PCONSOLE_TABLE ConTbl;
    00807     BOOL ret;
    00808
    00809     LockConsoleTable();
    00810
    00811     ConTbl = SearchConsole(hConsole);
    00812     if (ConTbl == NULL)
    00813     {
    00814         UnlockConsoleTable();
    00815         return FALSE;
    00816     }
    00817     ret = RemoveConsoleWorker(hwnd, ConTbl);
    00818
    00819     UnlockConsoleTable();
    00820     return ret;
    00821 }

BOOL RemoveConsoleWorker | ( | HWND | hwnd,
|  | PCONSOLE_TABLE | ConTbl
| ) |

Definition at line 824 of file ntcon/conime/conime.c.

References _CONSOLE_TABLE::CandSep, _CONSOLE_TABLE::ConsoleCP, _CONSOLE_TABLE::ConsoleOutputCP, DWORD, _CONSOLE_TABLE::Enable, FALSE, _CONSOLE_TABLE::hConsole, _CONSOLE_TABLE::hIMC_Original, _CONSOLE_TABLE::hklActive, ImmDestroyContext(), _CONSOLE_TABLE::LateRemove, _CONSOLE_TABLE::lpCandListMem, _CONSOLE_TABLE::lpCompStrMem, _CONSOLE_TABLE::lphklList, MAX_LISTCAND, NULL, _CONSOLE_TABLE::ScreenBufferSize, and TRUE.

Referenced by InsertConsole(), and RemoveConsole().

    00828 {
    00829     DWORD j;
    00830
    00831     if (ConTbl->Enable) {
    00832         ConTbl->hConsole = NULL;
    00833         ConTbl->ScreenBufferSize.X = 0;
    00834         ConTbl->ConsoleCP = 0;
    00835         ConTbl->ConsoleOutputCP = 0;
    00836         ConTbl->hklActive = 0;
    00837
    00838         ImmDestroyContext(ConTbl->hIMC_Original);
    00839
    00840         if (ConTbl->lpCompStrMem != NULL){
    00841             LocalFree(ConTbl->lpCompStrMem);
    00842         }
    00843         for (j = 0; j < MAX_LISTCAND; j++){
    00844             if (ConTbl->lpCandListMem[j] != NULL) {
    00845                 LocalFree(ConTbl->lpCandListMem[j]);
    00846             }
    00847         }
    00848         if (ConTbl->CandSep != NULL) {
    00849             LocalFree(ConTbl->CandSep);
    00850         }
    00851
    00852         if (ConTbl->lphklList != NULL) {
    00853             LocalFree(ConTbl->lphklList) ;
    00854         }
    00855
    00856         ConTbl->Enable     = FALSE;
    00857         ConTbl->LateRemove = FALSE;
    00858     }
    00859     else
    00860         ConTbl->LateRemove = TRUE;
    00861
    00862 #ifdef DEBUG_MODE
    00863     InvalidateRect(hwnd,NULL,TRUE);
    00864 #endif
    00865     return TRUE;
    00866 }

PCONSOLE_TABLE SearchConsole | ( | HANDLE | hConsole | ) |

Definition at line 767 of file ntcon/conime/conime.c.

References ConsoleTable, _CONSOLE_TABLE::hConsole, LastConsole, _CONSOLE_TABLE::LateRemove, LockConsoleTable, NULL, NumberOfConsoleTable, and UnlockConsoleTable.

Referenced by CharHandlerToConsole(), ConImeInputLangchange(), ConImeInputLangchangeRequest(), ConsoleCodepageChange(), ConsoleKillFocus(), ConsoleScreenBufferSize(), ConsoleSetFocus(), GetCompositionStr(), GetNLSMode(), ImeSysPropertyWindow(), ImeUICloseCandidate(), ImeUIEndComposition(), ImeUIGuideLine(), ImeUIOpenCandidate(), ImeUIOpenStatusWindow(), ImeUISetConversionMode(), ImeUISetOpenStatus(), ImeUIStartComposition(), InputLangchange(), InsertNewConsole(), ReDisplayCompositionStr(), RemoveConsole(), SetNLSMode(), and WndProc().

    00770 {
    00771     ULONG i;
    00772     PCONSOLE_TABLE FocusedConsole;
    00773
    00774     LockConsoleTable();
    00775
    00776     // conime receive ime message from console before 1st console registered.
    00777     // this will happen after restart conime when conime dead by bogus ime's AV or
    00778     // other problem
    00779     // so this fail safe code is  necessary to protect consrv.
    00780     if (LastConsole == 0) {
    00781         LastConsole = hConsole ;
    00782     }
    00783
    00784     for (i = 1; i < NumberOfConsoleTable; i++) {
    00785         FocusedConsole = ConsoleTable[i];
    00786         if (FocusedConsole != NULL)
    00787         {
    00788             if ((FocusedConsole->hConsole == hConsole)&&
    00789                 (!FocusedConsole->LateRemove)) {
    00790
    00791                 UnlockConsoleTable();
    00792                 return FocusedConsole;
    00793             }
    00794         }
    00795     }
    00796     UnlockConsoleTable();
    00797     return NULL;
    00798 }

int APIENTRY WinMain | ( | HINSTANCE | hInstance,
|  | HINSTANCE | hPrevInstance,
|  | LPSTR | lpCmdLine,
|  | int | nCmdShow
| ) |

Definition at line 62 of file ntcon/conime/conime.c.

    00068 {
    00069     MSG msg;
    00070     WCHAR systemPath[MAX_PATH];
    00071
    00072     GetSystemDirectory ( systemPath, MAX_PATH );
    00073     SetCurrentDirectory ( systemPath );
    00074
    00075     if (!InitConsoleIME(hInstance) ) {
    00076         DBGPRINT(("CONIME: InitConsoleIME failure!\n"));
    00077         return FALSE;
    00078     }
    00079     else {
    00080         DBGPRINT(("CONIME: InitConsoleIME successful!\n"));
    00081     }
    00082
    00083     try {
    00084
    00085         while (TRUE)  {
    00086             if (GetMessage(&msg, NULL, 0, 0)) {
    00087                 TranslateMessage(&msg);
    00088                 DispatchMessage(&msg);
    00089             } else {
    00090                 break;
    00091             }
    00092         }
    00093
    00094     } except (InputExceptionFilter(GetExceptionInformation())) {
    00095
    00096         if (dwConsoleThreadId)
    00097         {
    00098             DBGPRINT(("CONIME: Exception on WinMain!!\n"));
    00099             UnregisterConsoleIME();
    00100             dwConsoleThreadId = 0;
    00101         }
    00102
    00103     }
    00104
    00105     return (int)msg.wParam;
    00106 }

LRESULT FAR PASCAL WndProc | ( | HWND | hWnd,
|  | UINT | Message,
|  | WPARAM | wParam,
|  | LPARAM | lParam
| ) |

Definition at line 288 of file ntcon/conime/conime.c.

Referenced by InitConsoleIME(), and InitializeInstance().

    00292 {
    00293     DWORD dwImmRet = 0;        // return value of ImmSrvProcessKey()
    00294
    00295     try {
    00296
    00297         switch (Message)
    00298         {
    00299             case CONIME_CREATE:
    00300                 DBGPRINT(("CONIME: CONIME_CREATE: Console Handle=%08x\n", wParam));
    00301                 return InsertNewConsole(hWnd,(HANDLE)wParam,(HWND)lParam);
    00302
    00303             case CONIME_DESTROY:
    00304                 DBGPRINT(("CONIME: CONIME_DESTROY: Console Handle=%08x\n", wParam));
    00305                 return RemoveConsole(hWnd, (HANDLE)wParam);
    00306
    00307             case CONIME_SETFOCUS:
    00308                 DBGPRINT(("CONIME: CONIME_SETFOCUS: Console Handle=%08x\n", wParam));
    00309                 return ConsoleSetFocus(hWnd, (HANDLE)wParam, (HKL)lParam);
    00310
    00311             case CONIME_KILLFOCUS:
    00312                 DBGPRINT(("CONIME: CONIME_KILLFOCUS: Console Handle=%08x\n", wParam));
    00313                 return ConsoleKillFocus(hWnd, (HANDLE)wParam);
    00314
    00315             case CONIME_GET_NLSMODE:
    00316                 DBGPRINT(("CONIME: CONIME_GET_NLSMODE: Console Handle=%08x\n", wParam));
    00317                 return GetNLSMode(hWnd, (HANDLE)wParam);
    00318
    00319             case CONIME_SET_NLSMODE:
    00320                 DBGPRINT(("CONIME: CONIME_SET_NLSMODE: Console Handle=%08x\n", wParam));
    00321                 return SetNLSMode(hWnd, (HANDLE)wParam, (DWORD)lParam);
    00322
    00323             case CONIME_HOTKEY:
    00324                 DBGPRINT(("CONIME: CONIME_HOTKEY\n"));
    00325                 return ConimeHotkey(hWnd, (HANDLE)wParam, (DWORD)lParam);
    00326
    00327             case CONIME_NOTIFY_VK_KANA:
    00328                 DBGPRINT(("CONIME: CONIME_NOTIFY_VK_KANA\n"));
    00329                 return ImeUISetConversionMode(hWnd);
    00330
    00331             case CONIME_NOTIFY_SCREENBUFFERSIZE: {
    00332                 COORD ScreenBufferSize;
    00333                 DBGPRINT(("CONIME: CONIME_NOTIFY_SCREENBUFFERSIZE: Console Handle=%08x\n", wParam));
    00334                 ScreenBufferSize.X = LOWORD(lParam);
    00335                 ScreenBufferSize.Y = HIWORD(lParam);
    00336                 return ConsoleScreenBufferSize(hWnd, (HANDLE)wParam, ScreenBufferSize);
    00337             }
    00338
    00339             case CONIME_INPUTLANGCHANGE: {
    00340                 DBGPRINT(("CONIME: CONIME_INPUTLANGCHANGE: Console Handle=%08x \n",wParam));
    00341                 ConImeInputLangchange(hWnd, (HANDLE)wParam, (HKL)lParam );
    00342                 return TRUE;
    00343             }
    00344
    00345             case CONIME_NOTIFY_CODEPAGE: {
    00346                 BOOL Output;
    00347                 WORD Codepage;
    00348
    00349                 Codepage = HIWORD(lParam);
    00350                 Output = LOWORD(lParam);
    00351                 DBGPRINT(("CONIME: CONIME_NOTIFY_CODEPAGE: Console Handle=%08x %04x %04x\n",wParam, Output, Codepage));
    00352                 return ConsoleCodepageChange(hWnd, (HANDLE)wParam, Output, Codepage);
    00353             }
    00354
    00355             case WM_KEYDOWN    +CONIME_KEYDATA:
    00356             case WM_KEYUP      +CONIME_KEYDATA:
    00357             case WM_SYSKEYDOWN +CONIME_KEYDATA:
    00358             case WM_SYSKEYUP   +CONIME_KEYDATA:
    00359             case WM_DEADCHAR   +CONIME_KEYDATA:
    00360             case WM_SYSDEADCHAR+CONIME_KEYDATA:
    00361             case WM_SYSCHAR    +CONIME_KEYDATA:
    00362             case WM_CHAR       +CONIME_KEYDATA:
    00363                 CharHandlerFromConsole( hWnd, Message, (ULONG)wParam, (ULONG)lParam );
    00364                 break;
    00365             case WM_KEYDOWN:
    00366             case WM_KEYUP:
    00367             case WM_SYSKEYDOWN:
    00368             case WM_SYSKEYUP:
    00369             case WM_DEADCHAR:
    00370             case WM_SYSDEADCHAR:
    00371             case WM_SYSCHAR:
    00372             case WM_CHAR:
    00373                 CharHandlerToConsole( hWnd, Message, (ULONG)wParam, (ULONG)lParam );
    00374                 break;
    00375
    00376             case WM_INPUTLANGCHANGE:
    00377                 DBGPRINT(("CONIME: CONIME_INPUTLANGCHANGE: Console Handle=%08x \n",wParam));
    00378                 InputLangchange(hWnd, (DWORD)wParam, (HKL)lParam );
    00379                 return TRUE;
    00380
    00381             case WM_INPUTLANGCHANGEREQUEST:
    00382                 // Console IME never receive this message for this window is hidden
    00383                 // and doesn't have focus.
    00384                 //
    00385                 // However, Hot key of IME_CHOTKEY_IME_NONIME_TOGGLE/IME_THOTKEY_IME_NONIME_TOGGLE
    00386                 // are send this message by ImmSimulateHotKey API.
    00387                 //
    00388                 // If nothing processing by this message, then DefWindowProc calls
    00389                 // ActivateKeyboardLayout on kernel side.
    00390                 // And, ActivateKeyboardLayout send WM_INPUTLANGCHANGE message to focus window
    00391                 // on this message queue.
    00392                 // It window is console window procedure.
    00393                 // Console window procedure can do send CONIME_INPUTLANGCHANGE message to
    00394                 // console IME window.
    00395                 // In console window is windowed case, this sequence as well.
    00396                 // But, In console window is full screen case, message queue have not focus.
    00397                 // WM_INPUTLANGCHANGE message can not send to console window procedure.
    00398                 //
    00399                 // This code avoid console full screen mode problem.
    00400                 // Send message to console window procedure when this window receive it.
    00401                 //
    00402                 {
    00403                     PCONSOLE_TABLE ConTbl;
    00404
    00405                     ConTbl = SearchConsole(LastConsole);
    00406                     if (ConTbl == NULL) {
    00407                         return DefWindowProc(hWnd, Message, wParam, lParam);
    00408                     }
    00409
    00410                     PostMessage(ConTbl->hWndCon, Message, wParam, lParam);
    00411                 }
    00412                 return TRUE;    // TRUE : process this message by application
    00413
    00414             case CONIME_INPUTLANGCHANGEREQUEST:
    00415                 DBGPRINT(("CONIME: CONIME_INPUTLANGCHANGEREQUEST: Console Handle=%08x \n",wParam));
    00416                 return ConImeInputLangchangeRequest(hWnd, (HANDLE)wParam, (HKL)lParam, CONIME_DIRECT);
    00417
    00418             case CONIME_INPUTLANGCHANGEREQUESTFORWARD:
    00419                 DBGPRINT(("CONIME: CONIME_INPUTLANGCHANGEREQUEST: Console Handle=%08x \n",wParam));
    00420                 return ConImeInputLangchangeRequest(hWnd, (HANDLE)wParam, (HKL)lParam, CONIME_FORWARD);
    00421
    00422             case CONIME_INPUTLANGCHANGEREQUESTBACKWARD:
    00423                 DBGPRINT(("CONIME: CONIME_INPUTLANGCHANGEREQUEST: Console Handle=%08x \n",wParam));
    00424                 return ConImeInputLangchangeRequest(hWnd, (HANDLE)wParam, (HKL)lParam, CONIME_BACKWARD);
    00425
    00426 #ifdef DEBUG_MODE
    00427             case WM_MOVE:
    00428                 ImeUIMoveCandWin( hWnd );
    00429                 break;
    00430
    00431             case WM_COMMAND: // message: command from application menu
    00432
    00433                 // Message packing of wparam and lparam have changed for Win32,
    00434                 // so use the GET_WM_COMMAND macro to unpack the commnad
    00435
    00436                 switch (LOWORD(wParam)) {
    00437                     case MM_EXIT:
    00438                         PostMessage(hWnd,WM_CLOSE,0,0L);
    00439                         break;
    00440
    00441                     case MM_ACCESS_VIOLATION:
    00442                         {
    00443                             PBYTE p = 0;
    00444                             *p = 0;
    00445                         }
    00446                         break;
    00447                 }
    00448                 break;
    00449 #endif
    00450
    00451             case WM_IME_STARTCOMPOSITION:
    00452                 ImeUIStartComposition( hWnd );
    00453                 break;
    00454             case WM_IME_ENDCOMPOSITION:
    00455                 ImeUIEndComposition( hWnd );
    00456                 break;
    00457             case WM_IME_COMPOSITION:
    00458                 ImeUIComposition( hWnd, wParam, lParam );
    00459                 break;
    00460             case WM_IME_COMPOSITIONFULL:
    00461                 break;
    00462             case WM_IME_NOTIFY:
    00463                 if ( !ImeUINotify( hWnd, wParam, lParam ) ) {
    00464                     return DefWindowProc(hWnd, Message, wParam, lParam);
    00465                 }
    00466                 break;
    00467             case WM_IME_SETCONTEXT:
    00468                 //
    00469                 // The application have to pass WM_IME_SETCONTEXT to DefWindowProc.
    00470                 // When the application want to handle the IME at the timing of
    00471                 // focus changing, the application should use WM_GETFOCUS or
    00472                 // WM_KILLFOCUS.
    00473                 //
    00474                 lParam &= ~ISC_SHOWUIALL;
    00475
    00476                 return DefWindowProc( hWnd, Message, wParam, lParam );
    00477             case WM_IME_SYSTEM:
    00478                 switch (wParam) {
    00479                     case IMS_CLOSEPROPERTYWINDOW:
    00480                     case IMS_OPENPROPERTYWINDOW:
    00481                         ImeSysPropertyWindow(hWnd, wParam, lParam);
    00482                         break;
    00483                     default:
    00484                         return DefWindowProc( hWnd, Message, wParam, lParam );
    00485                 }
    00486                 break;
    00487
    00488             case WM_CREATE:
    00489                 return Create(hWnd);
    00490                 break;
    00491
    00492             case WM_DESTROY:
    00493                 DBGPRINT(("CONIME:Recieve WM_DESTROY\n"));
    00494                 ExitList(hWnd);
    00495                 PostQuitMessage(0);
    00496                 return 0;
    00497                 break;
    00498
    00499             case WM_CLOSE:
    00500                 DBGPRINT(("CONIME:Recieve WM_CLOSE\n"));
    00501                 DestroyWindow(hWnd);
    00502                 return 0;
    00503                 break;
    00504
    00505             case WM_ENABLE:{
    00506                 PCONSOLE_TABLE FocusedConsole;
    00507                 if (!wParam) {
    00508                     FocusedConsole = SearchConsole(LastConsole);
    00509                     if (FocusedConsole != NULL &&
    00510                         FocusedConsole->hConsole != NULL) {
    00511                         FocusedConsole->Enable = FALSE;
    00512                         EnableWindow(FocusedConsole->hWndCon,FALSE);
    00513                         gfDoNotKillFocus = TRUE;
    00514                     }
    00515                 }
    00516                 else{
    00517                     DWORD i;
    00518                     LockConsoleTable();
    00519                     for ( i = 1; i < NumberOfConsoleTable; i ++){
    00520                         FocusedConsole = ConsoleTable[i];
    00521                         if (FocusedConsole != NULL)
    00522                         {
    00523                             if ((FocusedConsole->hConsole != NULL)&&
    00524                                 (!FocusedConsole->Enable)&&
    00525                                 (!IsWindowEnabled(FocusedConsole->hWndCon))){
    00526                                 EnableWindow(FocusedConsole->hWndCon,TRUE);
    00527                                 FocusedConsole->Enable = TRUE;
    00528                                 if (!FocusedConsole->LateRemove)
    00529                                     SetForegroundWindow(FocusedConsole->hWndCon);
    00530                             }
    00531                         }
    00532                     }
    00533                     UnlockConsoleTable();
    00534                 }
    00535                 return DefWindowProc(hWnd, Message, wParam, lParam);
    00536                 break;
    00537             }
    00538
    00539 #ifdef DEBUG_MODE
    00540             case WM_SETFOCUS:
    00541                 CreateCaret( hWnd,
    00542                              NULL,
    00543                              IsUnicodeFullWidth( ConvertLine[xPos] ) ?
    00544                              CaretWidth*2 : CaretWidth,
    00545                              (UINT)cyMetrics );
    00546                 SetCaretPos( xPos * cxMetrics, 0 );
    00547                 ShowCaret( hWnd );
    00548                 break;
    00549
    00550             case WM_KILLFOCUS:
    00551                 HideCaret( hWnd );
    00552                 DestroyCaret();
    00553                 break;
    00554
    00555             case WM_PAINT:
    00556                 {
    00557                     PAINTSTRUCT pstruc;
    00558                     HDC  hDC;
    00559                     hDC = BeginPaint(hWnd,&pstruc);
    00560                     ReDraw(hWnd);
    00561                     EndPaint(hWnd,&pstruc);
    00562                     break;
    00563                 }
    00564 #endif
    00565
    00566             case WM_QUERYENDSESSION:
    00567 #ifdef HIRSHI_DEBUG
    00568                 /*
    00569                  * If specified ntsd debugger on this process,
    00570                  * then never catch WM_QUERYENDSESSION when logoff/shutdown because
    00571                  * this process will terminate when ntsd process terminated.
    00572                  */
    00573                 {
    00574                     int i;
    00575                     i = MessageBox(hWnd,TEXT("Could you approve exit session?"), TEXT("Console IME"),
    00576                                    MB_ICONSTOP | MB_YESNO);
    00577                     return (i == IDYES ? TRUE : FALSE);
    00578                 }
    00579 #endif
    00580                 return TRUE;           // Logoff or shutdown time.
    00581
    00582             case WM_ENDSESSION:
    00583                 DBGPRINT(("CONIME:Recieve WM_ENDSESSION\n"));
    00584                 ExitList(hWnd);
    00585                 return 0;
    00586
    00587             default:          // Passes it on if unproccessed
    00588                 return DefWindowProc(hWnd, Message, wParam, lParam);
    00589         }
    00590
    00591     } except (InputExceptionFilter(GetExceptionInformation())) {
    00592
    00593         if (dwConsoleThreadId)
    00594         {
    00595             DBGPRINT(("CONIME: Exception on WndProc!!\n"));
    00596             UnregisterConsoleIME();
    00597             dwConsoleThreadId = 0;
    00598
    00599             DestroyWindow(hWnd);
    00600             return 0;
    00601         }
    00602
    00603     }
    00604
    00605
    00606     return TRUE;
    00607 }

## Variable Documentation

PCONSOLE_TABLE* ConsoleTable

| Definition at line 29 of file ntcon/conime/conime.c. Referenced by ExitList(), GrowConsoleTable(), InitConsoleIME(), InsertConsole(), SearchConsole(), and WndProc().

CRITICAL_SECTION ConsoleTableLock

| Definition at line 32 of file ntcon/conime/conime.c. Referenced by InitConsoleIME().

DWORD dwConsoleThreadId

| Definition at line 40 of file ntcon/conime/conime.c. Referenced by AllocateConsole(), ExitList(), InitConsoleIME(), WinMain(), and WndProc().

BOOL gfDoNotKillFocus

| Definition at line 37 of file ntcon/conime/conime.c. Referenced by ConsoleKillFocus(), ConsoleSetFocus(), and WndProc().

HIMC ghDefaultIMC

| Definition at line 27 of file ntcon/conime/conime.c. Referenced by ConsoleKillFocus(), Create(), and ExitList().

HANDLE LastConsole

| Definition at line 26 of file ntcon/conime/conime.c. Referenced by CharHandlerToConsole(), ConImeInputLangchange(), ConsoleSetFocus(), GetCompositionStr(), ImeSysPropertyWindow(), ImeUICloseCandidate(), ImeUIEndComposition(), ImeUIGuideLine(), ImeUIOpenCandidate(), ImeUIOpenStatusWindow(), ImeUISetConversionMode(), ImeUISetOpenStatus(), ImeUIStartComposition(), InputLangchange(), ReDisplayCompositionStr(), SearchConsole(), and WndProc().

ULONG NumberOfConsoleTable

| Definition at line 30 of file ntcon/conime/conime.c. Referenced by ExitList(), GrowConsoleTable(), InitConsoleIME(), InsertConsole(), SearchConsole(), and WndProc().