You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3143 lines
78 KiB
3143 lines
78 KiB
//+---------------------------------------------------------------------------
|
|
//
|
|
// File: immapp.cpp
|
|
//
|
|
// Contents: IActiveIMM methods with application win32 mappings.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include "private.h"
|
|
|
|
#include "globals.h"
|
|
#include "cdimm.h"
|
|
#include "defs.h"
|
|
#include "enum.h"
|
|
|
|
extern HRESULT CAImmProfile_CreateInstance(IUnknown *pUnkOuter, REFIID riid, void **ppvObj);
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
// Input Context Group
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI
|
|
CActiveIMM::CreateContext(
|
|
OUT HIMC *phIMC
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::CreateContext
|
|
IActiveIMMIME::CreateContext
|
|
|
|
Routine Description:
|
|
|
|
Creates a new input context, allocating memory for the context and initializing it.
|
|
|
|
Arguments:
|
|
|
|
phIMC - [out] Address of a handle to receive the new input context.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::CreateContext");
|
|
|
|
HRESULT hr;
|
|
|
|
if (FAILED(hr = _InputContext.CreateContext(_GetIMEProperty(PROP_PRIVATE_DATA_SIZE),
|
|
(_GetIMEProperty(PROP_IME_PROPERTY) & IME_PROP_UNICODE) ? TRUE : FALSE,
|
|
phIMC, _IsAlreadyActivate())))
|
|
{
|
|
return hr;
|
|
}
|
|
|
|
if (_IsAlreadyActivate() && !_IsRealIme())
|
|
{
|
|
_AImeSelect(*phIMC, TRUE);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDAPI
|
|
CActiveIMM::DestroyContext(
|
|
IN HIMC hIMC
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::DestroyContext
|
|
IActiveIMMIME::DestroyContext
|
|
|
|
Routine Description:
|
|
|
|
Releases the input context and frees any memory associated with it.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::DestroyContext");
|
|
|
|
if (_IsAlreadyActivate() && !_IsRealIme()) {
|
|
_AImeSelect(hIMC, FALSE);
|
|
}
|
|
|
|
return _InputContext.DestroyContext(hIMC);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::AssociateContext(
|
|
IN HWND hWnd,
|
|
IN HIMC hIMC,
|
|
OUT HIMC *phPrev
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::AssociateContext
|
|
IActiveIMMIME::AssociateContext
|
|
|
|
Routine Description:
|
|
|
|
Associates the specified input context with the specified window.
|
|
|
|
Arguments:
|
|
|
|
hWnd - [in] Handle to the window to be associated with the input context.
|
|
hIMC - [in] Handle to the input context. If hIMC is NULL, the method removed any
|
|
association the window may have had with input context.
|
|
phPrev - [out] Address of the handle to the input context previously associated
|
|
with the window.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
HRESULT hr;
|
|
|
|
TraceMsg(TF_API, "CActiveIMM::AssociateContext");
|
|
|
|
hr = _InputContext.AssociateContext(hWnd, hIMC, phPrev);
|
|
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
if (!_IsRealIme())
|
|
{
|
|
if (_hFocusWnd == hWnd)
|
|
{
|
|
_AImeAssociateFocus(hWnd, *phPrev, 0);
|
|
_ResetMapWndFocus(hWnd);
|
|
_AImeAssociateFocus(hWnd, hIMC, AIMMP_AFF_SETFOCUS);
|
|
_SetMapWndFocus(hWnd);
|
|
}
|
|
}
|
|
|
|
return IsOnImm() ? Imm32_AssociateContext(hWnd, hIMC, phPrev) : hr;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::AssociateContextEx(
|
|
IN HWND hWnd,
|
|
IN HIMC hIMC,
|
|
IN DWORD dwFlags
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::AssociateContextEx
|
|
IActiveIMMIME::AssociateContextEx
|
|
|
|
Routine Description:
|
|
|
|
Changes the association between the input method context and the specified window
|
|
or its children.
|
|
|
|
Arguments:
|
|
|
|
hWnd - [in] Handle to the window to be associated with the input context.
|
|
hIMC - [in] Handle to the input context.
|
|
dwFlags - [in] Unsigned long integer value that contains the type of association
|
|
between the window and the input method context.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
HRESULT hr;
|
|
HIMC hImcFocusOld;
|
|
|
|
TraceMsg(TF_API, "CActiveIMM::AssociateContextEx");
|
|
|
|
hr = _InputContext.AssociateContextEx(hWnd, hIMC, dwFlags);
|
|
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
if (!_IsRealIme())
|
|
{
|
|
hr = _InputContext.GetContext(hWnd, &hImcFocusOld);
|
|
if (FAILED(hr))
|
|
hImcFocusOld = NULL;
|
|
|
|
hr = _InputContext.AssociateContextEx(hWnd, hIMC, dwFlags);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (_hFocusWnd == hWnd)
|
|
{
|
|
_AImeAssociateFocus(hWnd, hImcFocusOld, 0);
|
|
_ResetMapWndFocus(hWnd);
|
|
_AImeAssociateFocus(hWnd, hIMC, AIMMP_AFF_SETFOCUS);
|
|
_SetMapWndFocus(hWnd);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
return IsOnImm() ? Imm32_AssociateContextEx(hWnd, hIMC, dwFlags) : hr;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetContext(
|
|
HWND hWnd,
|
|
HIMC *phIMC
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetContext
|
|
IActiveIMMIME::GetContext
|
|
|
|
Routine Description:
|
|
|
|
Retrieves the input context associated with the specified window. An application must
|
|
release each context retrieved by calling IActiveIMMApp::ReleaseContext.
|
|
|
|
Arguments:
|
|
|
|
hWnd - [in] Handle to the window that is retrieving an input context.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
return GetContextInternal(hWnd, phIMC, TRUE);
|
|
}
|
|
|
|
HRESULT
|
|
CActiveIMM::GetContextInternal(
|
|
HWND hWnd,
|
|
HIMC *phIMC,
|
|
BOOL fGetDefIMC
|
|
)
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetContext");
|
|
|
|
*phIMC = 0;
|
|
|
|
if (!IsWindow(hWnd))
|
|
return E_INVALIDARG;
|
|
|
|
if (!fGetDefIMC && !IsPresent(hWnd, FALSE) && !_IsRealIme())
|
|
return S_FALSE;
|
|
|
|
return _InputContext.GetContext(hWnd, phIMC);
|
|
}
|
|
|
|
|
|
STDAPI
|
|
CActiveIMM::ReleaseContext(
|
|
IN HWND hWnd,
|
|
IN HIMC hIMC
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::ReleaseContext
|
|
IActiveIMMIME::ReleaseContext
|
|
|
|
Routine Description:
|
|
|
|
Release the input context and unlocks the memory associated in the context.
|
|
An application must call this method for each call to the IActiveIMMApp::GetContext
|
|
method.
|
|
|
|
Arguments:
|
|
|
|
hWnd - [in] Handle to the window for which the input context was previously retrieved.
|
|
hIMC - [in] Handle to the input context.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::ReleaseContext");
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetOpenStatus(
|
|
IN HIMC hIMC
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetOpenStatus
|
|
IActiveIMMIME::GetOpenStatus
|
|
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
|
|
Return Value:
|
|
|
|
Returns a nonzero value if the IME is open, or zero otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetOpenStatus");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetOpenStatus(hIMC);
|
|
}
|
|
|
|
return _InputContext.GetOpenStatus(hIMC);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::SetOpenStatus(
|
|
HIMC hIMC,
|
|
BOOL fOpen
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::SetOpenStatus
|
|
IActiveIMMIME::SetOpenStatus
|
|
|
|
Routine Description:
|
|
|
|
Open or close the IME.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
fOpen - [in] Boolean value that contains the status. If TRUE, the IMM is opened:
|
|
otherwize the IMM is closed.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
HRESULT hr;
|
|
BOOL fOpenChg;
|
|
HWND hWnd;
|
|
|
|
TraceMsg(TF_API, "CActiveIMM::SetOpenStatus");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_SetOpenStatus(hIMC, fOpen);
|
|
}
|
|
|
|
{
|
|
DIMM_IMCLock lpIMC(hIMC);
|
|
if (FAILED(hr = lpIMC.GetResult()))
|
|
return hr;
|
|
|
|
hr = _InputContext.SetOpenStatus(lpIMC, fOpen, &fOpenChg);
|
|
|
|
hWnd = lpIMC->hWnd;
|
|
}
|
|
|
|
/*
|
|
* inform IME and Apps Wnd about the conversion mode changes.
|
|
*/
|
|
if (SUCCEEDED(hr) && fOpenChg) {
|
|
_SendIMENotify(hIMC, hWnd,
|
|
NI_CONTEXTUPDATED, (DWORD)0, IMC_SETOPENSTATUS,
|
|
IMN_SETOPENSTATUS, 0L);
|
|
|
|
/*
|
|
* notify shell and keyboard the conversion mode change
|
|
*/
|
|
// NtUserNotifyIMEStatus( hWnd, dwOpenStatus, dwConversion );
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetConversionStatus(
|
|
IN HIMC hIMC,
|
|
OUT DWORD *lpfdwConversion,
|
|
OUT DWORD *lpfdwSentence
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetConversionStatus
|
|
IActiveIMMIME::GetConversionStatus
|
|
|
|
Routine Description:
|
|
|
|
Retrieves the current conversion status.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context for which to retrieve information.
|
|
lpfdwConversion - [out] Address of an unsigned long integer value that receives a
|
|
combination of conversion mode.
|
|
lpfwSentence - [out] Address of an unsigned long integer value that receives a sentence
|
|
mode value.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetConversionStatus");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetConversionStatus(hIMC, lpfdwConversion, lpfdwSentence);
|
|
}
|
|
|
|
return _InputContext.GetConversionStatus(hIMC, lpfdwConversion, lpfdwSentence);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::SetConversionStatus(
|
|
IN HIMC hIMC,
|
|
IN DWORD fdwConversion,
|
|
IN DWORD fdwSentence
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::SetConversionStatus
|
|
IActiveIMMIME::SetConversionStatus
|
|
|
|
Routine Description:
|
|
|
|
Sets the current conversion status.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
fdwConversion - [in] Unsigned long value that contains the conversion mode values.
|
|
fdwSentence - [in] Unsigned long integer value that contains the sentence mode values.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL fConvModeChg = FALSE;
|
|
BOOL fSentenceChg = FALSE;
|
|
HWND hWnd;
|
|
DWORD fdwOldConversion;
|
|
DWORD fdwOldSentence;
|
|
HRESULT hr;
|
|
|
|
TraceMsg(TF_API, "CActiveIMM::SetConversionStatus");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_SetConversionStatus(hIMC, fdwConversion, fdwSentence);
|
|
}
|
|
|
|
DIMM_IMCLock lpIMC(hIMC);
|
|
if (FAILED(hr = lpIMC.GetResult()))
|
|
return hr;
|
|
|
|
hr = _InputContext.SetConversionStatus(lpIMC, fdwConversion, fdwSentence,
|
|
&fConvModeChg, &fSentenceChg, &fdwOldConversion, &fdwOldSentence);
|
|
|
|
hWnd = lpIMC->hWnd;
|
|
|
|
/*
|
|
* inform IME and Apps Wnd about the conversion mode changes.
|
|
*/
|
|
if (fConvModeChg) {
|
|
_SendIMENotify(hIMC, hWnd,
|
|
NI_CONTEXTUPDATED, fdwOldConversion, IMC_SETCONVERSIONMODE,
|
|
IMN_SETCONVERSIONMODE, 0L);
|
|
|
|
/*
|
|
* notify shell and keyboard the conversion mode change
|
|
*/
|
|
// NtUserNotifyIMEStatus( hWnd, dwOpenStatus, dwConversion );
|
|
}
|
|
|
|
/*
|
|
* inform IME and Apps Wnd about the sentence mode changes.
|
|
*/
|
|
if (fSentenceChg) {
|
|
_SendIMENotify(hIMC, hWnd,
|
|
NI_CONTEXTUPDATED, fdwOldSentence, IMC_SETSENTENCEMODE,
|
|
IMN_SETSENTENCEMODE, 0L);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetStatusWindowPos(
|
|
IN HIMC hIMC,
|
|
OUT POINT *lpptPos
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetStatusWindowPos
|
|
IActiveIMMIME::GetStatusWindowPos
|
|
|
|
Routine Description:
|
|
|
|
Retrieves the position of the status window.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
lpptPos - [out] Address of the POINT structure that receives the position coordinates.
|
|
These are screen coordinates, relative to the upper-left corner of the screen.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetStatusWindowPos");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetStatusWindowPos(hIMC, lpptPos);
|
|
}
|
|
|
|
return _InputContext.GetStatusWindowPos(hIMC, lpptPos);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::SetStatusWindowPos(
|
|
IN HIMC hIMC,
|
|
IN POINT *lpptPos
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::SetStatusWindowPos
|
|
|
|
Routine Description:
|
|
|
|
Sets the position of the status window.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
lpptPos - [in] Address of the POINT structure that receives the new position of the status
|
|
window.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr;
|
|
HWND hWnd;
|
|
|
|
TraceMsg(TF_API, "CActiveIMM::SetStatusWindowPos");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_SetStatusWindowPos(hIMC, lpptPos);
|
|
}
|
|
|
|
{
|
|
DIMM_IMCLock lpIMC(hIMC);
|
|
if (FAILED(hr = lpIMC.GetResult()))
|
|
return hr;
|
|
|
|
hr = _InputContext.SetStatusWindowPos(lpIMC, lpptPos);
|
|
|
|
hWnd = lpIMC->hWnd;
|
|
}
|
|
|
|
/*
|
|
* inform IME and Apps Wnd about the change of composition window position.
|
|
*/
|
|
_SendIMENotify(hIMC, hWnd,
|
|
NI_CONTEXTUPDATED, 0L, IMC_SETSTATUSWINDOWPOS,
|
|
IMN_SETSTATUSWINDOWPOS, 0L);
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetCompositionStringA(
|
|
IN HIMC hIMC,
|
|
IN DWORD dwIndex,
|
|
IN DWORD dwBufLen,
|
|
OUT LONG *plCopied,
|
|
OUT LPVOID lpBuf
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetCompositionStringA
|
|
IActiveIMMIME::GetCompositionStringA
|
|
|
|
Routine Description:
|
|
|
|
Retrieves information about the composition string. ANSI implementation.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
dwIndex - [in] Unsigned long integer value that contains the index of the information
|
|
to retrieve.
|
|
dwBufLen - [in] Unsigned long integer value that contains the size of the buffer, in bytes.
|
|
plCopied - [out] Address of long integer value that receives the number of bytes copied to
|
|
the buffer. If dwBufLen is zero, plCopied receives the number of bytes
|
|
needed to receive all of the requested information.
|
|
lpBuf - [out] Address of the buffer to receive the information.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetCompositionStringA");
|
|
|
|
//
|
|
// Specified hKL since hIMC updated by IME property and it synchronized by ImeSelectHandler().
|
|
//
|
|
// Especially, GetCompositionString() calls from application when changed keyboard layout.
|
|
// In this timing, Cicero's profile already updeted to Cicero's hKL but ImeSelectHandler(FALSE)
|
|
// is not yet received in IMM32.
|
|
// If IMM32 IME were ASCII style IME, then it hIMC is also ASCII and hIMC's A->W conversion
|
|
// occurred by ImeSelectHandler().
|
|
// For below ::GetKeyboardLayout() call, When IMM32 IME has been selected, we retreive
|
|
// composition string from IMM32 even while changing keyboard layout.
|
|
//
|
|
if (_IsRealIme(::GetKeyboardLayout(0)))
|
|
{
|
|
return Imm32_GetCompositionString(hIMC, dwIndex, dwBufLen, plCopied, lpBuf, FALSE);
|
|
}
|
|
|
|
return _GetCompositionString(hIMC, dwIndex, dwBufLen, plCopied, lpBuf, FALSE);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetCompositionStringW(
|
|
IN HIMC hIMC,
|
|
IN DWORD dwIndex,
|
|
IN DWORD dwBufLen,
|
|
OUT LONG *plCopied,
|
|
OUT LPVOID lpBuf
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetCompositionStringW
|
|
IActiveIMMIME::GetCompositionStringW
|
|
|
|
Routine Description:
|
|
|
|
Retrieves information about the composition string. Unicode implementation.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
dwIndex - [in] Unsigned long integer value that contains the index of the information
|
|
to retrieve.
|
|
dwBufLen - [in] Unsigned long integer value that contains the size of the buffer, in bytes.
|
|
plCopied - [out] Address of long integer value that receives the number of bytes copied to
|
|
the buffer. If dwBufLen is zero, plCopied receives the number of bytes
|
|
needed to receive all of the requested information.
|
|
lpBuf - [out] Address of the buffer to receive the information.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetCompositionStringW");
|
|
|
|
//
|
|
// Specified hKL since hIMC updated by IME property and it synchronized by ImeSelectHandler().
|
|
//
|
|
if (_IsRealIme(::GetKeyboardLayout(0)))
|
|
{
|
|
return Imm32_GetCompositionString(hIMC, dwIndex, dwBufLen, plCopied, lpBuf, TRUE);
|
|
}
|
|
|
|
return _GetCompositionString(hIMC, dwIndex, dwBufLen, plCopied, lpBuf, TRUE);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::SetCompositionStringA(
|
|
IN HIMC hIMC,
|
|
IN DWORD dwIndex,
|
|
IN LPVOID lpComp,
|
|
IN DWORD dwCompLen,
|
|
IN LPVOID lpRead,
|
|
IN DWORD dwReadLen
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::SetCompositionStringA
|
|
IActiveIMMIME::SetCompositionStringA
|
|
|
|
Routine Description:
|
|
|
|
Sets the characters, attributes, and clauses of the composition and reading strings.
|
|
ANSI implementation.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
dwIndex - [in] Unsigned long integer value that contains the type of information
|
|
to set.
|
|
lpComp - [in] Address of the buffer containing the information to set for the composition
|
|
string. The information is as specified by the dwIndex value.
|
|
dwCompLen - [in] Unsigned long integer value that contains the size, in bytes, of the
|
|
information buffer for the composition string.
|
|
lpRead - [in] Address of the buffer containing the information to set for the reading
|
|
string. The information is as specified by the dwIndex value.
|
|
dwReadLen - [in] Unsigned long integer value that contains the size, in bytes, of the
|
|
information buffer for the reading string.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_FUNC, TEXT("CActiveIMM::SetCompositionStringA"));
|
|
|
|
//
|
|
// Specified hKL since hIMC updated by IME property and it synchronized by ImeSelectHandler().
|
|
//
|
|
if (_IsRealIme(::GetKeyboardLayout(0)))
|
|
{
|
|
return Imm32_SetCompositionString(hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen, FALSE);
|
|
}
|
|
|
|
return _SetCompositionString(hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen, FALSE);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::SetCompositionStringW(
|
|
IN HIMC hIMC,
|
|
IN DWORD dwIndex,
|
|
IN LPVOID lpComp,
|
|
IN DWORD dwCompLen,
|
|
IN LPVOID lpRead,
|
|
IN DWORD dwReadLen
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::SetCompositionStringW
|
|
IActiveIMMIME::SetCompositionStringW
|
|
|
|
Routine Description:
|
|
|
|
Sets the characters, attributes, and clauses of the composition and reading strings.
|
|
Unicode implementation.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
dwIndex - [in] Unsigned long integer value that contains the type of information
|
|
to set.
|
|
lpComp - [in] Address of the buffer containing the information to set for the composition
|
|
string. The information is as specified by the dwIndex value.
|
|
dwCompLen - [in] Unsigned long integer value that contains the size, in bytes, of the
|
|
information buffer for the composition string.
|
|
lpRead - [in] Address of the buffer containing the information to set for the reading
|
|
string. The information is as specified by the dwIndex value.
|
|
dwReadLen - [in] Unsigned long integer value that contains the size, in bytes, of the
|
|
information buffer for the reading string.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
//
|
|
// Specified hKL since hIMC updated by IME property and it synchronized by ImeSelectHandler().
|
|
//
|
|
if (_IsRealIme(::GetKeyboardLayout(0)))
|
|
{
|
|
return Imm32_SetCompositionString(hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen, TRUE);
|
|
}
|
|
|
|
return _SetCompositionString(hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen, TRUE);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetCompositionFontA(
|
|
IN HIMC hIMC,
|
|
OUT LOGFONTA *lplf
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetCompositeFontA
|
|
IActiveIMMIME::GetCompositeFontA
|
|
|
|
Routine Description:
|
|
|
|
Retrieves information about the logical font currently used to display character
|
|
in the composition window. ANSI implementation.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
lplf - [out] Address of a LOGFONTA structure that receives the fontinformation.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetCompositionFontA");
|
|
|
|
//
|
|
// Specified hKL since hIMC updated by IME property and it synchronized by ImeSelectHandler().
|
|
//
|
|
if (_IsRealIme(::GetKeyboardLayout(0)))
|
|
{
|
|
return Imm32_GetCompositionFont(hIMC, (LOGFONTAW*)lplf, FALSE);
|
|
}
|
|
|
|
return _GetCompositionFont(hIMC, (LOGFONTAW*)lplf, FALSE);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetCompositionFontW(
|
|
IN HIMC hIMC,
|
|
IN LOGFONTW *lplf
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetCompositeFontW
|
|
IActiveIMMIME::GetCompositeFontW
|
|
|
|
Routine Description:
|
|
|
|
Retrieves information about the logical font currently used to display character
|
|
in the composition window. Unicode implementation.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
lplf - [out] Address of a LOGFONTW structure that receives the fontinformation.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetCompositionFontW");
|
|
|
|
//
|
|
// Specified hKL since hIMC updated by IME property and it synchronized by ImeSelectHandler().
|
|
//
|
|
if (_IsRealIme(::GetKeyboardLayout(0)))
|
|
{
|
|
return Imm32_GetCompositionFont(hIMC, (LOGFONTAW*)lplf, TRUE);
|
|
}
|
|
|
|
return _GetCompositionFont(hIMC, (LOGFONTAW*)lplf, TRUE);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::SetCompositionFontA(
|
|
IN HIMC hIMC,
|
|
IN LOGFONTA *lplf
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::SetCompositionFontA
|
|
IActiveIMMIME::SetCompositionFontA
|
|
|
|
Routine Description:
|
|
|
|
Sets the logocal font used to display characters in the composition window.
|
|
ANSI implementaion.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
lplf - [in] Address of the LOGFONTA structure containing the font information to set.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::SetCompositionFontA");
|
|
|
|
//
|
|
// Specified hKL since hIMC updated by IME property and it synchronized by ImeSelectHandler().
|
|
//
|
|
if (_IsRealIme(::GetKeyboardLayout(0)))
|
|
{
|
|
return Imm32_SetCompositionFont(hIMC, (LOGFONTAW*)lplf, FALSE);
|
|
}
|
|
|
|
return _SetCompositionFont(hIMC, (LOGFONTAW*)lplf, FALSE);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::SetCompositionFontW(
|
|
IN HIMC hIMC,
|
|
IN LOGFONTW *lplf
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::SetCompositionFontW
|
|
IActiveIMMIME::SetCompositionFontW
|
|
|
|
Routine Description:
|
|
|
|
Sets the logocal font used to display characters in the composition window.
|
|
Unicode implementaion.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
lplf - [in] Address of the LOGFONTW structure containing the font information to set.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::SetCompositionFontW");
|
|
|
|
//
|
|
// Specified hKL since hIMC updated by IME property and it synchronized by ImeSelectHandler().
|
|
//
|
|
if (_IsRealIme(::GetKeyboardLayout(0)))
|
|
{
|
|
return Imm32_SetCompositionFont(hIMC, (LOGFONTAW*)lplf, TRUE);
|
|
}
|
|
|
|
return _SetCompositionFont(hIMC, (LOGFONTAW*)lplf, TRUE);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetCompositionWindow(
|
|
IN HIMC hIMC,
|
|
OUT COMPOSITIONFORM *lpCompForm
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetCompositionWindow
|
|
IActiveIMMIME::GetCompositionWindow
|
|
|
|
Routine Description:
|
|
|
|
Retrieves information about the composition window.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
lpCompForm - [out] Address of the COMPOSITIONFORM structure that receives information
|
|
about the composition.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetCompositionWindow");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetCompositionWindow(hIMC, lpCompForm);
|
|
}
|
|
|
|
return _InputContext.GetCompositionWindow(hIMC, lpCompForm);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::SetCompositionWindow(
|
|
IN HIMC hIMC,
|
|
IN COMPOSITIONFORM *lpCompForm
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::SetCompositionWindow
|
|
|
|
Routine Description:
|
|
|
|
Sets the position of the composition window.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
lpCompForm - [in] Address of the COMPOSITIONFORM structure that contains the new position
|
|
and other related information about the composition window.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
HWND hWnd;
|
|
HRESULT hr;
|
|
|
|
TraceMsg(TF_API, "CActiveIMM::SetCompositionWindow");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_SetCompositionWindow(hIMC, lpCompForm);
|
|
}
|
|
|
|
{
|
|
DIMM_IMCLock lpIMC(hIMC);
|
|
if (FAILED(hr = lpIMC.GetResult()))
|
|
return hr;
|
|
|
|
hr = _InputContext.SetCompositionWindow(lpIMC, lpCompForm);
|
|
|
|
hWnd = lpIMC->hWnd;
|
|
}
|
|
|
|
/*
|
|
* inform IME and Apps Wnd about the change of composition window.
|
|
*/
|
|
_SendIMENotify(hIMC, hWnd,
|
|
NI_CONTEXTUPDATED, 0L, IMC_SETCOMPOSITIONWINDOW,
|
|
IMN_SETCOMPOSITIONWINDOW, 0L);
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetCandidateListA(
|
|
IN HIMC hIMC,
|
|
IN DWORD dwIndex,
|
|
IN UINT uBufLen,
|
|
OUT CANDIDATELIST *lpCandList,
|
|
OUT UINT *puCopied
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetCandidateListA
|
|
IActiveIMMIME::GetCandidateListA
|
|
|
|
Routine Description:
|
|
|
|
Retrieves a specified candidate list, copying the list to the specified buffer.
|
|
ANSI implementaion.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
dwIndex - [in] Unsigned long integer value that contains the zero-based index of
|
|
the candidate list.
|
|
uBufLen - [in] Unsigned integer value that contains the size of the buffer, in bytes.
|
|
If this is zero or if the buffer is insufficient to receive the candidate
|
|
list, the method returns the size in bytes required to receive the complete
|
|
candidate list to the variable specified by puCopied.
|
|
lpCandList - [out] Address of the CANDIDATELIST structure that receives the candidate list.
|
|
puCopied - [out] Address of an unsigned integer valiable that receives the number of bytes
|
|
copied to the specified buffer if the buffer is sufficient, otherwise it
|
|
receives the size in bytes required to receive the complete candidate list.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetCandidateListA");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetCandidateList(hIMC, dwIndex, uBufLen, lpCandList, puCopied, FALSE);
|
|
}
|
|
|
|
return _InputContext.GetCandidateList(hIMC, dwIndex, uBufLen, lpCandList, puCopied, FALSE);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetCandidateListW(
|
|
IN HIMC hIMC,
|
|
IN DWORD dwIndex,
|
|
IN UINT uBufLen,
|
|
OUT CANDIDATELIST *lpCandList,
|
|
OUT UINT *puCopied
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetCandidateListW
|
|
IActiveIMMIME::GetCandidateListW
|
|
|
|
Routine Description:
|
|
|
|
Retrieves a specified candidate list, copying the list to the specified buffer.
|
|
Unicode implementaion.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
dwIndex - [in] Unsigned long integer value that contains the zero-based index of
|
|
the candidate list.
|
|
uBufLen - [in] Unsigned integer value that contains the size of the buffer, in bytes.
|
|
If this is zero or if the buffer is insufficient to receive the candidate
|
|
list, the method returns the size in bytes required to receive the complete
|
|
candidate list to the variable specified by puCopied.
|
|
lpCandList - [out] Address of the CANDIDATELIST structure that receives the candidate list.
|
|
puCopied - [out] Address of an unsigned integer valiable that receives the number of bytes
|
|
copied to the specified buffer if the buffer is sufficient, otherwise it
|
|
receives the size in bytes required to receive the complete candidate list.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetCandidateListW");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetCandidateList(hIMC, dwIndex, uBufLen, lpCandList, puCopied, TRUE);
|
|
}
|
|
|
|
return _InputContext.GetCandidateList(hIMC, dwIndex, uBufLen, lpCandList, puCopied, TRUE);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetCandidateListCountA(
|
|
IN HIMC hIMC,
|
|
OUT DWORD *lpdwListSize,
|
|
OUT DWORD *pdwBufLen
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetCandidateListCountA
|
|
IActiveIMMIME::GetCandidateListCountA
|
|
|
|
Routine Description:
|
|
|
|
Retrieves the size, in bytes, of the candidate list. ANSI inplementaion.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
lpdwListSize - [out] Address of an unsigned long integer value that receives the size of
|
|
the candidate list.
|
|
pdwBufLen - [out] Address of an unsigned long integer value that contains the number of
|
|
bytes required to receive all candidate lists.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetCandidateListCountA");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetCandidateListCount(hIMC, lpdwListSize, pdwBufLen, FALSE);
|
|
}
|
|
|
|
return _InputContext.GetCandidateListCount(hIMC, lpdwListSize, pdwBufLen, FALSE);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetCandidateListCountW(
|
|
IN HIMC hIMC,
|
|
OUT DWORD *lpdwListSize,
|
|
OUT DWORD *pdwBufLen
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetCandidateListCountW
|
|
IActiveIMMIME::GetCandidateListCountW
|
|
|
|
Routine Description:
|
|
|
|
Retrieves the size, in bytes, of the candidate list. Unicode inplementaion.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
lpdwListSize - [out] Address of an unsigned long integer value that receives the size of
|
|
the candidate list.
|
|
pdwBufLen - [out] Address of an unsigned long integer value that contains the number of
|
|
bytes required to receive all candidate lists.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetCandidateListCountW");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetCandidateListCount(hIMC, lpdwListSize, pdwBufLen, TRUE);
|
|
}
|
|
|
|
return _InputContext.GetCandidateListCount(hIMC, lpdwListSize, pdwBufLen, TRUE);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetCandidateWindow(
|
|
IN HIMC hIMC,
|
|
IN DWORD dwIndex,
|
|
OUT CANDIDATEFORM *lpCandidate
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetCandidateWindow
|
|
IActiveIMMIME::GetCandidateWindow
|
|
|
|
Routine Description:
|
|
|
|
Retrieves information about the candidate list window.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
dwIndex - [in] Unsigned long integer value that contains the size, in byte, of the buffer.
|
|
lpCandidate - [out] Address of a CANDIDATEFORM structire that receives information about
|
|
the candidate window.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetCandidateWindow");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetCandidateWindow(hIMC, dwIndex, lpCandidate);
|
|
}
|
|
|
|
return _InputContext.GetCandidateWindow(hIMC, dwIndex, lpCandidate);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::SetCandidateWindow(
|
|
IN HIMC hIMC,
|
|
IN CANDIDATEFORM *lpCandForm
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::SetCandidateWindow
|
|
IActiveIMMIME::SetCandidateWindow
|
|
|
|
Routine Description:
|
|
|
|
Sets information about the candidate list window.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
lpCandForm - [in] Address of the CANDIDATEFORM structure that contains information about
|
|
the candidate window.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
HWND hWnd;
|
|
HRESULT hr;
|
|
|
|
TraceMsg(TF_API, "CActiveIMM::SetCandidateWindow");
|
|
|
|
if (lpCandForm->dwIndex >= 4) // over flow candidate index
|
|
return E_INVALIDARG;
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_SetCandidateWindow(hIMC, lpCandForm);
|
|
}
|
|
|
|
{
|
|
DIMM_IMCLock lpIMC(hIMC);
|
|
if (FAILED(hr = lpIMC.GetResult()))
|
|
return hr;
|
|
|
|
hr = _InputContext.SetCandidateWindow(lpIMC, lpCandForm);
|
|
|
|
hWnd = lpIMC->hWnd;
|
|
}
|
|
|
|
/*
|
|
* inform IME and Apps Wnd about the change of composition window.
|
|
*/
|
|
_SendIMENotify(hIMC, hWnd,
|
|
NI_CONTEXTUPDATED, 0L, IMC_SETCANDIDATEPOS,
|
|
IMN_SETCANDIDATEPOS, (LPARAM)(0x01 << lpCandForm->dwIndex));
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetGuideLineA(
|
|
IN HIMC hIMC,
|
|
IN DWORD dwIndex,
|
|
IN DWORD dwBufLen,
|
|
OUT LPSTR pBuf,
|
|
OUT DWORD *pdwResult
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetGuideLineA
|
|
IActiveIMMIME::GetGuideLineA
|
|
|
|
Routine Description:
|
|
|
|
Retrieves information about errors. Applications use this information to notify users.
|
|
ANSI implementation.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
dwIndex - [in] Unsigned long integer value that contains the guideline information to
|
|
retrieve.
|
|
dwBufLen - [in] Unsigned long integer value that contains the size, in bytes, of the
|
|
buffer referenced by pBuf.
|
|
pBuf - [out] Address of a string value that receives the error message string.
|
|
pdwResult - [out] Address of an unsigned long integer value that receives the error level,
|
|
error index, or size of an error message string, depending on the value
|
|
of dwIndex. If dwBufLen is set to zero, pdwResult receives the buffer size,
|
|
in bytes, needed to receive the requested information.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetGuideLineA");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetGuideLine(hIMC, dwIndex, dwBufLen, (CHARAW *)pBuf, pdwResult, FALSE);
|
|
}
|
|
|
|
return _InputContext.GetGuideLine(hIMC, dwIndex, dwBufLen, (CHARAW *)pBuf, pdwResult, FALSE);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetGuideLineW(
|
|
IN HIMC hIMC,
|
|
IN DWORD dwIndex,
|
|
IN DWORD dwBufLen,
|
|
OUT LPWSTR pBuf,
|
|
OUT DWORD *pdwResult
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetGuideLineW
|
|
IActiveIMMIME::GetGuideLineW
|
|
|
|
Routine Description:
|
|
|
|
Retrieves information about errors. Applications use this information to notify users.
|
|
Unicode implementation.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
dwIndex - [in] Unsigned long integer value that contains the guideline information to
|
|
retrieve.
|
|
dwBufLen - [in] Unsigned long integer value that contains the size, in bytes, of the
|
|
buffer referenced by pBuf.
|
|
pBuf - [out] Address of a string value that receives the error message string.
|
|
pdwResult - [out] Address of an unsigned long integer value that receives the error level,
|
|
error index, or size of an error message string, depending on the value
|
|
of dwIndex. If dwBufLen is set to zero, pdwResult receives the buffer size,
|
|
in bytes, needed to receive the requested information.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetGuideLineW");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetGuideLine(hIMC, dwIndex, dwBufLen, (CHARAW *)pBuf, pdwResult, TRUE);
|
|
}
|
|
|
|
return _InputContext.GetGuideLine(hIMC, dwIndex, dwBufLen, (CHARAW *)pBuf, pdwResult, TRUE);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::NotifyIME(
|
|
IN HIMC hIMC,
|
|
IN DWORD dwAction,
|
|
IN DWORD dwIndex,
|
|
IN DWORD dwValue
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::NotifyIME
|
|
|
|
Routine Description:
|
|
|
|
Notifies the IME about changes to the status of the input context.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
dwAction - [in] Unsigined long integer value that contains the notification code.
|
|
dwIndex - [in] Unsigned long integer value that contains the index of a candidate list or,
|
|
if dwAction is set to NI_COMPOSITIONSTR, one of the following values:
|
|
CPS_CANCEL: Clear the composition string and set the status to no composition
|
|
string.
|
|
CPS_COMPLETE: Set the composition string as the result string.
|
|
CPS_CONVERT: Convert the composition string.
|
|
CPS_REVERT: Cancel the current composition string and revert to the unconverted
|
|
string.
|
|
dwValue - [in] Unsigned long integer value that contains the index of a candidate string or
|
|
is not used, depending on the value of the dwAction parameter.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::NotifyIME");
|
|
|
|
return (!_IsRealIme()) ? _AImeNotifyIME(hIMC, dwAction, dwIndex, dwValue) :
|
|
Imm32_NotifyIME(hIMC, dwAction, dwIndex, dwValue);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetImeMenuItemsA(
|
|
IN HIMC hIMC,
|
|
IN DWORD dwFlags,
|
|
IN DWORD dwType,
|
|
IN IMEMENUITEMINFOA *pImeParentMenu,
|
|
OUT IMEMENUITEMINFOA *pImeMenu,
|
|
IN DWORD dwSize,
|
|
OUT DWORD *pdwResult
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetImeMenuItemsA
|
|
IActiveIMMIME::GetImeMenuItemsA
|
|
|
|
Routine Description:
|
|
|
|
Retrieves the menu items that are registerd in the IME menu.
|
|
ANSI implementation.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
dwFlags - [in] Unsigned long integer value that contains the menu infomation flags.
|
|
dwType - [in] Unsigned long integer value that contains the type of menu returned by this
|
|
method.
|
|
pImeParentMenu - [in] Address of an IMEMENUITEMINFOA structure that has the fType member
|
|
set to MFT_SUBMENU to return informaion about the submenu items
|
|
of this parent menu, If this parameter is NULL, the function returns
|
|
only top-level menu items.
|
|
pImeMenu - [out] Address of an array of IMEMENUITEMINFOA structure to reveive the
|
|
contents of the memu items.
|
|
dwSize - [in] Unsigned long integer value that contains the size of the buffer to receive
|
|
the structures.
|
|
pdwResult - [out] Address of an unsigned long integer value that receives the number of
|
|
menu items copied into pImeMenu. If pImeMenu is null, the function returns
|
|
the number of registered menu items.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetImeMenuItemsA");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetImeMenuItems(hIMC, dwFlags, dwType, (IMEMENUITEMINFOAW *)pImeParentMenu, (IMEMENUITEMINFOAW *)pImeMenu, dwSize, pdwResult, FALSE);
|
|
}
|
|
|
|
return _InputContext.GetImeMenuItems(hIMC, dwFlags, dwType, (IMEMENUITEMINFOAW *)pImeParentMenu, (IMEMENUITEMINFOAW *)pImeMenu, dwSize, pdwResult, FALSE);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetImeMenuItemsW(
|
|
HIMC hIMC,
|
|
DWORD dwFlags,
|
|
DWORD dwType,
|
|
IMEMENUITEMINFOW *pImeParentMenu,
|
|
IMEMENUITEMINFOW *pImeMenu,
|
|
DWORD dwSize,
|
|
DWORD *pdwResult
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetImeMenuItemsW
|
|
IActiveIMMIME::GetImeMenuItemsW
|
|
|
|
Routine Description:
|
|
|
|
Retrieves the menu items that are registerd in the IME menu.
|
|
Unicode implementation.
|
|
|
|
Arguments:
|
|
|
|
hIMC - [in] Handle to the input context.
|
|
dwFlags - [in] Unsigned long integer value that contains the menu infomation flags.
|
|
dwType - [in] Unsigned long integer value that contains the type of menu returned by this
|
|
method.
|
|
pImeParentMenu - [in] Address of an IMEMENUITEMINFOW structure that has the fType member
|
|
set to MFT_SUBMENU to return informaion about the submenu items
|
|
of this parent menu, If this parameter is NULL, the function returns
|
|
only top-level menu items.
|
|
pImeMenu - [out] Address of an array of IMEMENUITEMINFOW structure to reveive the
|
|
|
|
controls of the memu items.
|
|
dwSize - [in] Unsigned long integer value that contains the size of the buffer to receive
|
|
the structures.
|
|
pdwResult - [out] Address of an unsigned long integer value that receives the number of
|
|
menu items copied into pImeMenu. If pImeMenu is null, the function returns
|
|
the number of registered menu items.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetImeMenuItemsW");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetImeMenuItems(hIMC, dwFlags, dwType, (IMEMENUITEMINFOAW *)pImeParentMenu, (IMEMENUITEMINFOAW *)pImeMenu, dwSize, pdwResult, TRUE);
|
|
}
|
|
|
|
return _InputContext.GetImeMenuItems(hIMC, dwFlags, dwType, (IMEMENUITEMINFOAW *)pImeParentMenu, (IMEMENUITEMINFOAW *)pImeMenu, dwSize, pdwResult, TRUE);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::EnumInputContext(
|
|
DWORD idThread,
|
|
IEnumInputContext **ppEnum
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::EnumInputContext
|
|
IActiveIMMIME::EnumInputContext
|
|
|
|
Routine Description:
|
|
|
|
Enumerates the input contexts on a thread.
|
|
|
|
Arguments:
|
|
|
|
idThread - [in] Unsigned long integer value that specifies the thread.
|
|
ppEnum - [out] Address of a pointer to the IEnumInputContext interface of the enumeration
|
|
object.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::EnumInputContext");
|
|
|
|
CContextList _hIMC_List;
|
|
CEnumInputContext* pEnumInputContext = NULL;
|
|
|
|
_InputContext.EnumInputContext(idThread, _EnumContextProc, (LPARAM)&_hIMC_List);
|
|
|
|
if ((pEnumInputContext = new CEnumInputContext(_hIMC_List)) == NULL) {
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
*ppEnum = pEnumInputContext;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
// Window Handle Group
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
|
|
STDAPI
|
|
CActiveIMM::GetDefaultIMEWnd(
|
|
IN HWND hWnd,
|
|
OUT HWND *phDefWnd
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetDefaultIMEWnd
|
|
IActiveIMMIME::GetDefaultIMEWnd
|
|
|
|
Routine Description:
|
|
|
|
Retrieves the default window handle to the IME class.
|
|
|
|
Arguments:
|
|
|
|
hWnd - [in] Handle to the window for the application.
|
|
phDefWnd - [out] Address of the default window handle to the IME class.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetDefaultIMEWnd");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetDefaultIMEWnd(hWnd, phDefWnd);
|
|
}
|
|
|
|
return _DefaultIMEWindow.GetDefaultIMEWnd(hWnd, phDefWnd);
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetVirtualKey(
|
|
HWND hWnd,
|
|
UINT *puVirtualKey
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetVirtualKey
|
|
IActiveIMMIME::GetVirtualKey
|
|
|
|
Routine Description:
|
|
|
|
Recovers the original virtual-key value associated with a key input message that has already
|
|
been processed by the IME.
|
|
|
|
Arguments:
|
|
|
|
hWnd - [in] Handle to the window that receives the key message.
|
|
puVirtualKey - [out] Address of an unsigned integer value that receives the original
|
|
virtual-key value.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetVirtualKey");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetVirtualKey(hWnd, puVirtualKey);
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::IsUIMessageA(
|
|
HWND hWndIME,
|
|
UINT msg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::IsUIMessageA
|
|
IActiveIMMIME::IsUIMessageA
|
|
|
|
Routine Description:
|
|
|
|
Checks for messages intended for the IME window and sends those messages to the specified
|
|
window. ANSI implementation.
|
|
|
|
Arguments:
|
|
|
|
hWndIME - [in] Handle to a window belonging to the IME window class.
|
|
msg - [in] Unsigned integer value that contains the message to be checked.
|
|
wParam - [in] Message-specific parameter.
|
|
lParam - [in] Message-specific parameter.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::IsUIMessageA");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_IsUIMessageA(hWndIME, msg, wParam, lParam);
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::IsUIMessageW(
|
|
HWND hWndIME,
|
|
UINT msg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::IsUIMessageW
|
|
IActiveIMMIME::IsUIMessageW
|
|
|
|
Routine Description:
|
|
|
|
Checks for messages intended for the IME window and sends those messages to the specified
|
|
window. Unicode implementation.
|
|
|
|
Arguments:
|
|
|
|
hWndIME - [in] Handle to a window belonging to the IME window class.
|
|
msg - [in] Unsigned integer value that contains the message to be checked.
|
|
wParam - [in] Message-specific parameter.
|
|
lParam - [in] Message-specific parameter.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::IsUIMessageW");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_IsUIMessageW(hWndIME, msg, wParam, lParam);
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::SimulateHotKey(
|
|
HWND hWnd,
|
|
DWORD dwHotKeyID
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::SimulateHotKey
|
|
IActiveIMMIME::SimulateHotKey
|
|
|
|
Routine Description:
|
|
|
|
Simulates the specified IME hot key, causing the same response as if the user had pressed the
|
|
hot key in the specified window.
|
|
|
|
Arguments:
|
|
|
|
hWnd - [in] Handle to the window.
|
|
dwHotKeyID - [in] Unsigned long integer value that contains the identifier for the IME hot key.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::SimulateHotKey");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_SimulateHotKey(hWnd, dwHotKeyID);
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
// Keyboard Layout Group
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
|
|
STDAPI
|
|
CActiveIMM::EnumRegisterWordA(
|
|
HKL hKL,
|
|
LPSTR szReading,
|
|
DWORD dwStyle,
|
|
LPSTR szRegister,
|
|
LPVOID lpData,
|
|
IEnumRegisterWordA **pEnum
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::EnumRegisterWordA
|
|
IActiveIMMIME::EnumRegisterWordA
|
|
|
|
Routine Description:
|
|
|
|
Creates an enumeration object that will enumerate the register strings having the specified
|
|
reading string, style, and register string. ANSI implementation.
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle to the keyboard layout.
|
|
szReading - [in] Address of a string value that contains the reading string to be enumerated.
|
|
If NULL, this method enumerates all available reading strings that match
|
|
with the values specified by dwStyle and szRegister.
|
|
dwStyle - [in] Unsigned long integer value that contains the style to be enumerated. If set
|
|
to zero, this method enumerates all available styles that match with the
|
|
values specified by szReading and szRegister.
|
|
szRegister - [in] Address of a string value that contains the register string to enumerate.
|
|
If NULL, this method enumerates all register strings that match with the
|
|
values specified by szReading and dwStyle.
|
|
lpData - [in] Address of a buffer containing data supplied by the application.
|
|
pEnum - [out] Address of a pointer to the IEnumRegisterWordA interface of the enumeration
|
|
object.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::EnumRegisterWordA");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_EnumRegisterWordA(hKL, szReading, dwStyle, szRegister, lpData, pEnum);
|
|
}
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::EnumRegisterWordW(
|
|
HKL hKL,
|
|
LPWSTR szReading,
|
|
DWORD dwStyle,
|
|
LPWSTR szRegister,
|
|
LPVOID lpData,
|
|
IEnumRegisterWordW **pEnum
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::EnumRegisterWordW
|
|
IActiveIMMIME::EnumRegisterWordW
|
|
|
|
Routine Description:
|
|
|
|
Creates an enumeration object that will enumerate the register strings having the specified
|
|
reading string, style, and register string. Unicode implementation.
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle to the keyboard layout.
|
|
szReading - [in] Address of a string value that contains the reading string to be enumerated.
|
|
If NULL, this method enumerates all available reading strings that match
|
|
with the values specified by dwStyle and szRegister.
|
|
dwStyle - [in] Unsigned long integer value that contains the style to be enumerated. If set
|
|
to zero, this method enumerates all available styles that match with the
|
|
values specified by szReading and szRegister.
|
|
szRegister - [in] Address of a string value that contains the register string to enumerate.
|
|
If NULL, this method enumerates all register strings that match with the
|
|
values specified by szReading and dwStyle.
|
|
lpData - [in] Address of a buffer containing data supplied by the application.
|
|
pEnum - [out] Address of a pointer to the IEnumRegisterWordW interface of the enumeration
|
|
object.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::EnumRegisterWordW");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_EnumRegisterWordW(hKL, szReading, dwStyle, szRegister, lpData, pEnum);
|
|
}
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetRegisterWordStyleA(
|
|
HKL hKL,
|
|
UINT nItem,
|
|
STYLEBUFA *lpStyleBuf,
|
|
UINT *puCopied
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetRegisterWordStyleA
|
|
IActiveIMMIME::GetRegisterWordStyleA
|
|
|
|
Routine Description:
|
|
|
|
Retrieves a list of the styles supported by the IME associated with the specified keyboard
|
|
layout. ANSI implementaion.
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle to the keyboard layout.
|
|
nItem - [in] Unsigned integer value that contains the maximum number of styles that the buffer
|
|
can hold.
|
|
lpStyleBuf - [out] Address of a STYLEBUFA structure that receives the style information.
|
|
puCopied - [out] Address of an unsigned integer value that receives the number of layout
|
|
handles copied to the buffer, or if nItem is zero, receives the buffer size
|
|
in array elements needed to receive all available style information.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetRegisterWordStyleA");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetRegisterWordStyleA(hKL, nItem, lpStyleBuf, puCopied);
|
|
}
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetRegisterWordStyleW(
|
|
HKL hKL,
|
|
UINT nItem,
|
|
STYLEBUFW *lpStyleBuf,
|
|
UINT *puCopied
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetRegisterWordStyleW
|
|
IActiveIMMIME::GetRegisterWordStyleW
|
|
|
|
Routine Description:
|
|
|
|
Retrieves a list of the styles supported by the IME associated with the specified keyboard
|
|
layout. Unicode implementaion.
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle to the keyboard layout.
|
|
nItem - [in] Unsigned integer value that contains the maximum number of styles that the buffer
|
|
can hold.
|
|
lpStyleBuf - [out] Address of a STYLEBUFW structure that receives the style information.
|
|
puCopied - [out] Address of an unsigned integer value that receives the number of layout
|
|
handles copied to the buffer, or if nItem is zero, receives the buffer size
|
|
in array elements needed to receive all available style information.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetRegisterWordStyleW");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetRegisterWordStyleW(hKL, nItem, lpStyleBuf, puCopied);
|
|
}
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::RegisterWordA(
|
|
HKL hKL,
|
|
LPSTR lpszReading,
|
|
DWORD dwStyle,
|
|
LPSTR lpszRegister
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::RegisterWordA
|
|
IActiveIMMIME::RegisterWordA
|
|
|
|
Routine Description:
|
|
|
|
Registers a string into the dictionary of the IME associated with the specified keyboard
|
|
layout. ANSI implementation.
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle to the keyboard layout.
|
|
lpszReading - [in] Address of a string value that contains a null-terminated string specifying
|
|
the reading string associated with the string to register.
|
|
dwStyle - [in] Unsigned long integer value that contains the style of the register string.
|
|
lpszRegister - [in] Address of a string value that contains a null-terminated string specifying
|
|
the string to register.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::RegisterWordA");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_RegisterWordA(hKL, lpszReading, dwStyle, lpszRegister);
|
|
}
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::RegisterWordW(
|
|
HKL hKL,
|
|
LPWSTR lpszReading,
|
|
DWORD dwStyle,
|
|
LPWSTR lpszRegister
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::RegisterWordW
|
|
IActiveIMMIME::RegisterWordW
|
|
|
|
Routine Description:
|
|
|
|
Registers a string into the dictionary of the IME associated with the specified keyboard
|
|
layout. Unicode implementation.
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle to the keyboard layout.
|
|
lpszReading - [in] Address of a string value that contains a null-terminated string specifying
|
|
the reading string associated with the string to register.
|
|
dwStyle - [in] Unsigned long integer value that contains the style of the register string.
|
|
lpszRegister - [in] Address of a string value that contains a null-terminated string specifying
|
|
the string to register.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::RegisterWordW");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_RegisterWordW(hKL, lpszReading, dwStyle, lpszRegister);
|
|
}
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::UnregisterWordA(
|
|
HKL hKL,
|
|
LPSTR lpszReading,
|
|
DWORD dwStyle,
|
|
LPSTR lpszUnregister
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::UnregisterWordA
|
|
IActiveIMMIME::UnregisterWordA
|
|
|
|
Routine Description:
|
|
|
|
Removes a register string from the dictionary of the IME associated with the specified
|
|
keyboard layout. ANSI implementaion.
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle to the keyboard layout.
|
|
lpszReading - [in] Address of a string value that contains a null-terminated string specifying
|
|
the reading string associated with the string to remove.
|
|
dwStyle - [in] Unsigned long integer value that contains the style of the register string.
|
|
lpszUnregister - [in] Address of a string value that contains a null-terminated string
|
|
specifying the register string to remove.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::UnregisterWordA");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_UnregisterWordA(hKL, lpszReading, dwStyle, lpszUnregister);
|
|
}
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::UnregisterWordW(
|
|
HKL hKL,
|
|
LPWSTR lpszReading,
|
|
DWORD dwStyle,
|
|
LPWSTR lpszUnregister
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::UnregisterWordW
|
|
IActiveIMMIME::UnregisterWordW
|
|
|
|
Routine Description:
|
|
|
|
Removes a register string from the dictionary of the IME associated with the specified
|
|
keyboard layout. Unicode implementaion.
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle to the keyboard layout.
|
|
lpszReading - [in] Address of a string value that contains a null-terminated string specifying
|
|
the reading string associated with the string to remove.
|
|
dwStyle - [in] Unsigned long integer value that contains the style of the register string.
|
|
lpszUnregister - [in] Address of a string value that contains a null-terminated string
|
|
specifying the register string to remove.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::UnregisterWordW");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_UnregisterWordW(hKL, lpszReading, dwStyle, lpszUnregister);
|
|
}
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
|
|
STDAPI
|
|
CActiveIMM::ConfigureIMEA(
|
|
HKL hKL,
|
|
HWND hWnd,
|
|
DWORD dwMode,
|
|
REGISTERWORDA *lpdata
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::ConfigureIMEA
|
|
IActiveIMMIME::ConfigureIMEA
|
|
|
|
Routine Description:
|
|
|
|
Displays the configuration dialog box for the IME. ANSI implementation.
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle to the keyboard layout.
|
|
hWnd - [in] Handle to the parent window for the dialog box.
|
|
dwMode - [in] Unsigned long integer value that contains the type of dialog box to display.
|
|
This can be one of the following values:
|
|
IME_CONFIG_GENERAL: Displays the general purpose configuration dialog box.
|
|
IME_CONFIG_REGISTERWORD: Displays the register word dialog box.
|
|
IME_CONFIG_SELECTDICTIONARY: Displays the dictionary selection dialog box.
|
|
lpdata - [in] Address of a REGISTERWORDA structure. This structure will be used if dwMode is
|
|
set to IME_CONFIG_REGISTERWORD. Otherwise this parameter is ignored.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::ConfigureIMEA");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_ConfigureIMEA(hKL, hWnd, dwMode, lpdata);
|
|
}
|
|
else
|
|
{
|
|
HRESULT hr;
|
|
IAImeProfile* pAImeProfile;
|
|
|
|
hr = CAImmProfile_CreateInstance(NULL, IID_IAImeProfile, (void**)&pAImeProfile);
|
|
if (FAILED(hr)) {
|
|
TraceMsg(TF_ERROR, "CreateInstance(ConfigureIMEA) failed");
|
|
return hr;
|
|
}
|
|
|
|
hr = _ConfigureIMEA(hKL, hWnd, dwMode, lpdata);
|
|
|
|
pAImeProfile->Release();
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::ConfigureIMEW(
|
|
HKL hKL,
|
|
HWND hWnd,
|
|
DWORD dwMode,
|
|
REGISTERWORDW *lpdata
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::ConfigureIMEW
|
|
IActiveIMMIME::ConfigureIMEW
|
|
|
|
Routine Description:
|
|
|
|
Displays the configuration dialog box for the IME. Unicode implementation.
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle to the keyboard layout.
|
|
hWnd - [in] Handle to the parent window for the dialog box.
|
|
dwMode - [in] Unsigned long integer value that contains the type of dialog box to display.
|
|
This can be one of the following values:
|
|
IME_CONFIG_GENERAL: Displays the general purpose configuration dialog box.
|
|
IME_CONFIG_REGISTERWORD: Displays the register word dialog box.
|
|
IME_CONFIG_SELECTDICTIONARY: Displays the dictionary selection dialog box.
|
|
lpdata - [in] Address of a REGISTERWORDW structure. This structure will be used if dwMode is
|
|
set to IME_CONFIG_REGISTERWORD. Otherwise this parameter is ignored.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::ConfigureIMEW");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_ConfigureIMEW(hKL, hWnd, dwMode, lpdata);
|
|
}
|
|
else
|
|
{
|
|
HRESULT hr;
|
|
IAImeProfile* pAImeProfile;
|
|
|
|
hr = CAImmProfile_CreateInstance(NULL, IID_IAImeProfile, (void**)&pAImeProfile);
|
|
if (FAILED(hr)) {
|
|
TraceMsg(TF_ERROR, "CreateInstance(ConfigureIMEW) failed");
|
|
return hr;
|
|
}
|
|
|
|
hr = _ConfigureIMEW(hKL, hWnd, dwMode, lpdata);
|
|
|
|
pAImeProfile->Release();
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::EscapeA(
|
|
HKL hKL,
|
|
HIMC hIMC,
|
|
UINT uEscape,
|
|
LPVOID lpData,
|
|
LRESULT *plResult
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::EscapeA
|
|
IActiveIMMIME::EscapeA
|
|
|
|
Routine Description:
|
|
|
|
Executes IME-specific subfunctions and is used mainly for country-specific function.
|
|
ANSI implementaion.
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle to the keyboard layout.
|
|
hIMC - [in] Handle to the input context.
|
|
uEscape - [in] Unsigned integer that contains the index of the subfunction.
|
|
lpData - [in, out] Address of a buffer containing subfunction-specific data.
|
|
plResult - [out] Address of the LRESULT variable that received the escape-specific value
|
|
returned by the operation.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::EscapeA");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_Escape(hKL, hIMC, uEscape, lpData, plResult, FALSE);
|
|
}
|
|
else
|
|
{
|
|
HRESULT hr;
|
|
IAImeProfile* pAImeProfile;
|
|
|
|
hr = CAImmProfile_CreateInstance(NULL, IID_IAImeProfile, (void**)&pAImeProfile);
|
|
if (FAILED(hr)) {
|
|
TraceMsg(TF_ERROR, "CreateInstance(EscapeA) failed");
|
|
return hr;
|
|
}
|
|
|
|
if (SUCCEEDED(hr=pAImeProfile->ChangeCurrentKeyboardLayout(hKL)))
|
|
{
|
|
hr = _Escape(hKL, hIMC, uEscape, lpData, plResult, FALSE);
|
|
}
|
|
|
|
pAImeProfile->Release();
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::EscapeW(
|
|
HKL hKL,
|
|
HIMC hIMC,
|
|
UINT uEscape,
|
|
LPVOID lpData,
|
|
LRESULT *plResult
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::EscapeW
|
|
IActiveIMMIME::EscapeW
|
|
|
|
Routine Description:
|
|
|
|
Executes IME-specific subfunctions and is used mainly for country-specific function.
|
|
Unicode implementaion.
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle to the keyboard layout.
|
|
hIMC - [in] Handle to the input context.
|
|
uEscape - [in] Unsigned integer that contains the index of the subfunction.
|
|
lpData - [in, out] Address of a buffer containing subfunction-specific data.
|
|
plResult - [out] Address of the LRESULT variable that received the escape-specific value
|
|
returned by the operation.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::EscapeW");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_Escape(hKL, hIMC, uEscape, lpData, plResult, TRUE);
|
|
}
|
|
else
|
|
{
|
|
HRESULT hr;
|
|
IAImeProfile* pAImeProfile;
|
|
|
|
hr = CAImmProfile_CreateInstance(NULL, IID_IAImeProfile, (void**)&pAImeProfile);
|
|
if (FAILED(hr)) {
|
|
TraceMsg(TF_ERROR, "CreateInstance(EscapeW) failed");
|
|
return hr;
|
|
}
|
|
|
|
if (SUCCEEDED(hr=pAImeProfile->ChangeCurrentKeyboardLayout(hKL)))
|
|
{
|
|
hr = _Escape(hKL, hIMC, uEscape, lpData, plResult, TRUE);
|
|
}
|
|
|
|
pAImeProfile->Release();
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
|
|
STDAPI
|
|
CActiveIMM::GetConversionListA(
|
|
HKL hKL,
|
|
HIMC hIMC,
|
|
LPSTR lpSrc,
|
|
UINT uBufLen,
|
|
UINT uFlag,
|
|
CANDIDATELIST *lpDst,
|
|
UINT *puCopied
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetConversionListA
|
|
IActiveIMMIME::GetConversionListA
|
|
|
|
Routine Description:
|
|
|
|
Retrieves the list of characters or words from one character or word. ANSI implementation.
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle to the keyboard layout.
|
|
hIMC - [in] Handle to the input context.
|
|
lpSrc - [in] Address of a string value containing a null-terminated character string.
|
|
uBufLen - [in] Unsigned integer value that contains the size of the destination buffer,
|
|
in bytes.
|
|
uFlag - [in] Unsigned integer value that contains action flags.
|
|
lpDst - [out] Address of the CANDIDATELIST structure that receives the conversion result.
|
|
puCopied - [out] Address of an unsigned integer value that receives the number of bytes
|
|
copied to the specified buffer. If uBufLen is zero, puCopied receives the
|
|
number of bytes needed to receive the list.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetConversionListA");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetConversionListA(hKL, hIMC, lpSrc, uBufLen, uFlag, lpDst, puCopied);
|
|
}
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetConversionListW(
|
|
HKL hKL,
|
|
HIMC hIMC,
|
|
LPWSTR lpSrc,
|
|
UINT uBufLen,
|
|
UINT uFlag,
|
|
CANDIDATELIST *lpDst,
|
|
UINT *puCopied
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetConversionListW
|
|
IActiveIMMIME::GetConversionListW
|
|
|
|
Routine Description:
|
|
|
|
Retrieves the list of characters or words from one character or word. Unicode implementation.
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle to the keyboard layout.
|
|
hIMC - [in] Handle to the input context.
|
|
lpSrc - [in] Address of a string value containing a null-terminated character string.
|
|
uBufLen - [in] Unsigned integer value that contains the size of the destination buffer,
|
|
in bytes.
|
|
uFlag - [in] Unsigned integer value that contains action flags.
|
|
lpDst - [out] Address of the CANDIDATELIST structure that receives the conversion result.
|
|
puCopied - [out] Address of an unsigned integer value that receives the number of bytes
|
|
copied to the specified buffer. If uBufLen is zero, puCopied receives the
|
|
number of bytes needed to receive the list.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetConversionListW");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetConversionListW(hKL, hIMC, lpSrc, uBufLen, uFlag, lpDst, puCopied);
|
|
}
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetDescriptionA(
|
|
HKL hKL,
|
|
UINT uBufLen,
|
|
LPSTR lpszDescription,
|
|
UINT *puCopied
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetDescriptionA
|
|
IActiveIMMIME::GetDescriptionA
|
|
|
|
Routine Description:
|
|
|
|
Copies the description of the IME to the specified buffer (ANSI implementation).
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle to the keyboard layout.
|
|
uBufLen - [in] Unsigned long integer value that contains the size of the buffer in characters.
|
|
lpszDescription - [out] Address of a string buffer that receives the null-terminated string
|
|
describing the IME.
|
|
puCopied - [out] Address of an unsigned long integer that receives the number of characters
|
|
copied to the buffer. If uBufLen is zero, puCopied receives the buffer size,
|
|
in characters, needed to receive the description.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetDescriptionA");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetDescriptionA(hKL, uBufLen, lpszDescription, puCopied);
|
|
}
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetDescriptionW(
|
|
HKL hKL,
|
|
UINT uBufLen,
|
|
LPWSTR lpszDescription,
|
|
UINT *puCopied
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetDescriptionW
|
|
IActiveIMMIME::GetDescriptionW
|
|
|
|
Routine Description:
|
|
|
|
Copies the description of the IME to the specified buffer (Unicode implementation).
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle to the keyboard layout.
|
|
uBufLen - [in] Unsigned long integer value that contains the size of the buffer in characters.
|
|
lpszDescription - [out] Address of a string buffer that receives the null-terminated string
|
|
describing the IME.
|
|
puCopied - [out] Address of an unsigned long integer that receives the number of characters
|
|
copied to the buffer. If uBufLen is zero, puCopied receives the buffer size,
|
|
in characters, needed to receive the description.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetDescriptionW");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetDescriptionW(hKL, uBufLen, lpszDescription, puCopied);
|
|
}
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetIMEFileNameA(
|
|
HKL hKL,
|
|
UINT uBufLen,
|
|
LPSTR lpszFileName,
|
|
UINT *puCopied
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetIMEFileNameA
|
|
IActiveIMMIME::GetIMEFileNameA
|
|
|
|
Routine Description:
|
|
|
|
Retrieves the file name of the IME associated with the specified keyboard layout
|
|
(ANSI implementation).
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle to the keyboard layout.
|
|
uBufLen - [in] Unsigned integer value that contains the size, in bytes, of the buffer.
|
|
lpszFileName - [out] Address of a string buffer that receives the file name.
|
|
puCopied - [out] Address of an unsigned integer that receives the number of bytes
|
|
copied to the buffer. If uBufLen is zero, puCopied receives the buffer size,
|
|
in bytes, required to receive the file name.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetIMEFileNameA");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetIMEFileNameA(hKL, uBufLen, lpszFileName, puCopied);
|
|
}
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetIMEFileNameW(
|
|
HKL hKL,
|
|
UINT uBufLen,
|
|
LPWSTR lpszFileName,
|
|
UINT *puCopied
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetIMEFileNameW
|
|
IActiveIMMIME::GetIMEFileNameW
|
|
|
|
Routine Description:
|
|
|
|
Retrieves the file name of the IME associated with the specified keyboard layout
|
|
(Unicode implementation).
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle to the keyboard layout.
|
|
uBufLen - [in] Unsigned integer value that contains the size, in bytes, of the buffer.
|
|
lpszFileName - [out] Address of a string buffer that receives the file name.
|
|
puCopied - [out] Address of an unsigned integer that receives the number of bytes
|
|
copied to the buffer. If uBufLen is zero, puCopied receives the buffer size,
|
|
in bytes, required to receive the file name.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetIMEFileNameW");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_GetIMEFileNameW(hKL, uBufLen, lpszFileName, puCopied);
|
|
}
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::GetProperty(
|
|
IN HKL hKL,
|
|
IN DWORD dwIndex,
|
|
OUT DWORD *pdwProperty
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetProperty
|
|
IActiveIMMIME::GetProperty
|
|
|
|
Routine Description:
|
|
|
|
Retrieves the property and capabilities of the IME associated with specified
|
|
keyboard layout.
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle of the keyboard layout.
|
|
dwIndex - [in] Unsigned long integer value that contains the type of property
|
|
information to retrieve.
|
|
pdwProperty - [out] Address of an unsigned long integer value that receives the
|
|
property or capability value, depending on the value of the
|
|
dwIndex parameter.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::GetProperty");
|
|
|
|
|
|
if (_IsRealIme(hKL))
|
|
{
|
|
return Imm32_GetProperty(hKL, dwIndex, pdwProperty);
|
|
}
|
|
|
|
if (dwIndex != IGP_GETIMEVERSION &&
|
|
( (dwIndex & 3) || dwIndex > IGP_LAST))
|
|
{
|
|
// bad fdwIndex
|
|
return E_FAIL;
|
|
}
|
|
|
|
if (dwIndex == IGP_GETIMEVERSION) {
|
|
*pdwProperty = IMEVER_0400;
|
|
return S_OK;
|
|
}
|
|
|
|
// Inquire IME's information and UI class name.
|
|
if (_pActiveIME)
|
|
_pActiveIME->Inquire(FALSE, &_IMEInfoEx.ImeInfo, _IMEInfoEx.achWndClass, &_IMEInfoEx.dwPrivate);
|
|
|
|
*pdwProperty = *(DWORD *)((BYTE *)&_IMEInfoEx.ImeInfo + dwIndex);
|
|
return S_OK;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::InstallIMEA(
|
|
LPSTR lpszIMEFileName,
|
|
LPSTR lpszLayoutText,
|
|
HKL *phKL
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::InstallIMEA
|
|
IActiveIMMIME::InstallIMEA
|
|
|
|
Routine Description:
|
|
|
|
Installs an IME into the system. ANSI implementaion.
|
|
|
|
Arguments:
|
|
|
|
lpszIMEFileName - [in] Address of a null-terminated string value that specifies the full path
|
|
of the IME.
|
|
lpszLayoutText - [in] Address of a null-terminated string value that specifies the name of the
|
|
IME. This name also specifies the layout text of the IME.
|
|
phKL - [out] Address of the handle to the keyboard layout for the IME.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::InstallIMEA");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_InstallIMEA(lpszIMEFileName, lpszLayoutText, phKL);
|
|
}
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::InstallIMEW(
|
|
LPWSTR lpszIMEFileName,
|
|
LPWSTR lpszLayoutText,
|
|
HKL *phKL
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::InstallIMEW
|
|
IActiveIMMIME::InstallIMEW
|
|
|
|
Routine Description:
|
|
|
|
Installs an IME into the system. Unicode implementaion.
|
|
|
|
Arguments:
|
|
|
|
lpszIMEFileName - [in] Address of a null-terminated string value that specifies the full path
|
|
of the IME.
|
|
lpszLayoutText - [in] Address of a null-terminated string value that specifies the name of the
|
|
IME. This name also specifies the layout text of the IME.
|
|
phKL - [out] Address of the handle to the keyboard layout for the IME.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::InstallIMEW");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_InstallIMEW(lpszIMEFileName, lpszLayoutText, phKL);
|
|
}
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDAPI
|
|
CActiveIMM::IsIME(
|
|
HKL hKL
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::IsIME
|
|
IActiveIMMIME::IsIME
|
|
|
|
Routine Description:
|
|
|
|
Checks whether the specified handle identifies an IME.
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle to the keyboard layout to check.
|
|
|
|
Return Value:
|
|
|
|
Returns a S_OK value if the handle identifies an IME, or S_FALSE otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::IsIME");
|
|
|
|
if (_IsRealIme(hKL))
|
|
{
|
|
return Imm32_IsIME(hKL);
|
|
}
|
|
|
|
HRESULT hr;
|
|
IAImeProfile* pAImeProfile;
|
|
extern HRESULT CAImmProfile_CreateInstance(IUnknown *pUnkOuter, REFIID riid, void **ppvObj);
|
|
|
|
hr = CAImmProfile_CreateInstance(NULL, IID_IAImeProfile, (void**)&pAImeProfile);
|
|
|
|
if (FAILED(hr)) {
|
|
TraceMsg(TF_ERROR, "CreateInstance(IsIME) failed");
|
|
return hr;
|
|
}
|
|
|
|
hr = pAImeProfile->IsIME(hKL);
|
|
|
|
pAImeProfile->Release();
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDAPI
|
|
CActiveIMM::DisableIME(
|
|
DWORD idThread
|
|
)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::DisableIME
|
|
IActiveIMMIME::DisableIME
|
|
|
|
Routine Description:
|
|
|
|
Disables the Input Method Editor (IME) for a thread or all threads in a process.
|
|
|
|
Arguments:
|
|
|
|
idThread - [in] Unsigned long integer value that contains the thread identifier for which
|
|
the IME will be disabled. If idThread is zero, the IME for the current thread
|
|
is disabled. If idThread is -1, the IME is disabled for all threads in the
|
|
current process.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TraceMsg(TF_API, "CActiveIMM::DisableIME");
|
|
|
|
if (_IsRealIme())
|
|
{
|
|
return Imm32_DisableIME(idThread);
|
|
}
|
|
|
|
return E_NOTIMPL;
|
|
}
|