/******************************************************************************
Function Name : nParseTSFile
Input(s) : CString omstrTSFile
Output : INT
Functionality : Load the omStrTSFille
Member of : CTestSetupEntity
Friend of : -
Author(s) : Venkatanarayana Makam
Date Created : 06/04/2011
Modifications :
Codetag : CS002
******************************************************************************/
INT CTestSetupEntity::nParseTSFile(CString omstrTSFile)
{
MSXML2::IXMLDOMDocumentPtr pIDOMDoc;
HRESULT hr = pIDOMDoc.CreateInstance(L"Msxml2.DOMDocument");
if ( FAILED(hr) )
{
throw "Unable to create XML parser object";
}
if(PathFileExists(omstrTSFile) == FALSE)
{
return ERR_PATH_INCORRECT;
}
//Create A TestSetup DOM document
CComVariant varFileName((LPCSTR)omstrTSFile);
try
{
pIDOMDoc->load(varFileName);
//GetTest Setup Title
MSXML2::IXMLDOMNodePtr pIDOMTiltleNode;
_bstr_t bstrNodeName = def_STR_TSNODE_NAME;
CComVariant NodeValue;
pIDOMTiltleNode = pIDOMDoc->selectSingleNode(bstrNodeName);
MSXML2::IXMLDOMNamedNodeMapPtr pDOMTCAtrributes;
pDOMTCAtrributes = pIDOMTiltleNode->Getattributes();
MSXML2::IXMLDOMNodePtr pIDOMChildNode;
//bstrNodeName = def_STR_TSATTRIB_TITLE;
bstrNodeName.Assign(SysAllocString(CT2W(def_STR_TSATTRIB_TITLE)));
pIDOMChildNode = pDOMTCAtrributes->getNamedItem(bstrNodeName);
pIDOMChildNode->get_nodeTypedValue(&NodeValue);
m_omstrTestSetupTitle = strCopyBSTRToCString(NodeValue);
pIDOMChildNode.Release();
//Get Description
//bstrNodeName = def_STR_TSDESCRIPTION;
bstrNodeName.Assign(SysAllocString(CT2W(def_STR_TSDESCRIPTION)));
MSXML2::IXMLDOMNodePtr pIDOMDescriptionNode = pIDOMDoc->selectSingleNode(bstrNodeName);
pIDOMDescriptionNode->get_nodeTypedValue(&NodeValue);
m_omstrDescription = strCopyBSTRToCString(NodeValue);
//Get Header Node
//bstrNodeName = def_STR_TSHEADER;
bstrNodeName.Assign(SysAllocString(CT2W(def_STR_TSHEADER)));
MSXML2::IXMLDOMNodePtr pIDOMHeaderNode = pIDOMDoc->selectSingleNode(bstrNodeName);
nLoadHeader(pIDOMHeaderNode);
pIDOMHeaderNode.Release();
//Get TestCases List
//bstrNodeName = def_STR_TSTCLIST;
bstrNodeName.Assign(SysAllocString(CT2W(def_STR_TSTCLIST)));
MSXML2::IXMLDOMNodePtr pIDOMTSNode = pIDOMDoc->selectSingleNode(bstrNodeName);
GetData(pIDOMTSNode);
}
catch(...)
{
return S_FALSE;
}
return S_OK;
}
bool StillImage::RegisterApplication(HINSTANCE hInstace)
{
CComPtr<IStillImage> pSti = GetStillImage(hInstace);
if (pSti == 0)
return false;
return pSti->RegisterLaunchApplication(CT2W(GetAppName()), CT2W(GetExePath())) == S_OK;
}
/******************************************************************************
Function Name : GetData
Input(s) :
Output : HRESULT
Functionality :
Member of : CVerifyEntity
Friend of : -
Author(s) : Venkatanarayana Makam
Date Created : 06/04/2011
Modifications :
******************************************************************************/
HRESULT CVerifyEntity::GetCommonVerifyData(MSXML2::IXMLDOMNodePtr& pIDomNode, CVerifyData *verifyData)
{
m_ouData = verifyData;
_bstr_t bstrNodeName = def_STR_VERIFYMSG_NODE;
CComVariant NodeValue;
MSXML2::IXMLDOMNamedNodeMapPtr pDOMVerifyAtrributes;
MSXML2::IXMLDOMNodePtr pIDOMChildNode;
pDOMVerifyAtrributes = pIDomNode->Getattributes();
//bstrNodeName = L"failure";
bstrNodeName.Assign(SysAllocString(CT2W("failure")));
pIDOMChildNode = pDOMVerifyAtrributes->getNamedItem(bstrNodeName);
pIDOMChildNode->get_nodeTypedValue(&NodeValue);
CString strTemp;
strTemp = strCopyBSTRToCString(NodeValue);
//m_ouData = new CVerifyData();
if(strTemp == "SUCCESS")
{
m_ouData->m_eAttributeError = SUCCESS;
}
else if(strTemp == "WARNING")
{
m_ouData->m_eAttributeError = WARNING;
}
else if(strTemp == "ERRORS")
{
m_ouData->m_eAttributeError = ERRORS;
}
else
{
m_ouData->m_eAttributeError = FATAL;
}
MSXML2::IXMLDOMNodeListPtr pIDOMSendList;
LONG lCount;
//bstrNodeName = def_STR_VERIFYMSG_NODE;
bstrNodeName.Assign(SysAllocString(CT2W(def_STR_VERIFYMSG_NODE)));
pIDOMSendList = pIDomNode->selectNodes(bstrNodeName);
pIDOMSendList->get_length(&lCount);
for(int i = 0; i < lCount; i++)
{
CVerifySubEntity *odVerifySubEntity;
MSXML2::IXMLDOMNodePtr pIXMLDOMVerifyMsgEntity;
pIXMLDOMVerifyMsgEntity = pIDOMSendList->Getitem(i);
//if(CVerifySubEntity::GetData(&odVerifySubEntity, pIXMLDOMVerifyMsgEntity) == S_OK)
if(this->GetSubEntityData(&odVerifySubEntity, pIXMLDOMVerifyMsgEntity) == S_OK)
{
m_ouData->m_odVerifySubEntityList.push_back(odVerifySubEntity);
}
}
return S_OK;
}
/******************************************************************************
Function Name : GetData
Input(s) :
Output : HRESULT
Functionality :
Member of : CVerifyResponse
Friend of : -
Author(s) : Venkatanarayana Makam
Date Created : 06/04/2011
Modifications :
******************************************************************************/
HRESULT CVerifyResponse::GetData(MSXML2::IXMLDOMNodePtr& pIDomNode)
{
CVerifyEntity::GetData(pIDomNode);
_bstr_t bstrNodeName = def_STR_VERIFYMSG_NODE;
CComVariant NodeValue;
MSXML2::IXMLDOMNamedNodeMapPtr pDOMVerifyAtrributes;
MSXML2::IXMLDOMNodePtr pIDOMChildNode;
pDOMVerifyAtrributes = pIDomNode->Getattributes();
//bstrNodeName = def_STR_ATTRIB_WAITFOR;
bstrNodeName.Assign(SysAllocString(CT2W(def_STR_ATTRIB_WAITFOR)));
pIDOMChildNode = pDOMVerifyAtrributes->getNamedItem(bstrNodeName);
pIDOMChildNode->get_nodeTypedValue(&NodeValue);
CString strTemp;
strTemp = strCopyBSTRToCString(NodeValue);
//W4 Removal
m_ushDuration = (USHORT)atoi((LPCSTR)strTemp);
INT nCount = (INT)m_ouData.m_odVerify_MessageEntityList.GetCount();
for(int i = 0; i < nCount; i++)
{
CVerify_MessageData ouVerifyData;
POSITION pos = m_ouData.m_odVerify_MessageEntityList.FindIndex(i);
CVerify_MessageEntity& ouVerifyEntity = m_ouData.m_odVerify_MessageEntityList.GetAt(pos);
ouVerifyEntity.GetEntityData(VERIFY_MESSAGE, &ouVerifyData);
m_ouVerifyMsgMap[ouVerifyData.m_dwMessageID] = ouVerifyData;
}
return S_OK;
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
int CWsHook::GetAddrInfoW(PCWSTR pNodeName, PCWSTR pServiceName, const ADDRINFOW * pHints, PADDRINFOW * ppResult)
{
int ret = WSAEINVAL;
bool overrideDNS = false;
void * context = NULL;
CString name = CW2T(pNodeName);
CAtlArray<DWORD> addresses;
if( dlg && pNodeName )
overrideDNS = dlg->DnsLookupStart( name, context, addresses );
if( _GetAddrInfoW && !overrideDNS )
ret = _GetAddrInfoW(CT2W((LPCWSTR)name), pServiceName, pHints, ppResult);
else if( overrideDNS ) {
if( addresses.IsEmpty() )
ret = EAI_NONAME;
else {
// build the response structure with the addresses we looked up
ret = 0;
DWORD count = addresses.GetCount();
ADDRINFOW_ADDR * result = (ADDRINFOW_ADDR *)malloc(sizeof(ADDRINFOW_ADDR) * count);
for (DWORD i = 0; i < count; i++) {
memset( &result[i], 0, sizeof(ADDRINFOW_ADDR) );
result->info.ai_family = AF_INET;
result->info.ai_addrlen = sizeof(struct sockaddr_in);
result->info.ai_addr = (struct sockaddr *)&(result->addr);
result->addr.sin_family = AF_INET;
result->addr.sin_addr.S_un.S_addr = addresses[i];
if( i < count - 1 )
result->info.ai_next = (PADDRINFOW)&result[i+1];
}
addrInfo.AddTail(result);
*ppResult = (PADDRINFOW)result;
}
}
if (!ret && dlg) {
PADDRINFOW addr = *ppResult;
while (addr) {
if (addr->ai_canonname)
dlg->DnsLookupAlias(name, addr->ai_canonname);
if (context &&
addr->ai_addrlen >= sizeof(struct sockaddr_in) &&
addr->ai_family == AF_INET ) {
struct sockaddr_in * ipName = (struct sockaddr_in *)addr->ai_addr;
dlg->DnsLookupAddress(context, ipName->sin_addr);
}
addr = addr->ai_next;
}
if (context)
dlg->DnsLookupDone(context);
}
return ret;
}
/******************************************************************************
* EntryPaneProc *
*---------------*
* Description:
* Handles messages specifically for the entry pane.
*
******************************************************************************/
LRESULT EntryPaneProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
{
switch ( message )
{
case WM_INITPANE:
{
TCHAR tBuf[MAX_LOADSTRING];
LoadString( g_hInst, IDS_WELCOME, tBuf, MAX_LOADSTRING );
// Speak the welcome prompt, and do not wait for the operation to complete
g_cpVoice->Speak( CT2W(tBuf), SPF_ASYNC, NULL);
return ( 1 );
}
case WM_GOTOCOUNTER:
// Set the right message handler and repaint
g_fpCurrentPane = CounterPaneProc;
PostMessage( hWnd, WM_INITPANE, NULL, NULL );
InvalidateRect( hWnd, NULL, TRUE );
return ( 1 );
case WM_GOTOOFFICE:
// Set the right message handler and repaint
g_fpCurrentPane = OfficePaneProc;
PostMessage( hWnd, WM_INITPANE, NULL, NULL );
InvalidateRect( hWnd, NULL, TRUE );
return ( 1 );
case WM_PAINT:
EntryPanePaint( hWnd );
return ( 1 );
}
return ( 0 );
}
STDMETHODIMP CComPolygon::get_TextStyleName(BSTR * pVal)
{
CHECKOUTPARAM(pVal);
try
{
Acad::ErrorStatus es;
AcAxObjectRefPtr<AsdkPoly> pPoly(&m_objRef,AcDb::kForRead,Adesk::kTrue);
if((es=pPoly.openStatus()) != Acad::eOk)
throw es;
AcDbTextStyleTableRecordPointer pTextStyleRecord(pPoly->styleId(),AcDb::kForRead);
if((es=pTextStyleRecord.openStatus()) != Acad::eOk)
throw es;
const TCHAR* pName;
if ((es=pTextStyleRecord->getName(pName))!=Acad::eOk)
throw es;
USES_CONVERSION;
*pVal = ::SysAllocString(CT2W(pName));
}
catch(const Acad::ErrorStatus)
{
return Error(L"Failed to open object.",IID_IComPolygon,E_FAIL);
}
catch(const HRESULT hr)
{
return Error(L"Invalid argument.",IID_IComPolygon,hr);
}
return S_OK;
}
// 文件校验
bool CDownloadAndSetupThread::CheckDownLoadFile(LPCTSTR lpPath)
{
//std::list<std::wstring>::const_iterator it;
//for(it = UrlList.begin (); it != UrlList.end (); it ++)
{
#ifdef _UNICODE
CStringW str(lpPath);
if(!BankMdrVerifier::VerifyModule(str) )
{
return false;
}
#else
#error "why use ansi???"
USES_CONVERSION;
std::wstring wstr(CT2W(m_vecLocalFiles[j].c_str()));
CStringW str = wstring.c_str();
if(!BankMdrVerifier::VerifyModule(str) )
{
return false;
}
#endif
}
return true;
}
HBITMAP AtlLoadGdiplusImage(LPCTSTR lpszPath)
{
std::auto_ptr<Bitmap> pBitmap(new Bitmap(CT2W(lpszPath)));
HBITMAP hBitmap = 0;
pBitmap->GetHBITMAP(0, &hBitmap);
return hBitmap;
}
char* CStringToNPStringCharacters(const CString &str)
{
CStringW wstr = CT2W(str);
int nUTF8 = WideCharToMultiByte(CP_UTF8, 0, wstr, wstr.GetLength() + 1, NULL, 0, NULL, NULL);
if (nUTF8 == 0)
return NULL;
char* utf8str = (char *)NPN_MemAlloc(nUTF8);
WideCharToMultiByte(CP_UTF8, 0, wstr, wstr.GetLength() + 1, utf8str, nUTF8, NULL, NULL);
return utf8str;
}
bool StillImage::UnregisterApplication(HINSTANCE hInstace)
{
CComPtr<IStillImage> pSti = GetStillImage(hInstace);
if (pSti == 0)
return false;
USES_CONVERSION;
return pSti->UnregisterLaunchApplication(CT2W(GetAppName())) == S_OK;
}
bool CCheckSign::CheckFile(LPCTSTR lpszFile)
{
#ifdef _UNICODE
CStringW str(lpszFile);
return BankMdrVerifier::VerifyModule(str);
#else
#error "why use ansi???"
USES_CONVERSION;
std::wstring wstr(CT2W(lpszFile));
CStringW str = wstring.c_str();
return BankMdrVerifier::VerifyModule(str);
#endif
}
//OPM calls this function for each property to obtain a list of strings and cookies if they are available.
//For our textstyle property we would like to display all the textstyles currently available in the database.
//This function is declared on the IPerPropertyBrowsing interface. Our IOPMPropertyExtensionImpl
//class implements this member by reading the values in the OPM property map. (You set this up in your
//head file when you use BEGIN_OPMPROP_MAP, OPMPROP_ENTRY, END_OPMPROP_MAP macros.)
//Since we need a dynamic list of entries in this drop down list and a static map cannot implement this,
//we need to override this function a provide dynamic list of text styles to OPM.
STDMETHODIMP CComPolygon::GetPredefinedStrings(DISPID dispID, CALPOLESTR *pCaStringsOut, CADWORD *pCaCookiesOut)
{
if (dispID != DISPID_TEXTSTYLENAME)
return IOPMPropertyExtensionImpl<CComPolygon>::GetPredefinedStrings(dispID,pCaStringsOut,pCaCookiesOut);
USES_CONVERSION;
AcDbTextStyleTable* pTT;
AcDbDatabase *pDb = m_objRef.objectId().database();
if (NULL == pDb)
pDb = acdbHostApplicationServices()->workingDatabase();
if (pDb->getTextStyleTable(pTT,AcDb::kForRead)==Acad::eOk)
{
AcDbTextStyleTableIterator* pIter;
if (pTT->newIterator(pIter)==Acad::eOk)
{
long size = 0;
// Clear the array.
mObjectIdArray.removeAll();
for (pIter->start();!pIter->done();pIter->step())
size++;
pCaStringsOut->pElems = (LPOLESTR *)::CoTaskMemAlloc(sizeof(LPOLESTR) * size);
pCaCookiesOut->pElems = (DWORD *)::CoTaskMemAlloc(sizeof(DWORD) * size);
long i=0;
for (pIter->start();!pIter->done();pIter->step())
{
AcDbTextStyleTableRecord* pTTR;
if (pIter->getRecord(pTTR,AcDb::kForRead)!=Acad::eOk)
continue;
const TCHAR* pName = NULL;
if (pTTR->getName(pName)==Acad::eOk){
//we want to show the name of the textstyle as
//it appears in the database
pCaStringsOut->pElems[i] = ::SysAllocString(CT2W(pName));
pCaCookiesOut->pElems[i] = mObjectIdArray.append(pTTR->objectId());
}
pTTR->close();
i++;
}
pCaStringsOut->cElems = i;
pCaCookiesOut->cElems = i;
}
if (pIter)
delete pIter;
pTT->close();
}
return S_OK;
}
HRESULT CDefaultRecordGraphBuilder::CreateAudioSrcFilter(IBaseFilter** ppSrcFilter)
{
CHECK_POINTER_RETURN_VALUE_IF_FAIL(ppSrcFilter, E_POINTER);
HRESULT hr = E_FAIL;
CFSharePtr<FTL::CFDShowHardwareMgr> spAudioCaptureHardwareMgr(new FTL::CFDShowHardwareMgr());
DX_VERIFY_EXCEPT1(spAudioCaptureHardwareMgr->Refresh(&CLSID_AudioInputDeviceCategory), S_FALSE);
if (S_OK == hr)
{
CAtlStringW wstrAudioInputString;
if (m_Param.strAudioInputName.IsEmpty())
{
//get first -- TODO: use enum
FTL::HardwareMonikerInfoContainer& rHardwares = spAudioCaptureHardwareMgr->GetAllHardwares();
if (!rHardwares.empty())
{
wstrAudioInputString = (*rHardwares.begin())->wachFriendlyName;
//m_spAudioCaptureHardwareMgr->GetDefault
}
}
else
{
//User Save audio
wstrAudioInputString = CT2W(m_Param.strAudioInputName);
}
if (!wstrAudioInputString.IsEmpty())
{
CComPtr<IBaseFilter> spAudioSrcFilter;
DX_VERIFY(spAudioCaptureHardwareMgr->GetBindObject(wstrAudioInputString, IID_IBaseFilter, (void **)&spAudioSrcFilter));
if (SUCCEEDED(hr))
{
DX_VERIFY(m_spGraphBuilder->AddFilter(spAudioSrcFilter, wstrAudioInputString));
if (SUCCEEDED(hr))
{
*ppSrcFilter = spAudioSrcFilter.Detach();
//(*ppSrcFilter)->AddRef();
}
}
else
{
//maybe user change audio device ?
}
}
}
return hr;
}
void SZYamlDocument::_EncodeText(LPCTSTR lpszSrc, CStringA &strTextOut, UINT uCodePage)
{
int nBOMType;
for (nBOMType = 0; nBOMType < nBOMFlagCount - 1; nBOMType ++)
{
if (BOMFlags[nBOMType].uMultiByteCodePage == uCodePage)
break;
}
strTextOut = BOMFlags[nBOMType].pszBOM;
if (BOMFlags[nBOMType].bIsMutibyte)
strTextOut += CT2A(lpszSrc, uCodePage);
else
strTextOut += CT2W((LPCWSTR)lpszSrc, uCodePage);
}
STDMETHODIMP CComPolygon::get_TextString(BSTR * pVal)
{
CHECKOUTPARAM(pVal);
try
{
Acad::ErrorStatus es;
AcAxObjectRefPtr<AsdkPoly> pPoly(&m_objRef,AcDb::kForRead,Adesk::kTrue);
if((es=pPoly.openStatus()) != Acad::eOk)
throw es;
USES_CONVERSION;
*pVal = SysAllocString(CT2W(pPoly->name()));
}
catch(const Acad::ErrorStatus)
{
return Error(L"Failed to open object",IID_IComPolygon,E_FAIL);
}
return S_OK;
}
void CUnicodeFile::Write(const TCHAR* data)
{
std::string convertedData;
std::wstring convertedWideData;
switch(m_encoding)
{
case ENCODING_UTF_16:
convertedWideData = CT2W(data);
break;
case ENCODING_UTF_8:
convertedData = CT2A(data, CP_UTF8);
break;
case ENCODING_ANSI:
default:
convertedData = CT2A(data);
break;
}
DWORD bytesWritten;
if(m_encoding==ENCODING_UTF_16)
{
unsigned writeSize = convertedWideData.length()*sizeof(wchar_t);
m_file.Write(convertedWideData.c_str(), writeSize, &bytesWritten);
ATLASSERT(bytesWritten == writeSize);
}
else
{
unsigned dataLength = convertedData.length();
for(unsigned int i = 0; i < dataLength; i += BLOCKSIZE)
{
unsigned int writeSize = dataLength - i;
if (writeSize > BLOCKSIZE)
writeSize = BLOCKSIZE;
m_file.Write(convertedData.c_str() + i, writeSize, &bytesWritten);
ATLASSERT(bytesWritten == writeSize);
}
}
}
/******************************************************************************
Function Name : GetData
Input(s) : MSXML2::IXMLDOMNodePtr& pIDomNode
Output : HRESULT
Functionality :
Member of : CWaitEntity
Friend of : -
Author(s) : Venkatanarayana Makam
Date Created : 06/04/2011
Modifications :
******************************************************************************/
HRESULT CWaitEntity::GetData(MSXML2::IXMLDOMNodePtr& pIDomNode)
{
_bstr_t bstrNodeName;
CComVariant NodeValue;
MSXML2::IXMLDOMNamedNodeMapPtr pDOMWaitAtrributes;
pDOMWaitAtrributes = pIDomNode->Getattributes();
MSXML2::IXMLDOMNodePtr pIDOMChildNode;
//bstrNodeName = L"purpose";
bstrNodeName.Assign(SysAllocString(CT2W("purpose")));
pIDOMChildNode = pDOMWaitAtrributes->getNamedItem(bstrNodeName);
pIDOMChildNode->get_nodeTypedValue(&NodeValue);
m_ouData.m_omPurpose = strCopyBSTRToCString(NodeValue);
pIDomNode->get_nodeTypedValue(&NodeValue);
CString strTemp;
strTemp = strCopyBSTRToCString(NodeValue);
//W4 Removal - Type Conversion No problem.
m_ouData.m_ushDuration = (USHORT)atoi((LPCSTR)strTemp);
pIDOMChildNode.Release();
pDOMWaitAtrributes.Release();
return S_OK;
}
//OPM calls this function when the user selects an element from a drop down list. OPM provides
//the cookie that we associated with the element in the GetPredefinedStrings function. We are
//responsible for mapping this cookie back to a value that the properties corresponding put_ function
//can understand.
//In this particular case all we need to do is to provide the name of the text style as
//the put_TextStyle method needs that.
STDMETHODIMP CComPolygon::GetPredefinedValue(DISPID dispID, DWORD dwCookie, VARIANT *pVarOut)
{
if (dispID != DISPID_TEXTSTYLENAME)
return IOPMPropertyExtensionImpl<CComPolygon>::GetPredefinedValue(dispID,dwCookie, pVarOut);
USES_CONVERSION;
assert((INT_PTR)dwCookie >= 0);
assert((INT_PTR)dwCookie < mObjectIdArray.length());
AcDbObjectId id = mObjectIdArray[dwCookie];
assert(!id.isNull());
AcDbTextStyleTableRecord* pTTR;
HRESULT hr = S_OK;
if (acdbOpenObject(pTTR,id,AcDb::kForRead)!=Acad::eOk)
return E_FAIL;
const TCHAR* pName = NULL;
if (pTTR->getName(pName)==Acad::eOk)
::VariantCopy(pVarOut,&CComVariant(CT2W(pName)));
else
hr = E_FAIL;
pTTR->close();
return hr;
}
/******************************************************************************
Function Name : GetData
Input(s) : MSXML2::IXMLDOMNodePtr& pIDomNode
Output : HRESULT
Functionality : Fills the datastructure from the XML node
Member of : CTestCaseEntity
Friend of : -
Author(s) : Venkatanarayana Makam
Date Created : 06/04/2011
Modifications :
******************************************************************************/
HRESULT CTestCaseEntity::GetData(MSXML2::IXMLDOMNodePtr& pIDomNode)
{
//Getting Attributes
_bstr_t bstrNodeName;
CComVariant NodeValue;
MSXML2::IXMLDOMNamedNodeMapPtr pDOMTCAtrributes;
pDOMTCAtrributes = pIDomNode->Getattributes();
MSXML2::IXMLDOMNodePtr pIDOMChildNode;
//bstrNodeName = L"identifier";
bstrNodeName.Assign(SysAllocString(CT2W("identifier")));
pIDOMChildNode = pDOMTCAtrributes->getNamedItem(bstrNodeName);
pIDOMChildNode->get_nodeTypedValue(&NodeValue);
m_ouData.m_omID = strCopyBSTRToCString(NodeValue);
pIDOMChildNode.Release();
//bstrNodeName = L"title";
bstrNodeName.Assign(SysAllocString(CT2W("title")));
pIDOMChildNode = pDOMTCAtrributes->getNamedItem(bstrNodeName);
pIDOMChildNode->get_nodeTypedValue(&NodeValue);
m_ouData.m_omTitle = strCopyBSTRToCString(NodeValue);
pIDOMChildNode.Release();
//bstrNodeName = L"exp_handler";
bstrNodeName.Assign(SysAllocString(CT2W("exp_handler")));
pIDOMChildNode = pDOMTCAtrributes->getNamedItem(bstrNodeName);
pIDOMChildNode->get_nodeTypedValue(&NodeValue);
CString strTemp;
strTemp = strCopyBSTRToCString(NodeValue);
pIDOMChildNode.Release();
if(strTemp == "CONTINUE")
{
m_ouData.m_eExcpAction = CONTINUE;
}
else
{
m_ouData.m_eExcpAction = EXIT;
}
//Getting Testcases
MSXML2::IXMLDOMNodeListPtr pDOMChildList = pIDomNode->GetchildNodes();
LONG lCount;
pDOMChildList->get_length(&lCount);
CComBSTR NodeName;
for(int i = 0;i < lCount; i++)
{
pIDOMChildNode = pDOMChildList->Getitem(i);
pIDOMChildNode->get_nodeName(&NodeName);
CBaseEntityTA *odpBaseEntity = NULL;
if(NodeName == def_STR_SEND_NODE)
{
odpBaseEntity = new CSendEntity();
}
else if(NodeName == def_STR_VERIFY_NODE)
{
odpBaseEntity = new CVerifyEntity();
}
else if(NodeName == def_STR_WAIT_NODE)
{
odpBaseEntity = new CWaitEntity();
}
else if(NodeName == def_STR_REPLAY_NODE)
{
odpBaseEntity = new CReplayEntity();
}
else if(NodeName == def_STR_VERIFYRES_NODE)
{
odpBaseEntity = new CVerifyResponse();
}
if(odpBaseEntity == NULL)
{
//TODO::return a correct value
return -1;
}
odpBaseEntity->GetData(pIDOMChildNode);
m_ouData.m_odTAEntityList.AddTail(odpBaseEntity);
//pIDOMChildNode->Release();
}
return S_OK;
}
// 创建一个快捷方式
BOOL CreateDesktopShotCut(tstring strName, tstring strSourcePath)
{
if (FAILED(CoInitialize(NULL)))
return FALSE;
TCHAR szPath[MAX_PATH + 1];
tstring strDestDir;
LPITEMIDLIST pidl;
LPMALLOC pShell;
if (!SUCCEEDED(SHGetMalloc(&pShell)))
{
::CoUninitialize();
return FALSE;
}
if (!SUCCEEDED(SHGetSpecialFolderLocation(NULL, CSIDL_DESKTOPDIRECTORY, &pidl)))
{
pShell->Release();
::CoUninitialize();
return FALSE;
}
if (!SHGetPathFromIDList(pidl, szPath))
{
pShell->Free(pidl);
::CoUninitialize();
return FALSE;
}
pShell->Free(pidl);
pShell->Release();
strDestDir = szPath;
strDestDir += _T("\\") + strName + _T(".lnk");
IShellLink* psl;
if (SUCCEEDED(CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (LPVOID*)&psl)))
{
psl->SetPath(strSourcePath.c_str());
IPersistFile* ppf;
if (SUCCEEDED(psl->QueryInterface(IID_IPersistFile, (LPVOID*)&ppf)))
{
USES_CONVERSION;
if(SUCCEEDED(ppf->Save(CT2W(strDestDir.c_str()), TRUE)))
{
ppf->Release();
psl->Release();
::CoUninitialize();
return TRUE;
}
else
{
ppf->Release();
psl->Release();
::CoUninitialize();
return FALSE;
}
}
else
{
ppf->Release();
psl->Release();
::CoUninitialize();
return FALSE;
}
}
else
{
::CoUninitialize();
return FALSE;
}
}
void CTTSApp::MainHandleCommand( int id, HWND hWndControl, UINT codeNotify )
/////////////////////////////////////////////////////////////////
//
// Handle each of the WM_COMMAND messages that come in, and deal with
// them appropriately
//
{
UINT cNumChar = 0;
HRESULT hr = S_OK;
TCHAR szAFileName[NORM_SIZE] = _T("");
static BOOL bIsUnicode = FALSE;
BOOL bWavFileOpened = FALSE;
LRESULT iFormat;
CComPtr<ISpStream> cpWavStream;
CComPtr<ISpStreamFormat> cpOldStream;
HWND hwndEdit;
BOOL bFileOpened = FALSE;
// Get handle to the main edit box
hwndEdit = GetDlgItem( m_hWnd, IDE_EDITBOX );
switch(id)
{
// About Box display
case IDC_ABOUT:
::DialogBox( m_hInst, (LPCTSTR)IDD_ABOUT, m_hWnd, (DLGPROC)About );
break;
// Any change to voices is sent to VoiceChange() function
case IDC_COMBO_VOICES:
if( codeNotify == CBN_SELCHANGE )
{
hr = VoiceChange();
}
if( FAILED( hr ) )
{
TTSAppStatusMessage( m_hWnd, _T("Error changing voices\r\n") );
}
break;
// If user wants to speak a file pop the standard windows open file
// dialog box and load the text into a global buffer (m_pszwFileText)
// which will be used when the user hits speak.
case IDB_OPEN:
bFileOpened = CallOpenFileDialog( szAFileName,
_T("TXT (*.txt)\0*.txt\0XML (*.xml)\0*.xml\0All Files (*.*)\0*.*\0") );
if( bFileOpened )
{
DWORD dwFileSize = 0;
wcscpy_s( m_szWFileName, _countof(m_szWFileName), CT2W( szAFileName ) );
ReadTheFile( szAFileName, &bIsUnicode, &m_pszwFileText );
if( bIsUnicode )
{
// Unicode source
UpdateEditCtlW( m_pszwFileText );
}
else
{
// MBCS source
#ifdef _UNICODE
LPTSTR pszFileText = _tcsdup( m_pszwFileText );
#else
// We're compiling ANSI, so we need to convert the string to MBCS
// Note that a W2T may not be good here, since this string might
// be very big
LPTSTR pszFileText = NULL;
int iNeeded = ::WideCharToMultiByte( CP_ACP, 0, m_pszwFileText, -1, NULL, 0, NULL, NULL );
pszFileText = (LPTSTR) ::malloc( sizeof( TCHAR ) * ( iNeeded + 1 ) );
::WideCharToMultiByte( CP_ACP, 0, m_pszwFileText, -1, pszFileText, iNeeded + 1, NULL, NULL );
#endif
if ( pszFileText )
{
SetDlgItemText( m_hWnd, IDE_EDITBOX, pszFileText );
free( pszFileText );
}
}
}
else
{
wcscpy_s( m_szWFileName, _countof(m_szWFileName), L"" );
}
// Always SetFocus back to main edit window so text highlighting will work
SetFocus( hwndEdit );
break;
// Handle speak
case IDB_SPEAK:
HandleSpeak();
break;
case IDB_PAUSE:
if( !m_bStop )
{
if( !m_bPause )
{
SetWindowText( GetDlgItem( m_hWnd, IDB_PAUSE ), _T("Resume") );
// Pause the voice...
m_cpVoice->Pause();
m_bPause = TRUE;
TTSAppStatusMessage( m_hWnd, _T("Pause\r\n") );
}
else
{
SetWindowText( GetDlgItem( m_hWnd, IDB_PAUSE ), _T("Pause") );
m_cpVoice->Resume();
m_bPause = FALSE;
}
}
SetFocus( hwndEdit );
break;
case IDB_STOP:
TTSAppStatusMessage( m_hWnd, _T("Stop\r\n") );
// Set the global audio state to stop
Stop();
SetFocus( hwndEdit );
break;
case IDB_SKIP:
{
SetFocus( hwndEdit );
int fSuccess = false;
int SkipNum = GetDlgItemInt( m_hWnd, IDC_SKIP_EDIT, &fSuccess, true );
ULONG ulGarbage = 0;
WCHAR szGarbage[] = L"Sentence";
if ( fSuccess )
{
TTSAppStatusMessage( m_hWnd, _T("Skip\r\n") );
m_cpVoice->Skip( szGarbage, SkipNum, &ulGarbage );
}
else
{
TTSAppStatusMessage( m_hWnd, _T("Skip failed\r\n") );
}
break;
}
case IDE_EDITBOX:
// Set the global audio state to stop if user has changed contents of edit control
if( codeNotify == EN_CHANGE )
{
Stop();
}
break;
case IDB_SPEAKWAV:
bWavFileOpened = CallOpenFileDialog( szAFileName,
_T("WAV (*.wav)\0*.wav\0All Files (*.*)\0*.*\0") );
// Speak the wav file using SpeakStream
if( bWavFileOpened )
{
WCHAR szwWavFileName[NORM_SIZE] = L"";;
wcscpy_s( szwWavFileName, _countof(szwWavFileName), CT2W( szAFileName ) );
// User helper function found in sphelper.h to open the wav file and
// get back an IStream pointer to pass to SpeakStream
hr = SPBindToFile( szwWavFileName, SPFM_OPEN_READONLY, &cpWavStream );
if( SUCCEEDED( hr ) )
{
hr = m_cpVoice->SpeakStream( cpWavStream, SPF_ASYNC, NULL );
}
if( FAILED( hr ) )
{
TTSAppStatusMessage( m_hWnd, _T("Speak error\r\n") );
}
}
break;
// Reset all values to defaults
case IDB_RESET:
TTSAppStatusMessage( m_hWnd, _T("Reset\r\n") );
SendDlgItemMessage( m_hWnd, IDC_VOLUME_SLIDER, TBM_SETPOS, TRUE, m_DefaultVolume );
SendDlgItemMessage( m_hWnd, IDC_RATE_SLIDER, TBM_SETPOS, TRUE, m_DefaultRate );
SendDlgItemMessage( m_hWnd, IDC_SAVETOWAV, BM_SETCHECK, BST_UNCHECKED, 0 );
SendDlgItemMessage( m_hWnd, IDC_EVENTS, BM_SETCHECK, BST_UNCHECKED, 0 );
SetDlgItemText( m_hWnd, IDE_EDITBOX, _T("Enter text you wish spoken here.") );
// reset output format
SendDlgItemMessage( m_hWnd, IDC_COMBO_OUTPUT, CB_SETCURSEL, m_DefaultFormatIndex, 0 );
SendMessage( m_hWnd, WM_COMMAND, MAKEWPARAM(IDC_COMBO_OUTPUT, CBN_SELCHANGE), 0 );
// Change the volume and the rate to reflect what the UI says
HandleScroll( ::GetDlgItem( m_hWnd, IDC_VOLUME_SLIDER ) );
HandleScroll( ::GetDlgItem( m_hWnd, IDC_RATE_SLIDER ) );
SetFocus( hwndEdit );
break;
case IDC_COMBO_OUTPUT:
if( codeNotify == CBN_SELCHANGE )
{
// Get the audio output format and set it's GUID
iFormat = SendDlgItemMessage( m_hWnd, IDC_COMBO_OUTPUT, CB_GETCURSEL, 0, 0 );
SPSTREAMFORMAT eFmt = (SPSTREAMFORMAT)SendDlgItemMessage( m_hWnd, IDC_COMBO_OUTPUT,
CB_GETITEMDATA, iFormat, 0 );
CSpStreamFormat Fmt;
Fmt.AssignFormat(eFmt);
if ( m_cpOutAudio )
{
hr = m_cpOutAudio->SetFormat( Fmt.FormatId(), Fmt.WaveFormatExPtr() );
}
else
{
hr = E_FAIL;
}
if( SUCCEEDED( hr ) )
{
hr = m_cpVoice->SetOutput( m_cpOutAudio, FALSE );
}
if( FAILED( hr ) )
{
TTSAppStatusMessage( m_hWnd, _T("Format rejected\r\n") );
}
EnableSpeakButtons( SUCCEEDED( hr ) );
}
break;
case IDC_SAVETOWAV:
{
TCHAR szFileName[256];
_tcscpy_s(szFileName, _countof(szFileName), _T("\0"));
bFileOpened = CallSaveFileDialog( szFileName,
_T("WAV (*.wav)\0*.wav\0All Files (*.*)\0*.*\0") );
if (bFileOpened == FALSE) break;
wcscpy_s( m_szWFileName, _countof(m_szWFileName), CT2W(szFileName) );
CSpStreamFormat OriginalFmt;
hr = m_cpVoice->GetOutputStream( &cpOldStream );
if (hr == S_OK)
{
hr = OriginalFmt.AssignFormat(cpOldStream);
}
else
{
hr = E_FAIL;
}
// User SAPI helper function in sphelper.h to create a wav file
if (SUCCEEDED(hr))
{
hr = SPBindToFile( m_szWFileName, SPFM_CREATE_ALWAYS, &cpWavStream, &OriginalFmt.FormatId(), OriginalFmt.WaveFormatExPtr() );
}
if( SUCCEEDED( hr ) )
{
// Set the voice's output to the wav file instead of the speakers
hr = m_cpVoice->SetOutput(cpWavStream, TRUE);
}
if ( SUCCEEDED( hr ) )
{
// Do the Speak
HandleSpeak();
}
// Set output back to original stream
// Wait until the speak is finished if saving to a wav file so that
// the smart pointer cpWavStream doesn't get released before its
// finished writing to the wav.
m_cpVoice->WaitUntilDone( INFINITE );
cpWavStream.Release();
// Reset output
m_cpVoice->SetOutput( cpOldStream, FALSE );
TCHAR szTitle[MAX_PATH];
TCHAR szConfString[MAX_PATH];
if ( SUCCEEDED( hr ) )
{
LoadString( m_hInst, IDS_SAVE_NOTIFY, szConfString, MAX_PATH );
LoadString( m_hInst, IDS_NOTIFY_TITLE, szTitle, MAX_PATH );
MessageBox( m_hWnd, szConfString, szTitle, MB_OK | MB_ICONINFORMATION );
}
else
{
LoadString( m_hInst, IDS_SAVE_ERROR, szConfString, MAX_PATH );
MessageBox( m_hWnd, szConfString, NULL, MB_ICONEXCLAMATION );
}
break;
}
}
return;
}
/******************************************************************************
* ManageEmployeesPaneProc *
*-------------------------*
* Description:
* Handles messages specifically for the manage employees pane.
*
******************************************************************************/
LRESULT ManageEmployeesPaneProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
{
static ULONG ulNumTokens;
static ULONG ulCurToken;
static WCHAR** ppszTokenIds;
static CSpDynamicString* ppcDescriptionString; // This is string helper class in sphelper.h
static UINT iCurEnum; // Indicates if we should list males, females, or both
switch ( message )
{
case WM_GOTOOFFICE:
{
// Set the right message handler and repaint
g_fpCurrentPane = OfficePaneProc;
//Cleanup our variables
ManageEmployeesPaneCleanup( ppszTokenIds, ppcDescriptionString, ulNumTokens );
ppszTokenIds = NULL;
ppcDescriptionString = NULL;
ulNumTokens = 0;
// Set the hear voice rule to inactive
HRESULT hr = g_cpCmdGrammar->SetRuleIdState( VID_HearTheVoice, SPRS_INACTIVE );
_ASSERTE( SUCCEEDED( hr ) );
hr = g_cpCmdGrammar->SetRuleIdState( VID_OtherRules, SPRS_INACTIVE );
_ASSERTE( SUCCEEDED( hr ) );
hr = g_cpCmdGrammar->SetRuleIdState( DYN_TTSVOICERULE, SPRS_ACTIVE );
_ASSERTE( SUCCEEDED( hr ) );
PostMessage( hWnd, WM_INITPANE, NULL, NULL );
InvalidateRect( hWnd, NULL, TRUE );
return ( 1 );
}
case WM_GOTOCOUNTER:
{
// Set the right message handler and repaint
g_fpCurrentPane = CounterPaneProc;
//Cleanup our variables
ManageEmployeesPaneCleanup( ppszTokenIds, ppcDescriptionString, ulNumTokens );
ppszTokenIds = NULL;
ppcDescriptionString = NULL;
ulNumTokens = 0;
// Set the hear voice rule to inactive
HRESULT hr = g_cpCmdGrammar->SetRuleIdState( VID_HearTheVoice, SPRS_INACTIVE );
_ASSERTE( SUCCEEDED( hr ) );
hr = g_cpCmdGrammar->SetRuleIdState( VID_OtherRules, SPRS_INACTIVE );
_ASSERTE( SUCCEEDED( hr ) );
hr = g_cpCmdGrammar->SetRuleIdState( DYN_TTSVOICERULE, SPRS_ACTIVE );
_ASSERTE( SUCCEEDED( hr ) );
PostMessage( hWnd, WM_INITPANE, NULL, NULL );
InvalidateRect( hWnd, NULL, TRUE );
return ( 1 );
}
case WM_PAINT:
{
// Do the actual UI paint
ManageEmployeesPanePaint( hWnd, ulNumTokens, ppcDescriptionString, ulCurToken, iCurEnum );
return ( 1 );
}
case WM_INITPANE:
{
ISpObjectToken *pToken = NULL; // Token interface pointer
CComPtr<IEnumSpObjectTokens> cpEnum; // Pointer to token enumerator
ULONG ulIndex = 0;
ulCurToken = 0xffffffff;
WCHAR *szRequiredAttributes = NULL;
SPSTATEHANDLE hDynamicRuleHandle; // Handle to our dynamic rule
// Set the required attributes field for the enum if we have special needs
// based on our LPARAM in
if ( 0 == lParam )
{
szRequiredAttributes = L"Gender=Male";
}
else if ( 1 == lParam )
{
szRequiredAttributes = L"Gender=Female";
}
// Get a token enumerator for tts voices available
HRESULT hr = SpEnumTokens(SPCAT_VOICES, szRequiredAttributes, NULL, &cpEnum);
if ( S_OK == hr )
{
// Get the numbers of tokens found
hr = cpEnum->GetCount( &ulNumTokens );
if ( SUCCEEDED( hr ) && 0 != ulNumTokens )
{
// Create arrays we need for storing data
ppcDescriptionString = new CSpDynamicString [ulNumTokens];
if ( NULL == ppcDescriptionString )
{
break;
}
ppszTokenIds = new WCHAR* [ulNumTokens];
if ( NULL == ppszTokenIds )
{
break;
}
ZeroMemory( ppszTokenIds, ulNumTokens*sizeof( WCHAR* ) );
// Get the next token in the enumeration
// State is maintained in the enumerator
while (cpEnum->Next(1, &pToken, NULL) == S_OK)
{
// Get a string which describes the token, in our case, the voice name
hr = SpGetDescription( pToken, &ppcDescriptionString[ulIndex] );
_ASSERTE( SUCCEEDED( hr ) );
// Get the token id, for a low overhead way to retrieve the token later
// without holding on to the object itself
hr = pToken->GetId( &ppszTokenIds[ulIndex] );
_ASSERTE( SUCCEEDED( hr ) );
ulIndex++;
// Release the token itself
pToken->Release();
pToken = NULL;
}
}
// if we've failed to properly initialize, then we should completely shut-down
if ( S_OK != hr )
{
if ( pToken )
{
pToken->Release();
}
ManageEmployeesPaneCleanup( ppszTokenIds, ppcDescriptionString, ulNumTokens );
ppszTokenIds = NULL;
ppcDescriptionString = NULL;
ulNumTokens = 0;
}
// Find out which token corresponds to our voice which is currently in use
else
{
WCHAR *pszCurTokenId = NULL;
// Get the token representing the current voice
hr = g_cpVoice->GetVoice( &pToken );
if ( SUCCEEDED( hr ) )
{
// Get the current token ID, and compare it against others to figure out
// which description string is the one currently selected.
hr = pToken->GetId( &pszCurTokenId );
if ( SUCCEEDED( hr ) )
{
ulIndex = 0;
while ( ulIndex < ulNumTokens &&
0 != _wcsicmp( pszCurTokenId, ppszTokenIds[ulIndex] ) )
{
ulIndex++;
}
// We found it, so set the current index to that of the current token
if ( ulIndex < ulNumTokens )
{
ulCurToken = ulIndex;
}
CoTaskMemFree( pszCurTokenId );
}
pToken->Release();
}
}
}
// Initially, we see both genders
_ASSERTE( lParam >= 0 && lParam <= 2);
iCurEnum = (UINT)lParam;
// Create a dynamic rule containing the description strings of the voice tokens
hr = g_cpCmdGrammar->GetRule(NULL, DYN_TTSVOICERULE, SPRAF_TopLevel | SPRAF_Active | SPRAF_Dynamic, TRUE, &hDynamicRuleHandle);
if ( SUCCEEDED( hr ) )
{
// Clear the rule first
hr = g_cpCmdGrammar->ClearRule( hDynamicRuleHandle );
_ASSERTE( SUCCEEDED( hr ) );
// Commit the changes
hr = g_cpCmdGrammar->Commit(0);
_ASSERTE( SUCCEEDED( hr ) );
// Add description names as the word, ulIndex as id
for ( ulIndex = 0; ulIndex < ulNumTokens; ulIndex++ )
{
SPPROPERTYINFO prop;
prop.pszName = L"Id";
prop.pszValue = L"Property";
prop.vValue.vt = VT_I4;
prop.vValue.ulVal = ulIndex;
hr = g_cpCmdGrammar->AddWordTransition( hDynamicRuleHandle, NULL, ppcDescriptionString[ulIndex], L" ",
SPWT_LEXICAL, 1.0, &prop);
_ASSERTE( SUCCEEDED( hr ) );
}
// Commit the changes
hr = g_cpCmdGrammar->Commit(0);
_ASSERTE( SUCCEEDED( hr ) );
// Set the dynamic rules to active
hr = g_cpCmdGrammar->SetRuleIdState( DYN_TTSVOICERULE, SPRS_ACTIVE );
_ASSERTE( SUCCEEDED( hr ) );
}
// Set the hear voice rule to active
hr = g_cpCmdGrammar->SetRuleIdState( VID_HearTheVoice, SPRS_ACTIVE );
_ASSERTE( SUCCEEDED( hr ) );
hr = g_cpCmdGrammar->SetRuleIdState( VID_OtherRules, SPRS_ACTIVE );
_ASSERTE( SUCCEEDED( hr ) );
InvalidateRect( hWnd, NULL, TRUE );
return ( 1 );
}
case WM_DESTROY:
// Windows is closing down, so we should cleanup
ManageEmployeesPaneCleanup( ppszTokenIds, ppcDescriptionString, ulNumTokens );
ppszTokenIds = NULL;
ppcDescriptionString = NULL;
ulNumTokens = 0;
return ( 1 );
case WM_HEARTHEVOICE:
// Set the voice to play
LoadString( g_hInst, IDS_VOICESPEAK, g_szCounterDisplay, MAX_LOADSTRING );
g_cpVoice->Speak( CT2W(g_szCounterDisplay), SPF_ASYNC | SPF_PURGEBEFORESPEAK, NULL );
return ( 1 );
case WM_MISCCOMMAND:
{
// Find out the offset from the first property we're interested in, so we can verify that
// it's within range.
UINT iSelection = (UINT)(lParam - VID_MalesOnly);
if ( 2 >= iSelection )
{
// If we have a new listing criteria, we basically shutdown the pane and start it again
if ( iSelection != iCurEnum )
{
HRESULT hr = g_cpCmdGrammar->SetRuleIdState( VID_HearTheVoice, SPRS_INACTIVE );
_ASSERTE( SUCCEEDED( hr ) );
hr = g_cpCmdGrammar->SetRuleIdState( VID_OtherRules, SPRS_INACTIVE );
_ASSERTE( SUCCEEDED( hr ) );
ManageEmployeesPaneCleanup( ppszTokenIds, ppcDescriptionString, ulNumTokens );
ppszTokenIds = NULL;
ppcDescriptionString = NULL;
ulNumTokens = 0;
PostMessage( hWnd, WM_INITPANE, 0, (LPARAM) iSelection );
}
}
return ( 1 );
}
case WM_TTSVOICESEL:
{
// If we are out of range, it is a programming error
_ASSERTE( 0 <= lParam && ulNumTokens > (ULONG) lParam );
// The returned Id is an index into our tokenId table, so create a token from the id
CComPtr< ISpObjectToken > pToken;
HRESULT hr = SpGetTokenFromId( ppszTokenIds[lParam], &pToken, FALSE);
if ( SUCCEEDED( hr ) )
{
// Set our current voice from the returned token
hr = g_cpVoice->SetVoice( pToken );
_ASSERTE( SUCCEEDED( hr ) );
// Change our current voice index
ulCurToken = (UINT)lParam;
}
InvalidateRect( hWnd, NULL, TRUE );
return ( 1 );
}
}
return ( 0 );
}
/******************************************************************************
* CounterPaneProc *
*-----------------*
* Description:
* Handles messages specifically for the counter (order) pane.
*
******************************************************************************/
LRESULT CounterPaneProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
{
HRESULT hr;
switch ( message )
{
case WM_ESPRESSOORDER:
{
ID_TEXT *pulIds = (ID_TEXT *) lParam;
_ASSERTE( pulIds );
if ( pulIds == NULL )
{
return 0;
}
KillTimer( hWnd, 0 );
int i = 0, ilen = 0;
TCHAR szTempBuf[NORMAL_LOADSTRING];
TCHAR szSpace[] = _T(" ");
int iTemplen;
g_szCounterDisplay[0] = '\0';
// Sort the array
while ( 0 != pulIds[i].ulId )
{
i++;
}
for ( int j = 0; j < i; j++ )
{
int iminIndex = j;
for ( int k = j; k < i; k++ )
{
if ( pulIds[iminIndex].ulId > pulIds[k].ulId )
{
iminIndex = k;
}
}
ULONG ulId = pulIds[iminIndex].ulId;
WCHAR *pwstr = pulIds[iminIndex].pwstrCoMemText;
pulIds[iminIndex].pwstrCoMemText = pulIds[j].pwstrCoMemText;
pulIds[j].pwstrCoMemText = pwstr;
pulIds[iminIndex].ulId = pulIds[j].ulId;
pulIds[j].ulId = ulId;
}
i = 0;
// Put in the first order words if we actually have an order
if ( 0 != pulIds[0].ulId )
{
iTemplen = LoadString( g_hInst, IDS_ORDERBEGIN, szTempBuf, NORMAL_LOADSTRING );
_tcscat_s( g_szCounterDisplay + ilen, _countof(g_szCounterDisplay) - ilen, szTempBuf );
ilen += iTemplen;
}
while ( i < MAX_ID_ARRAY && 0 != pulIds[i].ulId )
{
CW2T pTempStr( pulIds[i].pwstrCoMemText );
iTemplen = lstrlen( pTempStr );
// We'll quit now so we dont overrun the buffer
if ( ilen + iTemplen >= MAX_LOADSTRING )
{
break;
}
if ( i > 0 )
{
_tcscat_s( g_szCounterDisplay + ilen, _countof(g_szCounterDisplay) - ilen, szSpace );
ilen += 1;
}
_tcscat_s( g_szCounterDisplay, _countof(g_szCounterDisplay), pTempStr );
ilen += iTemplen;
i++;
}
// Put the thank you on this order
if ( 0 < i )
{
iTemplen = LoadString( g_hInst, IDS_ORDEREND, szTempBuf, NORMAL_LOADSTRING );
if ( ilen + iTemplen < MAX_LOADSTRING )
{
_tcscat_s( g_szCounterDisplay + ilen, _countof(g_szCounterDisplay) - ilen, szTempBuf );
ilen += iTemplen;
}
}
InvalidateRect( hWnd, NULL, TRUE );
SetTimer( hWnd, 0, TIMEOUT, NULL );
// Speak the order
g_cpVoice->Speak( CT2W(g_szCounterDisplay), SPF_ASYNC, NULL);
// Delete the CoTaskMem we were given initially by ISpPhrase->GetText
i = 0;
while ( i < MAX_ID_ARRAY && 0 != pulIds[i].ulId )
{
CoTaskMemFree( pulIds[i].pwstrCoMemText );
i++;
}
delete [] pulIds;
return ( 1 );
}
case WM_PAINT:
CounterPanePaint( hWnd, g_szCounterDisplay );
return ( 1 );
case WM_INITPANE:
LoadString( g_hInst, IDS_PLEASEORDER, g_szCounterDisplay, MAX_LOADSTRING );
// Set the rule recognizing an espresso order to active, now that we are ready for it
g_cpCmdGrammar->SetRuleIdState( VID_EspressoDrinks, SPRS_ACTIVE );
// Set our interests to include false recognitions
hr = g_cpRecoCtxt->SetInterest( SPFEI(SPEI_RECOGNITION)|SPFEI(SPEI_FALSE_RECOGNITION),
SPFEI(SPEI_RECOGNITION)|SPFEI(SPEI_FALSE_RECOGNITION) );
_ASSERTE( SUCCEEDED( hr ) );
// Speak the welcome string
g_cpVoice->Speak( CT2W(g_szCounterDisplay), SPF_ASYNC, NULL);
return ( 1 );
case WM_TIMER:
// Revert back to 'go ahead and order' message
LoadString( g_hInst, IDS_PLEASEORDER, g_szCounterDisplay, MAX_LOADSTRING );
InvalidateRect( hWnd, NULL, TRUE );
// Speak the welcome string
g_cpVoice->Speak( CT2W(g_szCounterDisplay), SPF_ASYNC, NULL);
KillTimer( hWnd, 0 );
return ( 1 );
case WM_GOTOOFFICE:
KillTimer( hWnd, 0 );
// Set the rule recognizing an espresso order to inactive
// since you cant order from the office
g_cpCmdGrammar->SetRuleIdState( VID_EspressoDrinks, SPRS_INACTIVE );
// Set our interests to include only recognitions
hr = g_cpRecoCtxt->SetInterest( SPFEI(SPEI_RECOGNITION),SPFEI(SPEI_RECOGNITION) );
_ASSERTE( SUCCEEDED( hr ) );
// Set the right message handler and repaint
g_fpCurrentPane = OfficePaneProc;
PostMessage( hWnd, WM_INITPANE, NULL, NULL );
InvalidateRect( hWnd, NULL, TRUE );
return ( 1 );
case WM_DIDNTUNDERSTAND:
KillTimer( hWnd, 0 );
LoadString( g_hInst, IDS_DIDNTUNDERSTAND, g_szCounterDisplay, MAX_LOADSTRING );
InvalidateRect( hWnd, NULL, TRUE );
// Speak the didn't understand string
g_cpVoice->Speak( CT2W(g_szCounterDisplay), SPF_ASYNC, NULL);
SetTimer( hWnd, 0, TIMEOUT, NULL );
return ( 1 );
}
return ( 0 );
}
/******************************************************************************
Function Name : nLoadHeader
Input(s) : MSXML2::IXMLDOMNodePtr& pHeaderDOMNode
Output : INT
Functionality : Retrives the Header info
Member of : CTestSetupEntity
Friend of : -
Author(s) : Venkatanarayana Makam
Date Created : 06/04/2011
Modifications :
Codetag :
******************************************************************************/
INT CTestSetupEntity::nLoadHeader(MSXML2::IXMLDOMNodePtr& pHeaderDOMNode)
{
// CComPtr<IXMLDOMNode> pHeaderDOMNode;
MSXML2::IXMLDOMNodeListPtr pXMLDOMInfoList;
MSXML2::IXMLDOMNodePtr pInfoNode;
MSXML2::IXMLDOMNodePtr pInfoCategoryNode;
MSXML2::IXMLDOMNodePtr pInfoValueNode;
_bstr_t bstrNodeName = "info";
CComVariant NodeValue;
pXMLDOMInfoList = pHeaderDOMNode->selectNodes(bstrNodeName);
LONG lCount = 0;
pXMLDOMInfoList->get_length(&lCount);
SInfo ouTempSInfo;
for(int i = 0; i<lCount; i++)
{
pInfoNode = pXMLDOMInfoList->Getitem(i);
//bstrNodeName = def_STR_CATEGORY_NODE;
bstrNodeName.Assign(SysAllocString(CT2W(def_STR_CATEGORY_NODE)));
pInfoCategoryNode = pInfoNode->selectSingleNode(bstrNodeName);
pInfoCategoryNode->get_nodeTypedValue(&NodeValue);
ouTempSInfo.m_omCategory = strCopyBSTRToCString(NodeValue);
pInfoCategoryNode.Release();
//bstrNodeName = def_STR_VALUE_NODE;
bstrNodeName.Assign(SysAllocString(CT2W(def_STR_VALUE_NODE)));
pInfoCategoryNode = pInfoNode->selectSingleNode(bstrNodeName);
pInfoCategoryNode->get_nodeTypedValue(&NodeValue);
ouTempSInfo.m_omValue = strCopyBSTRToCString(NodeValue);
pInfoCategoryNode.Release();
pInfoNode.Release();
if(ouTempSInfo.m_omCategory == def_STR_MODULENAME)
{
m_ouTestSetupHeader.m_sModuleName.m_omCategory = ouTempSInfo.m_omCategory;
m_ouTestSetupHeader.m_sModuleName.m_omValue = ouTempSInfo.m_omValue;
}
if(ouTempSInfo.m_omCategory == def_STR_ENGINEERNAME)
{
m_ouTestSetupHeader.m_sEngineerInfo1.m_omCategory = ouTempSInfo.m_omCategory;
m_ouTestSetupHeader.m_sEngineerInfo1.m_omValue = ouTempSInfo.m_omValue;
}
if(ouTempSInfo.m_omCategory == def_STR_ENGINERROLE)
{
m_ouTestSetupHeader.m_sEngineerInfo2.m_omCategory = ouTempSInfo.m_omCategory;
m_ouTestSetupHeader.m_sEngineerInfo2.m_omValue = ouTempSInfo.m_omValue;
}
if(ouTempSInfo.m_omCategory == def_STR_VERSION)
{
m_ouTestSetupHeader.m_sVersion.m_omCategory = ouTempSInfo.m_omCategory;
m_ouTestSetupHeader.m_sVersion.m_omValue = ouTempSInfo.m_omValue;
}
}
//Taking Database
//bstrNodeName = def_STR_LISTOFDB;
bstrNodeName.Assign(SysAllocString(CT2W(def_STR_LISTOFDB)));
pInfoNode = pHeaderDOMNode->selectSingleNode(bstrNodeName);
pInfoNode->get_nodeTypedValue(&NodeValue);
m_ouTestSetupHeader.m_omDatabasePath = strCopyBSTRToCString(NodeValue);
//Set The Database Path
SetDatabaseFile(m_ouTestSetupHeader.m_omDatabasePath);
pInfoNode.Release();
//bstrNodeName = def_STR_REPORT_FORMAT;
bstrNodeName.Assign(SysAllocString(CT2W(def_STR_REPORT_FORMAT)));
pInfoNode = pHeaderDOMNode->selectSingleNode(bstrNodeName);
pInfoNode->get_nodeTypedValue(&NodeValue);
CString omStrExt;
omStrExt = strCopyBSTRToCString(NodeValue);
pInfoNode.Release();
if(omStrExt == "HTM")
{
m_ouTestSetupHeader.m_sReportFile.m_eType = HTM;
}
else
{
m_ouTestSetupHeader.m_sReportFile.m_eType = TXT;
}
//bstrNodeName = def_STR_REPORT_PATH;
bstrNodeName.Assign(SysAllocString(CT2W(def_STR_REPORT_PATH)));
pInfoNode = pHeaderDOMNode->selectSingleNode(bstrNodeName);
pInfoNode->get_nodeTypedValue(&NodeValue);
m_ouTestSetupHeader.m_sReportFile.m_omPath = strCopyBSTRToCString(NodeValue);
pInfoNode.Release();
//bstrNodeName = def_STR_REPORT_TIMEMODE;
bstrNodeName.Assign(SysAllocString(CT2W(def_STR_REPORT_TIMEMODE)));
pInfoNode = pHeaderDOMNode->selectSingleNode(bstrNodeName);
pInfoNode->get_nodeTypedValue(&NodeValue);
CString strTemp;
strTemp = strCopyBSTRToCString(NodeValue);
if(strTemp == "ABS")
{
m_ouTestSetupHeader.m_sReportFile.m_eTimeMode = ABS;
}
else //Default
{
m_ouTestSetupHeader.m_sReportFile.m_eTimeMode = REL;
}
pInfoNode.Release();
//bstrNodeName = def_STR_BUS_TYPE;
bstrNodeName.Assign(SysAllocString(CT2W(def_STR_BUS_TYPE)));
pInfoNode= pHeaderDOMNode->selectSingleNode(bstrNodeName);
pInfoNode->get_nodeTypedValue(&NodeValue);
strTemp = strCopyBSTRToCString(NodeValue);
if(strTemp == "CAN")
{
m_ouTestSetupHeader.m_eBus = CAN;
}
pInfoNode.Release();
return 0;
}
HRESULT STDMETHODCALLTYPE CSf::EnumObjects(
/* [unique][in] */ __RPC__in_opt HWND hwnd,
/* [in] */ SHCONTF grfFlags,
/* [out] */ __RPC__deref_out_opt IEnumIDList **ppenumIDList)
{
ATLTRACE2(atlTraceCOM, LevCallee, "# %s \n", __FUNCTION__);
ATLASSERT(ppenumIDList != NULL);
*ppenumIDList = NULL;
CComObject<CSubf> *pOb = NULL;
HRESULT hr;
if (FAILED(hr = CComObject<CSubf>::CreateInstance(&pOb)))
return hr;
pOb->AddRef();
CRegKey rkP;
LONG res;
for (int side = 0; side < 2; side++) {
if (ERROR_SUCCESS == (res = rkP.Open((side == 0) ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE, _T("Software\\HIRAOKA HYPERS TOOLS, Inc.\\MyFav"), KEY_READ))) {
{
CRegKey rk;
if (ERROR_SUCCESS == (res = rk.Open(rkP, _T("Favorites"), KEY_READ))) {
DWORD y = 0;
while (true) {
TCHAR tcName[MAX_PATH +1] = {0}; // need null char
DWORD cch = 1000;
DWORD valueType = 0;
BYTE abData[MAX_PATH +2] = {0}; // need null char
DWORD cb = 1000;
if (ERROR_SUCCESS != (res = RegEnumValue(rk.m_hKey, y, tcName, &cch, NULL, &valueType, abData, &cb)))
break;
if (valueType == REG_SZ) {
pOb->folders.Add(CString(CT2W(reinterpret_cast<LPTSTR>(abData))));
}
else if (valueType == REG_EXPAND_SZ) {
TCHAR tcDst[MAX_PATH];
if (0 != ExpandEnvironmentStrings(reinterpret_cast<LPTSTR>(abData), tcDst, MAX_PATH)) {
pOb->folders.Add(tcDst);
}
}
++y;
}
}
}
{
TCHAR tcRawDir[MAX_PATH + 1] = {0};
ULONG n = MAX_PATH;
if (ERROR_SUCCESS == (res = rkP.QueryStringValue(_T("Fav_Dir"), tcRawDir, &n))) {
TCHAR tcDir[MAX_PATH +1] = {0};
ExpandEnvironmentStrings(tcRawDir, tcDir, MAX_PATH);
TCHAR tcFind[MAX_PATH +1] = {0};
PathCombine(tcFind, tcDir, _T("*.lnk"));
WIN32_FIND_DATA fd;
HANDLE hhf = FindFirstFile(tcFind, &fd);
if (hhf != NULL && hhf != INVALID_HANDLE_VALUE) {
while (true) {
CComPtr<IShellLink> psl;
if (false
//|| S_OK == (hr = psl.CoCreateInstance(CLSID_FolderShortcut))
|| S_OK == (hr = psl.CoCreateInstance(CLSID_ShellLink))
) {
CComQIPtr<IPersistFile> ppf = psl;
if (ppf != NULL) {
TCHAR tcfplnk[MAX_PATH +1] = {0};
PathCombine(tcfplnk, tcDir, fd.cFileName);
if (S_OK == (hr = ppf->Load(tcfplnk, STGM_READ))) {
TCHAR tctar[MAX_PATH +1] = {0};
LPITEMIDLIST pidlLink = NULL;
if (S_OK == (hr = psl->GetPath(tctar, MAX_PATH, NULL, 0))) {
pOb->folders.Add(tctar);
}
else if (S_OK == (hr = psl->GetIDList(&pidlLink))) {
pOb->folders.Add(IDLUt::ToStr(pidlLink));
ILFree(pidlLink);
}
}
printf("");
}
}
if (!FindNextFile(hhf, &fd))
break;
continue;
};
FindClose(hhf);
}
}
}
}
}
*ppenumIDList = pOb;
return S_OK;
}
std::wstring TestExcelAttachedDocument::GetExpectedPath() const
{
std::wstring ret(CT2W(TEST_PATH ""));
return ret;
}
std::wstring TestExcelAttachedDocument::GetExpectedFullPath() const
{
std::wstring ret(CT2W(TESTRESULT_EXCEL));
return ret;
}
bool StillImage::IsLaunchedByEventMonitor(HINSTANCE hInstace, IEvents *pFrame)
{
USES_CONVERSION;
HRESULT hr;
bool bLaunchedByEventManager = false;
WCHAR szDeviceName[STI_MAX_INTERNAL_NAME_LENGTH];
DWORD dwEventCode;
WCHAR szEventName[64];
GUID guidEventName;
TCHAR szTwainName[sizeof(TW_STR32)]; // sizeof(TW_IDENTITY::ProductName)
DWORD dwTwainNameSize = sizeof(szTwainName);
bool bScan = false;
bool bPrint = false;
CComPtr<IStillImage> pSti = GetStillImage(hInstace);
if (pSti == 0)
return false;
if (pSti->RegisterLaunchApplication(CT2W(GetAppName()), CT2W(GetExePath())) != S_OK)
return false;
hr = pSti->GetSTILaunchInformation(szDeviceName, &dwEventCode, szEventName);
if (hr == S_OK)
{
// if we are launched by the event manager, determine the event type
bLaunchedByEventManager = TRUE;
if (CLSIDFromString(szEventName, &guidEventName) != S_OK)
{
return false;
}
if (IW::InlineIsEqualGUID(guidEventName, xGUID_DeviceArrivedLaunch))
{
bScan = true;
}
else if (IW::InlineIsEqualGUID(guidEventName, xGUID_ScanImage))
{
bScan = true;
}
else if (IW::InlineIsEqualGUID(guidEventName, xGUID_ScanPrintImage))
{
bScan = true;
bPrint = true;
}
else
{
return false;
}
// if we are supposed to get the image from the device,
// get the TWAIN source name and pop up the scan dialog
if (bScan)
{
if (!pSti->GetDeviceValue(szDeviceName, STI_DEVICE_VALUE_TWAIN_NAME, 0, (PBYTE) szTwainName, &dwTwainNameSize) != S_OK)
{
return false;
}
pFrame->TwainAcquire(szTwainName);
}
// if we are supposed to print the image afterwards,
// pop up the print dialog
if (bPrint)
{
// Print?
}
}
return bLaunchedByEventManager;
}
/******************************************************************************
* ManageEmployeesPaneProc *
*-------------------------*
* Description:
* Handles messages specifically for the manage employees pane.
*
******************************************************************************/
LRESULT ManageEmployeesPaneProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
{
static ULONG ulNumTokens;
static ULONG ulCurToken;
static WCHAR** ppszTokenIds;
static CSpDynamicString* ppcDescriptionString; // This is string helper class in sphelper.h
switch ( message )
{
case WM_GOTOOFFICE:
{
// Set the right message handler and repaint
g_fpCurrentPane = OfficePaneProc;
//Cleanup our variables
ManageEmployeesPaneCleanup( ppszTokenIds, ppcDescriptionString, ulNumTokens );
ppszTokenIds = NULL;
ppcDescriptionString = NULL;
ulNumTokens = 0;
// Set the hear voice rule to inactive
HRESULT hr = g_cpCmdGrammar->SetRuleIdState( VID_HearTheVoice, SPRS_INACTIVE );
_ASSERTE( SUCCEEDED( hr ) );
PostMessage( hWnd, WM_INITPANE, NULL, NULL );
InvalidateRect( hWnd, NULL, TRUE );
return ( 1 );
}
case WM_GOTOCOUNTER:
{
// Set the right message handler and repaint
g_fpCurrentPane = CounterPaneProc;
//Cleanup our variables
ManageEmployeesPaneCleanup( ppszTokenIds, ppcDescriptionString, ulNumTokens );
ppszTokenIds = NULL;
ppcDescriptionString = NULL;
ulNumTokens = 0;
// Set the hear voice rule to inactive
HRESULT hr = g_cpCmdGrammar->SetRuleIdState( VID_HearTheVoice, SPRS_INACTIVE );
_ASSERTE( SUCCEEDED( hr ) );
PostMessage( hWnd, WM_INITPANE, NULL, NULL );
InvalidateRect( hWnd, NULL, TRUE );
return ( 1 );
}
case WM_PAINT:
{
// Do the actual UI paint
ManageEmployeesPanePaint( hWnd, ulNumTokens, ppcDescriptionString, ulCurToken );
return ( 1 );
}
case WM_INITPANE:
{
ISpObjectToken *pToken = NULL; // Token interface pointer
CComPtr<IEnumSpObjectTokens> cpEnum; // Pointer to token enumerator
ULONG ulIndex = 0;
ulCurToken = 0xffffffff;
// Get a token enumerator for tts voices available
HRESULT hr = SpEnumTokens(SPCAT_VOICES, NULL, NULL, &cpEnum);
if ( S_OK == hr )
{
// Get the numbers of tokens found
hr = cpEnum->GetCount( &ulNumTokens );
if ( SUCCEEDED( hr ) && 0 != ulNumTokens )
{
// Create arrays we need for storing data
ppcDescriptionString = new CSpDynamicString [ulNumTokens];
if ( NULL == ppcDescriptionString )
{
break;
}
ppszTokenIds = new WCHAR* [ulNumTokens];
if ( NULL == ppszTokenIds )
{
break;
}
ZeroMemory( ppszTokenIds, ulNumTokens*sizeof( WCHAR* ) );
// Get the next token in the enumeration
// State is maintained in the enumerator
while (cpEnum->Next(1, &pToken, NULL) == S_OK)
{
// Get a string which describes the token, in our case, the voice name
hr = SpGetDescription( pToken, &ppcDescriptionString[ulIndex] );
_ASSERTE( SUCCEEDED( hr ) );
// Get the token id, for a low overhead way to retrieve the token later
// without holding on to the object itself
hr = pToken->GetId( &ppszTokenIds[ulIndex] );
_ASSERTE( SUCCEEDED( hr ) );
ulIndex++;
// Release the token itself
pToken->Release();
pToken = NULL;
}
}
// if we've failed to properly initialize, then we should completely shut-down
if ( S_OK != hr )
{
if ( pToken )
{
pToken->Release();
}
ManageEmployeesPaneCleanup( ppszTokenIds, ppcDescriptionString, ulNumTokens );
ppszTokenIds = NULL;
ppcDescriptionString = NULL;
ulNumTokens = 0;
}
// Find out which token corresponds to our voice which is currently in use
else
{
WCHAR *pszCurTokenId = NULL;
// Get the token representing the current voice
hr = g_cpVoice->GetVoice( &pToken );
if ( SUCCEEDED( hr ) )
{
// Get the current token ID, and compare it against others to figure out
// which description string is the one currently selected.
hr = pToken->GetId( &pszCurTokenId );
if ( SUCCEEDED( hr ) )
{
ulIndex = 0;
while ( ulIndex < ulNumTokens &&
0 != _wcsicmp( pszCurTokenId, ppszTokenIds[ulIndex] ) )
{
ulIndex++;
}
// We found it, so set the current index to that of the current token
if ( ulIndex < ulNumTokens )
{
ulCurToken = ulIndex;
}
CoTaskMemFree( pszCurTokenId );
}
pToken->Release();
}
}
}
// Set the hear voice rule to active
hr = g_cpCmdGrammar->SetRuleIdState( VID_HearTheVoice, SPRS_ACTIVE );
_ASSERTE( SUCCEEDED( hr ) );
return ( 1 );
}
case WM_DESTROY:
// Windows is closing down, so we should cleanup
ManageEmployeesPaneCleanup( ppszTokenIds, ppcDescriptionString, ulNumTokens );
ppszTokenIds = NULL;
ppcDescriptionString = NULL;
ulNumTokens = 0;
return ( 1 );
case WM_HEARTHEVOICE:
// Set the voice to play
LoadString( g_hInst, IDS_VOICESPEAK, g_szCounterDisplay, MAX_LOADSTRING );
g_cpVoice->Speak( CT2W(g_szCounterDisplay), SPF_ASYNC | SPF_PURGEBEFORESPEAK, NULL );
}
return ( 0 );
}
