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.
2567 lines
66 KiB
2567 lines
66 KiB
//
|
|
// pimm.cpp
|
|
//
|
|
|
|
#include "private.h"
|
|
#include "defs.h"
|
|
#include "pimm.h"
|
|
#include "cdimm.h"
|
|
#include "globals.h"
|
|
#include "util.h"
|
|
#include "immxutil.h"
|
|
|
|
extern void DllAddRef(void);
|
|
extern void DllRelease(void);
|
|
|
|
HRESULT CActiveIMM_CreateInstance(IUnknown *pUnkOuter, REFIID riid, void **ppvObj);
|
|
|
|
LONG CProcessIMM::_cRef = -1;
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// RunningInExcludedModule
|
|
//
|
|
// Exclude some processes from using the old aimm IIDs/CLSIDs.
|
|
//----------------------------------------------------------------------------
|
|
|
|
BOOL RunningInExcludedModule()
|
|
{
|
|
static const TCHAR c_szOutlookModule[] = TEXT("outlook.exe");
|
|
static const TCHAR c_szMsoobeModule[] = TEXT("msoobe.exe");
|
|
|
|
DWORD dwHandle;
|
|
void *pvData;
|
|
VS_FIXEDFILEINFO *pffi;
|
|
UINT cb;
|
|
TCHAR ch;
|
|
TCHAR *pch;
|
|
TCHAR *pchFileName;
|
|
BOOL fRet;
|
|
TCHAR achModule[MAX_PATH+1];
|
|
|
|
if (GetModuleFileName(NULL, achModule, ARRAYSIZE(achModule)-1) == 0)
|
|
return FALSE;
|
|
|
|
// null termination.
|
|
achModule[ARRAYSIZE(achModule) - 1] = TEXT('\0');
|
|
|
|
pch = pchFileName = achModule;
|
|
|
|
while ((ch = *pch) != 0)
|
|
{
|
|
pch = CharNext(pch);
|
|
|
|
if (ch == '\\')
|
|
{
|
|
pchFileName = pch;
|
|
}
|
|
}
|
|
|
|
fRet = FALSE;
|
|
|
|
if (lstrcmpi(pchFileName, c_szOutlookModule) == 0)
|
|
{
|
|
static BOOL s_fCached = FALSE;
|
|
static BOOL s_fOldVersion = TRUE;
|
|
|
|
// don't run aimm with versions of outlook before 10.0
|
|
|
|
if (s_fCached)
|
|
{
|
|
return s_fOldVersion;
|
|
}
|
|
|
|
cb = GetFileVersionInfoSize(achModule, &dwHandle);
|
|
|
|
if (cb == 0)
|
|
{
|
|
// can't get ver info...assume the worst
|
|
return TRUE;
|
|
}
|
|
|
|
if ((pvData = cicMemAlloc(cb)) == NULL)
|
|
return TRUE; // assume the worst
|
|
|
|
if (GetFileVersionInfo(achModule, 0, cb, pvData) &&
|
|
VerQueryValue(pvData, TEXT("\\"), (void **)&pffi, &cb))
|
|
{
|
|
fRet = s_fOldVersion = (HIWORD(pffi->dwProductVersionMS) < 10);
|
|
s_fCached = TRUE; // set this last to be thread safe
|
|
}
|
|
else
|
|
{
|
|
fRet = TRUE; // something went wrong
|
|
}
|
|
|
|
cicMemFree(pvData);
|
|
}
|
|
else if (lstrcmpi(pchFileName, c_szMsoobeModule) == 0)
|
|
{
|
|
//
|
|
// #339234.
|
|
//
|
|
// MSOOBE.EXE starts before the end user logon. However it opens an
|
|
// interactive windows station ("WinSta0") and open a default
|
|
// desktop ("Default"). So MSIMTF.DLL thinks it is not winlogon
|
|
// desktop. But the fact is that the thread is running on
|
|
// ".Default user". So I think we may not want to start Cicero
|
|
// there because it could load 3rd vender TIP.
|
|
//
|
|
// #626606
|
|
// msoobe doesn't allow any creating new process under Windows
|
|
// Product Activation wizard. That's the security reason to prevent
|
|
// people from replacing msoobe.exe with explorer.exe and running the
|
|
// machine without activating.
|
|
|
|
fRet = TRUE;
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Class Factory's CreateInstance - CLSID_CActiveIMM12
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
// entry point for msimtf.dll
|
|
HRESULT CActiveIMM_CreateInstance(IUnknown *pUnkOuter, REFIID riid, void **ppvObj)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
HRESULT hr;
|
|
BOOL fInitedTLS = FALSE;
|
|
|
|
if (ppvObj == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*ppvObj = NULL;
|
|
|
|
if (NULL != pUnkOuter)
|
|
return CLASS_E_NOAGGREGATION;
|
|
|
|
//
|
|
// Look up disabling Text Services status from the registry.
|
|
// If it is disabled, return fail not to support Text Services.
|
|
//
|
|
if (IsDisabledTextServices())
|
|
return E_FAIL;
|
|
|
|
if (RunningInExcludedModule())
|
|
return E_NOINTERFACE;
|
|
|
|
if (!IsInteractiveUserLogon())
|
|
return E_NOINTERFACE;
|
|
|
|
if (NoTipsInstalled(NULL))
|
|
return E_NOINTERFACE;
|
|
|
|
// init the tls
|
|
// nb: we also try to do this in Activate, but this is to preserve
|
|
// existing behavior on the main thread (HACKHACK)
|
|
if ((pActiveIMM = GetTLS()) == NULL)
|
|
{
|
|
if ((pActiveIMM = new CActiveIMM) == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
if (FAILED(hr=pActiveIMM->_Init()) ||
|
|
FAILED(hr=IMTLS_SetActiveIMM(pActiveIMM) ? S_OK : E_FAIL))
|
|
{
|
|
delete pActiveIMM;
|
|
return hr;
|
|
}
|
|
|
|
fInitedTLS = TRUE;
|
|
}
|
|
|
|
// we return a per-process IActiveIMM
|
|
// why? because trident breaks the apt threaded rules
|
|
// and uses a single per-process obj
|
|
if (g_ProcessIMM)
|
|
{
|
|
hr = g_ProcessIMM->QueryInterface(riid, ppvObj);
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
if (fInitedTLS)
|
|
{
|
|
//
|
|
// Tell CActiveIMM which interface created.
|
|
//
|
|
if (SUCCEEDED(hr)) {
|
|
pActiveIMM->_EnableGuidMap( IsEqualIID(riid, IID_IActiveIMMAppEx) );
|
|
}
|
|
|
|
// dec the ref on the tls. Normally it will drop from 2 -> 1
|
|
// if QueryInterface failed, it will be deleted
|
|
pActiveIMM->Release();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Class Factory's CreateInstance - CLSID_CActiveIMM12_Trident
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
// entry point for msimtf.dll
|
|
HRESULT CActiveIMM_CreateInstance_Trident(IUnknown *pUnkOuter, REFIID riid, void **ppvObj)
|
|
{
|
|
HRESULT hr = CActiveIMM_CreateInstance(pUnkOuter, riid, ppvObj);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
g_fAIMM12Trident = TRUE;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// QueryInterface
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::QueryInterface(REFIID riid, void **ppvObj)
|
|
{
|
|
//
|
|
// 4955DD32-B159-11d0-8FCF-00AA006BCC59
|
|
//
|
|
static const IID IID_IActiveIMMAppTrident4x = {
|
|
0x4955DD32,
|
|
0xB159,
|
|
0x11d0,
|
|
{ 0x8F, 0xCF, 0x00, 0xaa, 0x00, 0x6b, 0xcc, 0x59 }
|
|
};
|
|
|
|
//
|
|
// c839a84c-8036-11d3-9270-0060b067b86e
|
|
//
|
|
static const IID IID_IActiveIMMAppPostNT4 = {
|
|
0xc839a84c,
|
|
0x8036,
|
|
0x11d3,
|
|
{0x92, 0x70, 0x00, 0x60, 0xb0, 0x67, 0xb8, 0x6e}
|
|
};
|
|
|
|
if (ppvObj == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*ppvObj = NULL;
|
|
|
|
if (IsEqualIID(riid, IID_IUnknown) ||
|
|
IsEqualIID(riid, IID_IActiveIMMAppTrident4x) ||
|
|
IsEqualIID(riid, IID_IActiveIMMAppPostNT4) ||
|
|
IsEqualIID(riid, IID_IActiveIMMApp))
|
|
{
|
|
*ppvObj = SAFECAST(this, IActiveIMMApp *);
|
|
}
|
|
else if (IsEqualIID(riid, IID_IActiveIMMAppEx))
|
|
{
|
|
*ppvObj = SAFECAST(this, IActiveIMMAppEx*);
|
|
}
|
|
else if (IsEqualIID(riid, IID_IActiveIMMMessagePumpOwner))
|
|
{
|
|
*ppvObj = SAFECAST(this, IActiveIMMMessagePumpOwner *);
|
|
}
|
|
else if (IsEqualIID(riid, IID_IServiceProvider))
|
|
{
|
|
*ppvObj = SAFECAST(this, IServiceProvider*);
|
|
}
|
|
else if (IsEqualIID(riid, IID_IAImmThreadCompartment))
|
|
{
|
|
*ppvObj = SAFECAST(this, IAImmThreadCompartment*);
|
|
}
|
|
|
|
if (*ppvObj)
|
|
{
|
|
AddRef();
|
|
return S_OK;
|
|
}
|
|
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// AddRef
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI_(ULONG) CProcessIMM::AddRef()
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
// nb: our ref count is special!
|
|
// it is initialized to -1 so we can use InterlockedIncrement
|
|
// correctly on win95
|
|
if (InterlockedIncrement(&_cRef) == 0)
|
|
{
|
|
DllAddRef();
|
|
}
|
|
|
|
// inc the thread ref
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
pActiveIMM->AddRef();
|
|
}
|
|
else
|
|
{
|
|
Assert(0); // how did we get this far with no tls!?
|
|
}
|
|
|
|
return _cRef+1; // "diagnostic" unthread-safe return
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Release
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI_(ULONG) CProcessIMM::Release()
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
// dec the thread ref
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
pActiveIMM->Release();
|
|
}
|
|
else
|
|
{
|
|
Assert(0); // how did we get this far with no tls!?
|
|
}
|
|
|
|
// nb: our ref count is special!
|
|
// it is initialized to -1 so we can use InterlockedIncrement
|
|
// correctly on win95
|
|
if (InterlockedDecrement(&_cRef) < 0)
|
|
{
|
|
DllRelease();
|
|
}
|
|
|
|
// this obj lives as long as the process does,
|
|
// so no need for a delete
|
|
return _cRef+1; // "diagnostic" unthread safe return
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Start
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::Start()
|
|
{
|
|
Assert(0); // who's calling this?
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// End
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::End()
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// OnTranslateMessage
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::OnTranslateMessage(const MSG *pMsg)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Pause
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::Pause(DWORD *pdwCookie)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Resume
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::Resume(DWORD dwCookie)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// CreateContext
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::CreateContext(HIMC *phIMC)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (phIMC == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*phIMC = 0;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->CreateContext(phIMC);
|
|
}
|
|
|
|
return Imm32_CreateContext(phIMC);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// DestroyContext
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::DestroyContext(HIMC hIMC)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->DestroyContext(hIMC);
|
|
}
|
|
|
|
return Imm32_DestroyContext(hIMC);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// AssociateContext
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::AssociateContext(HWND hWnd, HIMC hIME, HIMC *phPrev)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (phPrev == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*phPrev = 0;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->AssociateContext(hWnd, hIME, phPrev);
|
|
}
|
|
|
|
return Imm32_AssociateContext(hWnd, hIME, phPrev);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// AssociateContextEx
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::AssociateContextEx(HWND hWnd, HIMC hIMC, DWORD dwFlags)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->AssociateContextEx(hWnd, hIMC, dwFlags);
|
|
}
|
|
|
|
return Imm32_AssociateContextEx(hWnd, hIMC, dwFlags);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetContext
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetContext(HWND hWnd, HIMC *phIMC)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (phIMC == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*phIMC = 0;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetContext(hWnd, phIMC);
|
|
}
|
|
|
|
return Imm32_GetContext(hWnd, phIMC);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// ReleaseContext
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::ReleaseContext(HWND hWnd, HIMC hIMC)
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetIMCLockCount
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetIMCLockCount(HIMC hIMC, DWORD *pdwLockCount)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pdwLockCount == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*pdwLockCount = 0;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetIMCLockCount(hIMC, pdwLockCount);
|
|
}
|
|
|
|
return Imm32_GetIMCLockCount(hIMC, pdwLockCount);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// LockIMC
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::LockIMC(HIMC hIMC, INPUTCONTEXT **ppIMC)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (ppIMC == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*ppIMC = 0;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->LockIMC(hIMC, ppIMC);
|
|
}
|
|
|
|
return Imm32_LockIMC(hIMC, ppIMC);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// UnlockIMC
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::UnlockIMC(HIMC hIMC)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->UnlockIMC(hIMC);
|
|
}
|
|
|
|
return Imm32_UnlockIMC(hIMC);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// CreateIMCC
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::CreateIMCC(DWORD dwSize, HIMCC *phIMCC)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (phIMCC == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->CreateIMCC(dwSize, phIMCC);
|
|
}
|
|
|
|
return Imm32_CreateIMCC(dwSize, phIMCC);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// DestroyIMCC
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::DestroyIMCC(HIMCC hIMCC)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->DestroyIMCC(hIMCC);
|
|
}
|
|
|
|
return Imm32_DestroyIMCC(hIMCC);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetIMCCSize
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetIMCCSize(HIMCC hIMCC, DWORD *pdwSize)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pdwSize == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*pdwSize = 0;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetIMCCSize(hIMCC, pdwSize);
|
|
}
|
|
|
|
return Imm32_GetIMCCSize(hIMCC, pdwSize);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// ReSizeIMCC
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::ReSizeIMCC(HIMCC hIMCC, DWORD dwSize, HIMCC *phIMCC)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (phIMCC == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*phIMCC = 0;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->ReSizeIMCC(hIMCC, dwSize, phIMCC);
|
|
}
|
|
|
|
return Imm32_ReSizeIMCC(hIMCC, dwSize, phIMCC);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetIMCCLockCount
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetIMCCLockCount(HIMCC hIMCC, DWORD *pdwLockCount)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pdwLockCount == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*pdwLockCount = 0;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetIMCCLockCount(hIMCC, pdwLockCount);
|
|
}
|
|
|
|
return Imm32_GetIMCCLockCount(hIMCC, pdwLockCount);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// LockIMCC
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::LockIMCC(HIMCC hIMCC, void **ppv)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (ppv == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*ppv = NULL;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->LockIMCC(hIMCC, ppv);
|
|
}
|
|
|
|
return Imm32_LockIMCC(hIMCC, ppv);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// UnlockIMCC
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::UnlockIMCC(HIMCC hIMCC)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->UnlockIMCC(hIMCC);
|
|
}
|
|
|
|
return Imm32_UnlockIMCC(hIMCC);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetOpenStatus
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetOpenStatus(HIMC hIMC)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetOpenStatus(hIMC);
|
|
}
|
|
|
|
return Imm32_GetOpenStatus(hIMC);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// SetOpenStatus
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::SetOpenStatus(HIMC hIMC, BOOL fOpen)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->SetOpenStatus(hIMC, fOpen);
|
|
}
|
|
|
|
return Imm32_SetOpenStatus(hIMC, fOpen);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetConversionStatus
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetConversionStatus(HIMC hIMC, DWORD *lpfdwConversion, DWORD *lpfdwSentence)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (lpfdwConversion != NULL)
|
|
{
|
|
*lpfdwConversion = 0;
|
|
}
|
|
if (lpfdwSentence != NULL)
|
|
{
|
|
*lpfdwSentence = 0;
|
|
}
|
|
if (lpfdwConversion == NULL || lpfdwSentence == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetConversionStatus(hIMC, lpfdwConversion, lpfdwSentence);
|
|
}
|
|
|
|
return Imm32_GetConversionStatus(hIMC, lpfdwConversion, lpfdwSentence);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// SetConversionStatus
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::SetConversionStatus(HIMC hIMC, DWORD fdwConversion, DWORD fdwSentence)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->SetConversionStatus(hIMC, fdwConversion, fdwSentence);
|
|
}
|
|
|
|
return Imm32_SetConversionStatus(hIMC, fdwConversion, fdwSentence);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetStatusWindowPos
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetStatusWindowPos(HIMC hIMC, POINT *lpptPos)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (lpptPos == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
memset(lpptPos, 0, sizeof(POINT));
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetStatusWindowPos(hIMC, lpptPos);
|
|
}
|
|
|
|
return Imm32_GetStatusWindowPos(hIMC, lpptPos);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// SetStatusWindowPos
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::SetStatusWindowPos(HIMC hIMC, POINT *lpptPos)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (lpptPos == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->SetStatusWindowPos(hIMC, lpptPos);
|
|
}
|
|
|
|
return Imm32_SetStatusWindowPos(hIMC, lpptPos);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetCompositionStringA
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetCompositionStringA(HIMC hIMC, DWORD dwIndex, DWORD dwBufLen, LONG *plCopied, LPVOID lpBuf)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (plCopied == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*plCopied = 0;
|
|
|
|
if (dwBufLen > 0 && lpBuf == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetCompositionStringA(hIMC, dwIndex, dwBufLen, plCopied, lpBuf);
|
|
}
|
|
|
|
return Imm32_GetCompositionString(hIMC, dwIndex, dwBufLen, plCopied, lpBuf, FALSE);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetCompositionStringW
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetCompositionStringW(HIMC hIMC, DWORD dwIndex, DWORD dwBufLen, LONG *plCopied, LPVOID lpBuf)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (plCopied == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*plCopied = 0;
|
|
|
|
if (dwBufLen > 0 && lpBuf == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetCompositionStringW(hIMC, dwIndex, dwBufLen, plCopied, lpBuf);
|
|
}
|
|
|
|
return Imm32_GetCompositionString(hIMC, dwIndex, dwBufLen, plCopied, lpBuf, TRUE);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// SetCompositionStringA
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::SetCompositionStringA(HIMC hIMC, DWORD dwIndex, LPVOID lpComp, DWORD dwCompLen, LPVOID lpRead, DWORD dwReadLen)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if ((dwIndex & (SCS_SETSTR | SCS_CHANGEATTR | SCS_CHANGECLAUSE | SCS_SETRECONVERTSTRING | SCS_QUERYRECONVERTSTRING)) == 0)
|
|
return E_INVALIDARG;
|
|
|
|
if (lpComp == NULL && lpRead == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->SetCompositionStringA(hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
|
|
}
|
|
|
|
return Imm32_SetCompositionString(hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen, FALSE);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// SetCompositionStringW
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::SetCompositionStringW(HIMC hIMC, DWORD dwIndex, LPVOID lpComp, DWORD dwCompLen, LPVOID lpRead, DWORD dwReadLen)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if ((dwIndex & (SCS_SETSTR | SCS_CHANGEATTR | SCS_CHANGECLAUSE | SCS_SETRECONVERTSTRING | SCS_QUERYRECONVERTSTRING)) == 0)
|
|
return E_INVALIDARG;
|
|
|
|
if (lpComp == NULL && lpRead == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->SetCompositionStringW(hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
|
|
}
|
|
|
|
return Imm32_SetCompositionString(hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen, TRUE);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetCompositionFontA
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetCompositionFontA(HIMC hIMC, LOGFONTA *lplf)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (lplf == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
memset(lplf, 0, sizeof(LOGFONTA));
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetCompositionFontA(hIMC, lplf);
|
|
}
|
|
|
|
return Imm32_GetCompositionFont(hIMC, (LOGFONTAW *)lplf, FALSE);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetCompositionFontW
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetCompositionFontW(HIMC hIMC, LOGFONTW *lplf)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (lplf == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
memset(lplf, 0, sizeof(LOGFONTW));
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetCompositionFontW(hIMC, lplf);
|
|
}
|
|
|
|
return Imm32_GetCompositionFont(hIMC, (LOGFONTAW *)lplf, TRUE);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// SetCompositionFontA
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::SetCompositionFontA(HIMC hIMC, LOGFONTA *lplf)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (lplf == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->SetCompositionFontA(hIMC, lplf);
|
|
}
|
|
|
|
return Imm32_SetCompositionFont(hIMC, (LOGFONTAW *)lplf, FALSE);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// SetCompositionFontW
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::SetCompositionFontW(HIMC hIMC, LOGFONTW *lplf)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (lplf == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->SetCompositionFontW(hIMC, lplf);
|
|
}
|
|
|
|
return Imm32_SetCompositionFont(hIMC, (LOGFONTAW *)lplf, TRUE);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetCompositionWindow
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetCompositionWindow(HIMC hIMC, COMPOSITIONFORM *lpCompForm)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (lpCompForm == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
memset(lpCompForm, 0, sizeof(COMPOSITIONFORM));
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetCompositionWindow(hIMC, lpCompForm);
|
|
}
|
|
|
|
return Imm32_GetCompositionWindow(hIMC, lpCompForm);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// SetCompositionWindow
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::SetCompositionWindow(HIMC hIMC, COMPOSITIONFORM *lpCompForm)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (lpCompForm == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->SetCompositionWindow(hIMC, lpCompForm);
|
|
}
|
|
|
|
return Imm32_SetCompositionWindow(hIMC, lpCompForm);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetCandidateListA
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetCandidateListA(HIMC hIMC, DWORD dwIndex, UINT uBufLen, CANDIDATELIST *lpCandList, UINT *puCopied)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (puCopied != NULL)
|
|
{
|
|
*puCopied = 0;
|
|
}
|
|
if (uBufLen > 0 && lpCandList != NULL)
|
|
{
|
|
memset(lpCandList, 0, uBufLen);
|
|
}
|
|
|
|
if (puCopied == NULL)
|
|
return E_INVALIDARG;
|
|
if (uBufLen > 0 && lpCandList == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetCandidateListA(hIMC, dwIndex, uBufLen, lpCandList, puCopied);
|
|
}
|
|
|
|
return Imm32_GetCandidateList(hIMC, dwIndex, uBufLen, lpCandList, puCopied, FALSE);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetCandidateListW
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetCandidateListW(HIMC hIMC, DWORD dwIndex, UINT uBufLen, CANDIDATELIST *lpCandList, UINT *puCopied)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (puCopied != NULL)
|
|
{
|
|
*puCopied = 0;
|
|
}
|
|
if (uBufLen > 0 && lpCandList != NULL)
|
|
{
|
|
memset(lpCandList, 0, uBufLen);
|
|
}
|
|
|
|
if (puCopied == NULL)
|
|
return E_INVALIDARG;
|
|
if (uBufLen > 0 && lpCandList == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetCandidateListW(hIMC, dwIndex, uBufLen, lpCandList, puCopied);
|
|
}
|
|
|
|
return Imm32_GetCandidateList(hIMC, dwIndex, uBufLen, lpCandList, puCopied, TRUE);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetCandidateListCountA
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetCandidateListCountA(HIMC hIMC, DWORD *lpdwListSize, DWORD *pdwBufLen)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (lpdwListSize != NULL)
|
|
{
|
|
*lpdwListSize = 0;
|
|
}
|
|
if (pdwBufLen != NULL)
|
|
{
|
|
*pdwBufLen = 0;
|
|
}
|
|
if (lpdwListSize == NULL || pdwBufLen == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetCandidateListCountA(hIMC, lpdwListSize, pdwBufLen);
|
|
}
|
|
|
|
return Imm32_GetCandidateListCount(hIMC, lpdwListSize, pdwBufLen, FALSE);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetCandidateListCountW
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetCandidateListCountW(HIMC hIMC, DWORD *lpdwListSize, DWORD *pdwBufLen)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (lpdwListSize != NULL)
|
|
{
|
|
*lpdwListSize = 0;
|
|
}
|
|
if (pdwBufLen != NULL)
|
|
{
|
|
*pdwBufLen = 0;
|
|
}
|
|
if (lpdwListSize == NULL || pdwBufLen == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetCandidateListCountW(hIMC, lpdwListSize, pdwBufLen);
|
|
}
|
|
|
|
return Imm32_GetCandidateListCount(hIMC, lpdwListSize, pdwBufLen, TRUE);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetCandidateWindow
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetCandidateWindow(HIMC hIMC, DWORD dwBufLen, CANDIDATEFORM *lpCandidate)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (lpCandidate == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
memset(lpCandidate, 0, dwBufLen);
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetCandidateWindow(hIMC, dwBufLen, lpCandidate);
|
|
}
|
|
|
|
return Imm32_GetCandidateWindow(hIMC, dwBufLen, lpCandidate);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// SetCandidateWindow
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::SetCandidateWindow(HIMC hIMC, CANDIDATEFORM *lpCandidate)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (lpCandidate == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->SetCandidateWindow(hIMC, lpCandidate);
|
|
}
|
|
|
|
return Imm32_SetCandidateWindow(hIMC, lpCandidate);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetGuideLineA
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetGuideLineA(HIMC hIMC, DWORD dwIndex, DWORD dwBufLen, LPSTR pBuf, DWORD *pdwResult)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
// consider: check params
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetGuideLineA(hIMC, dwIndex, dwBufLen, pBuf, pdwResult);
|
|
}
|
|
|
|
return Imm32_GetGuideLine(hIMC, dwIndex, dwBufLen, (CHARAW *)pBuf, pdwResult, FALSE);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetGuideLineW
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetGuideLineW(HIMC hIMC, DWORD dwIndex, DWORD dwBufLen, LPWSTR pBuf, DWORD *pdwResult)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
// consider: check params
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetGuideLineW(hIMC, dwIndex, dwBufLen, pBuf, pdwResult);
|
|
}
|
|
|
|
return Imm32_GetGuideLine(hIMC, dwIndex, dwBufLen, (CHARAW *)pBuf, pdwResult, TRUE);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// NotifyIME
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::NotifyIME(HIMC hIMC, DWORD dwAction, DWORD dwIndex, DWORD dwValue)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->NotifyIME(hIMC, dwAction, dwIndex, dwValue);
|
|
}
|
|
|
|
return Imm32_NotifyIME(hIMC, dwAction, dwIndex, dwValue);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetImeMenuItemsA
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetImeMenuItemsA(HIMC hIMC, DWORD dwFlags, DWORD dwType, IMEMENUITEMINFOA *pImeParentMenu, IMEMENUITEMINFOA *pImeMenu, DWORD dwSize, DWORD *pdwResult)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
// consider: check params
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetImeMenuItemsA(hIMC, dwFlags, dwType, pImeParentMenu, pImeMenu, dwSize, pdwResult);
|
|
}
|
|
|
|
return Imm32_GetImeMenuItems(hIMC, dwFlags, dwType, (IMEMENUITEMINFOAW *)pImeParentMenu, (IMEMENUITEMINFOAW *)pImeMenu, dwSize, pdwResult, FALSE);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetImeMenuItemsW
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetImeMenuItemsW(HIMC hIMC, DWORD dwFlags, DWORD dwType, IMEMENUITEMINFOW *pImeParentMenu, IMEMENUITEMINFOW *pImeMenu, DWORD dwSize, DWORD *pdwResult)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
// consider: check params
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetImeMenuItemsW(hIMC, dwFlags, dwType, pImeParentMenu, pImeMenu, dwSize, pdwResult);
|
|
}
|
|
|
|
return Imm32_GetImeMenuItems(hIMC, dwFlags, dwType, (IMEMENUITEMINFOAW *)pImeParentMenu, (IMEMENUITEMINFOAW *)pImeMenu, dwSize, pdwResult, TRUE);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// RegisterWordA
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::RegisterWordA(HKL hKL, LPSTR lpszReading, DWORD dwStyle, LPSTR lpszRegister)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
// consider: check params
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->RegisterWordA(hKL, lpszReading, dwStyle, lpszRegister);
|
|
}
|
|
|
|
return Imm32_RegisterWordA(hKL, lpszReading, dwStyle, lpszRegister);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// RegisterWordW
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::RegisterWordW(HKL hKL, LPWSTR lpszReading, DWORD dwStyle, LPWSTR lpszRegister)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
// consider: check params
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->RegisterWordW(hKL, lpszReading, dwStyle, lpszRegister);
|
|
}
|
|
|
|
return Imm32_RegisterWordW(hKL, lpszReading, dwStyle, lpszRegister);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// UnregisterWordA
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::UnregisterWordA(HKL hKL, LPSTR lpszReading, DWORD dwStyle, LPSTR lpszUnregister)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
// consider: check params
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->UnregisterWordA(hKL, lpszReading, dwStyle, lpszUnregister);
|
|
}
|
|
|
|
return Imm32_UnregisterWordA(hKL, lpszReading, dwStyle, lpszUnregister);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// UnregisterWordW
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::UnregisterWordW(HKL hKL, LPWSTR lpszReading, DWORD dwStyle, LPWSTR lpszUnregister)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
// consider: check params
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->UnregisterWordW(hKL, lpszReading, dwStyle, lpszUnregister);
|
|
}
|
|
|
|
return Imm32_UnregisterWordW(hKL, lpszReading, dwStyle, lpszUnregister);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// EnumRegisterWordA
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::EnumRegisterWordA(HKL hKL, LPSTR szReading, DWORD dwStyle, LPSTR szRegister, LPVOID lpData, IEnumRegisterWordA **ppEnum)
|
|
{
|
|
if (ppEnum != NULL)
|
|
{
|
|
*ppEnum = NULL;
|
|
}
|
|
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->EnumRegisterWordA(hKL, szReading, dwStyle, szRegister, lpData, ppEnum);
|
|
}
|
|
|
|
return Imm32_EnumRegisterWordA(hKL, szReading, dwStyle, szRegister, lpData, ppEnum);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// EnumRegisterWordW
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::EnumRegisterWordW(HKL hKL, LPWSTR szReading, DWORD dwStyle, LPWSTR szRegister, LPVOID lpData, IEnumRegisterWordW **ppEnum)
|
|
{
|
|
if (ppEnum != NULL)
|
|
{
|
|
*ppEnum = NULL;
|
|
}
|
|
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->EnumRegisterWordW(hKL, szReading, dwStyle, szRegister, lpData, ppEnum);
|
|
}
|
|
|
|
return Imm32_EnumRegisterWordW(hKL, szReading, dwStyle, szRegister, lpData, ppEnum);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetRegisterWordStyleA
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetRegisterWordStyleA(HKL hKL, UINT nItem, STYLEBUFA *lpStyleBuf, UINT *puCopied)
|
|
{
|
|
if (puCopied != NULL)
|
|
{
|
|
*puCopied = 0;
|
|
}
|
|
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetRegisterWordStyleA(hKL, nItem, lpStyleBuf, puCopied);
|
|
}
|
|
|
|
return Imm32_GetRegisterWordStyleA(hKL, nItem, lpStyleBuf, puCopied);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetRegisterWordStyleW
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetRegisterWordStyleW(HKL hKL, UINT nItem, STYLEBUFW *lpStyleBuf, UINT *puCopied)
|
|
{
|
|
if (puCopied != NULL)
|
|
{
|
|
*puCopied = 0;
|
|
}
|
|
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetRegisterWordStyleW(hKL, nItem, lpStyleBuf, puCopied);
|
|
}
|
|
|
|
return Imm32_GetRegisterWordStyleW(hKL, nItem, lpStyleBuf, puCopied);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// ConfigureIMEA
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::ConfigureIMEA(HKL hKL, HWND hWnd, DWORD dwMode, REGISTERWORDA *lpdata)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
// consider: check params
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->ConfigureIMEA(hKL, hWnd, dwMode, lpdata);
|
|
}
|
|
|
|
return Imm32_ConfigureIMEA(hKL, hWnd, dwMode, lpdata);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// ConfigureIMEW
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::ConfigureIMEW(HKL hKL, HWND hWnd, DWORD dwMode, REGISTERWORDW *lpdata)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
// consider: check params
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->ConfigureIMEW(hKL, hWnd, dwMode, lpdata);
|
|
}
|
|
|
|
return Imm32_ConfigureIMEW(hKL, hWnd, dwMode, lpdata);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetDescriptionA
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetDescriptionA(HKL hKL, UINT uBufLen, LPSTR lpszDescription, UINT *puCopied)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (puCopied != NULL)
|
|
{
|
|
*puCopied = 0;
|
|
}
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetDescriptionA(hKL, uBufLen, lpszDescription, puCopied);
|
|
}
|
|
|
|
return GetDescriptionA(hKL, uBufLen, lpszDescription, puCopied);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetDescriptionW
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetDescriptionW(HKL hKL, UINT uBufLen, LPWSTR lpszDescription, UINT *puCopied)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (puCopied != NULL)
|
|
{
|
|
*puCopied = 0;
|
|
}
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetDescriptionW(hKL, uBufLen, lpszDescription, puCopied);
|
|
}
|
|
|
|
return Imm32_GetDescriptionW(hKL, uBufLen, lpszDescription, puCopied);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetIMEFileNameA
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetIMEFileNameA(HKL hKL, UINT uBufLen, LPSTR lpszFileName, UINT *puCopied)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (puCopied != NULL)
|
|
{
|
|
*puCopied = 0;
|
|
}
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetIMEFileNameA(hKL, uBufLen, lpszFileName, puCopied);
|
|
}
|
|
|
|
return Imm32_GetIMEFileNameA(hKL, uBufLen, lpszFileName, puCopied);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetIMEFileNameW
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetIMEFileNameW(HKL hKL, UINT uBufLen, LPWSTR lpszFileName, UINT *puCopied)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (puCopied != NULL)
|
|
{
|
|
*puCopied = 0;
|
|
}
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetIMEFileNameW(hKL, uBufLen, lpszFileName, puCopied);
|
|
}
|
|
|
|
return Imm32_GetIMEFileNameW(hKL, uBufLen, lpszFileName, puCopied);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// InstallIMEA
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::InstallIMEA(LPSTR lpszIMEFileName, LPSTR lpszLayoutText, HKL *phKL)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
// consider: check params
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->InstallIMEA(lpszIMEFileName, lpszLayoutText, phKL);
|
|
}
|
|
|
|
return Imm32_InstallIMEA(lpszIMEFileName, lpszLayoutText, phKL);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// InstallIMEW
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::InstallIMEW(LPWSTR lpszIMEFileName, LPWSTR lpszLayoutText, HKL *phKL)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
// consider: check params
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->InstallIMEW(lpszIMEFileName, lpszLayoutText, phKL);
|
|
}
|
|
|
|
return Imm32_InstallIMEW(lpszIMEFileName, lpszLayoutText, phKL);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetProperty
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetProperty(HKL hKL, DWORD fdwIndex, DWORD *pdwProperty)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pdwProperty == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*pdwProperty = 0;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetProperty(hKL, fdwIndex, pdwProperty);
|
|
}
|
|
|
|
return Imm32_GetProperty(hKL, fdwIndex, pdwProperty);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// IsIME
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::IsIME(HKL hKL)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->IsIME(hKL);
|
|
}
|
|
|
|
return Imm32_IsIME(hKL);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// EscapeA
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::EscapeA(HKL hKL, HIMC hIMC, UINT uEscape, LPVOID lpData, LRESULT *plResult)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (plResult == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*plResult = 0;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->EscapeA(hKL, hIMC, uEscape, lpData, plResult);
|
|
}
|
|
|
|
return Imm32_Escape(hKL, hIMC, uEscape, lpData, plResult, FALSE);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// EscapeW
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::EscapeW(HKL hKL, HIMC hIMC, UINT uEscape, LPVOID lpData, LRESULT *plResult)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (plResult == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*plResult = 0;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->EscapeW(hKL, hIMC, uEscape, lpData, plResult);
|
|
}
|
|
|
|
return Imm32_Escape(hKL, hIMC, uEscape, lpData, plResult, TRUE);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetConversionListA
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetConversionListA(HKL hKL, HIMC hIMC, LPSTR lpSrc, UINT uBufLen, UINT uFlag, CANDIDATELIST *lpDst, UINT *puCopied)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (puCopied != NULL)
|
|
{
|
|
*puCopied = 0;
|
|
}
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetConversionListA(hKL, hIMC, lpSrc, uBufLen, uFlag, lpDst, puCopied);
|
|
}
|
|
|
|
return Imm32_GetConversionListA(hKL, hIMC, lpSrc, uBufLen, uFlag, lpDst, puCopied);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetConversionListW
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetConversionListW(HKL hKL, HIMC hIMC, LPWSTR lpSrc, UINT uBufLen, UINT uFlag, CANDIDATELIST *lpDst, UINT *puCopied)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (puCopied != NULL)
|
|
{
|
|
*puCopied = 0;
|
|
}
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetConversionListW(hKL, hIMC, lpSrc, uBufLen, uFlag, lpDst, puCopied);
|
|
}
|
|
|
|
return Imm32_GetConversionListW(hKL, hIMC, lpSrc, uBufLen, uFlag, lpDst, puCopied);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetDefaultIMEWnd
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetDefaultIMEWnd(HWND hWnd, HWND *phDefWnd)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (phDefWnd == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*phDefWnd = 0;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetDefaultIMEWnd(hWnd, phDefWnd);
|
|
}
|
|
|
|
return Imm32_GetDefaultIMEWnd(hWnd, phDefWnd);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetVirtualKey
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetVirtualKey(HWND hWnd, UINT *puVirtualKey)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (puVirtualKey == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*puVirtualKey = 0;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetVirtualKey(hWnd, puVirtualKey);
|
|
}
|
|
|
|
return Imm32_GetVirtualKey(hWnd, puVirtualKey);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// IsUIMessageA
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::IsUIMessageA(HWND hWndIME, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->IsUIMessageA(hWndIME, msg, wParam, lParam);
|
|
}
|
|
|
|
return Imm32_IsUIMessageA(hWndIME, msg, wParam, lParam);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// IsUIMessageW
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::IsUIMessageW(HWND hWndIME, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->IsUIMessageW(hWndIME, msg, wParam, lParam);
|
|
}
|
|
|
|
return Imm32_IsUIMessageW(hWndIME, msg, wParam, lParam);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GenerateMessage
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GenerateMessage(HIMC hIMC)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GenerateMessage(hIMC);
|
|
}
|
|
|
|
return Imm32_GenerateMessage(hIMC);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetHotKey
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetHotKey(DWORD dwHotKeyID, UINT *puModifiers, UINT *puVKey, HKL *phKL)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (puModifiers != NULL)
|
|
{
|
|
*puModifiers = 0;
|
|
}
|
|
if (puVKey != NULL)
|
|
{
|
|
*puVKey = 0;
|
|
}
|
|
if (phKL != NULL)
|
|
{
|
|
*phKL = 0;
|
|
}
|
|
if (puModifiers == NULL || puVKey == NULL || phKL == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->GetHotKey(dwHotKeyID, puModifiers, puVKey, phKL);
|
|
}
|
|
|
|
return Imm32_GetHotKey(dwHotKeyID, puModifiers, puVKey, phKL);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// SetHotKey
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::SetHotKey(DWORD dwHotKeyID, UINT uModifiers, UINT uVKey, HKL hKL)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->SetHotKey(dwHotKeyID, uModifiers, uVKey, hKL);
|
|
}
|
|
|
|
return Imm32_SetHotKey(dwHotKeyID, uModifiers, uVKey, hKL);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// SimulateHotKey
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::SimulateHotKey(HWND hWnd, DWORD dwHotKeyID)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->SimulateHotKey(hWnd, dwHotKeyID);
|
|
}
|
|
|
|
return Imm32_SimulateHotKey(hWnd, dwHotKeyID);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// CreateSoftKeyboard
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::CreateSoftKeyboard(UINT uType, HWND hOwner, int x, int y, HWND *phSoftKbdWnd)
|
|
{
|
|
if (phSoftKbdWnd != NULL)
|
|
{
|
|
*phSoftKbdWnd = 0;
|
|
}
|
|
|
|
return Imm32_CreateSoftKeyboard(uType, hOwner, x, y, phSoftKbdWnd);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// DestroySoftKeyboard
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::DestroySoftKeyboard(HWND hSoftKbdWnd)
|
|
{
|
|
return Imm32_DestroySoftKeyboard(hSoftKbdWnd);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// ShowSoftKeyboard
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::ShowSoftKeyboard(HWND hSoftKbdWnd, int nCmdShow)
|
|
{
|
|
return Imm32_ShowSoftKeyboard(hSoftKbdWnd, nCmdShow);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// DisableIME
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::DisableIME(DWORD idThread)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->DisableIME(idThread);
|
|
}
|
|
|
|
return Imm32_DisableIME(idThread);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// RequestMessageA
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::RequestMessageA(HIMC hIMC, WPARAM wParam, LPARAM lParam, LRESULT *plResult)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (plResult == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*plResult = 0;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->RequestMessageA(hIMC, wParam, lParam, plResult);
|
|
}
|
|
|
|
return Imm32_RequestMessageA(hIMC, wParam, lParam, plResult);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// RequestMessageW
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::RequestMessageW(HIMC hIMC, WPARAM wParam, LPARAM lParam, LRESULT *plResult)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (plResult == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*plResult = 0;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->RequestMessageW(hIMC, wParam, lParam, plResult);
|
|
}
|
|
|
|
return Imm32_RequestMessageW(hIMC, wParam, lParam, plResult);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// EnumInputContext
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::EnumInputContext(DWORD idThread, IEnumInputContext **ppEnum)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (ppEnum != NULL)
|
|
{
|
|
*ppEnum = NULL;
|
|
}
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->EnumInputContext(idThread, ppEnum);
|
|
}
|
|
|
|
Assert(0);
|
|
return E_NOTIMPL; // consider: need code to wrap up HIMC's into enumerator
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Activate
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::Activate(BOOL fRestoreLayout)
|
|
{
|
|
PENDINGFILTER *pPending;
|
|
PENDINGFILTERGUIDMAP *pPendingGuidMap;
|
|
PENDINGFILTEREX *pPendingEx;
|
|
IMTLS *ptls;
|
|
CActiveIMM *pActiveIMM;
|
|
HRESULT hr;
|
|
BOOL fInitedTLS = FALSE;
|
|
|
|
if ((ptls = IMTLS_GetOrAlloc()) == NULL)
|
|
return E_FAIL;
|
|
|
|
// init the tls
|
|
if ((pActiveIMM = ptls->pActiveIMM) == NULL)
|
|
{
|
|
if ((pActiveIMM = new CActiveIMM) == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
if (FAILED(hr=pActiveIMM->_Init()) ||
|
|
FAILED(hr=IMTLS_SetActiveIMM(pActiveIMM) ? S_OK : E_FAIL))
|
|
{
|
|
delete pActiveIMM;
|
|
return hr;
|
|
}
|
|
|
|
fInitedTLS = TRUE;
|
|
|
|
// handle any calls to FilterClientWindows that preceded the activate call
|
|
// consider: is it safe to limit filter list to per-thread? Shouldn't this be per-process
|
|
// to make trident happy?
|
|
while (ptls->pPendingFilterClientWindows != NULL)
|
|
{
|
|
ptls->pActiveIMM->FilterClientWindows(ptls->pPendingFilterClientWindows->rgAtoms, ptls->pPendingFilterClientWindows->uSize, ptls->pPendingFilterClientWindowsGuidMap->rgGuidMap);
|
|
|
|
pPending = ptls->pPendingFilterClientWindows->pNext;
|
|
cicMemFree(ptls->pPendingFilterClientWindows);
|
|
ptls->pPendingFilterClientWindows = pPending;
|
|
|
|
pPendingGuidMap = ptls->pPendingFilterClientWindowsGuidMap->pNext;
|
|
cicMemFree(ptls->pPendingFilterClientWindowsGuidMap);
|
|
ptls->pPendingFilterClientWindowsGuidMap = pPendingGuidMap;
|
|
}
|
|
while (ptls->pPendingFilterClientWindowsEx != NULL)
|
|
{
|
|
ptls->pActiveIMM->FilterClientWindowsEx(ptls->pPendingFilterClientWindowsEx->hWnd,
|
|
ptls->pPendingFilterClientWindowsEx->fGuidMap);
|
|
|
|
pPendingEx = ptls->pPendingFilterClientWindowsEx->pNext;
|
|
cicMemFree(ptls->pPendingFilterClientWindowsEx);
|
|
ptls->pPendingFilterClientWindowsEx = pPendingEx;
|
|
}
|
|
}
|
|
|
|
hr = pActiveIMM->Activate(fRestoreLayout);
|
|
|
|
if (fInitedTLS)
|
|
{
|
|
// the first Activate call on this thread will do an internal AddRef
|
|
// on success, so we must release
|
|
pActiveIMM->Release();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Deactivate
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::Deactivate()
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->Deactivate();
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// OnDefWindowProc
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::OnDefWindowProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, LRESULT *plResult)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (plResult == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*plResult = 0;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->OnDefWindowProc(hWnd, Msg, wParam, lParam, plResult);
|
|
}
|
|
|
|
return S_FALSE;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// FilterClientWindows
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::FilterClientWindows(ATOM *aaWindowClasses, UINT uSize)
|
|
{
|
|
return FilterClientWindowsGUIDMap(aaWindowClasses, uSize, NULL);
|
|
}
|
|
|
|
STDAPI CProcessIMM::FilterClientWindowsGUIDMap(ATOM *aaWindowClasses, UINT uSize, BOOL *aaGuidMap)
|
|
{
|
|
IMTLS *ptls;
|
|
PENDINGFILTER *pPending;
|
|
PENDINGFILTERGUIDMAP *pPendingGuidMap;
|
|
|
|
if ((ptls = IMTLS_GetOrAlloc()) == NULL)
|
|
return E_FAIL;
|
|
|
|
if (ptls->pActiveIMM != NULL)
|
|
{
|
|
return ptls->pActiveIMM->FilterClientWindows(aaWindowClasses, uSize, aaGuidMap);
|
|
}
|
|
|
|
// Activate hasn't been called yet on this thread
|
|
// need to handle the call later
|
|
|
|
pPending = (PENDINGFILTER *)cicMemAlloc(sizeof(PENDINGFILTER)+uSize*sizeof(ATOM)-sizeof(ATOM));
|
|
if (pPending == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
pPendingGuidMap = (PENDINGFILTERGUIDMAP *)cicMemAlloc(sizeof(PENDINGFILTERGUIDMAP)+uSize*sizeof(BOOL)-sizeof(BOOL));
|
|
if (pPendingGuidMap == NULL) {
|
|
cicMemFree(pPending);
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
pPending->uSize = uSize;
|
|
memcpy(pPending->rgAtoms, aaWindowClasses, uSize*sizeof(ATOM));
|
|
|
|
pPendingGuidMap->uSize = uSize;
|
|
if (aaGuidMap) {
|
|
memcpy(pPendingGuidMap->rgGuidMap, aaGuidMap, uSize*sizeof(BOOL));
|
|
}
|
|
else {
|
|
memset(pPendingGuidMap->rgGuidMap, FALSE, uSize*sizeof(BOOL));
|
|
}
|
|
|
|
pPending->pNext = ptls->pPendingFilterClientWindows;
|
|
ptls->pPendingFilterClientWindows = pPending;
|
|
|
|
pPendingGuidMap->pNext = ptls->pPendingFilterClientWindowsGuidMap;
|
|
ptls->pPendingFilterClientWindowsGuidMap = pPendingGuidMap;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// FilterClientWindowsEx
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::FilterClientWindowsEx(HWND hWnd, BOOL fGuidMap)
|
|
{
|
|
IMTLS *ptls;
|
|
PENDINGFILTEREX *pPending;
|
|
|
|
if ((ptls = IMTLS_GetOrAlloc()) == NULL)
|
|
return E_FAIL;
|
|
|
|
if (ptls->pActiveIMM != NULL)
|
|
{
|
|
return ptls->pActiveIMM->FilterClientWindowsEx(hWnd, fGuidMap);
|
|
}
|
|
|
|
// Activate hasn't been called yet on this thread
|
|
// need to handle the call later
|
|
|
|
pPending = (PENDINGFILTEREX *)cicMemAlloc(sizeof(PENDINGFILTEREX));
|
|
|
|
if (pPending == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
pPending->hWnd = hWnd;
|
|
pPending->fGuidMap = fGuidMap;
|
|
|
|
pPending->pNext = ptls->pPendingFilterClientWindowsEx;
|
|
ptls->pPendingFilterClientWindowsEx = pPending;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetGuidAtom
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetGuidAtom(HIMC hImc, BYTE bAttr, TfGuidAtom *pGuidAtom)
|
|
{
|
|
IMTLS *ptls;
|
|
|
|
if ((ptls = IMTLS_GetOrAlloc()) == NULL)
|
|
return E_FAIL;
|
|
|
|
if (ptls->pActiveIMM != NULL)
|
|
{
|
|
return ptls->pActiveIMM->GetGuidAtom(hImc, bAttr, pGuidAtom);
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// UnfilterClientWindowsEx
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::UnfilterClientWindowsEx(HWND hWnd)
|
|
{
|
|
IMTLS *ptls;
|
|
|
|
if ((ptls = IMTLS_GetOrAlloc()) == NULL)
|
|
return E_FAIL;
|
|
|
|
if (ptls->pActiveIMM != NULL)
|
|
{
|
|
return ptls->pActiveIMM->UnfilterClientWindowsEx(hWnd);
|
|
}
|
|
|
|
// Activate hasn't been called yet on this thread
|
|
// need to remove a handle from the waiting list
|
|
|
|
PENDINGFILTEREX *current = ptls->pPendingFilterClientWindowsEx;
|
|
PENDINGFILTEREX *previous = NULL;
|
|
|
|
while (current != NULL)
|
|
{
|
|
if (current->hWnd == hWnd)
|
|
{
|
|
PENDINGFILTEREX *pv;
|
|
pv = current->pNext;
|
|
cicMemFree(current);
|
|
|
|
if (previous == NULL)
|
|
ptls->pPendingFilterClientWindowsEx = pv;
|
|
else
|
|
previous->pNext = pv;
|
|
|
|
current = pv;
|
|
}
|
|
else
|
|
{
|
|
previous = current;
|
|
current = current->pNext;
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetCodePageA
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
extern UINT GetCodePageFromLangId(LCID lcid);
|
|
|
|
STDAPI CProcessIMM::GetCodePageA(HKL hKL, UINT *puCodePage)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetCodePageA
|
|
IActiveIMMIME::GetCodePageA
|
|
|
|
Routine Description:
|
|
|
|
Retrieves the code page associated with the given keyboard layout.
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle to the keyboard layout.
|
|
puCodePage - [out] Address of an unsigned integer that receives the code page
|
|
identifier associated with the keyboard.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
if (puCodePage == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*puCodePage = CP_ACP;
|
|
|
|
TraceMsg(TF_API, "CProcessIMM::GetCodePageA");
|
|
|
|
if (_IsValidKeyboardLayout(hKL)) {
|
|
*puCodePage = ::GetCodePageFromLangId(LOWORD(hKL));
|
|
return S_OK;
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetLangId
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetLangId(HKL hKL, LANGID *plid)
|
|
|
|
/*++
|
|
|
|
Method:
|
|
|
|
IActiveIMMApp::GetLangId
|
|
IActiveIMMIME::GetLangId
|
|
|
|
Routine Description:
|
|
|
|
Retrieves the language identifier associated with the given keyboard layout.
|
|
|
|
Arguments:
|
|
|
|
hKL - [in] Handle to the keyboard layout.
|
|
plid - [out] Address of the LANGID associated with the keyboard layout.
|
|
|
|
Return Value:
|
|
|
|
Returns S_OK if successful, or an error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
if (plid == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*plid = MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
|
|
|
|
TraceMsg(TF_API, "CProcessIMM::GetLangId");
|
|
|
|
if (_IsValidKeyboardLayout(hKL)) {
|
|
*plid = LOWORD(hKL);
|
|
return S_OK;
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// QueryService
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::QueryService(REFGUID guidService, REFIID riid, void **ppv)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (ppv == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
*ppv = NULL;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
{
|
|
return pActiveIMM->QueryService(guidService, riid, ppv);
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// SetThreadCompartmentValue
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::SetThreadCompartmentValue(REFGUID rguid, VARIANT *pvar)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pvar == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
return pActiveIMM->SetThreadCompartmentValue(rguid, pvar);
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetThreadCompartmentValue
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CProcessIMM::GetThreadCompartmentValue(REFGUID rguid, VARIANT *pvar)
|
|
{
|
|
CActiveIMM *pActiveIMM;
|
|
|
|
if (pvar == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
QuickVariantInit(pvar);
|
|
|
|
if (pActiveIMM = GetTLS())
|
|
return pActiveIMM->GetThreadCompartmentValue(rguid, pvar);
|
|
|
|
return E_FAIL;
|
|
}
|