CnC_Renegade/Code/wwui/IMEManager.cpp

/*
**	Command & Conquer Renegade(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program is free software: you can redistribute it and/or modify
**	it under the terms of the GNU General Public License as published by
**	the Free Software Foundation, either version 3 of the License, or
**	(at your option) any later version.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/******************************************************************************
*
* FILE
*     $Archive: /Commando/Code/wwui/IMEManager.cpp $
*
* DESCRIPTION
*     Input Method Editor Manager for input of far east characters.
*
* PROGRAMMER
*     $Author: Denzil_l $
*
* VERSION INFO
*     $Revision: 6 $
*     $Modtime: 1/12/02 9:44p $
*
******************************************************************************/

#include "IMEManager.h"
#include "WWString.h"
#include "WWDebug.h"
#include <locale.h>
#include <mbctype.h>

#if defined(_MSC_VER)
#pragma warning(push, 3)
#endif

#include <algorithm>
#include <memory>

#if defined(_MSC_VER)
#pragma warning(pop)
#endif

#pragma comment(lib, "imm32.lib")

namespace IME {

/******************************************************************************
*
* NAME
*     IMEManager::Create
*
* DESCRIPTION
*     Create an IME manager instance
*
* INPUTS
*     Window - HWND to associate IME manager instance with.
*
* RESULT
*     IMEManager - Pointer to IME manager
*
******************************************************************************/

IMEManager* IMEManager::Create(HWND hwnd)
	{
	if (hwnd)
		{
		IMEManager* ime = new IMEManager;

		if (ime)
			{
			if (ime->FinalizeCreate(hwnd))
				{
				return ime;
				}

			ime->Release_Ref();
			}
		}

	return NULL;
	}


/******************************************************************************
*
* NAME
*     IMEManager::IMEManager
*
* DESCRIPTION
*     Constructor
*
* INPUTS
*     NONE
*
* RESULT
*     NONE
*
******************************************************************************/

IMEManager::IMEManager() :
		mHWND(NULL),
		mHIMC(NULL),
		mDisabledHIMC(NULL),
		mDisableCount(0),
		mCodePage(CP_ACP),
		mIMEProperties(0),
		mHilite(true),
		mStartCandListFrom1(true),
		mOSCanUnicode(false),
		mUseUnicode(false),
		mInComposition(false)
	{
	WWDEBUG_SAY(("IMEManager: Instantiated\n"));

	mLangID = MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT);

	ResetComposition();
	mResultString[0] = 0;
	}


/******************************************************************************
*
* NAME
*     IMEManager::~IMEManager
*
* DESCRIPTION
*     Destructor
*
* INPUTS
*     NONE
*
* RESULT
*     NONE
*
******************************************************************************/

IMEManager::~IMEManager()
	{
	WWDEBUG_SAY(("IMEManager: destroyed\n"));

	if (mHIMC)
		{
		ImmAssociateContext(mHWND, mDefaultHIMC);
		ImmDestroyContext(mHIMC);
		}

	mCandidateColl.clear();
	}


/******************************************************************************
*
* NAME
*     IMEManager::FinalizeCreate
*
* DESCRIPTION
*     Post creation finalization.
*
* INPUTS
*     HWND - Window to associate IME context with.
*
* RESULT
*     True if successful
*
******************************************************************************/

bool IMEManager::FinalizeCreate(HWND hwnd)
	{
	if (hwnd == NULL)
		{
		return false;
		}

	mHWND = hwnd;

	// Check the OS version, if Win98 or better then we can use unicode
	OSVERSIONINFO osvi;
	osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
	GetVersionEx(&osvi);

	bool isWin98orLater = (osvi.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) && ((osvi.dwMajorVersion > 4) || ((osvi.dwMajorVersion == 4) && (osvi.dwMinorVersion >= 10)));
	bool isNT4orLater = (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT) && ((osvi.dwMajorVersion > 4) || ((osvi.dwMajorVersion == 4) && (osvi.dwMinorVersion >= 0)));
	mOSCanUnicode = (isWin98orLater || isNT4orLater);

	// Create new input context for the specified window.
	mHIMC = ImmCreateContext();
	
	if (mHIMC == NULL)
		{
		return false;
		}

	// Associate the new context with this window.
	mDefaultHIMC = ImmAssociateContext(mHWND, mHIMC);

	// Set the language for the current keyboard layout.
	InputLanguageChanged(GetKeyboardLayout(0));

	mCandidateColl.resize(32);

	return true;
	}


/******************************************************************************
*
* NAME
*     IMEManager::Activate
*
* DESCRIPTION
*
* INPUTS
*     NONE
*
* RESULT
*     NONE
*
******************************************************************************/

void IMEManager::Activate(void)
	{
	WWDEBUG_SAY(("IMEManager: Activate\n"));

	HIMC imc = ImmGetContext(mHWND);

	if (imc)
		{
		BOOL open = ImmGetOpenStatus(imc);

		if (!open)
			{
			ImmSetOpenStatus(imc, TRUE);

			IMEEvent action(IME_ACTIVATED, this);
			NotifyObservers(action);
			}

		ImmReleaseContext(mHWND, imc);
		}
	}


/******************************************************************************
*
* NAME
*     IMEManager::Deactivate
*
* DESCRIPTION
*
* INPUTS
*     NONE
*
* RESULT
*     NONE
*
******************************************************************************/

void IMEManager::Deactivate(void)
	{
	WWDEBUG_SAY(("IMEManager: Deactivate\n"));

	HIMC imc = ImmGetContext(mHWND);

	if (imc)
		{
		BOOL open = ImmGetOpenStatus(imc);

		if (open)
			{
			ImmSetOpenStatus(imc, FALSE);

			IMEEvent action(IME_DEACTIVATED, this);
			NotifyObservers(action);
			}

		ImmReleaseContext(mHWND, imc);
		}

	ResetComposition();
	}


/******************************************************************************
*
* NAME
*     IMEManager::IsActive
*
* DESCRIPTION
*     Check if IME is active.
*
* INPUTS
*     NONE
*
* RESULT
*     True if IME is currently active.
*
******************************************************************************/

bool IMEManager::IsActive(void) const
	{
	bool isActive = false;

	HIMC imc = ImmGetContext(mHWND);

	if (imc)
		{
		BOOL open = ImmGetOpenStatus(imc);
		isActive = (open != 0);
		ImmReleaseContext(mHWND, imc);
		}

	return isActive;
	}


/******************************************************************************
*
* NAME
*     IMEManager::Disable
*
* DESCRIPTION
*
* INPUTS
*     NONE
*
* RESULT
*     NONE
*
******************************************************************************/

void IMEManager::Disable(void)
	{
	++mDisableCount;

	// If this is the first disable lock the perform the actuall disabling.
	if (1 == mDisableCount)
		{
		WWDEBUG_SAY(("IMEManager: Disabled\n"));
		mDisabledHIMC = ImmAssociateContext(mHWND, NULL);

		IMEEvent action(IME_DISABLED, this);
		NotifyObservers(action);
		}
	}


/******************************************************************************
*
* NAME
*     IMEManager::Enable
*
* DESCRIPTION
*
* INPUTS
*     NONE
*
* RESULT
*     NONE
*
******************************************************************************/

void IMEManager::Enable(void)
	{
	if (mDisableCount > 0)
		{
		--mDisableCount;

		// Re-enable when there is no disable locks.
		if (0 == mDisableCount)
			{
			WWDEBUG_SAY(("IMEManager: Enabled\n"));
			ImmAssociateContext(mHWND, mDisabledHIMC);
			mDisabledHIMC = NULL;

			IMEEvent action(IME_ENABLED, this);
			NotifyObservers(action);
			}
		}
	}


/******************************************************************************
*
* NAME
*     IMEManager::IsDisabled
*
* DESCRIPTION
*     Check if IME is turned off.
*
* INPUTS
*     NONE
*
* RESULT
*     True if IME is currently off.
*
******************************************************************************/

bool IMEManager::IsDisabled(void) const
	{
	return (mDisableCount > 0);
	}


/******************************************************************************
*
* NAME
*     IMEManager::ProcessMessage
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*     True of message handled and therefore should NOT be passed to the
*     default window procedure.
*
******************************************************************************/

bool IMEManager::ProcessMessage(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, LRESULT& outResult)
	{
	if (hwnd != mHWND)
		{
		return false;
		}

	bool handled = true;
	outResult = 0;

	switch (msg)
		{
		// Request New keyboard layout and / or Input method
		case WM_INPUTLANGCHANGEREQUEST:
			{
			HKL layout = InputLanguageChangeRequest((HKL)lParam);

			if (layout)
				{
				lParam = (LPARAM)layout;
				handled = false;
				}
			}
			break;

		// Input language has changed.
		case WM_INPUTLANGCHANGE:
			InputLanguageChanged((HKL)lParam);
			outResult = TRUE;
			handled = false;
			break;

		// Sent when the system is about to change the current IME.
		case WM_IME_SELECT:
			WWDEBUG_SAY(("IMEManager: WM_IME_SELECT\n"));
			break;

		// We will handle all of the UI so clear all of the flags.
		case WM_IME_SETCONTEXT:
			lParam &= ~(ISC_SHOWUIALL);
			handled = false;
			break;

		// Sent when a composition string is about to be generated in response to a
		// keystroke. This message informs us to prepare for composition.
		case WM_IME_STARTCOMPOSITION:
			StartComposition();
			break;

		// Sent when composition status has changed in response to a keystroke.
		case WM_IME_COMPOSITION:
			DoComposition(wParam, lParam);
			break;

		// Sent when composition has closed.
		case WM_IME_ENDCOMPOSITION:
			EndComposition();
			break;

		// Sent when unable to extend the composition to accomodate any more characters.
		case WM_IME_COMPOSITIONFULL:
			{
			WWDEBUG_SAY(("IMEManager: WM_IME_COMPOSITIONFULL\n"));
			CompositionEvent event(COMPOSITION_FULL, this);
			NotifyObservers(event);
			}
			break;

		// Sent when the IME status has changed.
		case WM_IME_NOTIFY:
			outResult = IMENotify(wParam, lParam);
			break;

		// IMEs send this message when the user accepts the conversion string.
		// wParam contains a single-byte or double-byte character.
		case WM_IME_CHAR:
			handled = IMECharHandler((unsigned short)wParam);

			if (handled)
				{
				outResult = TRUE;
				}
			break;

		case WM_CHAR:
			handled = CharHandler((unsigned short)wParam);

			if (handled)
				{
				outResult = TRUE;
				}
			break;

		case WM_KEYDOWN:
			if (mInComposition)
				{
				outResult = DefWindowProc(hwnd, msg, wParam, lParam);
				}
			else
				{
				handled = false;
				}
			break;

		case WM_KEYUP:
			if (mInComposition)
				{
				#ifdef SHOW_IME_TYPING

				bool typingChanged = false;
				UINT virtualKey = wParam;

				if (VK_BACK == virtualKey)
					{
					if (mTypingCursorPos > 0)
						{
						--mTypingCursorPos;
						mTypingString[mTypingCursorPos] = 0;
						typingChanged = true;
						}
					}
				else if ((0x30 <= virtualKey && 0x39 >= virtualKey) || (0x41 <= virtualKey && 0x5A >= virtualKey))
					{
					if (mTypingCursorPos < IME_MAX_TYPING_LEN)
						{
						mTypingString[mTypingCursorPos] = (wchar_t)virtualKey;
						++mTypingCursorPos;
						mTypingString[mTypingCursorPos] = 0;
						typingChanged = true;
						}
					}

				if (typingChanged)
					{
					CompositionEvent event(COMPOSITION_TYPING, this);
					NotifyObservers(event);
					}
				#endif

				outResult = DefWindowProc(hwnd, msg, wParam, lParam);
				}
			else
				{
				handled = false;
				}
			break;

		case WM_IME_CONTROL:
		case WM_IME_KEYDOWN:
		case WM_IME_KEYUP:
		default:
			handled = false;
			break;
		}

	return handled;
	}


/******************************************************************************
*
* NAME
*     IMEManager::IMENotify
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*
******************************************************************************/

LRESULT IMEManager::IMENotify(WPARAM wParam, LPARAM lParam)
	{
	switch (wParam)
		{
		// The open status of the input context has changed.
		case IMN_SETOPENSTATUS:
			WWDEBUG_SAY(("IMEManager: IMN_SETOPENSTATUS\n"));
			{
			HIMC imc = ImmGetContext(mHWND);

			if (imc)
				{
				IMEAction action = IME_DEACTIVATED;

				if (!ImmGetOpenStatus(imc))
					{
					// If the IME conversion engine is closed, we need to
					// erase all currently displayed composition chars and any
					// candidate windows.
					mCandidateColl.clear();
					ResetComposition();
					}
				else
					{
					action = IME_ACTIVATED;
					}

				ImmReleaseContext(mHWND, imc);

				IMEEvent event(action, this);
				NotifyObservers(event);
				}
			}
			break;

		// Open the status window
		case IMN_OPENSTATUSWINDOW:
			WWDEBUG_SAY(("IMEManager: IMN_OPENSTATUSWINDOW\n"));
			break;

		// Close the status window
		case IMN_CLOSESTATUSWINDOW:
			WWDEBUG_SAY(("IMEManager: IMN_CLOSESTATUSWINDOW\n"));
			break;

		// Update the position of the status window.
		case IMN_SETSTATUSWINDOWPOS:
			WWDEBUG_SAY(("IMEManager: IMN_SETSTATUSWINDOWPOS\n"));
			break;

		// The font of the input context has changed.
		case IMN_SETCOMPOSITIONFONT:
			WWDEBUG_SAY(("IMEManager: IMN_SETCOMPOSITIONFONT\n"));
			break;

		// The style or position of the composition window has changed.
		case IMN_SETCOMPOSITIONWINDOW:
			WWDEBUG_SAY(("IMEManager: IMN_SETCOMPOSITIONWINDOW\n"));
			break;

		// The conversion mode of the input context has changed.
		case IMN_SETCONVERSIONMODE:
			WWDEBUG_SAY(("IMEManager: IMN_SETCONVERSIONMODE\n"));

#ifdef WWDEBUG
			{
			HIMC imc = ImmGetContext(mHWND);

			if (imc)
				{
				DWORD conversionMode = 0;
				DWORD sentenceMode = 0;

				BOOL okay = ImmGetConversionStatus(imc, &conversionMode, &sentenceMode);

				if (okay)
					{
					WWDEBUG_SAY(("IMEManager: ConversionMode - "));

					static struct convmodestruct {long flag; const char* ondesc; const char* offdesc;} _convModes[] = 
						{
						{IME_CMODE_CHARCODE, "CharCode:On", "CharCode:Off"},
						{IME_CMODE_EUDC, " EUDC:On", " EUDC:Off"},
						{IME_CMODE_FIXED, " Fixed:On", " Fixed:Off"},
						{IME_CMODE_FULLSHAPE, " FullShape", " HalfShape"},
						{IME_CMODE_HANJACONVERT, " Hanja:On", " Hanja:Off"},
						{IME_CMODE_KATAKANA, " Katakana", " Hiragana"},
						{IME_CMODE_NATIVE, " Native", " Alphanumberic"},
						{IME_CMODE_NOCONVERSION, " Conversion:Off", " Conversion:On"},
						{IME_CMODE_ROMAN, " Roman:On", " Roman:Off"},
						{IME_CMODE_SOFTKBD, " SoftKbd:On", " SoftKbd:Off"},
						{IME_CMODE_SYMBOL, " Symbol:On", " Symbol:Off"},
						{0, ""}
						};

					int flgidx = 0;

					while (_convModes[flgidx].flag)
						{
						if (conversionMode & _convModes[flgidx].flag)
							{
							WWDEBUG_SAY((_convModes[flgidx].ondesc));
							}
						else
							{
							WWDEBUG_SAY((_convModes[flgidx].offdesc));
							}

						flgidx++;
						}

					WWDEBUG_SAY(("\n"));
					}

				ImmReleaseContext(mHWND, imc);
				}
			}
#endif
			break;

		// The sentence mode has changed.
		case IMN_SETSENTENCEMODE:
			WWDEBUG_SAY(("IMEManager: IMN_SETSENTENCEMODE\n"));

#ifdef WWDEBUG
			{
			HIMC imc = ImmGetContext(mHWND);

			if (imc)
				{
				DWORD conversionMode = 0;
				DWORD sentenceMode = 0;

				BOOL okay = ImmGetConversionStatus(imc, &conversionMode, &sentenceMode);

				if (okay)
					{
					WWDEBUG_SAY(("IMEManager: SentenceMode - "));

					static struct smodestruct {long flag; const char* ondesc; const char* offdesc;} _sModes[] = 
						{
						{IME_SMODE_AUTOMATIC, "Automatic:On", "Automatic:Off"},
						{IME_SMODE_NONE, " SentenceInfo:Off", " SentenceInfo:On"},
						{IME_SMODE_PHRASEPREDICT, " PhrasePredict:On", " PhrasePredict:Off"},
						{IME_SMODE_PLAURALCLAUSE, " PluralClause:On", " PluralClause:Off"},
						{IME_SMODE_SINGLECONVERT, " SingleConvert:On", " SingleConvert:Off"},
						{IME_SMODE_CONVERSATION, " Conversation:On", " Conversation:Off"},
						{0, ""}
						};

					int flgidx = 0;

					while (_sModes[flgidx].flag)
						{
						if (sentenceMode & _sModes[flgidx].flag)
							{
							WWDEBUG_SAY((_sModes[flgidx].ondesc));
							}
						else
							{
							WWDEBUG_SAY((_sModes[flgidx].offdesc));
							}

						flgidx++;
						}

					WWDEBUG_SAY(("\n"));
					}

				ImmReleaseContext(mHWND, imc);
				}
			}
#endif
			break;

		// Open the candidate window (lParam = candidate flags)
		case IMN_OPENCANDIDATE:
			OpenCandidate(lParam);
			break;

		// Close the candidate window. (lParam = candidate flags)
		case IMN_CLOSECANDIDATE:
			CloseCandidate(lParam);
			break;

		// Changing the contents of the candidate window (lParam = candidate flags)
		case IMN_CHANGECANDIDATE:
			ChangeCandidate(lParam);
			break;

		// Candidate processing is finished; moving the candidate window
		case IMN_SETCANDIDATEPOS:
			WWDEBUG_SAY(("IMEManager: IMN_SETCANDIDATEPOS\n"));
			break;

		// Show error message or other information
		case IMN_GUIDELINE:
			WWDEBUG_SAY(("IMEManager: IMN_GUIDELINE\n"));
			{
			IMEEvent event(IME_GUIDELINE, this);
			NotifyObservers(event);
			}
			break;

		default:
			break;
		}
	
	return TRUE;
	}


/******************************************************************************
*
* NAME
*     IMEManager::InputLanguageChangeRequest
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*
******************************************************************************/

HKL IMEManager::InputLanguageChangeRequest(HKL hkl)
	{
	WWDEBUG_SAY(("IMEManager: Input language change request\n"));

	// Get the number of Keyboard layouts available to the system
	UINT numLayouts = GetKeyboardLayoutList(0, NULL);

	if (numLayouts)
		{
		// Get the list of layouts
		std::vector<HKL> layoutList(numLayouts);
		layoutList.resize(numLayouts);

		numLayouts = GetKeyboardLayoutList(numLayouts, layoutList.begin());

		// Find the position in the list of the layout which has been requested.
		std::vector<HKL>::iterator iter = std::find(layoutList.begin(), layoutList.end(), hkl);

		if (iter != layoutList.end())
			{
			// Rotate the list so the requested layout is at the head.
			std::rotate(layoutList.begin(), iter, layoutList.end());

			// Look for the layout that doesn't have the  AT_CARET or SPECIAL_UI properties
			iter = layoutList.begin();

			while (iter != layoutList.end())
				{
				DWORD property = ImmGetProperty(*iter, IGP_PROPERTY);

				if ((property & (IME_PROP_AT_CARET | IME_PROP_SPECIAL_UI)) == (IME_PROP_AT_CARET | IME_PROP_SPECIAL_UI))
					{
					iter++;
					}
				else
					{
					return *iter;
					}
				}
			}
		}

	return NULL;
	}


/******************************************************************************
*
* NAME
*     IMEManager::InputLanguageChanged
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*
******************************************************************************/

void IMEManager::InputLanguageChanged(HKL hkl)
	{
	mLangID = LOWORD(hkl);
	DWORD lcid = MAKELCID(mLangID, SORT_DEFAULT);

	// Get the default codepage for this input language
	char localeData[8];
	GetLocaleInfo(lcid, LOCALE_IDEFAULTANSICODEPAGE, localeData, sizeof(localeData));

	// Set the codepage for character conversion
	mCodePage = atoi(localeData);

	// Get properties
	mIMEProperties = ImmGetProperty(hkl, IGP_PROPERTY);

	mStartCandListFrom1 = ((mIMEProperties & IME_PROP_CANDLIST_START_FROM_1) == IME_PROP_CANDLIST_START_FROM_1);
	mUseUnicode = (mOSCanUnicode && (mIMEProperties & IME_PROP_UNICODE));

	// Get IME description
	if (mUseUnicode)
		{
		UINT descSize = ImmGetDescriptionW(hkl, NULL, 0);
		++descSize;
		wchar_t* descPtr = mIMEDescription.Get_Buffer(descSize);

		ImmGetDescriptionW(hkl, descPtr, descSize);
		}
	else
		{
		UINT descSize = ImmGetDescription(hkl, NULL, 0);
		++descSize;

		StringClass desc((int)descSize, true);
		char* descPtr = desc.Get_Buffer(descSize);

		ImmGetDescription(hkl, descPtr, descSize);
		mIMEDescription = desc;
		}

	#if(0)
	mHilite = true;

	static const wchar_t _TradChImeName[] = {0x6CE8,0x97F3,0x8F38,0x5165,0x6CD5,0x0020,0x0034,0x002E,0x0031,0x0020,0x7248,0x0000};

	if (mIMEDescription.Compare(_TradChImeName) == 0)
		{
		mHilite = false;
		}
	#endif

	WWDEBUG_SAY(("IMEManager: Language Changed - LangID = %04X, CodePage = %d, Description: '%S'\n",
			mLangID, mCodePage, mIMEDescription));

	WWDEBUG_SAY(("IMEManager: Properties - %s%s%s%s%s\n",
			mIMEProperties & IME_PROP_AT_CARET ? "At Caret" : "",
			mIMEProperties & IME_PROP_SPECIAL_UI ? ", SpecialUI" : "",
			mIMEProperties & IME_PROP_CANDLIST_START_FROM_1 ? ", CandlistFrom1" : "",
			mIMEProperties & IME_PROP_UNICODE ? ", Unicode" : "",
			mIMEProperties & IME_PROP_COMPLETE_ON_UNSELECT ? ", Complete on Unselect" : ""));

	IMEEvent action(IME_LANGUAGECHANGED, this);
	NotifyObservers(action);
	}


/******************************************************************************
*
* NAME
*     IMEManager::ResetComposition
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*
******************************************************************************/

void IMEManager::ResetComposition(void)
	{
	mInComposition = false;

#ifdef SHOW_IME_TYPING
	mTypingString[0] = 0;
	mTypingCursorPos = 0;
#endif

	mCompositionString[0] = 0;
	memset(mCompositionAttr, 0, sizeof(mCompositionAttr));
	memset(mCompositionClause, 0, sizeof(mCompositionClause));
	mCompositionCursorPos = 0;

	mReadingString[0] = 0;
	}


/******************************************************************************
*
* NAME
*     IMEManager::StartComposition
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*
******************************************************************************/

void IMEManager::StartComposition(void)
	{
	WWDEBUG_SAY(("IMEManager: StartComposition\n"));

	mInComposition = true;
	mResultString[0] = 0;

	CompositionEvent event(COMPOSITION_START, this);
	NotifyObservers(event);
	}


/******************************************************************************
*
* NAME
*     IMEManager::DoComposition
*
* DESCRIPTION
*     Handle composition message.
*
* INPUTS
*
* RESULT
*
******************************************************************************/

void IMEManager::DoComposition(unsigned int dbcs, long compFlags)
	{
	WWDEBUG_SAY(("IMEManager: DoComposition\n"));

#if(0)
	#ifdef _DEBUG
	static struct flagstruct {long flag; const char* desc;} _gcsFlags[] = 
		{
		{GCS_COMPATTR, "GCS_COMPATTR"},
		{GCS_COMPCLAUSE, " GCS_COMPCLAUSE"},
		{GCS_COMPREADATTR, " GCS_COMPREADATTR"},
		{GCS_COMPREADCLAUSE, " GCS_COMPREADCLAUSE"},
		{GCS_DELTASTART, " GCS_DELTASTART"},
		{GCS_RESULTCLAUSE, " GCS_RESULTCLAUSE"},
		{GCS_RESULTREADCLAUSE, " GCS_RESULTREADCLAUSE"},
		{GCS_RESULTREADSTR, " GCS_RESULTREADSTR"},
		{CS_INSERTCHAR, " CS_INSERTCHAR"},
		{CS_NOMOVECARET, " CS_NOMOVECARET"},
		{0, ""}
		};

	WWDEBUG_SAY(("Flags: "));

	int flgidx = 0;

	while (_gcsFlags[flgidx].flag)
		{
		if (compFlags & _gcsFlags[flgidx].flag)
			{
			WWDEBUG_SAY((_gcsFlags[flgidx].desc));
			}

		flgidx++;
		}

	WWDEBUG_SAY(("\n"));
	#endif
#endif

#ifdef SHOW_IME_TYPING
	// Reset the typing string
	mTypingString[0] = 0;
	mTypingCursorPos = 0;
	CompositionEvent event(COMPOSITION_TYPING, this);
	NotifyObservers(event);
#endif

	HIMC imc = ImmGetContext(mHWND);

	if (imc)
		{
		if (compFlags == 0)
			{
			ResetComposition();
			CompositionEvent event(COMPOSITION_CANCEL, this);
			NotifyObservers(event);
			}
		else if (compFlags & GCS_RESULTSTR)
			{
			// Retrieve the result string
			if (ReadCompositionString(imc, GCS_RESULTSTR, mResultString, sizeof(mResultString)))
				{
				WWDEBUG_SAY(("Result string '%S'\n", mResultString));

				CompositionEvent event(COMPOSITION_RESULT, this);
				NotifyObservers(event);
				}
			}
		else
			{
			CompositionAction action = COMPOSITION_INVALID;

			// Update reading string.
			if (compFlags & GCS_COMPREADSTR)
				{
				if (ReadCompositionString(imc, GCS_COMPREADSTR, mReadingString, sizeof(mReadingString)))
					{
					WWDEBUG_SAY(("Reading string '%S'\n", (const wchar_t*)mReadingString));
					action = COMPOSITION_CHANGE;
					}
				}

#ifdef WWDEBUG
			if (compFlags & GCS_COMPREADATTR)
				{
				unsigned char attr[IME_MAX_STRING_LEN * 2];
				long size = ReadReadingAttr(imc, attr, sizeof(attr));

				WWDEBUG_SAY(("ReadAttr: "));
				
				for (long index = 0; index < size; ++index)
					{
					WWDEBUG_SAY(("%01x", (int)attr[index]));
					}
				
				WWDEBUG_SAY(("\n"));
				}
#endif

			// Update composition string.
			if (compFlags & GCS_COMPSTR)
				{
				if (ReadCompositionString(imc, GCS_COMPSTR, mCompositionString, sizeof(mCompositionString)))
					{
					WWDEBUG_SAY(("Composition string '%S'\n", (const wchar_t*)mCompositionString));
					action = COMPOSITION_CHANGE;
					}
				}

			if (compFlags & GCS_COMPATTR)
				{
				long size = ReadCompositionAttr(imc, mCompositionAttr, sizeof(mCompositionAttr));

#ifdef WWDEBUG
				WWDEBUG_SAY(("CompAttr: "));

				for (long index = 0; index < size; ++index)
					{
					WWDEBUG_SAY(("%01x", (int)mCompositionAttr[index]));
					}
				
				WWDEBUG_SAY(("\n"));
#endif
				}

			if (compFlags & GCS_COMPCLAUSE)
				{
				mCompositionClause[0] = 0;
				long size = ReadCompositionClause(imc, mCompositionClause, sizeof(mCompositionClause));

#ifdef WWDEBUG
				WWDEBUG_SAY(("CompClause: "));
				const int count = (size / sizeof(unsigned long));

				for (int index = 0; index < count; ++index)
					{
					WWDEBUG_SAY(("%u ", mCompositionClause[index]));
					}

				WWDEBUG_SAY(("\n"));
#endif
				}

			if (compFlags & GCS_CURSORPOS)
				{
				mCompositionCursorPos = ReadCursorPos(imc);
				action = COMPOSITION_CHANGE;
				}

			if (action != COMPOSITION_INVALID)
				{
				CompositionEvent event(action, this);
				NotifyObservers(event);
				}
			}

		ImmReleaseContext(mHWND, imc);
		}
	}


/******************************************************************************
*
* NAME
*     IMEManager::EndComposition
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*
******************************************************************************/

void IMEManager::EndComposition(void)
	{
	WWDEBUG_SAY(("IMEManager: EndComposition\n"));

	HIMC imc = ImmGetContext(mHWND);

	if (imc)
		{
		ReadCompositionString(imc, GCS_COMPSTR, mResultString, sizeof(mResultString));
		ImmReleaseContext(mHWND, imc);
		}

	ResetComposition();
	CompositionEvent event(COMPOSITION_END, this);
	NotifyObservers(event);
	}


/******************************************************************************
*
* NAME
*     IMEManager::ReadCompositionString
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*
******************************************************************************/

bool IMEManager::ReadCompositionString(HIMC imc, unsigned long flag, wchar_t* buffer, int length)
	{
	if (mUseUnicode)
		{
		LONG size = ImmGetCompositionStringW(imc, flag, buffer, length);

		if (size < 0)
			{
			buffer[0] = 0;
			return false;
			}
		
		// Terminate string
		buffer[(size / sizeof(wchar_t))] = 0;
		}
	else
		{
		// Read the string as multibyte ANSI
		unsigned char string[IME_MAX_STRING_LEN];
		LONG size = ImmGetCompositionString(imc, flag, string, sizeof(string));

		if (size < 0)
			{
			buffer[0] = 0;
			return false;
			}

		// Terminate the string
		string[size] = 0;

		// Convert to Unicode
		MultiByteToWideChar(mCodePage, 0, (const char*)string, -1, buffer, (length / sizeof(wchar_t)));
		}

	return true;
	}


/******************************************************************************
*
* NAME
*     IMEManager::
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*
******************************************************************************/

long IMEManager::ReadReadingAttr(HIMC imc, unsigned char* attr, int length)
	{
	if (mUseUnicode)
		{
		LONG size = ImmGetCompositionStringW(imc, GCS_COMPREADATTR, attr, length);
		return (size / sizeof(wchar_t));
		}

	// Read the string as multibyte ANSI
	unsigned char string[IME_MAX_STRING_LEN];
	LONG size = ImmGetCompositionString(imc, GCS_COMPREADSTR, string, sizeof(string));

	if (size <= 0)
		{
		return 0;
		}

	// Terminate the string
	string[size] = 0;
		
	LONG attrSize = ImmGetCompositionString(imc, GCS_COMPREADATTR, attr, length);
	WWASSERT(size == attrSize);

	if (attrSize <= size)
		{
		return 0;
		}

	return ConvertAttrForUnicode(string, attr);
	}


/******************************************************************************
*
* NAME
*     IMEManager::
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*
******************************************************************************/

long IMEManager::ReadReadingClause(HIMC imc, unsigned long* clause, int length)
	{
	if (mUseUnicode)
		{
		LONG size = ImmGetCompositionStringW(imc, GCS_COMPREADCLAUSE, clause, length);
		return (size / sizeof(wchar_t));
		}

	// Read the string as multibyte ANSI
	unsigned char string[IME_MAX_STRING_LEN];
	LONG size = ImmGetCompositionString(imc, GCS_COMPREADSTR, string, sizeof(string));

	if (size <= 0)
		{
		return 0;
		}

	// Terminate the string
	string[size] = 0;

	LONG clauseSize = ImmGetCompositionString(imc, GCS_COMPREADCLAUSE, clause, length);

	if (clauseSize <= 0)
		{
		return 0;
		}
	
	return ConvertClauseForUnicode(string, size, clause);
	}


/******************************************************************************
*
* NAME
*     IMEManager::
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*
******************************************************************************/

long IMEManager::ReadCompositionAttr(HIMC imc, unsigned char* attr, int length)
	{
	if (mUseUnicode)
		{
		return ImmGetCompositionStringW(imc, GCS_COMPATTR, attr, length);
		}

	// Read the string as multibyte ANSI
	unsigned char string[IME_MAX_STRING_LEN];
	LONG size = ImmGetCompositionString(imc, GCS_COMPSTR, string, sizeof(string));

	if (size <= 0)
		{
		return size;
		}

	// Terminate the string
	string[size] = 0;
		
	LONG attrSize = ImmGetCompositionString(imc, GCS_COMPATTR, attr, length);
	WWASSERT(size == attrSize);

	if (attrSize <= size)
		{
		return 0;
		}

	return ConvertAttrForUnicode(string, attr);
	}


/******************************************************************************
*
* NAME
*     IMEManager::
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*
******************************************************************************/

long IMEManager::ReadCompositionClause(HIMC imc, unsigned long* clause, int length)
	{
	if (mUseUnicode)
		{
		return ImmGetCompositionStringW(imc, GCS_COMPCLAUSE, clause, length);
		}

	// Read the string as multibyte ANSI
	unsigned char string[IME_MAX_STRING_LEN];
	LONG size = ImmGetCompositionString(imc, GCS_COMPSTR, string, sizeof(string));

	if (size <= 0)
		{
		return size;
		}

	// Terminate the string
	string[size] = 0;

	LONG clauseSize = ImmGetCompositionString(imc, GCS_COMPCLAUSE, clause, length);

	if (clauseSize <= 0)
		{
		return 0;
		}
	
	return ConvertClauseForUnicode(string, size, clause);
	}


/******************************************************************************
*
* NAME
*     IMEManager::ReadCursorPos
*
* DESCRIPTION
*     Read the composition string cursor position.
*
* INPUTS
*
* RESULT
*
******************************************************************************/

long IMEManager::ReadCursorPos(HIMC imc)
	{
	if (mUseUnicode)
		{
		long cursorPos = ImmGetCompositionStringW(imc, GCS_CURSORPOS, NULL, 0);
		return (cursorPos & 0x0000FFFF);
		}

	// Get the multibyte string
	char string[IME_MAX_STRING_LEN];
	LONG size = ImmGetCompositionString(imc, GCS_COMPSTR, string, sizeof(string));

	if (size < 0)
		{
		return 0;
		}

	string[size] = 0;

	long cursorPos = ImmGetCompositionString(imc, GCS_CURSORPOS, NULL, 0);
	cursorPos = (cursorPos & 0x0000FFFF);

	// Convert multibyte character position in unicode position.
	return _mbsnccnt((unsigned char*)string, cursorPos);
	}


/******************************************************************************
*
* NAME
*     IMEManager::GetTargetClause
*
* DESCRIPTION
*     Get the composition string conversion target range. This is the characters
*     that are currently be considered for conversion.
*
* INPUTS
*
* RESULT
*
******************************************************************************/

void IMEManager::GetTargetClause(unsigned long& start, unsigned long& end)
	{
	int index = 0;
	const unsigned long compLength = wcslen(mCompositionString);

	while (mCompositionClause[index] < compLength)
		{
		unsigned long offset = mCompositionClause[index];

		if (ATTR_TARGET_CONVERTED == mCompositionAttr[offset])
			{
			start = offset;
			end = mCompositionClause[index + 1];
			return;
			}

		++index;
		}

	start = 0;
	end = 0;
	}


/******************************************************************************
*
* NAME
*     IMEManager::GetCompositionFont
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*
******************************************************************************/

bool IMEManager::GetCompositionFont(LPLOGFONT lpFont)
	{
	BOOL success = FALSE;
	HIMC imc = ImmGetContext(mHWND);

	if (imc)
		{
		success = ImmGetCompositionFont(imc, lpFont);
		ImmReleaseContext(mHWND, imc);
		}

	return (success == TRUE);
	}


/******************************************************************************
*
* NAME
*     IMEManager::OpenCandidate
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*
******************************************************************************/

void IMEManager::OpenCandidate(unsigned long candList)
	{
	WWDEBUG_SAY(("IMEManager: OpenCandidate\n"));

	for (int index = 0; index < 32; index++)
		{
		if (candList & (1 << index))
			{
			IMECandidate& candidate = mCandidateColl[index];
			candidate.Open(index, mHWND, mCodePage, mUseUnicode, mStartCandListFrom1);
			candidate.Read();

			CandidateEvent event(CANDIDATE_OPEN, &candidate);
			NotifyObservers(event);
			}
		}
	}


/******************************************************************************
*
* NAME
*     IMEManager::ChangeCandidate
*
* DESCRIPTION
*     The contents of the candidate list has changed.
*
* INPUTS
*     Changed - Bitfield of the candidate lists that have changed.
*
* RESULT
*     NONE
*
******************************************************************************/

void IMEManager::ChangeCandidate(unsigned long candList)
	{
	WWDEBUG_SAY(("IMEManager: ChangeCandidate\n"));

	for (int index = 0; index < 32; index++)
		{
		if (candList & (1 << index))
			{
			IMECandidate& candidate = mCandidateColl[index];
			candidate.Read();
			CandidateEvent event(CANDIDATE_CHANGE, &candidate);
			NotifyObservers(event);
			}
		}
	}

	
/******************************************************************************
*
* NAME
*     IMEManager::CloseCandidate
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*
******************************************************************************/

void IMEManager::CloseCandidate(unsigned long candList)
	{
	WWDEBUG_SAY(("IMEManager: CloseCandidate\n"));

	for (int index = 0; index < 32; index++)
		{
		if (candList & (1 << index))
			{
			IMECandidate& candidate = mCandidateColl[index];
			CandidateEvent event(CANDIDATE_CLOSE, &candidate);
			NotifyObservers(event);
			candidate.Close();
			}
		}
	}


/******************************************************************************
*
* NAME
*     IMEManager::GetGuideLine
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*
******************************************************************************/

unsigned long IMEManager::GetGuideline(wchar_t* outString, int length)
	{
	unsigned long level = GL_LEVEL_NOGUIDELINE;

	HIMC imc = ImmGetContext(mHWND);

	if (imc)
		{
		level = ImmGetGuideLine(imc, GGL_LEVEL, NULL, 0);

		if ((GL_LEVEL_NOGUIDELINE != level) && outString)
			{
			if (mUseUnicode)
				{
				DWORD size = ImmGetGuideLineW(imc, GGL_STRING, outString, (length * sizeof(wchar_t)));
				WWASSERT(size <= (DWORD)length);
				outString[size / sizeof(wchar_t)] = 0;
				}
			else
				{
				char temp[512];
				DWORD size = ImmGetGuideLine(imc, GGL_STRING, temp, sizeof(temp));
				temp[size] = 0;

				MultiByteToWideChar(mCodePage, 0, temp, -1, outString, length);
				outString[length] = 0;
				}
			}

		ImmReleaseContext(mHWND, imc);
		}

	return level;
	}


/******************************************************************************
*
* NAME
*     IMEManager::IMECharHandler
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*     True if character converted.
*
******************************************************************************/

bool IMEManager::IMECharHandler(unsigned short dbcs)
	{
	unsigned long mbcs = dbcs;

	// If this char has a lead byte then it is double byte. Swap the bytes
	// for generate string order
	if (dbcs & 0xFF00)
		{
		mbcs = (((dbcs & 0xFF) << 8) | (dbcs >> 8));
		}

	// Convert char to unicode
	wchar_t unicode = 0;
	MultiByteToWideChar(mCodePage, 0, (const char*)&mbcs, -1, &unicode, 1);

	UnicodeChar event(unicode);
	NotifyObservers(event);

	return true;
	}


/******************************************************************************
*
* NAME
*     IMEManager::CharHandler
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*     True if character handled.
*
******************************************************************************/

bool IMEManager::CharHandler(unsigned short ch)
	{
	// Because DBCS characters are usually generated by IMEs (as two PostMessages),
	// if a lead byte comes in, the trail byte should arrive very soon after.
	// We wait here for the trail byte and store them into the text buffer together.
	if (!IsDBCSLeadByte((unsigned char)ch))
		{
		return false;
		}

	// Wait an arbitrary amount of time for the trail byte to arrive.
	// If it doesn't, then discard the lead byte. This could happen if the IME
	// screwed up.  Or, more likely, the user generated the lead byte through ALT-numpad.
	MSG msg;
	int i = 10;

	while (!PeekMessage(&msg, mHWND, WM_CHAR, WM_CHAR, PM_REMOVE))
		{
		if (--i == 0)
			{
			return true;
			}

		Sleep(0);
		}

	// Convert char to unicode.
	unsigned long dbcs = (unsigned long)(((unsigned)msg.wParam << 8) | ch);
	wchar_t unicode = 0;
	MultiByteToWideChar(mCodePage, 0, (const char*)&dbcs, 2, &unicode, 1);

	UnicodeChar event(unicode);
	NotifyObservers(event);

	return true;
	}


/******************************************************************************
*
* NAME
*     IMEManager::
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*
******************************************************************************/

long IMEManager::ConvertAttrForUnicode(unsigned char* mbcs, unsigned char* attr)
	{
	// Scale the attributes for unicode string length
	unsigned char* mbsPtr = mbcs;
	unsigned char* attrPtr = attr;

	while (*mbsPtr != 0)
		{
		*attrPtr = attr[mbsPtr - mbcs];
		++attrPtr;
		mbsPtr = _mbsinc(mbsPtr);
		}

	return (attrPtr - attr);
	}


/******************************************************************************
*
* NAME
*     IMEManager::
*
* DESCRIPTION
*
* INPUTS
*
* RESULT
*
******************************************************************************/

long IMEManager::ConvertClauseForUnicode(unsigned char* mbcs, long length, unsigned long* clause)
	{
	//---------------------------------------------------------------------------
	// Scale the clause offsets for unicode string
	//---------------------------------------------------------------------------
	unsigned char* mbsPtr = mbcs;
	unsigned long offset = 0;

	// The first clause is always zero so there is no need to adjust it.
	int index = 1;

	// The clause is terminated with the size of the string
	while (clause[index] < (unsigned long)length)
		{
		// Count the number of characters in this clause
		unsigned char* mbsStop = (mbcs + clause[index]);

		while (mbsPtr < mbsStop)
			{
			++offset;
			mbsPtr = _mbsinc(mbsPtr);
			}

		clause[index] = offset;
		++index;
		}

	// Terminate the unicode adjusted clause with the string length
	clause[index] = _mbslen(mbcs);
	++index;

	return (&clause[index] - clause);
	}

} // namespace IME