/ime/imm.c

/* # SKKIME1.0 (Simple Kana-Kanji Input Method Editor for Windows2000)

 * imm.c

 * This file is part of skkime1.0.

 * Copyright (C) 1999

 * Takashi SAKAMOTO (tatari_sakamoto@nifty.ne.jp)

 *

 * 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 2, 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 skkinput; see the file COPYING.  If not, write to

 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

 */

#include "windows.h"

#include "tchar.h"

#include "immdev.h"

#include "skki1_5.h"

#include "resource.h"

#include "ImeDoc.h"

#include "TSearchSession.h"

#include "TLispSession.h"

#include "skkui.h"

#include "jstring.h"

#include "ImeConfig.h"





/*

 *	Private Prototypes

 */

static	DWORD	PASCAL	getImeLeftMenuItems		(HIMC, DWORD, DWORD, LPMYIMEMENUITEMINFO, LPMYIMEMENUITEMINFO, DWORD) ;

static	DWORD	PASCAL	getImeRightMenuItems	(HIMC, DWORD, DWORD, LPMYIMEMENUITEMINFO, LPMYIMEMENUITEMINFO, DWORD) ;

static	DWORD	PASCAL	getImeRightSubMenuItems	(HIMC, DWORD, DWORD, LPMYIMEMENUITEMINFO, LPMYIMEMENUITEMINFO, DWORD) ;

static	long	PASCAL	insertStringMenuItem	(LPMYIMEMENUITEMINFO, const LPMYSTRTYPEPAIR, UINT) ;

static	long	PASCAL	insertStringMenuItemEx	(LPMYIMEMENUITEMINFO, const LPMYSTRTYPEPAIREX, UINT) ;

static	long	PASCAL	insertSeparatorMenuItem	(LPMYIMEMENUITEMINFO) ;

static	long	PASCAL	insertInputModeMenuItems(HIMC, LPMYIMEMENUITEMINFO) ;



/***********************************************************************

 *	ImeInquire ()

 *		For Windows 95, Windows 98, and Windows NT 3.51

 *	ImeInquire 関数は IME の初期化を取り扱う。また、ImeInquire 関数は

 *	IMEINFO 構造体及び IME の UI class name も又返す。

 *	BOOL

 *		ImeInquire(

 *		LPIMEINFO lpIMEInfo,

 *		LPTSTR lpszWndClass,

 *		LPCTSTR lpszData

 *	)

 *	Parameters

 *	lpIMEInfo

 *		IME info 構造体を指すポインタ。

 *	lpszWndClass

 *		IME によって window class 名が詰められる。この名前が IME の UI

 *		class 名である。

 *	lpszData

 *		IME オプションブロック。このバージョンでは NULL。

 *

 *		For Windows NT 4.0 and Windows 2000

 *	BOOL

 *		ImeInquire(

 *		LPIMEINFO lpIMEInfo,

 *		LPTSTRlpszWndClass,

 *		DWORD dwSystemInfoFlags

 *	)

 *	Parameters

 *	lpIMEInfo

 *		IME info 構造体を指すポインタ。

 *	lpszWndClass

 *		IME によって window class 名が詰められる。この名前が IME の UI

 *		class 名である。

 *	dwSystemInfoFlags

 *		システムによって提供されるシステム情報を変更する。次のようなフラグ

 *		が与えられる。

 *		IME_SYSINFO_WINLOGON

 *			IME にクライアントプロセスが Winlogon プロセスであることを IME

 *			に知らせる。IME はこのフラグが指定された時 IME の設定をユーザに

 *			許すべきではない。

 *		IME_SYSINFO_WOW16

 *			IME にクライアントプロセスは 16-bit アプリケーションであること

 *			を知らせる。

 *	Return Values

 *		成功すれば、TRUE。そうでなければ、FALSE。

 ***********************************************************************/

BOOL	WINAPI

ImeInquire (

	LPIMEINFO	lpIMEInfo,

	LPTSTR		lpszClassName,

	DWORD		dwSystemInfoFlags)

{

#if defined (_DEBUG)

	static	TCHAR	tszLastUser [UNLEN + 1] = { TEXT ('\0') } ;

#endif

	/*

	 * IMEINFO 構造体を初期化する。

	 */

	lpIMEInfo->dwPrivateDataSize 	= sizeof (UIEXTRA) ;

	lpIMEInfo->fdwProperty			= IME_PROP_KBD_CHAR_FIRST |

#if defined (MIXED_UNICODE_ANSI) || defined (UNICODE)

									  IME_PROP_UNICODE |

#endif

									  IME_PROP_AT_CARET ;

	lpIMEInfo->fdwConversionCaps	= IME_CMODE_LANGUAGE |

									  IME_CMODE_FULLSHAPE |

									  IME_CMODE_ROMAN |

							   		  IME_CMODE_CHARCODE ;

	lpIMEInfo->fdwSentenceCaps		= 0L ;

	lpIMEInfo->fdwUICaps			= UI_CAP_2700 ;



	/*

	 *	fdwSCSCaps

	 *		fdwSCSCaps ビットは SetCompositionString の能力を指定する。

	 * 		----------------------------------------------------------

	 *		SCS_CAP_COMPSTR

	 *			IME は SCS_SETSTR で composition string を生成できる。

	 *		SCS_CAP_MAKEREAD

	 *			ImmSetCompositionString を SCS_SETSTR で呼び出した時に

	 *			IME は compositoin string の reading string を lpRead 

	 *			なしに生成することができる。この能力のある IME の下で

	 *			はアプリケーションは SCS_SETSTR に lpRead を設定する

	 *			必要がない。

	 *		SCS_CAP_CONVERTSTRING

	 *			IME は reconvert 機能を持っている。

	 * 		----------------------------------------------------------

	 *		SKK は composition string を直接操作されるようなインター

	 *		フェースと無茶苦茶相性が良くないので、これらの能力は持たな

	 *		い。

	 */

	lpIMEInfo->fdwSCSCaps		= SCS_CAP_COMPSTR | SCS_CAP_MAKEREAD | SCS_CAP_SETRECONVERTSTRING ;

	lpIMEInfo->fdwSelectCaps	= SELECT_CAP_CONVERSION ;



	/*

	 * 呼び出し側が IME UI class 名を知ることができるように lpszClassName

	 * に UI class 名を代入する。

	 */

#if defined (MIXED_UNICODE_ANSI)

	memcpy ((LPWSTR)lpszClassName, (LPWSTR)g_wszUIClassName, (lstrlenW((LPWSTR)g_wszUIClassName) + 1) * sizeof(WCHAR)) ;

#else

	lstrcpy (lpszClassName, (LPTSTR)g_szUIClassName) ;

#endif



	/*	Logon Session かどうか */

	g_bSkkImeSecure	= ((dwSystemInfoFlags & IME_SYSINFO_WINLOGON) != 0) ;

	return	TRUE ;

}



/***********************************************************************

 *	ImeConversionList

 *	ImeConversionList 関数によって別の文字もしくは文字列の変換結果のリス

 *	トを得ることができる。

 *		DWORD

 *			IMEConversionList(

 *			HIMC			hIMC,

 *			LPCTSTR			lpSrc,

 *			LPCANDIDATELIST	lpDst,

 *			DWORD			dwBufLen,

 *			UINT			uFlag

 *			)

 *	Parameters

 *	hIMC

 *		入力コンテキストのハンドル。

 *	lpSrc

 *		変換される文字列

 *	lpDst

 *		変換結果が格納されるバッファを指すポインタ。

 *	dwBufLen

 *		変換結果を格納するバッファの大きさ。

 *	uFlag

 *		現在は次の3つのフラグの1つを設定することができる。

 *		・GCL_CONVERSION

 *			読み文字列を lpSrc パラメータに設定する。IME は lpDst パラメ

 *			ータにその変換結果を返す。

 *		・GCL_REVERSECONVERSION

 *			変換結果文字列を lpSrc パラメータに設定する。IME はその読みを

 *			lpDstパラメータに返す。

 *		・GCL_REVERSE_LENGTH

 *			lpSrc パラメータに変換結果文字列を設定する。IME は

 *			GCL_REVERSECONVERSION の扱える長さを返す。例えば、IME は

 *			sentence period を持った変換結果を読みに変換することができな

 *			い。結果として、sentence period を除いたバイト単位で文字列長

 *			を返す。

 *	Return Values

 *		変換結果文字列リストのバイト数を返す。

 *	Comments

 *		この関数はアプリケーションもしくは IME-related メッセージを作ら

 *		ない IME によって呼び出されることを意図している。それゆえに、IME

 *		はこの関数 IME-related メッセージを生成すべきでない。

 ***********************************************************************/

DWORD	WINAPI

ImeConversionList (

	HIMC				hIMC,

	LPCTSTR				lpSource,

	LPCANDIDATELIST		pCandList,

	DWORD				dwBufLen,

	UINT				uFlags)

{

#if defined (MIXED_UNICODE_ANSI)

	return	0 ;

#else

	struct CTSearchSession*	pHenkanSession ;

	LPCDSTR		dstrResult ;

	int			nNeedLength, nCandidate, iAnnotationType, nKeyLen ;

	DWORD		dwSize ;

	DCHAR		bufTemp [256] ;



	/* 逆変換は実行できない。

	if (uFlags == GCL_REVERSECONVERSION || uFlags == GCL_REVERSE_LENGTH)

		return	0 ;

	*/

	if (uFlags != GCL_CONVERSION)

		return	0 ;



	nKeyLen	= wcstodcs_n (bufTemp, ARRAYSIZE (bufTemp), lpSource, lstrlen (lpSource)) ;

	/*	数値変換の設定がうまく取れないのはまずいか…。

	 */

	pHenkanSession	= THenkanSession_pCreate (bufTemp, nKeyLen, SEARCH_OKURI_NASHI, ImeConfig_bSkkNumericConversionp (), ImeConfig_bSkkNumConvertFloatp ()) ;

	if (pHenkanSession == NULL)

		return	0 ;

	iAnnotationType	= ImeConfig_iGetSkkShowAnnotationType () ;

	nCandidate		= 0 ;

	nNeedLength		= 0 ;

	for ( ; ; ) {

		dstrResult	= TSearchSession_pGetReferCandidate (pHenkanSession) ;

		if (dstrResult == NULL)

			dstrResult	= TSearchSession_pGetCandidate (pHenkanSession) ;

		if (dstrResult != NULL) {

			int			nResultWLen, nResultDLen ;



			/*	Lisp Conversion と Annotation の処理。

			 */

			

			nResultDLen	= dcslen (dstrResult) ;

			if (iAnnotationType != DISABLE_ANNOTATION) {

				LPCDSTR	pdSrc, pdNote ;

				int		nWordLen, nNoteLen, nWordWLen, nNoteWLen ;



				pdSrc	= dstrResult + nResultDLen - 1 ;

				while (pdSrc >= dstrResult && *pdSrc != L';') 

					pdSrc	-- ;



				if (pdSrc >= dstrResult && *pdSrc == L';') {

					pdNote		= pdSrc + 1 ;

					nNoteLen	= nResultDLen - (pdNote - dstrResult) ;

					nWordLen	= pdSrc - dstrResult ;

				} else {

					nNoteLen	= 0 ;

					nWordLen	= nResultDLen ;

				}



				nWordWLen = nNoteWLen = -1 ;

				if (nWordLen > 1 && dstrResult [0] == L'(' && dstrResult [nWordLen - 1] == L')') {

					if (TLispSession_bEval (dstrResult, nWordLen, bufTemp, ARRAYSIZE (bufTemp) - 1)) {

						bufTemp [ARRAYSIZE (bufTemp) - 1]	= L'\0' ;

						nWordWLen	= dcstowcs (NULL, 0, bufTemp, dcslen (bufTemp)) ;

					}

				}

				if (nWordWLen < 0) {

					nWordWLen	= dcstowcs (NULL, 0, dstrResult, nWordLen) ;

				}

				if (nNoteLen > 1 && pdNote [0] == L'(' && pdNote [nNoteLen - 1] == L')') {

					if (TLispSession_bEval (pdNote, nNoteLen, bufTemp, ARRAYSIZE (bufTemp) - 1)) {

						bufTemp [ARRAYSIZE (bufTemp) - 1]	= L'\0' ;

						nNoteWLen	= dcstowcs (NULL, 0, bufTemp, dcslen (bufTemp)) ;

					}

				}

				if (nNoteWLen < 0) {

					if (nNoteLen > 0) {

						nNoteWLen	= dcstowcs (NULL, 0, pdNote, nNoteLen) ;

					} else {

						nNoteWLen	= 0 ;

					}

				}

				nResultWLen	= nWordWLen + nNoteWLen + ((nNoteWLen > 0)? 1 : 0)  ;

			} else {

				nResultWLen	= dcstowcs (NULL, 0, dstrResult, nResultDLen) ;

			}

			nNeedLength	+= nResultWLen + 1 ; 

			nCandidate	++ ;

		}

		if (! TSearchSession_bNextCandidate (pHenkanSession))

			break ;

	}

	TSearchSession_bRewind (pHenkanSession) ;



	dwSize	= sizeof (CANDIDATELIST) + sizeof (DWORD) * nCandidate + sizeof (MYCHAR) * nNeedLength ;

	if (pCandList != NULL && dwBufLen >= sizeof (CANDIDATELIST)) {

		pCandList->dwSize		= dwSize ;

		pCandList->dwStyle		= IME_CAND_READ ;

		pCandList->dwCount		= (DWORD) nCandidate ;

		pCandList->dwPageSize	= (nCandidate < MAX_SKKCANDPAGESIZE)? nCandidate : MAX_SKKCANDPAGESIZE ;

		pCandList->dwSelection	= 0 ;

		pCandList->dwPageStart	= 0 ;

	}

	if (pCandList != NULL && dwBufLen >= dwSize) {

		LPMYSTR		pCandidateStr ;

		LPMYSTR		pLast ;

		DWORD*		pdwCandidateOffset ;

		DWORD*		pdwAnnotationOffset ;

		int			i ;



		pCandidateStr			= (LPMYSTR)((LPSTR)pCandList + sizeof (CANDIDATELIST) + sizeof (DWORD) * nCandidate * 2) ;

		pLast					= pCandidateStr + nNeedLength ;

		pdwCandidateOffset		= pCandList->dwOffset ;

		pdwAnnotationOffset		= pdwCandidateOffset + nCandidate ;

		for (i = 0 ; i < nCandidate ; i ++) {

			*pdwCandidateOffset		= (DWORD)((LPSTR)pCandidateStr - (LPSTR)pCandList) ;

			*pdwAnnotationOffset	= 0 ;

			

			dstrResult	= TSearchSession_pGetReferCandidate (pHenkanSession) ;

			if (dstrResult == NULL)

				dstrResult	= TSearchSession_pGetCandidate (pHenkanSession) ;

			if (dstrResult != NULL) {

				int			nResultLen ;



				/*	Lisp Eval が必要かどうかをチェックするために Annotation と本体を分離する。

				 */

				nResultLen	= dcslen (dstrResult) ;

				if (iAnnotationType != DISABLE_ANNOTATION) {

					LPCDSTR	pdSrc, pdNote, pdWord ;

					int		nWordLen, nNoteLen ;



					pdSrc	= dstrResult + nResultLen - 1 ;

					pdWord	= dstrResult ;

					while (pdSrc >= dstrResult && *pdSrc != L';') 

						pdSrc	-- ;

					if (pdSrc >= dstrResult && *pdSrc == L';') {

						pdNote		= pdSrc + 1 ;

						nNoteLen	= nResultLen - (pdNote - dstrResult) ;

						nWordLen	= pdSrc - dstrResult ;

					} else {

						nNoteLen	= 0 ;

						nWordLen	= nResultLen ;

					}

					/* Word を Eval する必要があるかどうかチェックする。*/

					if (nWordLen > 1 && dstrResult [0] == L'(' && dstrResult [nWordLen - 1] == L')') {

						if (TLispSession_bEval (dstrResult, nWordLen, bufTemp, ARRAYSIZE (bufTemp) - 1)) {

							bufTemp [ARRAYSIZE (bufTemp) - 1]	= L'\0' ;

							nWordLen	= dcslen (bufTemp) ;

							pdWord		= bufTemp ;

						}

					}

					if (nWordLen > 0) {

						int	n	= dcstowcs (pCandidateStr, pLast - pCandidateStr, pdWord, nWordLen) ;

						pCandidateStr [n]	= L'\0' ;

						pCandidateStr		+= n + 1 ;

					} else {

						*pCandidateStr ++	= L'\0' ;

					}



					/* Annotation を Eval する必要があるかどうかチェックする。*/

					if (nNoteLen > 1 && pdNote [0] == L'(' && pdNote [nNoteLen - 1] == L')') {

						if (TLispSession_bEval (pdNote, nNoteLen, bufTemp, ARRAYSIZE (bufTemp) - 1)) {

							bufTemp [ARRAYSIZE (bufTemp) - 1]	= L'\0' ;

							nNoteLen	= dcslen (bufTemp) ;

							pdNote		= bufTemp ;

						}

					}

					if (nNoteLen > 0) {

						int	n	= dcstowcs (pCandidateStr, pLast - pCandidateStr, pdNote, nNoteLen) ;



						pCandidateStr [n]		= L'\0' ;

						*pdwAnnotationOffset	= (DWORD)((LPSTR)pCandidateStr - (LPSTR)pCandList) ;

						pCandidateStr			+= n + 1 ;

					}

				} else {

					int	n = dcstowcs (pCandidateStr, pLast - pCandidateStr, dstrResult, nResultLen) ;



					pCandidateStr [n]	= L'\0' ;

					pCandidateStr		+= n + 1 ;

				}

				pdwCandidateOffset	++ ;

				pdwAnnotationOffset	++ ;

			}

			TSearchSession_bNextCandidate (pHenkanSession) ;

		}

	}

	TSearchSession_vDestroy (pHenkanSession) ;

	return	dwSize ;

#endif

}



/***********************************************************************

 *	ImeDestroy()

 *	ImeDestroy 関数は IME 自身を終了させる。

 *	BOOL

 *		ImeDestroy(

 *			UINT uReserved

 *		)

 *	Parameters

 *		uReserved

 *			予約されているけど、現在は 0 であれぞかし。このバージョンで

 *			は、0でなかったら FALSE を返すこと。

 *	Return Values

 *		関数が成功したら、TRUE。そうじゃなかったら、FALSE。

 ***********************************************************************/

BOOL	WINAPI

ImeDestroy (

	UINT	uForce)

{

	DEBUGPRINTFEX (99, (MYTEXT ("ImeDestroy (uReserved:%x)\n"), uForce)) ;



	if (uForce)

		return	FALSE ;

	/*

	 * 終了処理を書くべきなのだが…InputContext が無いと解放すべき資源が

	 * 分からないような…。結局何もできないのでは？

	 * IME 全体で共有している資源は全て skkiserv.exe に渡したので、何も

	 * することがない？

	 */

	return	TRUE ;

}



/***********************************************************************

 *	ImeEscape

 *	ImeEscape 関数はアプリケーションに、他の IMM 関数では直接に利用でき

 *	ないような IME の特性にアクセスすることを許す。

 *	これは IME の country-specific 関数もしくは private 関数に対してなく

 *	てはならないものである…らしい。

 *	LRESULT

 *		ImeEscape(

 *			HIMC hIMC,

 *			UINT uEscape,

 *			LPVOID lpData

 *		)

 *	Parameters

 *		hIMC

 *			入力コンテキストのハンドル。

 *		uEscape

 *			実行されるエスケープ関数を指定する。

 *		lpData

 *			指定されたエスケープに必要なデータを指すポインタ。

 *	ImeEscape 関数は次のようなエスケープ関数をサポートしている。

 *	IME_ESC_QUERY _SUPPORT

 *		実装されているかどうかチェックする。もし、このエスケープが実装さ

 *		れていなかったら零を返す。

 *	IME_ESC_RESERVED_FIRST

 *		IME_ESC_RESERVED_FIRST と IME_ESC_RESERVED_LAST の間のエスケープ

 *		がシステムに予約される。

 *	IME_ESC_RESERVED_LAST

 *		IME_ESC_RESERVED_FIRST と IME_ESC_RESERVED_LAST の間のエスケープ

 *		がシステムに予約される。

 *	IME_ESC_PRIVATE_FIRST

 *		IME_ESC_PRIVATE_FIRST と IME_ESC_PRIVATE_LAST の間のエスケープが

 *		IME に予約される。IME は自由に自分の目的に応じてこれらのエスケー

 *		プ関数を使うことができる。

 *	IME_ESC_PRIVATE_LAST

 *		IME_ESC_PRIVATE_FIRST と IME_ESC_PRIVATE_LAST の間のエスケープが

 *		IME に予約される。IME は自由に自分の目的に応じてこれらのエスケー

 *		プ関数を使うことができる。

 *	IME_ESC_SEQUENCE_TO_INTERNAL

 *		中国語固有のエスケープ。Far East プラットフォームの下で動くこと

 *		を要求するアプリケーションはこれを使うべきではない。中国語EUDC

 *		エディタのためのものである。*(LPWORD)lpData は sequence code 

 *		であり、返り値はその sequence code に対する文字コードである。

 *	IME_ESC_GETHELPFILENAME

 *		IME のヘルプファイルの名前を得るエスケープ。関数から戻った時に

 *		(LPTSTR)lpData は IME ヘルプファイルのフルパスになっている。

 *		パス名は 80 * sizeof (TCHAR) より短かい。この関数は Windows'98

 *		Windows 2000 に追加されている。

 *	IME_ESC_PRIVATE_HOTKEY

 *		lpData は hot key ID を格納している DWORD へのポインタである。

 *		(IME_HOTKEY_PRIVATE_FIRST からIME_HOTKEY_PRIVATE_LAST の範囲)

 *		システムがこの範囲内の hot key を受けとった後、IMM が

 *		ImeEscape 関数を使って IME にディスパッチする。WindowsR95 で

 *		はサポートしていない。

 *	Return Values

 *		失敗したら 0 になる。さもなくばエスケープ関数に従って返り値が

 *		決まる。

 *	Comments

 *		パラメータが正当かどうかは各々のエスケープ関数による。

 *		uEscape が IME_ESC_QUERY_SUPPORT の時、lpData は IME エスケー

 *		プ値を含んだ変数へのポインタである。次のサンプルは、IME が 

 *		IME_ESC_GETHELPFILENAME をサポートしているかどうかを決定する

 *		のに利用できる。

 *		DWORD	dwEsc	= IME_ESC_GETHELPFILENAME ;

 *		LRESULT lRet	= ImmEscape(hKL, hIMC, IME_ESC_QUERYSUPPORT, (LPVOID)&dwEsc) ;

 *	See Also

 *		ImmEscape

 ***********************************************************************/

LRESULT	WINAPI

ImeEscape (

	HIMC	hIMC,

	UINT	uSubFunc,

	LPVOID	lpData)

{

	LRESULT	lRet	= FALSE ;

	

	DEBUGPRINTFEX (99, (TEXT ("ImeEscape (hIMC: %ld, uSubFunc: %x, lpData: %p)"), hIMC, uSubFunc, lpData)) ;



	switch (uSubFunc){

	case IME_ESC_QUERY_SUPPORT:

		switch (*(LPUINT)lpData){

		case IME_ESC_QUERY_SUPPORT:

		case IME_ESC_PRI_GETDWORDTEST:

		case IME_ESC_GETHELPFILENAME:

			lRet	= TRUE ;

			break ;

		default:

			lRet	= FALSE ;

			break ;

		}

		break ;



	case IME_ESC_PRI_GETDWORDTEST:

		lRet	= 0x12345678 ;

		break ;



	case IME_ESC_GETHELPFILENAME:

		Mylstrcpy ((LPMYSTR)lpData, MYTEXT("SKKI1_0.HLP")) ;

		lRet	= TRUE ;

		break ;



	default:

		lRet	= FALSE ;

		break ;

	}

	return	lRet ;

}



/***********************************************************************

 *	ImeSetActiveContext ()

 *	ImeSetActiveContext 関数は current IME に Input Context が active に

 *	なったことを知らせる。

 *	BOOL

 *		ImeSetActiveContext(

 *		HIMC hIMC,

 *		BOOL fFlag

 *	)

 *	Parameters

 *		hIMC

 *			Input Context Handle

 *		fFlag

 *			TRUE ならアクティブに FALSE なら非アクティブになったことを示

 *			す。

 *		Return Values

 *			成功したら TRUE を、さもなくば FALSE を返す。

 *	Comments

 *		IME は新しく選択された Input Context についてこの関数で知らされ

 *		る。IME は初期化を実行してよいが、要求されているわけではない。

 *	See Also

 *		ImeSetActiveContext

 ***********************************************************************/

BOOL	WINAPI

ImeSetActiveContext (

	HIMC		hIMC,

	BOOL		fFlag)

{

	TRANSMSG		GnMsg ;

	LPINPUTCONTEXT	lpIMC ;



	DEBUGPRINTFEX (106, (TEXT ("ImeSetActiveContext (hIMC: %lx, fFlag:%d)\n"), hIMC, fFlag)) ;



	if (!hIMC) {

#if !defined (NO_TSF)

		if (fFlag) 

			vTSF_ActivateLanguageBar (hIMC, TRUE) ;

#endif

		return	TRUE ;

	}



	lpIMC		= (LPINPUTCONTEXT)ImmLockIMC (hIMC) ;

	if (lpIMC){

		if (ImmGetIMCCSize (lpIMC->hCompStr) >= sizeof (MYCOMPSTR)) {

			GnMsg.message	= WM_IME_NOTIFY ;

			GnMsg.wParam	= IMN_PRIVATE ;

			if (fFlag){

				GnMsg.lParam	= IMN_PRIVATE_ACTIVATECONTEXT ;

				GenerateMessage (hIMC, lpIMC, g_lpCurTransKey, (LPTRANSMSG)&GnMsg) ;

				TSkkIme_vUpdateConfig (hIMC) ;

			} else {

				GnMsg.lParam	= IMN_PRIVATE_DEACTIVATECONTEXT ;

				GenerateMessage (hIMC, lpIMC, g_lpCurTransKey, (LPTRANSMSG)&GnMsg) ;

			}



			/*

			 *	現在のところ、DEACTIVATECONTEXT は利用していないので、以下のコードはコメント

			 *	とする。(Wed Nov 09 21:44:01 2005)

			 *

			if (fFlag){

				GnMsg.lParam	= IMN_PRIVATE_ACTIVATECONTEXT ;

				GenerateMessage (hIMC, lpIMC, g_lpCurTransKey, (LPTRANSMSG)&GnMsg) ;

				TSkkIme_vInvalidateConfig (hIMC, TRUE) ;

			} else {

				GnMsg.lParam	= IMN_PRIVATE_DEACTIVATECONTEXT ;

				GenerateMessage (hIMC, lpIMC, g_lpCurTransKey, (LPTRANSMSG)&GnMsg) ;

			}

			*/

		}

		ImmUnlockIMC (hIMC) ;

	}

	return	TRUE ;

}



/***********************************************************************

 *	ImeProcessKey ()

 *	ImeProcessKey 関数は IMM を通して与えられた全てのキーストロークを前処

 *	理して、もしそのキーが与えられた Input Context で IME に必要なもので

 *	あれば TRUE を返す。

 *	BOOL

 *		ImeProcessKey(

 *		HIMC hIMC,

 *		UINT uVirKey,

 *		DWORD lParam,

 *		CONST LPBYTE lpbKeyState

 *	)

 *	Parameters

 *		hIMC

 *			Input context handle

 *		uVirKey

 *			処理されるべき仮想キー。

 *		lParam

 *			キーメッセージの lParam。(WM_KEYDOWN,WM_KEYUP の LPARAM)

 *		lpbKeyState

 *			現在のキーボードの状態を含んだ256バイトの配列を指すポインタ。

 *			IME はこの内容を変更すべきではない。

 *	Return Values

 *		成功なら TRUE。そうでなければ FALSE。

 *	Comments

 *		システムはキーが IME によって取り扱われるべきか否かをこの関数を

 *		呼び出すことによって決定している。アプリケーションがキーメッセー

 *		ジを受け取る前にこの関数が TRUE を返せば、IME はそのキーを処理す

 *		る。システムは ImeToAsciiEx 関数を呼び出す。

 *		FALSE を返したならば、システムはそのキーが IME によって処理され

 *		ないことが分かるのでキーメッセージはアプリケーションに送られる。

 ***********************************************************************/

BOOL	WINAPI

ImeProcessKey (

	HIMC			hIMC,

	UINT			vKey,

	LPARAM			lKeyData,

	CONST LPBYTE	lpbKeyState)

{

	LPINPUTCONTEXT	lpIMC ;

	BOOL			fOpen ;

	BOOL 					fEaten		= FALSE ;

	LPCOMPOSITIONSTRING		lpCompStr ;

	LPMYCOMPSTR				lpMyCompStr ;

	

	if (lKeyData & 0x80000000)

		return	FALSE ;



	lpIMC	= ImmLockIMC (hIMC) ;

	if (!lpIMC)

		return	FALSE ;



	fOpen		 = lpIMC->fOpen ;

	lpCompStr	= (LPCOMPOSITIONSTRING)ImmLockIMCC (lpIMC->hCompStr) ;

	if (lpCompStr != NULL) {

		struct TMSG	msg ;

		BOOL		fToggleIME ;



		lpMyCompStr	= (LPMYCOMPSTR) lpCompStr ;

		msg.m_nMessage	= WM_KEYDOWN ;

		msg.m_wParam	= vKey ;		/* wParam, lParam の設定はこれで VK_KEYDOWN に相当するのか？ 特殊なメッセージにするのか？ */

		msg.m_lParam	= lKeyData ;

		msg.m_rParam	= 0 ;

		if (lpbKeyState != NULL) {

			msg.m_rParam	|= (lpbKeyState [VK_LCONTROL]	& 0x80)? KEYMASK_LCONTROL	: 0 ;

			msg.m_rParam	|= (lpbKeyState [VK_RCONTROL]	& 0x80)? KEYMASK_RCONTROL	: 0 ;

			msg.m_rParam	|= (lpbKeyState [VK_LMENU]		& 0x80)? KEYMASK_LMENU		: 0 ;

			msg.m_rParam	|= (lpbKeyState [VK_RMENU]		& 0x80)? KEYMASK_RMENU		: 0 ;

			msg.m_rParam	|= (lpbKeyState [VK_LSHIFT]		& 0x80)? KEYMASK_LSHIFT		: 0 ;

			msg.m_rParam	|= (lpbKeyState [VK_RSHIFT]		& 0x80)? KEYMASK_RSHIFT		: 0 ;

			msg.m_rParam	|= (lpbKeyState [VK_SCROLL]		& 0x80)? KEYMASK_SCROLL		: 0 ;

			msg.m_rParam	|= (lpbKeyState [VK_NUMLOCK]	& 0x80)? KEYMASK_NUMLOCK	: 0 ;

		} else {

			msg.m_rParam	|= (GetKeyState (VK_LCONTROL))?	KEYMASK_LCONTROL	: 0 ;

			msg.m_rParam	|= (GetKeyState (VK_RCONTROL))?	KEYMASK_RCONTROL	: 0 ;

			msg.m_rParam	|= (GetKeyState (VK_LMENU))?	KEYMASK_LMENU		: 0 ;

			msg.m_rParam	|= (GetKeyState (VK_RMENU))?	KEYMASK_RMENU		: 0 ;

			msg.m_rParam	|= (GetKeyState (VK_LSHIFT))?	KEYMASK_LSHIFT		: 0 ;

			msg.m_rParam	|= (GetKeyState (VK_RSHIFT))?	KEYMASK_RSHIFT		: 0 ;

			msg.m_rParam	|= (GetKeyState (VK_SCROLL))?	KEYMASK_SCROLL		: 0 ;

			msg.m_rParam	|= (GetKeyState (VK_NUMLOCK))?	KEYMASK_NUMLOCK		: 0 ;

		}

		msg.m_nTime		= GetTickCount () ;

		msg.m_pt.x		= msg.m_pt.y	= 0 ;

		if (! ImeDoc_bQueryToggleIMEEvent (&lpMyCompStr->_Doc, &msg, &fEaten))

			fEaten	= FALSE ;

		if (fOpen && ! fEaten)

			ImeDoc_bQueryFilterEvent (&lpMyCompStr->_Doc, &msg, &fEaten) ;

		ImmUnlockIMCC (lpIMC->hCompStr) ;

	}

	ImmUnlockIMC (hIMC) ;

	return	fEaten ;

}



/***********************************************************************

 *	ImeSelect

 *	ImeSelect 関数は IME private context の初期化及び非初期化処理を行う

 *	のに用いられる。

 *	BOOL

 *		ImeSelect(

 *			HIMC hIMC,

 *			BOOL fSelect

 *		)

 *	Parameters

 *		hIMC

 *			Input context handle

 *		fSelect

 *			TRUE ならば初期化を、FALSE なら非初期化(リソースの解放)を意

 *			味する。

 *	Return Values

 *		成功すれば TRUE。さもなくば FALSE。

 ***********************************************************************/

BOOL	WINAPI

ImeSelect (

	HIMC		hIMC,

	BOOL		fSelect)

{

	LPINPUTCONTEXT		lpIMC ;

	LPCOMPOSITIONSTRING	lpCompStr ;

	TRANSMSG			GnMsg ;

	LOGFONT				lf ;



	/* it's NULL context. */

	if (!hIMC)

		return TRUE ;



	lpIMC	= ImmLockIMC(hIMC) ;

	if (lpIMC){

		DEBUGPRINTFEX (106, (TEXT ("ImeSelect (hIMC: %lx, fSelect:%d)\n"), hIMC, fSelect)) ;

		if (fSelect){

			/* Initialize */

			LPCANDIDATEINFO	lpCandInfo ;



			/*	MS-IME と SKKIME を Toolbar で切り替えられると、

			 *	ImeSelect には来るが、ActiveContext には来ないという

			 *	現象が発生する。Config の読み込みのタイミングが	ActiveContext

			 *	だけに絞れない…。

			 *

			 *	ここでレジストリに触れることが UserEnv のエラーになるのだろう

			 *	か？

			 */

			ImeConfig_vLoad () ;



			/* Init the general member of IMC. */

			if (!(lpIMC->fdwInit & INIT_LOGFONT)){

#if defined (UNICODE)

				/* これで正しいのか？ もとは .A. だけだったけど */

				lpIMC->lfFont.W.lfCharSet	= SHIFTJIS_CHARSET ;

#else

				lpIMC->lfFont.A.lfCharSet	= SHIFTJIS_CHARSET ;

#endif

				lpIMC->fdwInit				|= INIT_LOGFONT ;

			}

			if (!(lpIMC->fdwInit & INIT_CONVERSION)){

				lpIMC->fdwConversion	= IME_CMODE_ROMAN | IME_CMODE_FULLSHAPE | IME_CMODE_NATIVE ;

				lpIMC->fdwInit			|= INIT_CONVERSION ;

			}

			if (!(lpIMC->fdwInit & INIT_COMPFORM)) {

				lpIMC->cfCompForm.dwStyle			= 1 ; // ？

				lpIMC->cfCompForm.ptCurrentPos.x	= 0 ;

				lpIMC->cfCompForm.ptCurrentPos.y	= 0 ;

				lpIMC->fdwInit				|= INIT_COMPFORM ;

			}



			lpIMC->hCompStr = ImmReSizeIMCC (lpIMC->hCompStr, sizeof (MYCOMPSTR)) ;

			lpCompStr		= (LPCOMPOSITIONSTRING)ImmLockIMCC (lpIMC->hCompStr) ;

			if (lpCompStr){

				LPMYCOMPSTR	lpMyCompStr	= (LPMYCOMPSTR) lpCompStr ;



				lpCompStr->dwSize	= sizeof (MYCOMPSTR) ;

				TSkkIme_vInitCompStr (lpCompStr, CLR_RESULT_AND_UNDET) ;

				ImeDoc_bInit (&lpMyCompStr->_Doc) ;

				lpMyCompStr->_bCandMode				= FALSE ;

				lpMyCompStr->_fComposing			= FALSE ;

				lpMyCompStr->cfCandBase.hWnd		= (HWND) 0 ;

				lpMyCompStr->cfCandBase.dwIndex		= (DWORD) -1 ;

				lpMyCompStr->cfCandBase.dwStyle		= (DWORD) 0 ;

				ImmUnlockIMCC (lpIMC->hCompStr) ;

			}

			TSkkIme_bSetConversionMode (hIMC, lpIMC->fdwConversion) ;



			lpIMC->hCandInfo	= ImmReSizeIMCC (lpIMC->hCandInfo, sizeof (MYCAND)) ;

			lpCandInfo			= (LPCANDIDATEINFO)ImmLockIMCC (lpIMC->hCandInfo) ;

			if (lpCandInfo){

				TSkkIme_vClearCandidate (lpCandInfo) ;

				ImmUnlockIMCC (lpIMC->hCandInfo) ;

			}



			/*	ImeSelect (TRUE) は Text Service Framework を利用する application でも

			 *	呼ばれてしまう。このため、LangBarItemMgr に LangBarItem を登録するべき

			 *	場所として適切ではない。

			 *	ImeActiveContext (TRUE) で登録する方が適切であるように見える。

			 *

			 *	---- 削除されたコード (Sun Aug 14 02:21:27 2005)

#if !defined (NO_TSF)	

			vTSF_ActivateLanguageBar (hIMC, TRUE) ;//commented out

#endif

			 */

			MakeInfoGuideLine (hIMC, NULL, 0, -1) ;

		} else {

			/* Uninitialize */

			/*  DEBUGPRINTF ((TEXT ("ImeSelect: (%ld) -> MakeInfoGuideLine (0)\n"), hIMC)) ;

			 *	MakeInfoGuideLine (hIMC, NULL, 0, -1) ;	

			 *	この MakeInfoGuideLine は不要。

			 *	ここで GenerateMessage を実行すると application 終了時に

			 *	hangup するものが現れる。注意！！

			 */

			if (lpIMC->hCompStr){

				lpCompStr	= (LPCOMPOSITIONSTRING)ImmLockIMCC (lpIMC->hCompStr) ;

				if (lpCompStr && lpCompStr->dwSize == sizeof(MYCOMPSTR)){

					ImeDoc_vClear (&((LPMYCOMPSTR)lpCompStr)->_Doc) ;

					ImmUnlockIMCC (lpIMC->hCompStr) ;

				}

			}

			ImeConfig_vUnload () ;



			/*	LangBarItemMgr から LangBarItem を削除するのに適した場所はこちらだと思わ

			 *	れる。ImeActiveContext (FALSE) の段階では、本来消えるべきでない場合(同じ

			 *	Application で focus が少し移動した等)にも LangBarItem が削除されてしまう

			 *	ことになる。

			 */

			/*	CloseStatusWindow の位置に追加したが、こちらにも残すことにする。

			 *		(Fri Dec 09 14:28:56 2005)

			 *

			 *	この操作は良くないようだ。自動的に TSF Manager が削除してくれる？

			 *	ここで無理に削除しようとすると、操作に異常に時間がかかってしまうことがあ

			 *	る。

			 *		(Thu Apr 26 21:45:29 2007)

			 *	下記はまずいコード。

#if !defined (NO_TSF)

				vTSF_ActivateLanguageBar (hIMC, FALSE) ;//commented out

#endif

			 *

			 *	どうしても消えてくれない。ThreadMgrが存在する時には消せるとするのか？

			 *	これでもまずいのか？

			 *	修正してみたコード。

			 *

#if !defined (NO_TSF)

			if (bTSF_DoesThreadMgrExistp ()) {

				vTSF_ActivateLanguageBar (hIMC, FALSE) ;//commented out

			}

#endif

			 */

#if !defined (NO_TSF)

			if (bTSF_DoesThreadMgrExistp ()) {

				vTSF_ActivateLanguageBar (hIMC, FALSE) ;

			}

#endif

		}

		ImmUnlockIMC (hIMC) ;

	}

	return	TRUE ;

}



/***********************************************************************

 *	ImeSetCompositionString ()

 *	ImeSetCompositionString 関数はアプリケーションに lpComp やlpRead パ

 *	ラメータに入れられたデータをIMEのcomposition string 構造体に設定する

 *	のに用いられる。IME は WM_IME_COMPOSITION メッセージを生成する。

 *	BOOL WINAPI

 *		ImeSetCompositionString(

 *		HIMC hIMC,

 *		DWORD dwIndex,

 *		LPCVOID lpComp,

 *		DWORD dwCompLen,

 *		LPCVOID lpRead,

 *		DWORD dwReadLen

 *	);

 *	Parameters

 *		hIMC

 *			Input context handle. 

 *		dwIndex

 *			dwIndex に与えられる値は次の通りである。

 *			------------------------------------------------------------

 *	SCS_SETSTR

 *		アプリケーションは composition string 又は reading string また

 *		はその両方をセットする。少なくとも lpComp か lpRead パラメータ

 *		の1つは正当な文字列を指すポインタでなければならない。

 *		もし文字列が長すぎるのなら、IME はそれを切り詰め。

 *	SCS_CHANGEATTR

 *		アプリケーションは composition string 又は reading string 又は

 *		その両者の節情報を設定する。少なくとも lpComp か lpRead の1つ

 *		は valid な節情報の配列を指すポインタでなければならない。

 *	SCS_QUERYRECONVERTSTRING

 *		アプリケーションは IME にその RECONVERTSTRINGSTRUCTURE を調整

 *		してくれるよう依頼する。もしアプリケーションがこの値を設定して

 *		ImeSetCompositionString を呼び出したなら、IME は RECONVERTSTRING

 *		構造体を調整しなければならない。アプリケーションはその時調整さ

 *		れた RECONVERTSTRING 構造体を SCS_RECONVERTSTRING でもって、

 *		この関数に渡すことができる。IME は WM_IMECOMPOSITION メッセージ

 *		を生成してはならない。

 *	SCS_SETRECONVERTSTRING

 *		アプリケーションは IME に RECONVERTSTRING 構造体に含まれる

 *		文字列を reconvert するように依頼する。

 *			------------------------------------------------------------

 *		lpComp

 *			更新された文字列を含むバッファを指すポインタ。文字列の型は

 *			dwIndex の値によって決定される。

 *		dwCompLen

 *			バッファのバイト長。

 *		lpRead

 *			更新された文字列を含むバッファを指すポインタ。文字列の型は

 *			dwIndex の値によって決定される。dwIndex の値が

 *			SCS_SETRECONVERTSTRING もしくは SCS_QUERYRECONVERTSTRING な

 *			らば、lpRead は更新された reading string を含む

 *			RECONVERTSTRING 構造体を指すポインタである。もし選択された

 *			IME が SCS_CAP_MAKEREAD をもっていれば、NULL になる。

 *		dwReadLen

 *			バッファのバイト長。

 *	Comments

 *		Unicode については、たとえ SCS_SETSTR が特定されており Unicode 

 *		文字列を含んでいても、dwCompLen や dwReadLen はバッファのバイト

 *		長である。

 *		SCS_SETRECONVERTSTRING または SCS_QUERYRECONVERTSTRING は

 *		SCS_CAP_CONVERTSTRING プロパティを持った IME にのみ利用できる。

 *		このプロパティは ImmGetProperty 関数を使うことで得ることができる。

 ***********************************************************************/

BOOL	WINAPI

ImeSetCompositionString(

	HIMC			hIMC,

	DWORD			dwIndex,

	LPVOID			lpComp,

	DWORD			dwComp,

	LPVOID			lpRead,

	DWORD			dwRead)

{

	LPINPUTCONTEXT			lpIMC ;

	LPCOMPOSITIONSTRING	lpCompStr ;



	switch (dwIndex) {

	case	SCS_SETSTR:

	{

		if (lpComp == NULL || dwComp <= 0)

			break ;



		lpIMC	= ImmLockIMC (hIMC) ;

		if (!lpIMC)

			break ;



		lpCompStr	= (LPCOMPOSITIONSTRING)ImmLockIMCC (lpIMC->hCompStr) ;

		if (lpCompStr != NULL) {

			TSkkIme_vInitCompStr (lpCompStr, CLR_RESULT_AND_UNDET) ;

			ImeDoc_bSetConversionString (&((LPMYCOMPSTR)lpCompStr)->_Doc, lpComp, dwComp) ;

			TSkkIme_bUpdateComposition (hIMC, lpIMC, lpCompStr) ;

			ImmUnlockIMCC (lpIMC->hCompStr) ;

		}

		ImmUnlockIMC (hIMC) ;

		return	TRUE ;

	}

	case	SCS_CHANGEATTR:

	case	SCS_CHANGECLAUSE:

		break ;

	case	SCS_QUERYRECONVERTSTRING:

	{

		LPRECONVERTSTRING		pRStr		= (LPRECONVERTSTRING)lpComp ;



#if defined (DEBUG) || defined (DBG)

		DebugPrintf (TEXT ("SCS_QUERYRECONVERTSTRING:\n")) ;

		if (lpComp != NULL) {

			DebugPrintf (TEXT ("lpComp:\n")) ;

			DebugDumpRS (lpComp) ;

		}

		if (lpRead != NULL) {

			DebugPrintf (TEXT ("lpRead:\n")) ;

			DebugDumpRS (lpRead) ;

		}

#endif

		if (pRStr != NULL) {

			/*	サイズがおまかせの場合には、取り敢えずは dwStrLen に

			 *	あわせる。kakasi とこの位置で連携した方がいいのかもし

			 *	れない。*/

			if (pRStr->dwCompStrLen   <= 0 ||

				pRStr->dwTargetStrLen <= 0) {

				pRStr->dwCompStrOffset		= 0 ;

				pRStr->dwTargetStrOffset	= 0 ;

				pRStr->dwCompStrLen			= pRStr->dwStrLen ;

				pRStr->dwTargetStrLen		= pRStr->dwStrLen ;

			}

			/*	サイズが大き過ぎるなら調整しなければ。*/

			if (pRStr->dwCompStrLen >= MAXCOMPSIZE) 

				pRStr->dwCompStrLen			= MAXCOMPSIZE - 1 ;

			if (pRStr->dwTargetStrLen >= MAXCOMPSIZE) 

				pRStr->dwTargetStrLen		= MAXCOMPSIZE - 1 ;

		}

		return	TRUE ;

	}

	case	SCS_SETRECONVERTSTRING:

	{

		LPRECONVERTSTRING		pRStr		= (LPRECONVERTSTRING)lpComp ;



#if defined (DEBUG) || defined (DBG)

		DebugPrintf (TEXT ("SCS_SETRECONVERTSTRING:\n")) ;

		if (lpComp != NULL) {

			DebugPrintf (TEXT ("lpComp:\n")) ;

			DebugDumpRS (lpComp) ;

		}

		if (lpRead != NULL) {

			DebugPrintf (TEXT ("lpRead:\n")) ;

			DebugDumpRS (lpRead) ;

		}

#endif

		if (!pRStr)

			break ;



		lpIMC	= ImmLockIMC (hIMC) ;

		if (!lpIMC) {

			break ;

		}

		if (ImmGetIMCCSize (lpIMC->hCompStr) < sizeof (MYCOMPSTR)){

			ImmUnlockIMC (hIMC) ;

			break ;

		}

		/*	変換モードを強制的に仮名入力モードに設定する。*/

		//SKKChangeConversionMode (hIMC, IDM_CMODE_TO_ROMANHIRA) ;

		lpCompStr	= (LPCOMPOSITIONSTRING)ImmLockIMCC (lpIMC->hCompStr) ;

		if (lpCompStr != NULL) {

			if (! ImmGetOpenStatus (hIMC))

				ImmSetOpenStatus (hIMC, TRUE) ;

			TSkkIme_bSetReconvertStr (hIMC, lpIMC, lpCompStr, pRStr, TRUE) ;

			ImmUnlockIMCC (lpIMC->hCompStr) ;

		}

		ImmUnlockIMC (hIMC) ;

		return	TRUE ;

	}

	default:

		break ;

	}

	return	FALSE ;

}



/***********************************************************************

 *	ImeGetImeMenuItems

 *	ImeGetImeMenuItems 関数は IME menu に登録されている menu item を得る。

 *	DWORD WINAPI

 *		ImeGetImeMenuItems(

 *		HIMC hIMC,

 *		DWORD dwFlags,

 *		DWORD dwType,

 *		LPIMEMENUITEMINFO lpImeParentMenu,

 *		LPIMEMENUITEMINFO lpImeMenu,

 *		DWORD dwSize

 *	)

 *	Parameters

 *		hIMC

 *			lpMenuItem はこの input context に関連付けられている menu

 *			item を含む。

 *		dwFlags

 *			続くビットの組み合わせからなる。

 *			------------------------------------------------------------

 *			IGIMIF_RIGHTMENU	

 *				もし 1 なら、この関数は右クリック Context menu に対する

 *				menu item を返す。

 *			------------------------------------------------------------

 *		dwType

 *			続くビットの組み合わせからなる。

 *			------------------------------------------------------------

 *			IGIMII_CMODE

 *				conversion mode に関連付けられている menu item を返す。

 *			IGIMII_SMODE

 *				sentence mode に関連付けられている menu item を返す。

 *			IGIMII_CONFIGURE

 *				IME の設定に関連付けられている menu item を返す。

 *			IGIMII_TOOLS

 *				IME ツールに関連付けられている menu item を返す。

 *			IGIMII_HELP

 *				IME ヘルプに関連付けられている menu item を返す。

 *			IGIMII_OTHER

 *				その他の menu item を返す。

 *			IGIMII_INPUTTOOLS

 *				拡張された文字の入力方法を提供する IME 入力ツールに関連

 *				付けられた menu item を返す。

 *			------------------------------------------------------------

 *		lpImeParentMenu

 *			fType に MFT_SUBMENU を持った IMEMENUINFO 構造体を指すポイン

 *			タ。ImeGetMenuItems はこの menu item の submenu item を返す。

 *			もし NULL なら lpImeMenu は top-level の IME menu item を含

 *			んでいる。

 *		lpImeMenu

 *			menu item の内容を受け取るバッファを指したポインタ。このバッ

 *			ファは IMEMENUINFO 構造体の配列である。もし NULL なら

 *			ImeGetImeMenuItems は登録される menu item の数を返す。

 *		dwSize

 *			IMEMENUITEMINFO 構造体を受けるバッファのサイズ。

 *	Return Values

 *		lpIM に設定された menu item の数が帰る。もし lpImeMenu が NULL 

 *		ならば ImeMenuItems は指定された hKL に登録されている menu item 

 *		の数を返す。

 *	ImeGetImeMenuItems は Windows'98 や Windows 2000 用の新しい関数である。

 ***********************************************************************/

DWORD	WINAPI

ImeGetImeMenuItems (

	HIMC		hIMC,

	DWORD		dwFlags,

	DWORD		dwType,

	LPMYIMEMENUITEMINFO	lpImeParentMenu,

	LPMYIMEMENUITEMINFO	lpImeMenu,

	DWORD					dwSize)

{

	/*	dwType を MSIME はチェックしていないようだ。それに合わせる。

	 *	ただ、TSF が生きていると、この method は常に動作してないように思えるが。

	 *

	 *	if (IsTSFEnabled ())

	 *		return	0 ;

	 *

	 *	このコードを有効にするかどうかは微妙だ。

	 *	[Sun Nov 23 00:26:08 2003]

	 */

	dwType	|= IGIMII_CMODE | IGIMII_SMODE | IGIMII_CONFIGURE | IGIMII_TOOLS | IGIMII_HELP | IGIMII_OTHER ;

	if (dwFlags & IGIMIF_RIGHTMENU){

		return	getImeRightMenuItems (hIMC, dwFlags, dwType, lpImeParentMenu, lpImeMenu, dwSize) ;

	} else {

		return	getImeLeftMenuItems (hIMC, dwFlags, dwType, lpImeParentMenu, lpImeMenu, dwSize) ;

	}

}



DWORD	PASCAL

getImeLeftMenuItems (

	HIMC		hIMC,

	DWORD		dwFlags,

	DWORD		dwType,

	LPMYIMEMENUITEMINFO	lpImeParentMenu,

	LPMYIMEMENUITEMINFO	lpImeMenu,

	DWORD		dwSize)

{

	static MYSTRTYPEPAIR	myLeftMenuItemInfoTbl []	= {

		{ IDIM_SHOW_TOOLBAR,	MYTEXT ("ツールバーを表示(&I)"), },

		{ IDIM_CANCEL,			MYTEXT ("キャンセル"), },

	} ;

	long					lUsage ;

	int						iMenuItem ;



	if (! TSkkIme_bIsHideToolbarp ())

		return	0 ;



	iMenuItem		= 0 ;

	/*	ツールバーを表示(&I) をメニューに追加する。*/

	if (dwType & IGIMII_OTHER) {

		if (lpImeMenu != NULL) {

			insertStringMenuItem (lpImeMenu ++, &myLeftMenuItemInfoTbl [0], IMFS_ENABLED) ;

			insertSeparatorMenuItem (lpImeMenu ++) ;

		}

		iMenuItem		+= 2 ;

	}

	if (dwType & IGIMII_CMODE) {

		/*	入力モードの変更メニューを追加する。*/

		lUsage			= insertInputModeMenuItems (hIMC, lpImeMenu) ;

		if (lUsage > 0) {

			if (lpImeMenu != NULL) {

				lpImeMenu		+= lUsage ;

				insertSeparatorMenuItem (lpImeMenu ++) ;

			}

			iMenuItem		+= lUsage + 1 ;

		}

	}

	/*	キャンセルを追加する。*/

	if (lpImeMenu != NULL)

		insertStringMenuItem (lpImeMenu ++, &myLeftMenuItemInfoTbl [1], IMFS_ENABLED) ;

	iMenuItem		++ ;



	DEBUGPRINTFEX (102, (TEXT ("getImeLeftMenuItems return (%d), lUsage = %d\n"),

						 iMenuItem, (int) lUsage)) ;

	return	iMenuItem ;

}



DWORD	PASCAL

getImeRightMenuItems (

	HIMC			hIMC,

	DWORD			dwFlags,

	DWORD			dwType, 

	LPMYIMEMENUITEMINFO	lpImeParentMenu, 

	LPMYIMEMENUITEMINFO	lpImeMenu,

	DWORD			dwSize)

{

	static MYSTRTYPEPAIREX	myRightMenuItemInfoTbl [NUM_ROOT_MENU_R]	= {

		{ IDIM_SHOW_TOOLBAR,	IGIMII_OTHER,		MYTEXT ("ツールバーを表示(&I)"), },

		{ 0,					IGIMII_OTHER,		0, },

		{ IDIM_PROPERTY,		IGIMII_CONFIGURE,	MYTEXT ("プロパティ(&R)"), },

		{ 0,					IGIMII_CONFIGURE | IGIMII_OTHER,	0, },

		{ IDIM_INPUTMODE,		IGIMII_CMODE,		MYTEXT ("入力モード(&N)"), },

		{ 0,					IGIMII_CMODE,		0, },

		{ IDIM_CANCEL,			(DWORD)-1,			MYTEXT ("キャンセル"), },

	} ;

	LPMYSTRTYPEPAIREX	ptr ;

	int				iMenuItem, nCount ;

	BOOL				fInsert ;



	if (lpImeParentMenu)

		return	getImeRightSubMenuItems (hIMC, dwFlags, dwType, lpImeParentMenu, lpImeMenu, dwSize) ;

	if (! TSkkIme_bIsHideToolbarp ())

		return	0 ;



	iMenuItem		= 0 ;

	ptr				= myRightMenuItemInfoTbl ;

	for (nCount = 0 ; nCount < ARRAYSIZE (myRightMenuItemInfoTbl) ; nCount ++) {

		fInsert	= (ptr->m_dwType != (DWORD) -1)? ((ptr->m_dwType & dwType) != 0) : TRUE ;

		if (fInsert) {

			if (lpImeMenu != NULL) {

				if (! ptr->m_lpString){

					insertSeparatorMenuItem (lpImeMenu) ;

				} else {

					/*	メニューを追加。*/

					insertStringMenuItemEx (lpImeMenu, ptr, IMFS_ENABLED) ;

					

					/*	入力モードの場合には submenu が存在する。*/

					if (ptr->m_wID == IDIM_INPUTMODE) 

						lpImeMenu->fType	= IMFT_SUBMENU ;

				}

				lpImeMenu	++ ;

			}

			iMenuItem	++ ;

		}

		ptr			++ ;

	}

	return	iMenuItem ;

}



DWORD	PASCAL

getImeRightSubMenuItems (

	HIMC		hIMC,

	DWORD		dwFlags,

	DWORD		dwType,

	LPMYIMEMENUITEMINFO	lpImeParentMenu,

	LPMYIMEMENUITEMINFO	lpImeMenu,

	DWORD		dwSize)

{

	if ((lpImeParentMenu->wID != IDIM_INPUTMODE) ||

		(dwType & IGIMII_CMODE) == 0)

		return	0 ;

	if (!lpImeMenu)

		return	NUM_INPUTMODE_MENU ;

	return	insertInputModeMenuItems (hIMC, lpImeMenu) ;

}



long	PASCAL

insertStringMenuItem (

	LPMYIMEMENUITEMINFO		lpImeMenu,

	const LPMYSTRTYPEPAIR		lpMyStrTypePair,

	UINT						uValue)

{

	if (!lpImeMenu || !lpMyStrTypePair)

		return	0L ;



	lpImeMenu->cbSize			= sizeof(IMEMENUITEMINFO) ;

	lpImeMenu->fType			= 0 ;

	lpImeMenu->fState			= uValue ;

	lpImeMenu->wID				= lpMyStrTypePair->m_wID ;

	Mylstrcpy (lpImeMenu->szString, lpMyStrTypePair->m_lpString) ;

	lpImeMenu->hbmpChecked		= 0 ;

	lpImeMenu->hbmpUnchecked	= 0 ;

	lpImeMenu->hbmpItem			= 0 ;

	return	1L ;

}



long	PASCAL

insertStringMenuItemEx (

	LPMYIMEMENUITEMINFO		lpImeMenu,

	const LPMYSTRTYPEPAIREX	lpMyStrTypePair,

	UINT						uValue)

{

	if (!lpImeMenu || !lpMyStrTypePair)

		return	0L ;



	lpImeMenu->cbSize			= sizeof(IMEMENUITEMINFO) ;

	lpImeMenu->fType			= 0 ;

	lpImeMenu->fState			= uValue ;

	lpImeMenu->wID				= lpMyStrTypePair->m_wID ;

	Mylstrcpy (lpImeMenu->szString, lpMyStrTypePair->m_lpString) ;

	lpImeMenu->hbmpChecked		= 0 ;

	lpImeMenu->hbmpUnchecked	= 0 ;

	lpImeMenu->hbmpItem			= 0 ;

	return	1L ;

}



long	PASCAL

insertSeparatorMenuItem (

	LPMYIMEMENUITEMINFO	lpImeMenu)

{

	if (!lpImeMenu)

		return	0L ;

	lpImeMenu->cbSize			= sizeof(IMEMENUITEMINFO) ;

	lpImeMenu->fType			= IMFT_SEPARATOR ;

	lpImeMenu->fState			= 0 ;

	lpImeMenu->wID				= 0 ;

	lpImeMenu->szString [0]		= MYTEXT ('\0') ;

	lpImeMenu->hbmpChecked		= 0 ;

	lpImeMenu->hbmpUnchecked	= 0 ;

	lpImeMenu->hbmpItem			= 0 ;

	return	1L ;

}



long	PASCAL

insertInputModeMenuItems (

	HIMC		hIMC,

	LPMYIMEMENUITEMINFO	lpImeMenu)

{

	static MYSTRTYPEPAIR	inputModeMenuItemTbl [NUM_INPUTMODE_MENU]	= {

		{ IDM_CMODE_TO_ASCII,			MYTEXT ("アスキー(&S)"), },

		{ IDM_CMODE_TO_ROMANHIRA,		MYTEXT ("ローマ字平仮名(&H)"), },

		{ IDM_CMODE_TO_ROMANKATA,		MYTEXT ("ローマ字片仮名(&K)"), },

		{ IDM_CMODE_TO_JISX0201KANA,	MYTEXT ("半角片仮名(&A)"), },

		{ IDM_CMODE_TO_JISX0201ROMAN,	MYTEXT ("半角英数(&R)"), },

		{ IDM_CMODE_TO_ZENEI,			MYTEXT ("全角英字(&E)"), },

		{ IDM_CMODE_TO_DIRECTINPUT,	MYTEXT ("直接入力(&C)"), },

	} ;

	DWORD					dwMyInputModeTbl [NUM_INPUTMODE_MENU]	= {

		IDM_CMODE_TO_ROMANHIRA,

		IDM_CMODE_TO_ROMANKATA,

		IDM_CMODE_TO_ZENEI,

		IDM_CMODE_TO_JISX0201KANA,

		IDM_CMODE_TO_JISX0201ROMAN,

		IDM_CMODE_TO_ASCII,

		IDM_CMODE_TO_DIRECTINPUT,

	} ;

	LPMYSTRTYPEPAIR			lpMyMenuItemInfo ;

	long					lCounter ;

	DWORD					dwCMode ;

	LPINPUTCONTEXT			lpIMC ;



	/* 現在の入力モードを得る。*/

	lpIMC	= (LPINPUTCONTEXT)ImmLockIMC (hIMC) ;

	if (!lpIMC)

		return	0 ;

	

	/*	IMECMODE_XXX から IDM_CMODE_ に変換する。

	 */

	dwCMode		= dwMyInputModeTbl [iGetConversionModeFromLPIMC (lpIMC)] ;

	ImmUnlockIMC (hIMC) ;



	if (lpImeMenu == NULL) 

		return	sizeof (inputModeMenuItemTbl) / sizeof (MYSTRTYPEPAIR) ;



	lpMyMenuItemInfo	= inputModeMenuItemTbl ;

	lCounter			= 0 ;

	while (lCounter < sizeof (inputModeMenuItemTbl) / sizeof (MYSTRTYPEPAIR)){

		lpImeMenu->cbSize			= sizeof(IMEMENUITEMINFO) ;

		lpImeMenu->fType			= IMFT_RADIOCHECK ;

		lpImeMenu->wID				= lpMyMenuItemInfo->m_wID ;

		if (lpMyMenuItemInfo->m_wID == dwCMode){

			lpImeMenu->fState		= IMFS_ENABLED | IMFS_CHECKED ;

		} else {

			lpImeMenu->fState		= IMFS_ENABLED | IMFS_UNCHECKED ;

		}

		Mylstrcpy (lpImeMenu->szString, lpMyMenuItemInfo->m_lpString) ;

		lpImeMenu->hbmpChecked		= 0 ;

		lpImeMenu->hbmpUnchecked	= 0 ;

		lpImeMenu->hbmpItem			= 0 ;

		lpMyMenuItemInfo	++ ;

		lpImeMenu	++ ;

		lCounter	++ ;

	}

	return	lCounter ;

}