1406 lines
37 KiB
C++
1406 lines
37 KiB
C++
//
|
|
// nui.cpp
|
|
//
|
|
|
|
#include "private.h"
|
|
#include "immxutil.h"
|
|
#include "sapilayr.h"
|
|
#include "xstring.h"
|
|
#include "nui.h"
|
|
#include "ids.h"
|
|
#include "cicspres.h"
|
|
#include "cresstr.h"
|
|
#include "slbarid.h"
|
|
#include "ptrary.h"
|
|
#include "ctffunc.h"
|
|
|
|
|
|
/* ad8d338b-fb07-4e06-8d5b-911baad9eeb3 */
|
|
const IID IID_PRIV_CSPEECHUISERVER = {
|
|
0xad8d338b,
|
|
0xfb07,
|
|
0x4e06,
|
|
{0x8d, 0x5b, 0x91, 0x1b, 0xaa, 0xd9, 0xee, 0xb3}
|
|
};
|
|
|
|
/* e49d6ff3-1fff-43ba-b835-3a122e98a1c9 */
|
|
const GUID GUID_LBI_SAPILAYR_MICROPHONE = {
|
|
0xe49d6ff3,
|
|
0x1fff,
|
|
0x43ba,
|
|
{0xb8, 0x35, 0x3a, 0x12, 0x2e, 0x98, 0xa1, 0xc9}
|
|
};
|
|
|
|
/* 3f9ea2e3-75d6-4879-86c2-2bcc2b6fa46e */
|
|
const GUID GUID_LBI_SAPILAYR_BALLOON = {
|
|
0x3f9ea2e3,
|
|
0x75d6,
|
|
0x4879,
|
|
{0x86, 0xc2, 0x2b, 0xcc, 0x2b, 0x6f, 0xa4, 0x6e}
|
|
};
|
|
|
|
/* 17f9fa7f-a9ed-47b5-8bcd-eebb94b2e6ca */
|
|
const GUID GUID_LBI_SAPILAYR_COMMANDING = {
|
|
0x17f9fa7f,
|
|
0xa9ed,
|
|
0x47b5,
|
|
{0x8b, 0xcd, 0xee, 0xbb, 0x94, 0xb2, 0xe6, 0xca}
|
|
};
|
|
|
|
/* 49261a4a-87df-47fc-8a68-6ea07ba82a87 */
|
|
const GUID GUID_LBI_SAPILAYR_DICTATION = {
|
|
0x49261a4a,
|
|
0x87df,
|
|
0x47fc,
|
|
{0x8a, 0x68, 0x6e, 0xa0, 0x7b, 0xa8, 0x2a, 0x87}
|
|
};
|
|
|
|
/* 791b4403-0cda-4fe1-b748-517d049fde08 */
|
|
const GUID GUID_LBI_SAPILAYR_TTS_PLAY_STOP = {
|
|
0x791b4403,
|
|
0x0cda,
|
|
0x4fe1,
|
|
{0xb7, 0x48, 0x51, 0x7d, 0x04, 0x9f, 0xde, 0x08}
|
|
};
|
|
|
|
/* e6fbfc9d-a2e0-4203-a27b-af2353e6a44e */
|
|
const GUID GUID_LBI_SAPILAYR_TTS_PAUSE_RESUME = {
|
|
0xe6fbfc9d,
|
|
0xa2e0,
|
|
0x4203,
|
|
{0xa2, 0x7b, 0xaf, 0x23, 0x53, 0xe6, 0xa4, 0x4e}
|
|
};
|
|
|
|
CPtrArray<SPTIPTHREAD> *g_rgstt = NULL;
|
|
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetSPTIPTHREAD
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
SPTIPTHREAD *GetSPTIPTHREAD()
|
|
{
|
|
SPTIPTHREAD *pstt;
|
|
|
|
if (g_dwTlsIndex == (DWORD)-1)
|
|
return NULL;
|
|
|
|
pstt = (SPTIPTHREAD *)TlsGetValue(g_dwTlsIndex);
|
|
if (!pstt)
|
|
{
|
|
pstt = (SPTIPTHREAD *)cicMemAllocClear(sizeof(SPTIPTHREAD));
|
|
if (!TlsSetValue(g_dwTlsIndex, pstt))
|
|
{
|
|
cicMemFree(pstt);
|
|
pstt = NULL;
|
|
}
|
|
|
|
EnterCriticalSection(g_cs);
|
|
|
|
if (!g_rgstt)
|
|
g_rgstt = new CPtrArray<SPTIPTHREAD>;
|
|
|
|
if (g_rgstt)
|
|
{
|
|
if (g_rgstt->Insert(0, 1))
|
|
{
|
|
g_rgstt->Set(0, pstt);
|
|
}
|
|
else
|
|
{
|
|
TlsSetValue(g_dwTlsIndex, NULL);
|
|
cicMemFree(pstt);
|
|
pstt = NULL;
|
|
}
|
|
}
|
|
|
|
LeaveCriticalSection(g_cs);
|
|
}
|
|
|
|
return pstt;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// FreeSPTIPTHREAD
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void FreeSPTIPTHREAD()
|
|
{
|
|
SPTIPTHREAD *pstt;
|
|
|
|
if (g_dwTlsIndex == (DWORD)-1)
|
|
return;
|
|
|
|
pstt = (SPTIPTHREAD *)TlsGetValue(g_dwTlsIndex);
|
|
if (pstt)
|
|
{
|
|
EnterCriticalSection(g_cs);
|
|
|
|
if (g_rgstt)
|
|
{
|
|
int nCnt = g_rgstt->Count();
|
|
while (nCnt)
|
|
{
|
|
nCnt--;
|
|
if (g_rgstt->Get(nCnt) == pstt)
|
|
{
|
|
g_rgstt->Remove(nCnt, 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
LeaveCriticalSection(g_cs);
|
|
|
|
cicMemFree(pstt);
|
|
TlsSetValue(g_dwTlsIndex, NULL);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// UninitProcess()
|
|
//
|
|
//+---------------------------------------------------------------------------
|
|
|
|
void UninitProcess()
|
|
{
|
|
//
|
|
// FreeSPTIPTHREAD2() removes psfn from PtrArray.
|
|
//
|
|
if (g_rgstt)
|
|
{
|
|
while(g_rgstt->Count())
|
|
{
|
|
SPTIPTHREAD *pstt = g_rgstt->Get(0);
|
|
g_rgstt->Remove(0, 1);
|
|
cicMemFree(pstt);
|
|
}
|
|
delete g_rgstt;
|
|
g_rgstt = NULL;
|
|
}
|
|
|
|
//
|
|
// Free speech grammar resource module(SPGRMR.DLL)
|
|
//
|
|
if (g_hInstSpgrmr)
|
|
{
|
|
FreeLibrary(g_hInstSpgrmr);
|
|
}
|
|
|
|
//
|
|
// Free XP SP1 resource module(XPSP1RES.DLL) if it is loaded.
|
|
//
|
|
FreeCicResInstance();
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// LoadSpgrmrModule()
|
|
//
|
|
//+---------------------------------------------------------------------------
|
|
|
|
void LoadSpgrmrModule()
|
|
{
|
|
if (!g_hInstSpgrmr)
|
|
{
|
|
TCHAR szSpgrmrPath[MAX_PATH + 32];
|
|
|
|
if (GetWindowsDirectory(szSpgrmrPath, MAX_PATH))
|
|
{
|
|
StringCchCat(szSpgrmrPath,
|
|
ARRAYSIZE(szSpgrmrPath),
|
|
TEXT("\\IME\\SPGRMR.DLL"));
|
|
|
|
g_hInstSpgrmr = LoadLibrary(szSpgrmrPath);
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CSpeechUIServer
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// PostCreateInstance
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CSpeechUIServer::PostCreateInstance(REFIID riid, void *pvObj)
|
|
{
|
|
if (IsEqualGUID(riid, IID_ITfSpeechUIServer))
|
|
{
|
|
((CSpeechUIServer *)pvObj)->_EnsureSpeechProfile();
|
|
}
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// ctor
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CSpeechUIServer::CSpeechUIServer()
|
|
{
|
|
_SetThis(this);
|
|
|
|
_tim = NULL;
|
|
_lbim = NULL;
|
|
_fShown = FALSE;
|
|
m_fCommandingReady = FALSE;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// dtor
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CSpeechUIServer::~CSpeechUIServer()
|
|
{
|
|
if (_fShown)
|
|
ShowUI(FALSE);
|
|
|
|
if (_pCes)
|
|
{
|
|
_pCes->_Unadvise();
|
|
SafeReleaseClear(_pCes);
|
|
}
|
|
|
|
SafeRelease(_plbiMicrophone);
|
|
SafeRelease(_plbiCfgMenuButton);
|
|
SafeRelease(_plbiBalloon);
|
|
SafeRelease(_plbiDictation);
|
|
SafeRelease(_plbiCommanding);
|
|
SafeRelease(_plbiTtsPlayStop);
|
|
SafeRelease(_plbiTtsPauseResume);
|
|
SafeRelease(_tim);
|
|
SafeRelease(_lbim);
|
|
|
|
GlobalDeleteAtom(m_hAtom);
|
|
|
|
_SetThis(NULL);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Initialize
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CSpeechUIServer::Initialize()
|
|
{
|
|
HRESULT hr;
|
|
if (_tim)
|
|
return S_OK;
|
|
|
|
if (FAILED(hr = TF_CreateThreadMgr(&_tim)))
|
|
return hr;
|
|
|
|
if (FAILED(hr = GetService(_tim,
|
|
IID_ITfLangBarItemMgr,
|
|
(IUnknown **)&_lbim)))
|
|
return hr;
|
|
|
|
if (!(_pCes = new CCompartmentEventSink(_CompEventSinkCallback, this)))
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
_pCes->_Advise(_tim, GUID_COMPARTMENT_SPEECH_OPENCLOSE, TRUE);
|
|
_pCes->_Advise(_tim, GUID_COMPARTMENT_SPEECH_DISABLED, FALSE);
|
|
_pCes->_Advise(_tim, GUID_COMPARTMENT_SPEECH_GLOBALSTATE, TRUE);
|
|
_pCes->_Advise(_tim, GUID_COMPARTMENT_SPEECH_UI_STATUS, TRUE);
|
|
_pCes->_Advise(_tim, GUID_COMPARTMENT_SHARED_BLN_TEXT, TRUE);
|
|
_pCes->_Advise(_tim, GUID_COMPARTMENT_TTS_STATUS, FALSE);
|
|
//TABLETPC
|
|
_pCes->_Advise(_tim, GUID_COMPARTMENT_SPEECH_STAGE, FALSE);
|
|
_pCes->_Advise(_tim, GUID_COMPARTMENT_SPEECH_STAGECHANGE, TRUE);
|
|
|
|
// SetCompartmentDWORD(0, _tim, GUID_COMPARTMENT_SPEECH_UI_STATUS, 7, TRUE);
|
|
|
|
// this is for TABLET
|
|
DWORD dw = 0;
|
|
GetCompartmentDWORD(_tim, GUID_COMPARTMENT_SPEECH_STAGECHANGE, &dw, TRUE);
|
|
m_fStageVisible = dw ? TRUE : FALSE;
|
|
m_fStageTip = FALSE;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// internal API specially added for ctfmon
|
|
extern "C"
|
|
HRESULT WINAPI TF_CreateLangProfileUtil(ITfFnLangProfileUtil **ppFnLangUtil);
|
|
extern "C" HRESULT WINAPI TF_InvalidAssemblyListCacheIfExist();
|
|
|
|
void CSpeechUIServer::_EnsureSpeechProfile()
|
|
{
|
|
CLangProfileUtil *pCLangUtil = NULL;
|
|
CSapiIMX *pimx;
|
|
|
|
|
|
if (pimx = GetIMX())
|
|
{
|
|
pCLangUtil = SAFECAST(pimx, CLangProfileUtil *);
|
|
pCLangUtil->AddRef();
|
|
}
|
|
else
|
|
{
|
|
// ref gets added by the API
|
|
TF_CreateLangProfileUtil((ITfFnLangProfileUtil **)&pCLangUtil);
|
|
}
|
|
|
|
if (pCLangUtil)
|
|
{
|
|
// do this only once when profiles are not populated for the user
|
|
if(!pCLangUtil->_fUserInitializedProfile())
|
|
{
|
|
if (S_OK == pCLangUtil->RegisterActiveProfiles())
|
|
TF_InvalidAssemblyListCacheIfExist();
|
|
}
|
|
}
|
|
|
|
SafeRelease(pCLangUtil);
|
|
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// ShowUI
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDAPI CSpeechUIServer::ShowUI(BOOL fShow)
|
|
{
|
|
DWORD dwDictState = GetDictStatus();
|
|
|
|
if (fShow)
|
|
{
|
|
BOOL fOn = GetOnOff();
|
|
BOOL fDisabled = GetDisabled();
|
|
#ifdef TF_DISABLE_SPEECH
|
|
BOOL fDictationDisabled = GetDictationDisabled();
|
|
BOOL fCommandingDisabled = GetCommandingDisabled();
|
|
#endif
|
|
|
|
SetCompartmentDWORD(0, _tim,
|
|
GUID_COMPARTMENT_SPEECHUISHOWN,
|
|
TF_SPEECHUI_SHOWN,
|
|
FALSE);
|
|
|
|
AddItemMicrophone();
|
|
DisableItemMicrophone(fDisabled);
|
|
if (_pimx)
|
|
{
|
|
AddItemCfgMenuButton();
|
|
DisableItemCfgMenuButton(fDisabled);
|
|
|
|
if (!fDisabled)
|
|
{
|
|
SetCfgMenu(TRUE);
|
|
}
|
|
}
|
|
|
|
if (fOn)
|
|
{
|
|
DWORD dwUIState = GetUIStatus();
|
|
|
|
if (!(dwUIState & TF_DISABLE_BALLOON))
|
|
{
|
|
AddItemBalloon();
|
|
DisableItemBalloon(fDisabled);
|
|
}
|
|
else
|
|
RemoveItemBalloon();
|
|
|
|
AddItemCommanding();
|
|
AddItemDictation();
|
|
DisableItemCommanding(fDisabled || fCommandingDisabled);
|
|
DisableItemDictation(fDisabled || fDictationDisabled || !(dwDictState & TF_DICTATION_ENABLED));
|
|
ToggleItemCommanding((dwDictState & TF_COMMANDING_ON) ? TRUE : FALSE);
|
|
ToggleItemDictation((dwDictState & TF_DICTATION_ON) ? TRUE : FALSE);
|
|
}
|
|
else
|
|
{
|
|
RemoveItemBalloon();
|
|
RemoveItemCommanding();
|
|
RemoveItemDictation();
|
|
}
|
|
|
|
#ifdef CHANGE_MIC_TOOLTIP_ONTHEFLY
|
|
_ToggleMicrophone(fOn);
|
|
#else
|
|
ToggleItemMicrophone(fOn);
|
|
#endif
|
|
|
|
// Handle TTS Play & Stop Buttons
|
|
BOOL fTTSButtonEnable;
|
|
|
|
AddItemTtsPlayStop( );
|
|
AddItemTtsPauseResume( );
|
|
|
|
fTTSButtonEnable = GetTtsButtonStatus();
|
|
|
|
DisableItemTtsPlayStop( !fTTSButtonEnable );
|
|
DisableItemTtsPauseResume( !fTTSButtonEnable );
|
|
|
|
if ( fTTSButtonEnable )
|
|
{
|
|
BOOL fTTSPlayOn;
|
|
BOOL fTTSPauseOn;
|
|
|
|
fTTSPlayOn = GetTtsPlayOnOff( );
|
|
ToggleItemTtsPlayStop(fTTSPlayOn);
|
|
fTTSPauseOn = GetTtsPauseOnOff( );
|
|
ToggleItemTtsPauseResume(fTTSPauseOn);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
RemoveItemMicrophone();
|
|
SetCfgMenu(FALSE);
|
|
|
|
RemoveItemCfgMenuButton();
|
|
RemoveItemBalloon();
|
|
RemoveItemCommanding();
|
|
RemoveItemDictation();
|
|
RemoveItemTtsPlayStop( );
|
|
RemoveItemTtsPauseResume( );
|
|
|
|
SetCompartmentDWORD(0, _tim,
|
|
GUID_COMPARTMENT_SPEECHUISHOWN,
|
|
0, FALSE);
|
|
}
|
|
|
|
_fShown = fShow;
|
|
return S_OK;
|
|
}
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// UpdateBalloon
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CSpeechUIServer::UpdateBalloon(TfLBBalloonStyle style,
|
|
const WCHAR *pch,
|
|
ULONG cch)
|
|
{
|
|
UpdateBalloonAndTooltip(style, pch, cch, NULL, 0);
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// UpdateBalloonAndTooltip (internal method)
|
|
//
|
|
//
|
|
//
|
|
HRESULT CSpeechUIServer::UpdateBalloonAndTooltip
|
|
(
|
|
TfLBBalloonStyle style,
|
|
const WCHAR *pch,
|
|
ULONG cch,
|
|
const WCHAR *pchTooltip,
|
|
ULONG cchTooltip
|
|
)
|
|
{
|
|
// check if it has same style and string already
|
|
if ((_plbiBalloon && _plbiBalloon->NeedUpdate(style, pch)) || GetSystemMetrics(SM_TABLETPC) > 0)
|
|
{
|
|
|
|
// we don't pick up out proc tooltip
|
|
if (pchTooltip && _plbiBalloon)
|
|
_plbiBalloon->SetToolTip((WCHAR *)pchTooltip);
|
|
|
|
// this is a private channel for non-cicero UI plugin
|
|
// they pick up this global compartment notification,
|
|
// and store the string for displaying what's set to
|
|
// any of the balloon objects in the system by Cicero apps.
|
|
// it should be deleted right after sent to non-cicero threads
|
|
// to avoid ref count management
|
|
//
|
|
if (m_hAtom)
|
|
{
|
|
GlobalDeleteAtom(m_hAtom);
|
|
}
|
|
|
|
m_hAtom = GlobalAddAtomW(pch);
|
|
if (m_hAtom && _tim)
|
|
{
|
|
DWORD dw;
|
|
|
|
dw = m_hAtom + (style << 16);
|
|
SetCompartmentDWORD(0, _tim, GUID_COMPARTMENT_SHARED_BLN_TEXT, dw, TRUE);
|
|
}
|
|
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CSpeechUIServer::SetBalloonSAPIInitFlag(BOOL fSet)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if (_plbiBalloon)
|
|
{
|
|
_plbiBalloon->SetToFireInitializeSAPI(fSet);
|
|
|
|
hr = S_OK;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
#ifdef CHANGE_MIC_TOOLTIP_ONTHEFLY
|
|
//
|
|
// ToggleMicrophone (internal method)
|
|
//
|
|
// synopsis: toggle microphone button and set tooltip accordingly
|
|
//
|
|
HRESULT CSpeechUIServer::_ToggleMicrophone(BOOL fOn)
|
|
{
|
|
if (!_plbiMicrophone)
|
|
return E_FAIL;
|
|
|
|
|
|
static WCHAR s_szTooltipOff[MAX_PATH] = {0};
|
|
static WCHAR s_szTooltipOn[MAX_PATH] = {0};
|
|
|
|
if (!s_szTooltipOff[0])
|
|
{
|
|
CicLoadStringWrapW(g_hInst, IDS_NUI_MICROPHONE_ON_TOOLTIP,
|
|
s_szTooltipOff,
|
|
ARRAYSIZE(s_szTooltipOff));
|
|
}
|
|
if (!s_szTooltipOn[0])
|
|
{
|
|
CicLoadStringWrapW(g_hInst, IDS_NUI_MICROPHONE_OFF_TOOLTIP,
|
|
s_szTooltipOn,
|
|
ARRAYSIZE(s_szTooltipOn));
|
|
}
|
|
|
|
WCHAR szMicTooltip[MAX_PATH];
|
|
|
|
StringCchCopyW(szMicTooltip, ARRAYSIZE(szMicTooltip), fOn ? s_szTooltipOn : s_szTooltipOff);
|
|
|
|
_plbiMicrophone->SetToolTip((WCHAR *)szMicTooltip);
|
|
|
|
_plbiMicrophone->SetOrClearStatus(TF_LBI_STATUS_BTN_TOGGLED, fOn);
|
|
if (_plbiMicrophone->GetSink())
|
|
_plbiMicrophone->GetSink()->OnUpdate(TF_LBI_STATUS);
|
|
|
|
return S_OK;
|
|
}
|
|
#endif
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// _CompEventSinkCallback (static)
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT CSpeechUIServer::_CompEventSinkCallback(void *pv, REFGUID rguid)
|
|
{
|
|
CSpeechUIServer *_this = (CSpeechUIServer *)pv;
|
|
|
|
if ((IsEqualGUID(rguid, GUID_COMPARTMENT_SPEECH_OPENCLOSE)) ||
|
|
(IsEqualGUID(rguid, GUID_COMPARTMENT_SPEECH_DISABLED)) ||
|
|
(IsEqualGUID(rguid, GUID_COMPARTMENT_TTS_STATUS)))
|
|
{
|
|
if (IsEqualGUID(rguid, GUID_COMPARTMENT_SPEECH_OPENCLOSE))
|
|
{
|
|
TraceMsg(TF_SAPI_PERF, "GUID_COMPARTMENT_SPEECH_OPENCLOSE to be handled in NUI");
|
|
}
|
|
|
|
_this->ShowUI(_this->_fShown);
|
|
|
|
if (IsEqualGUID(rguid, GUID_COMPARTMENT_SPEECH_OPENCLOSE))
|
|
{
|
|
TraceMsg(TF_SAPI_PERF, "GUID_COMPARTMENT_SPEECH_OPENCLOSE is handled in NUI ::ShowUI");
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
else if (IsEqualGUID(rguid, GUID_COMPARTMENT_SPEECH_GLOBALSTATE))
|
|
{
|
|
HRESULT hr = S_OK;
|
|
BOOL fFocus;
|
|
if ( (S_OK == _this->_tim->IsThreadFocus(&fFocus) && fFocus) ||
|
|
S_OK == _this->IsActiveThread())
|
|
{
|
|
// We switch states immediately if we have focus or we are the active thread.
|
|
// This allows the stage speech tip instance to turn on/off dictation at the correct time
|
|
// and allows other speech tip instances to turn on C&C only if they have focus (since the
|
|
// stage application does not care about focus-based C&C).
|
|
DWORD dwLocal, dwGlobal;
|
|
GetCompartmentDWORD(_this->_tim, GUID_COMPARTMENT_SPEECH_DICTATIONSTAT, &dwLocal, FALSE);
|
|
GetCompartmentDWORD(_this->_tim, GUID_COMPARTMENT_SPEECH_GLOBALSTATE, &dwGlobal, TRUE);
|
|
dwGlobal = dwGlobal & (TF_DICTATION_ON + TF_COMMANDING_ON);
|
|
if ( (dwLocal&(TF_DICTATION_ON + TF_COMMANDING_ON)) != dwGlobal)
|
|
{
|
|
dwLocal = (dwLocal & ~(TF_DICTATION_ON + TF_COMMANDING_ON)) + dwGlobal;
|
|
SetCompartmentDWORD(0, _this->_tim, GUID_COMPARTMENT_SPEECH_DICTATIONSTAT, dwLocal, FALSE);
|
|
}
|
|
}
|
|
_this->ShowUI(_this->_fShown);
|
|
return hr;
|
|
}
|
|
else if (IsEqualGUID(rguid, GUID_COMPARTMENT_SPEECH_UI_STATUS))
|
|
{
|
|
DWORD dwDictState = _this->GetDictStatus();
|
|
BOOL fOn = _this->GetOnOff();
|
|
DWORD dwUIState = _this->GetUIStatus();
|
|
|
|
if (fOn &&
|
|
(dwDictState & (TF_DICTATION_ENABLED | TF_COMMANDING_ENABLED)) &&
|
|
!(dwUIState & TF_DISABLE_BALLOON))
|
|
{
|
|
BOOL fDisabled = _this->GetDisabled();
|
|
_this->AddItemBalloon();
|
|
_this->DisableItemBalloon(fDisabled);
|
|
}
|
|
else
|
|
_this->RemoveItemBalloon();
|
|
|
|
if (fOn && !(dwUIState & TF_DISABLE_BALLOON))
|
|
{
|
|
// when balloon is shown and
|
|
// for the first time commanding is set on,
|
|
// we show "Begin Voice Command" as a hint
|
|
// that now user can start speaking
|
|
//
|
|
if (!_this->m_fCommandingReady &&
|
|
(dwDictState & TF_COMMANDING_ON))
|
|
{
|
|
|
|
WCHAR sz[128];
|
|
sz[0] = '\0';
|
|
CicLoadStringWrapW(g_hInst, IDS_NUI_BEGINVOICECMD, sz, ARRAYSIZE(sz));
|
|
|
|
_this->UpdateBalloon(TF_LB_BALLOON_RECO, sz , -1);
|
|
_this->m_fCommandingReady = TRUE;
|
|
}
|
|
}
|
|
}
|
|
else if (IsEqualGUID(rguid, GUID_COMPARTMENT_SHARED_BLN_TEXT))
|
|
{
|
|
if (_this->_plbiBalloon&&
|
|
!(TF_LBI_STATUS_HIDDEN & _this->_plbiBalloon->GetStatusInternal()))
|
|
{
|
|
DWORD dw;
|
|
|
|
if (SUCCEEDED(GetCompartmentDWORD(_this->_tim, rguid, &dw, TRUE)))
|
|
{
|
|
ATOM hAtom = (WORD)dw & 0xffff;
|
|
WCHAR szAtom[MAX_PATH] = {0};
|
|
TfLBBalloonStyle style;
|
|
|
|
style = (TfLBBalloonStyle) (dw >> 16);
|
|
|
|
GlobalGetAtomNameW(hAtom, szAtom, ARRAYSIZE(szAtom));
|
|
|
|
_this->_plbiBalloon->Set(style, szAtom);
|
|
|
|
if (_this->_plbiBalloon->GetSink())
|
|
{
|
|
_this->_plbiBalloon->GetSink()->OnUpdate(TF_LBI_BALLOON);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// TABLETPC
|
|
else if (IsEqualGUID(rguid, GUID_COMPARTMENT_SPEECH_STAGE))
|
|
{
|
|
_this->m_fStageTip = TRUE;
|
|
}
|
|
else if (IsEqualGUID(rguid, GUID_COMPARTMENT_SPEECH_STAGECHANGE))
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DWORD dw;
|
|
|
|
GetCompartmentDWORD(_this->_tim, GUID_COMPARTMENT_SPEECH_STAGECHANGE, &dw, TRUE);
|
|
_this->m_fStageVisible = dw ? TRUE:FALSE;
|
|
}
|
|
// TABLETPC
|
|
return S_FALSE;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CLBarItemMicrophone
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// ctor
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CLBarItemMicrophone::CLBarItemMicrophone(CSpeechUIServer *psus)
|
|
{
|
|
Dbg_MemSetThisName(TEXT("CLBarItemMicrophone"));
|
|
|
|
_psus = psus;
|
|
InitNuiInfo(CLSID_SYSTEMLANGBARITEM_SPEECH,
|
|
GUID_LBI_SAPILAYR_MICROPHONE,
|
|
TF_LBI_STYLE_HIDDENSTATUSCONTROL
|
|
| TF_LBI_STYLE_BTN_TOGGLE
|
|
| TF_LBI_STYLE_SHOWNINTRAY,
|
|
SORT_MICROPHONE,
|
|
CRStr(IDS_NUI_MICROPHONE_TOOLTIP));
|
|
|
|
SetToolTip(CRStr(IDS_NUI_MICROPHONE_TOOLTIP));
|
|
SetText(CRStr(IDS_NUI_MICROPHONE_TEXT));
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// dtor
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CLBarItemMicrophone::~CLBarItemMicrophone()
|
|
{
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetIcon
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CLBarItemMicrophone::GetIcon(HICON *phIcon)
|
|
{
|
|
if (!phIcon)
|
|
return E_INVALIDARG;
|
|
|
|
TraceMsg(TF_SAPI_PERF, "Microphone::GetIcon is called");
|
|
*phIcon = LoadSmIcon(g_hInst, MAKEINTRESOURCE(ID_ICON_MICROPHONE));
|
|
return S_OK;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// OnLButtonUp
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
HRESULT CLBarItemMicrophone::OnLButtonUp(const POINT pt, const RECT *prcArea)
|
|
{
|
|
TraceMsg(TF_SAPI_PERF, "Microphone button is hit");
|
|
return ToggleCompartmentDWORD(0,
|
|
_psus->GetTIM(),
|
|
GUID_COMPARTMENT_SPEECH_OPENCLOSE,
|
|
TRUE);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CLBarItemCfgmenuButton
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// ctor
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CLBarItemCfgMenuButton::CLBarItemCfgMenuButton(CSpeechUIServer *psus)
|
|
{
|
|
Dbg_MemSetThisName(TEXT("CLBarItemCfgMenuButton"));
|
|
|
|
_psus = psus;
|
|
InitNuiInfo(CLSID_SYSTEMLANGBARITEM_SPEECH,
|
|
GUID_LBI_SAPILAYR_CFGMENUBUTTON,
|
|
TF_LBI_STYLE_BTN_MENU,
|
|
SORT_CFGMENUBUTTON,
|
|
CRStr(IDS_NUI_CFGMENU_TOOLTIP));
|
|
|
|
SetToolTip(CRStr(IDS_NUI_CFGMENU_TOOLTIP));
|
|
SetText(CRStr(IDS_NUI_CFGMENU_TEXT));
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// dtor
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CLBarItemCfgMenuButton::~CLBarItemCfgMenuButton()
|
|
{
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetIcon
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CLBarItemCfgMenuButton::GetIcon(HICON *phIcon)
|
|
{
|
|
if (!phIcon)
|
|
return E_INVALIDARG;
|
|
|
|
*phIcon = LoadSmIcon(g_hInst, MAKEINTRESOURCE(ID_ICON_CFGMENU));
|
|
return S_OK;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// InitMenu
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CLBarItemCfgMenuButton::InitMenu(ITfMenu *pMenu)
|
|
{
|
|
UINT nTipCurMenuID = IDM_CUSTOM_MENU_START;
|
|
_InsertCustomMenus(pMenu, &nTipCurMenuID);
|
|
|
|
CSapiIMX::_SysLBarCallback(IDSLB_INITMENU, _psus->GetIMX(), pMenu, 0);
|
|
return S_OK;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// OnMenuSelect
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CLBarItemCfgMenuButton::OnMenuSelect(UINT uID)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if (uID >= IDM_CUSTOM_MENU_START)
|
|
hr = CLBarItemSystemButtonBase::OnMenuSelect(uID);
|
|
else
|
|
hr = CSapiIMX::_SysLBarCallback(IDSLB_ONMENUSELECT, _psus->GetIMX(), NULL, uID);
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CLBarItemBalloon
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// ctor
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CLBarItemBalloon::CLBarItemBalloon(CSpeechUIServer *psus)
|
|
{
|
|
Dbg_MemSetThisName(TEXT("CLBarItemBalloon"));
|
|
|
|
_psus = psus;
|
|
InitNuiInfo(CLSID_SYSTEMLANGBARITEM_SPEECH,
|
|
GUID_LBI_SAPILAYR_BALLOON,
|
|
0,
|
|
SORT_BALLOON,
|
|
CRStr(IDS_NUI_BALLOON_TEXT));
|
|
|
|
SIZE size;
|
|
size.cx = 100;
|
|
size.cy = 16;
|
|
SetPreferedSize(&size);
|
|
SetToolTip(CRStr(IDS_NUI_BALLOON_TOOLTIP));
|
|
|
|
// by default Balloon is hidden.
|
|
// SetStatusInternal(TF_LBI_STATUS_HIDDEN);
|
|
|
|
m_fFireInitializeSapi = FALSE;
|
|
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// dtor
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CLBarItemBalloon::~CLBarItemBalloon()
|
|
{
|
|
if (_bstrText)
|
|
SysFreeString(_bstrText);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetBalloonInfo
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CLBarItemBalloon::GetBalloonInfo(TF_LBBALLOONINFO *pInfo)
|
|
{
|
|
pInfo->style = _style;
|
|
pInfo->bstrText = SysAllocString(_bstrText);
|
|
|
|
//
|
|
// If the flag is set, we're asked to fire an event to set
|
|
// a timer to start SAPI intialization
|
|
//
|
|
if (m_fFireInitializeSapi)
|
|
{
|
|
// turns the flag off
|
|
SetToFireInitializeSAPI(FALSE);
|
|
|
|
TraceMsg(TF_SAPI_PERF, "GetBalloonInfo is called");
|
|
|
|
CSapiIMX *pimx = _psus->GetIMX();
|
|
if (pimx)
|
|
{
|
|
pimx->_EnsureWorkerWnd();
|
|
|
|
SetTimer(pimx->_GetWorkerWnd(), TIMER_ID_OPENCLOSE, 100, NULL);
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Set
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CLBarItemBalloon::Set(TfLBBalloonStyle style, const WCHAR *psz)
|
|
{
|
|
if (_bstrText)
|
|
SysFreeString(_bstrText);
|
|
|
|
_bstrText = SysAllocString(psz);
|
|
if (_bstrText)
|
|
{
|
|
SetToolTip(_bstrText);
|
|
}
|
|
|
|
_style = style;
|
|
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CLBarItemDictation
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// ctor
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CLBarItemDictation::CLBarItemDictation(CSpeechUIServer *psus)
|
|
{
|
|
Dbg_MemSetThisName(TEXT("CLBarItemDictation"));
|
|
|
|
_psus = psus;
|
|
InitNuiInfo(CLSID_SYSTEMLANGBARITEM_SPEECH,
|
|
GUID_LBI_SAPILAYR_DICTATION,
|
|
TF_LBI_STYLE_BTN_TOGGLE,
|
|
SORT_DICTATION,
|
|
CRStr(IDS_NUI_DICTATION_TOOLTIP));
|
|
|
|
SetToolTip(CRStr(IDS_NUI_DICTATION_TOOLTIP));
|
|
SetText(CRStr(IDS_NUI_DICTATION_TEXT));
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// dtor
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CLBarItemDictation::~CLBarItemDictation()
|
|
{
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetIcon
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CLBarItemDictation::GetIcon(HICON *phIcon)
|
|
{
|
|
if (!phIcon)
|
|
return E_INVALIDARG;
|
|
|
|
*phIcon = LoadSmIcon(g_hInst, MAKEINTRESOURCE(ID_ICON_DICTATION));
|
|
return S_OK;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// OnLButtonUp
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
HRESULT CLBarItemDictation::OnLButtonUp(const POINT pt, const RECT *prcArea)
|
|
{
|
|
_psus->SetDictStatus();
|
|
return S_OK;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CLBarItemCommanding
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// ctor
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CLBarItemCommanding::CLBarItemCommanding(CSpeechUIServer *psus)
|
|
{
|
|
Dbg_MemSetThisName(TEXT("CLBarItemCommanding"));
|
|
|
|
_psus = psus;
|
|
InitNuiInfo(CLSID_SYSTEMLANGBARITEM_SPEECH,
|
|
GUID_LBI_SAPILAYR_COMMANDING,
|
|
TF_LBI_STYLE_BTN_TOGGLE,
|
|
SORT_COMMANDING,
|
|
CRStr(IDS_NUI_COMMANDING_TOOLTIP));
|
|
|
|
SetToolTip(CRStr(IDS_NUI_COMMANDING_TOOLTIP));
|
|
SetText(CRStr(IDS_NUI_COMMANDING_TEXT));
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// dtor
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CLBarItemCommanding::~CLBarItemCommanding()
|
|
{
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetIcon
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CLBarItemCommanding::GetIcon(HICON *phIcon)
|
|
{
|
|
if (!phIcon)
|
|
return E_INVALIDARG;
|
|
|
|
*phIcon = LoadSmIcon(g_hInst, MAKEINTRESOURCE(ID_ICON_COMMANDING));
|
|
return S_OK;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// OnLButtonUp
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
HRESULT CLBarItemCommanding::OnLButtonUp(const POINT pt, const RECT *prcArea)
|
|
{
|
|
_psus->SetCmdStatus();
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CLBarItemTtsPlayStop
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// ctor
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CLBarItemTtsPlayStop::CLBarItemTtsPlayStop(CSpeechUIServer *psus)
|
|
{
|
|
Dbg_MemSetThisName(TEXT("CLBarItemTtsPlayStop"));
|
|
|
|
_psus = psus;
|
|
InitNuiInfo(CLSID_SYSTEMLANGBARITEM_SPEECH,
|
|
GUID_LBI_SAPILAYR_TTS_PLAY_STOP,
|
|
TF_LBI_STYLE_BTN_TOGGLE | TF_LBI_STYLE_HIDDENBYDEFAULT,
|
|
SORT_TTSPLAYSTOP,
|
|
CRStr(IDS_NUI_TTSPLAY_TOOLTIP));
|
|
|
|
SetToolTip(CRStr(IDS_NUI_TTSPLAY_TOOLTIP));
|
|
SetText(CRStr(IDS_NUI_TTSPLAY_TEXT));
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// dtor
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CLBarItemTtsPlayStop::~CLBarItemTtsPlayStop()
|
|
{
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetIcon
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CLBarItemTtsPlayStop::GetIcon(HICON *phIcon)
|
|
{
|
|
BOOL fTTSPlayOn;
|
|
|
|
if (!phIcon)
|
|
return E_INVALIDARG;
|
|
|
|
if (!_psus) return E_FAIL;
|
|
|
|
fTTSPlayOn = _psus->GetTtsPlayOnOff( );
|
|
|
|
if ( fTTSPlayOn )
|
|
{
|
|
*phIcon = LoadSmIcon(g_hInst, MAKEINTRESOURCE(ID_ICON_TTSSTOP));
|
|
}
|
|
else
|
|
{
|
|
*phIcon = LoadSmIcon(g_hInst, MAKEINTRESOURCE(ID_ICON_TTSPLAY));
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// OnLButtonUp
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
HRESULT CLBarItemTtsPlayStop::OnLButtonUp(const POINT pt, const RECT *prcArea)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CSapiIMX *pimx;
|
|
|
|
if ( _psus == NULL) return E_FAIL;
|
|
|
|
pimx = _psus->GetIMX();
|
|
|
|
if ( pimx )
|
|
{
|
|
hr = pimx->_HandleEventOnPlayButton( );
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
// +-------------------------------------------------------------------------
|
|
//
|
|
// UpdateStatus
|
|
//
|
|
// Update the text, tooltips, and icons based on current Play/Stop
|
|
// button's status.
|
|
// +-------------------------------------------------------------------------
|
|
|
|
HRESULT CLBarItemTtsPlayStop::UpdateStatus( )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
BOOL fTTSPlayOn;
|
|
|
|
if (!_psus) return E_FAIL;
|
|
|
|
fTTSPlayOn = _psus->GetTtsPlayOnOff( );
|
|
|
|
if ( fTTSPlayOn ) // Toggled status
|
|
{
|
|
SetToolTip(CRStr(IDS_NUI_TTSSTOP_TOOLTIP));
|
|
SetText(CRStr(IDS_NUI_TTSSTOP_TEXT));
|
|
}
|
|
else
|
|
{
|
|
SetToolTip(CRStr(IDS_NUI_TTSPLAY_TOOLTIP));
|
|
SetText(CRStr(IDS_NUI_TTSPLAY_TEXT));
|
|
}
|
|
|
|
if ( GetSink( ) )
|
|
GetSink( )->OnUpdate(TF_LBI_ICON | TF_LBI_TEXT | TF_LBI_TOOLTIP);
|
|
|
|
// Update the toolbar command grammar to use the new tooltip text
|
|
// Speak Text or Stop speaking
|
|
|
|
CSapiIMX *pImx;
|
|
|
|
pImx = _psus->GetIMX( );
|
|
|
|
if ( pImx)
|
|
{
|
|
CSpTask *psp;
|
|
|
|
pImx->GetSpeechTask(&psp);
|
|
if (psp)
|
|
{
|
|
if ( psp->m_pLangBarSink )
|
|
(psp->m_pLangBarSink)->OnThreadItemChange(0);
|
|
|
|
psp->Release();
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CLBarItemTtsPauseResume
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// ctor
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CLBarItemTtsPauseResume::CLBarItemTtsPauseResume(CSpeechUIServer *psus)
|
|
{
|
|
Dbg_MemSetThisName(TEXT("CLBarItemTtsPauseResume"));
|
|
|
|
_psus = psus;
|
|
InitNuiInfo(CLSID_SYSTEMLANGBARITEM_SPEECH,
|
|
GUID_LBI_SAPILAYR_TTS_PAUSE_RESUME,
|
|
TF_LBI_STYLE_BTN_TOGGLE | TF_LBI_STYLE_HIDDENBYDEFAULT,
|
|
SORT_TTSPAUSERESUME,
|
|
CRStr(IDS_NUI_TTSPAUSE_TOOLTIP));
|
|
|
|
SetToolTip(CRStr(IDS_NUI_TTSPAUSE_TOOLTIP));
|
|
SetText(CRStr(IDS_NUI_TTSPAUSE_TEXT));
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// dtor
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CLBarItemTtsPauseResume::~CLBarItemTtsPauseResume()
|
|
{
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// GetIcon
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI CLBarItemTtsPauseResume::GetIcon(HICON *phIcon)
|
|
{
|
|
if (!phIcon)
|
|
return E_INVALIDARG;
|
|
|
|
*phIcon = LoadSmIcon(g_hInst, MAKEINTRESOURCE(ID_ICON_TTSPAUSE));
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// OnLButtonUp
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
HRESULT CLBarItemTtsPauseResume::OnLButtonUp(const POINT pt, const RECT *prcArea)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CSapiIMX *pimx;
|
|
|
|
if ( _psus == NULL) return E_FAIL;
|
|
|
|
pimx = _psus->GetIMX();
|
|
|
|
if (pimx)
|
|
{
|
|
hr = pimx->_HandleEventOnPauseButton( );
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
// +-------------------------------------------------------------------------
|
|
//
|
|
// UpdateStatus
|
|
//
|
|
// Update text, tooltips, icons for Pause/Resume buttons
|
|
// based on current status.
|
|
// +-------------------------------------------------------------------------
|
|
|
|
HRESULT CLBarItemTtsPauseResume::UpdateStatus( )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
BOOL fTTSPauseOn;
|
|
|
|
if (!_psus) return E_FAIL;
|
|
|
|
fTTSPauseOn = _psus->GetTtsPauseOnOff( );
|
|
|
|
if ( fTTSPauseOn ) // Toggled status
|
|
{
|
|
SetToolTip(CRStr(IDS_NUI_TTSRESUME_TOOLTIP));
|
|
SetText(CRStr(IDS_NUI_TTSRESUME_TEXT));
|
|
}
|
|
else
|
|
{
|
|
SetToolTip(CRStr(IDS_NUI_TTSPAUSE_TOOLTIP));
|
|
SetText(CRStr(IDS_NUI_TTSPAUSE_TEXT));
|
|
}
|
|
|
|
if ( GetSink( ) )
|
|
GetSink( )->OnUpdate(TF_LBI_TEXT | TF_LBI_TOOLTIP);
|
|
|
|
// Update the toolbar command grammar to use the new tooltip text
|
|
// Pause Speaking or Resume speaking
|
|
|
|
CSapiIMX *pImx;
|
|
|
|
pImx = _psus->GetIMX( );
|
|
|
|
if ( pImx)
|
|
{
|
|
CSpTask *psp;
|
|
|
|
pImx->GetSpeechTask(&psp);
|
|
if (psp)
|
|
{
|
|
if ( psp->m_pLangBarSink )
|
|
(psp->m_pLangBarSink)->OnThreadItemChange(0);
|
|
|
|
psp->Release();
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|