able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/drivers/tpg/hwx/volcano/dll/wispapis.c

5390 lines
153 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
// FILE: WispApis.c
//
#include <stdlib.h>
#include "volcanop.h"
#include "RecTypes.h"
#include "RecApis.h"
#include <Limits.h>
#include <strsafe.h>
#include "TpcError.h"
#include "TpgHandle.h"
#include "res.h"
//#define ENABLE_CONFIDENCE_LEVEL
#define LARGE_BREAKS 500
// definitions of possible handle types that WISP used
#define TPG_HRECOCONTEXT (1)
#define TPG_HRECOGNIZER (2)
#define TPG_HRECOALT (3)
//Why cannot we include penwin.h???? I have to redefine everything I need....
#define SYV_UNKNOWN 0x00000001L
BOOL SymbolToCharacterW(SYV *pSyv, int cSyv, WCHAR *wsz, int *pConv);
// If this pointer is non-NULL, then free input is enabled.
extern BBOX_PROB_TABLE *g_pProbTable;
// String identifying which language is loaded
extern wchar_t *g_szRecognizerLanguage;
extern HINSTANCE g_hInstanceDllCode;
#define NUMBER_OF_ALTERNATES 10
#define TAB_STROKE_INC 30
// {7DFE11A7-FB5D-4958-8765-154ADF0D833F}
static const GUID GUID_CONFIDENCELEVEL =
{ 0x7dfe11a7, 0xfb5d, 0x4958, { 0x87, 0x65, 0x15, 0x4a, 0xdf, 0x0d, 0x83, 0x3f } };
// {8CC24B27-30A9-4b96-9056-2D3A90DA0727}
static const GUID GUID_LINEMETRICS =
{ 0x8cc24b27, 0x30a9, 0x4b96, { 0x90, 0x56, 0x2d, 0x3a, 0x90, 0xda, 0x07, 0x27 } };
// {6D4087D7-61D2-495f-9293-5B7B1C3FCEAB}
static const CLSID JPN_CLSID =
{ 0x6D4087D7, 0x61D2, 0x495f, { 0x92, 0x93, 0x5B, 0x7B, 0x1C, 0x3F, 0xCE, 0xAB } };
static const CLSID KOR_CLSID =
{ 0x6D5087D7, 0x61D2, 0x495f, { 0x92, 0x93, 0x5B, 0x7B, 0x1C, 0x3F, 0xCE, 0xAB } };
static const CLSID CHS_CLSID =
{ 0x6D6087D7, 0x61D2, 0x495f, { 0x92, 0x93, 0x5B, 0x7B, 0x1C, 0x3F, 0xCE, 0xAB } };
static const CLSID CHT_CLSID =
{ 0x6D7087D7, 0x61D2, 0x495f, { 0x92, 0x93, 0x5B, 0x7B, 0x1C, 0x3F, 0xCE, 0xAB } };
//
// Definitions of strucure which pointers are used
// to define the WISP handles (HRECOGNIZER, HRECOCONTEXT
// HRECOALTERNATE)
////////////////////////////////////////////////////////
// This is the structure used for the WISP recognizer
// There is no data, because we have nothing to store
struct WispRec
{
long unused;
};
// This is the structure for WISP alternates
// It contains an array of column used in the
// lattice and an array of indexes used in
// those columns.
// We alse cache the reco context for which
// this alternate is valis, the length of the
// string this alternate corresponds to and
// the original RECO_RANGE this alternate was
// produced from (in a call to GetAlternateList
// or other)
struct WispAlternate
{
HRECOCONTEXT hrc;
int *pIndexInColumn;
int *pColumnIndex;
int iNumberOfColumns;
int iLength;
RECO_RANGE OriginalRecoRange;
};
// This is the WISP structure for the reco context.
// It contains information on the guide used, the
// CAC modem the number of strokes currently
// entered, the context (prefix)
// It also contains the handle to the HWX reco
// context
// We store the lattice so that we not need to
// recreate it every time we are asked for it
struct WispContext
{
HRC hrc;
RECO_GUIDE *pGuide;
ULONG uiGuideIndex;
BOOL bIsBoxed;
BOOL bIsCAC;
BOOL bCACEndInk;
ULONG iCACMode;
UINT uAbort;
ULONG ulCurrentStrokeCount;
BOOL bHasTextContext; // Whether any context has been set
WCHAR *wszBefore; // Context before ink
WCHAR *wszAfter; // Context after ink
DWORD dwFlags; // Flags
WCHAR *wszFactoid; // Factoid
// Lattice for the automation code, with associated data structures
RECO_LATTICE *pLattice;
RECO_LATTICE_PROPERTY *pLatticeProperties;
BYTE *pLatticePropertyValues;
RECO_LATTICE_PROPERTY **ppLatticeProperties;
};
// Structure for the alternate list recursive call
////////////////////////////////////////////////
typedef struct tagAltRank
{
struct WispAlternate *wispalt;
FLOAT fScore;
struct tagAltRank *next;
BOOL bCurrentPath;
} AltRank;
typedef struct tagAltRankList
{
AltRank *pFirst;
AltRank *pLast;
ULONG ulSize;
} AltRankList;
typedef struct tagDiffBreakElement
{
int iColumn;
int iIndex;
struct tagDiffBreakElement *pNext;
} DiffBreakElement;
typedef struct tagDifBreakList
{
int iColumnCount;
DiffBreakElement *pFirst;
float score;
BOOL bCurrentPath;
} DifBreakList;
typedef struct tagDifBreakAltStruct
{
VRC *vrc; // the recognizer data structure
int iFirstStroke; // the first stroke in the original alternate
ULONG ulMax; // Max alternates that we want to return
int iLastChar; // This is to put in the original reco range of the alternate
int iFirstChar; // This is to put in the original reco range of the alternate
AltRankList *paltRankList; // List of Alternates
int iMode; // Segmentation mode (DIFF_BREAK, ...)
} DifBreakAltStruct;
/////////////////////////////////////////////////////
// Declare the GUIDs and consts of the Packet description
/////////////////////////////////////////////////////
const GUID g_guidx ={ 0x598a6a8f, 0x52c0, 0x4ba0, { 0x93, 0xaf, 0xaf, 0x35, 0x74, 0x11, 0xa5, 0x61 } };
const GUID g_guidy = { 0xb53f9f75, 0x04e0, 0x4498, { 0xa7, 0xee, 0xc3, 0x0d, 0xbb, 0x5a, 0x90, 0x11 } };
const PROPERTY_METRICS g_DefaultPropMetrics = { LONG_MIN, LONG_MAX, PROPERTY_UNITS_DEFAULT, 1.0 };
/////////////////////////////////////////////////////
// Helper function to bubble sort an array
/////////////////////////////////////////////////////
// I use a bubble sort because most likely if the
// array is not already sorted, we probably have one or
// two inversion. This is caused by the fact that
// people usually write the letters in a word in
// the correct order
BOOL SlowSort(ULONG *pTab, ULONG ulSize)
{
ULONG i, j, temp;
BOOL bPermut;
// Stupid bubble sort
for (i = 0; i<ulSize; i++)
{
bPermut = FALSE;
for (j = 0; j < ulSize-1-i; j++)
{
if (pTab[j] > pTab[j+1])
{
bPermut = TRUE;
temp = pTab[j];
pTab[j] = pTab[j+1];
pTab[j+1] = temp;
}
}
if (!bPermut) return TRUE;
}
return TRUE;
}
/////////////////////////////////////////////////////
// Implementation of the Wisp Reco Apis
/////////////////////////////////////////////////////
// CreateRecognizer
// Returns a recognizer handle to the recognizer
// corresponding to the passed CLSID. In the case
// of this dll, we only support one CLSID so we will
// not even check for the value of the clsid
// (even if the clsid is null)
//
// Parameter:
// pCLSID [in] : The pointer to the CLSID
// that determines what recognizer we want
// phrec [out] : The address of the returned recognizer
// handle.
//////////////////////////////////////////////////////////////////////
HRESULT WINAPI CreateRecognizer(CLSID *pCLSID, HRECOGNIZER *phrec)
{
struct WispRec *pRec;
// We might want to make NULL illegal later.
if (pCLSID != NULL && IsBadReadPtr(pCLSID, sizeof(CLSID)))
{
return E_POINTER;
}
// validate the pointer
if (IsBadWritePtr(phrec, sizeof(HRECOGNIZER)))
{
return E_POINTER;
}
// initialize the east asian recognizers
#ifdef USE_RESOURCES
if (!HwxConfig())
{
return E_FAIL;
}
#endif
// We might want to make NULL illegal later.
if (pCLSID != NULL)
{
if (wcscmp(g_szRecognizerLanguage, L"JPN") == 0 &&
!IsEqualCLSID(pCLSID, &JPN_CLSID))
{
return E_INVALIDARG;
}
if (wcscmp(g_szRecognizerLanguage, L"CHS") == 0 &&
!IsEqualCLSID(pCLSID, &CHS_CLSID))
{
return E_INVALIDARG;
}
if (wcscmp(g_szRecognizerLanguage, L"CHT") == 0 &&
!IsEqualCLSID(pCLSID, &CHT_CLSID))
{
return E_INVALIDARG;
}
if (wcscmp(g_szRecognizerLanguage, L"KOR") == 0 &&
!IsEqualCLSID(pCLSID, &KOR_CLSID))
{
return E_INVALIDARG;
}
}
// We only have one CLSID per recognizer so always return an hrec...
pRec = (struct WispRec*)ExternAlloc(sizeof(*pRec));
if (NULL == pRec)
{
return E_OUTOFMEMORY;
}
(*phrec) = (HRECOGNIZER)CreateTpgHandle(TPG_HRECOGNIZER, pRec);
if (0 == (*phrec))
{
ExternFree(pRec);
return E_OUTOFMEMORY;
}
return S_OK;
}
// DestroyRecognizer
// Destroys a recognizer handle. Free the associate memory
//
// Parameter:
// hrec [in] : handle to the recognizer
/////////////////////////////////////////////////////////////
HRESULT WINAPI DestroyRecognizer(HRECOGNIZER hrec)
{
struct WispRec *pRec;
// destroy the handle and return the corresponding pointer
pRec = (struct WispRec*)DestroyTpgHandle((HANDLE)hrec, TPG_HRECOGNIZER);
if (NULL == pRec)
{
return E_INVALIDARG;
}
#ifdef USE_RESOURCES
if (!HwxUnconfig(TRUE))
{
return E_FAIL;
}
#endif
ExternFree(pRec);
return S_OK;
}
// GetRecoAttributes
// This function returns the reco attributes corresponding
// to a given recognizer. Since we only have one recognizer
// type we always return the same things.
//
// Parameters:
// hrc [in] : The handle to the recognizer we want the
// the attributes for.
// pRecoAttrs [out] : Address of the user allocated buffer
// to hold the reco attributes.
///////////////////////////////////////////////////////////////////////////
HRESULT WINAPI GetRecoAttributes(HRECOGNIZER hrec, RECO_ATTRS* pRecoAttrs)
{
HRESULT hr = S_OK;
HRSRC hrsrc = NULL;
HGLOBAL hg = NULL;
LPBYTE pv = NULL;
WORD wCurrentCount = 0;
WORD wRecognizerCount = 0;
DWORD dwRecoCapa;
WORD wLanguageCount;
WORD *aLanguages;
WORD iLang;
struct WispRec *pRec;
if (IsBadWritePtr(pRecoAttrs, sizeof(RECO_ATTRS)))
return E_POINTER;
// Check the recognizer handle
pRec = (struct WispRec*)FindTpgHandle((HANDLE)hrec, TPG_HRECOGNIZER);
if (NULL == pRec)
{
return E_INVALIDARG;
}
ZeroMemory(pRecoAttrs, sizeof(RECO_ATTRS));
// Update the global structure is necessary
// Load the resources
// Load the recognizer friendly name
if (0 == LoadStringW(g_hInstanceDllCode, // handle to resource module
RESID_WISP_FRIENDLYNAME, // resource identifier
pRecoAttrs->awcFriendlyName, // resource buffer
sizeof(pRecoAttrs->awcFriendlyName) / sizeof(WCHAR) // size of buffer
))
{
hr = E_FAIL;
}
// Load the recognizer vendor name
if (0 == LoadStringW(g_hInstanceDllCode, // handle to resource module
RESID_WISP_VENDORNAME, // resource identifier
pRecoAttrs->awcVendorName, // resource buffer
sizeof(pRecoAttrs->awcVendorName) / sizeof(WCHAR) // size of buffer
))
{
hr = E_FAIL;
}
if (SUCCEEDED(hr))
{
hrsrc = FindResource(g_hInstanceDllCode, // module handle
(LPCTSTR)RESID_WISP_DATA, // resource name
(LPCTSTR)RT_RCDATA // resource type
);
if (NULL == hrsrc)
{
// The resource is not found!
ASSERT(NULL != hrsrc);
hr = E_FAIL;
}
}
if (SUCCEEDED(hr))
{
hg = LoadResource(
g_hInstanceDllCode, // module handle
hrsrc // resource handle
);
if (NULL == hg)
{
hr = E_FAIL;
}
}
if (SUCCEEDED(hr))
{
pv = (LPBYTE)LockResource(
hg // handle to resource
);
if (NULL == pv)
{
hr = E_FAIL;
}
}
dwRecoCapa = *((DWORD*)pv);
pv += sizeof(dwRecoCapa);
wLanguageCount = *((WORD*)pv);
pv += sizeof(wLanguageCount);
aLanguages = (WORD*)pv;
pv += wLanguageCount * sizeof(WORD);
// Fill the reco attricute structure for this recognizer
// Add the languages
ASSERT(wLanguageCount < 64);
for (iLang = 0; iLang < wLanguageCount; iLang++)
{
pRecoAttrs->awLanguageId[iLang] = aLanguages[iLang];
}
// End the list with a NULL
pRecoAttrs->awLanguageId[wLanguageCount] = 0;
// Add the recocapability flag
pRecoAttrs->dwRecoCapabilityFlags = dwRecoCapa;
return hr;
}
// CreateRecoContext
// This function creates a reco context for a given recognizer
// Since we only have one type of recognizers in this dll,
// always return the same kind of reco context.
//
// Parameters:
// hrec [in] : Handle to the recognizer we want to create a
// reco context for.
// phrc [out] : Pointer to the returned reco context's handle
////////////////////////////////////////////////////////////////////////
HRESULT WINAPI CreateContext(HRECOGNIZER hrec, HRECOCONTEXT *phrc)
{
struct WispContext *pWispContext = NULL;
struct WispRec *pRec;
// Check the recognizer handle
pRec = (struct WispRec*)FindTpgHandle((HANDLE)hrec, TPG_HRECOGNIZER);
if (NULL == pRec)
{
return E_INVALIDARG;
}
// validate the pointer
if (IsBadWritePtr(phrc, sizeof(HRECOCONTEXT)))
{
return E_POINTER;
}
pWispContext = (struct WispContext*)ExternAlloc(sizeof(struct WispContext));
if (!pWispContext)
return E_OUTOFMEMORY;
pWispContext->pGuide = NULL;
pWispContext->pLattice = NULL;
pWispContext->pLatticeProperties = NULL;
pWispContext->pLatticePropertyValues = NULL;
pWispContext->ppLatticeProperties = NULL;
pWispContext->bIsBoxed = FALSE;
pWispContext->bIsCAC = FALSE;
pWispContext->iCACMode = CAC_FULL;
pWispContext->bCACEndInk = FALSE;
pWispContext->uAbort = 0;
pWispContext->ulCurrentStrokeCount = 0;
pWispContext->hrc = NULL;
pWispContext->bHasTextContext = FALSE;
pWispContext->wszBefore = NULL;
pWispContext->wszAfter = NULL;
pWispContext->dwFlags = 0;
pWispContext->wszFactoid = NULL;
// create the handle
*phrc = (HRECOCONTEXT)CreateTpgHandle(TPG_HRECOCONTEXT, pWispContext);
if (NULL == (*phrc))
{
ExternFree(pWispContext);
return E_OUTOFMEMORY;
}
return S_OK;
}
// creates an HRC by calling the appropriate hwx api
HRESULT CreateHRCinContext(struct WispContext *pWispContext)
{
// are we in boxed mode
if (pWispContext->bIsBoxed)
{
pWispContext->hrc = HwxCreate(NULL);
}
// free
else
{
pWispContext->hrc = CreateCompatibleHRC(NULL, NULL);
}
// we failed
if (pWispContext->hrc == NULL)
{
return E_FAIL;
}
// reco settings
if (pWispContext->bHasTextContext)
{
if (!SetHwxCorrectionContext (pWispContext->hrc, pWispContext->wszBefore, pWispContext->wszAfter))
{
return E_FAIL;
}
}
if (!SetHwxFlags(pWispContext->hrc, pWispContext->dwFlags))
{
return E_FAIL;
}
switch (SetHwxFactoid(pWispContext->hrc, pWispContext->wszFactoid))
{
case HRCR_OK:
break;
case HRCR_UNSUPPORTED:
HwxDestroy(pWispContext->hrc);
return TPC_E_INVALID_PROPERTY;
case HRCR_CONFLICT:
HwxDestroy(pWispContext->hrc);
return TPC_E_OUT_OF_ORDER_CALL;
case HRCR_ERROR:
default:
HwxDestroy(pWispContext->hrc);
return E_FAIL;
}
return S_OK;
}
//
// Frees a reco lattice
//
HRESULT FreeRecoLattice(struct WispContext *wisphrc)
{
ULONG i = 0;
RECO_LATTICE *pRecoLattice = wisphrc->pLattice;
if (pRecoLattice == NULL)
{
return S_OK;
}
// Free the Lattice column information
if (pRecoLattice->pLatticeColumns)
{
// Free the array of strokes
if (pRecoLattice->pLatticeColumns[0].pStrokes)
{
ExternFree(pRecoLattice->pLatticeColumns[0].pStrokes);
}
for (i = 0; i < pRecoLattice->ulColumnCount; i++)
{
if (pRecoLattice->pLatticeColumns[i].cpProp.apProps)
{
ExternFree(pRecoLattice->pLatticeColumns[i].cpProp.apProps);
}
}
// Free the array of lattice elements
if (pRecoLattice->pLatticeColumns[0].pLatticeElements)
{
ExternFree(pRecoLattice->pLatticeColumns[0].pLatticeElements);
}
ExternFree(pRecoLattice->pLatticeColumns);
}
// Free the the RecoLattice properties
if (pRecoLattice->pGuidProperties)
{
ExternFree(pRecoLattice->pGuidProperties);
}
// Free the best result information
if (pRecoLattice->pulBestResultColumns)
{
ExternFree(pRecoLattice->pulBestResultColumns);
}
if (pRecoLattice->pulBestResultIndexes)
{
ExternFree(pRecoLattice->pulBestResultIndexes);
}
if (wisphrc->pLatticeProperties)
{
ExternFree(wisphrc->pLatticeProperties);
wisphrc->pLatticeProperties = NULL;
}
if (wisphrc->pLatticePropertyValues)
{
ExternFree(wisphrc->pLatticePropertyValues);
wisphrc->pLatticePropertyValues = NULL;
}
if (wisphrc->ppLatticeProperties != NULL)
{
ExternFree(wisphrc->ppLatticeProperties);
wisphrc->ppLatticeProperties = NULL;
}
// Free the RECO_LATTICE structure
ExternFree(wisphrc->pLattice);
wisphrc->pLattice = NULL;
return S_OK;
}
// DestroyContextInternal
// Destroy a reco context and free the associated memory.
//
// Parameters:
// hrc [in] : pointer to the reco context to destroy
//////////////////////////////////////////////////////////////
HRESULT WINAPI DestroyContextInternal(struct WispContext *wisphrc)
{
HRESULT hr;
// validate and destroy the handle & return the pointer
if (NULL == wisphrc)
{
return E_INVALIDARG;
}
// free the contents of the context
if (wisphrc->hrc)
{
if (wisphrc->bIsBoxed)
HwxDestroy(wisphrc->hrc);
else
DestroyHRC(wisphrc->hrc);
}
if (wisphrc->pGuide)
{
ExternFree(wisphrc->pGuide);
}
if (wisphrc->pLattice)
{
hr = FreeRecoLattice(wisphrc);
ASSERT(SUCCEEDED(hr));
}
wisphrc->pLattice = NULL;
if (wisphrc->bHasTextContext)
{
ExternFree(wisphrc->wszBefore);
ExternFree(wisphrc->wszAfter);
}
ExternFree(wisphrc->wszFactoid);
ExternFree(wisphrc);
return S_OK;
}
// DestroyContext
// Destroy a reco context and free the associated memory.
//
// Parameters:
// hrc [in] : handle to the reco context to destroy
//////////////////////////////////////////////////////////////
HRESULT WINAPI DestroyContext(HRECOCONTEXT hrc)
{
struct WispContext *wisphrc;
// validate and destroy the handle & return the pointer
wisphrc = (struct WispContext*)DestroyTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (NULL == wisphrc)
{
return E_INVALIDARG;
}
return DestroyContextInternal(wisphrc);
}
#ifdef ENABLE_CONFIDENCE_LEVEL
const ULONG PROPERTIES_COUNT = 2;
#else
const ULONG PROPERTIES_COUNT = 1;
#endif
// IRecognizer::GetResultPropertyList
HRESULT WINAPI GetResultPropertyList(HRECOGNIZER hrec, ULONG* pPropertyCount, GUID* pPropertyGuid)
{
HRESULT hr = S_OK;
struct WispRec *pRec;
// Check the recognizer handle
pRec = (struct WispRec*)FindTpgHandle((HANDLE)hrec, TPG_HRECOGNIZER);
if (NULL == pRec)
{
return E_INVALIDARG;
}
if (IsBadWritePtr(pPropertyCount, sizeof(ULONG)))
{
return E_POINTER;
}
if (!pPropertyGuid)
{
*pPropertyCount = PROPERTIES_COUNT; // For now we support only two GUID properties
}
else
{
// Check the array
if (PROPERTIES_COUNT > *pPropertyCount)
{
return TPC_E_INSUFFICIENT_BUFFER;
}
if (IsBadWritePtr(pPropertyGuid, sizeof(GUID)*(*pPropertyCount)))
{
return E_POINTER;
}
pPropertyGuid[0] = GUID_LINEMETRICS;
#ifdef ENABLE_CONFIDENCE_LEVEL
pPropertyGuid[1] = GUID_CONFIDENCELEVEL;
#endif
*pPropertyCount = PROPERTIES_COUNT;
}
return hr;
}
// GetPreferredPacketDescription
// Returns the preferred packet description for the recognizer
// This is going to be x, y only for this recognizer
//
// Parameters:
// hrec [in] : The recognizer we want the preferred
// packet description for
// pPacketDescription [out] : The packet description
/////////////////////////////////////////////////////////////////////////////////
HRESULT WINAPI GetPreferredPacketDescription(HRECOGNIZER hrec , PACKET_DESCRIPTION* pPacketDescription)
{
struct WispRec *pRec;
// Check the recognizer handle
pRec = (struct WispRec*)FindTpgHandle((HANDLE)hrec, TPG_HRECOGNIZER);
if (NULL == pRec)
{
return E_INVALIDARG;
}
// validate the pointer
if (IsBadWritePtr(pPacketDescription, sizeof(PACKET_DESCRIPTION)))
{
return E_POINTER;
}
// We can be called the first time with pPacketProperies
// equal to NULL, just to get the size of those buffer
// The second time we get called thoses buffers are allocated, so
// we can fill them with the data.
if (pPacketDescription->pPacketProperties)
{
// Make sure that the pPacketProperties is of a valid size
// Set the packet size to the size of x and y
pPacketDescription->cbPacketSize = 2 * sizeof(LONG);
// We are only setting 2 properties (X and Y)
if (pPacketDescription->cPacketProperties < 2)
return TPC_E_INSUFFICIENT_BUFFER;
pPacketDescription->cPacketProperties = 2;
// We are not setting buttons
pPacketDescription->cButtons = 0;
// Make sure that the pPacketProperties is of a valid size
if (IsBadWritePtr(pPacketDescription->pPacketProperties, 2 * sizeof(PACKET_PROPERTY)))
{
return E_POINTER;
}
// Fill in pPacketProperies
// Add the GUID_X
pPacketDescription->pPacketProperties[0].guid = g_guidx;
pPacketDescription->pPacketProperties[0].PropertyMetrics = g_DefaultPropMetrics;
// Add the GUID_Y
pPacketDescription->pPacketProperties[1].guid = g_guidy;
pPacketDescription->pPacketProperties[1].PropertyMetrics = g_DefaultPropMetrics;
}
else
{
// Just fill in the PacketDescription structure leavin NULL
// pointers for the pguidButtons and pPacketProperies
// Set the packet size to the size of x and y
pPacketDescription->cbPacketSize = 2*sizeof(LONG);
// We are only setting 2 properties (X and Y)
pPacketDescription->cPacketProperties = 2;
// We are not setting buttons
pPacketDescription->cButtons = 0;
// There are not guid buttons
pPacketDescription->pguidButtons = NULL;
}
return S_OK;
}
#define FUZZ_GEN (1e-9) // general fuzz - nine decimal digits
/**********************************************************************/
// Convert double to int
int RealToInt(double dbl)
{
// Add in the rounding threshold.
// NOTE: The MAXWORD bias used in the floor function
// below must not be combined with this line. If it
// is combined the effect of FUZZ_GEN will be lost.
dbl += 0.5 + FUZZ_GEN;
// Truncate
// The UINT_MAX bias in the floor function will cause
// truncation (rounding toward minuse infinity) within
// the range of a short.
dbl = floor(dbl + UINT_MAX) - UINT_MAX;
// Clip the result.
return dbl > INT_MAX - 7 ? INT_MAX - 7 :
dbl < INT_MIN + 7 ? INT_MIN + 7 : (int)dbl;
}
/**********************************************************************/
// Transform POINT array in place
void Transform(const XFORM *pXf, POINT * pPoints, ULONG cPoints)
{
ULONG iPoint = 0;
LONG xp = 0;
if(NULL != pXf)
{
for(iPoint = 0; iPoint < cPoints; ++iPoint)
{
xp = RealToInt(pPoints[iPoint].x * pXf->eM11 +
pPoints[iPoint].y * pXf->eM21 + pXf->eDx);
pPoints[iPoint].y = RealToInt(pPoints[iPoint].x * pXf->eM12 +
pPoints[iPoint].y * pXf->eM22 + pXf->eDy);
pPoints[iPoint].x = xp;
}
}
}
HRESULT WINAPI AddStroke(HRECOCONTEXT hrc, const PACKET_DESCRIPTION* pPacketDesc, ULONG cbPacket, const BYTE *pPacket, const XFORM *pXForm)
{
HRESULT hr = S_OK;
ULONG ulPointCount = 0;
STROKEINFO stInfo;
POINT *ptArray = NULL;
struct WispContext *wisphrc;
ULONG ulXIndex = 0, ulYIndex = 0;
BOOL bXFound = FALSE, bYFound = FALSE;
ULONG ulPropIndex = 0;
ULONG index = 0;
int hres = 0;
VRC *vrc = NULL;
const LONG* pLongs = (const LONG *)(pPacket);
int temp = 0;
// find the handle and validate the correpsonding pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (NULL == wisphrc)
{
return E_INVALIDARG;
}
if (pPacketDesc != NULL && IsBadReadPtr(pPacketDesc, sizeof(PACKET_DESCRIPTION)))
{
return E_POINTER;
}
if (pXForm != NULL && IsBadReadPtr(pXForm, sizeof(XFORM)))
{
return E_POINTER;
}
// validate the data pointer
if(IsBadReadPtr(pPacket, cbPacket))
{
return E_POINTER;
}
if (!wisphrc->hrc)
{
// If we have a free guide and this is not allowed by
// the recognizer, then fail. Return an out of order
// error because it probably means they forgot to
// set the guide before adding ink.
if (g_pProbTable == NULL && !wisphrc->bIsBoxed)
{
return TPC_E_OUT_OF_ORDER_CALL;
}
hr = CreateHRCinContext(wisphrc);
if (FAILED(hr))
{
return E_FAIL;
}
}
if (wisphrc->bCACEndInk)
{
hr = SetCACMode(hrc, wisphrc->iCACMode);
if (FAILED(hr))
return E_FAIL;
}
vrc = (VRC*)wisphrc->hrc;
// Get the number of packets
if (pPacketDesc)
{
ASSERT(!(cbPacket%(pPacketDesc->cbPacketSize)));
ulPointCount = (cbPacket)/(pPacketDesc->cbPacketSize);
}
else
{
ulPointCount = (cbPacket)/(2*sizeof(LONG));
}
// Fill in the stroke info stucture
// Should check it does not exceed the size of a UINT
stInfo.cPnt = ulPointCount;
// PLEASE FIND ANOTHER WAY TO STORE THE STROKE INDEX!!!
stInfo.dwTick = wisphrc->ulCurrentStrokeCount*60*1000;
stInfo.wPdk = 0x0001;
stInfo.cbPnts = ulPointCount*sizeof(POINT);
wisphrc->ulCurrentStrokeCount++;
// Find the index of GUID_X and GUID_Y
if (pPacketDesc)
{
for (ulPropIndex = 0; ulPropIndex < pPacketDesc->cPacketProperties; ulPropIndex++)
{
if (IsEqualGUID(&(pPacketDesc->pPacketProperties[ulPropIndex].guid), &g_guidx))
{
bXFound = TRUE;
ulXIndex = ulPropIndex;
}
else
if (IsEqualGUID(&(pPacketDesc->pPacketProperties[ulPropIndex].guid), &g_guidy))
{
bYFound = TRUE;
ulYIndex = ulPropIndex;
}
if (bXFound && bYFound)
{
break;
}
}
if (!bXFound || !bYFound)
{
// The coordinates are not part of the packet!
// Remove the last stroke from the stroke array
wisphrc->ulCurrentStrokeCount--;
return TPC_E_INVALID_PACKET_DESCRIPTION;
}
// Allocate the memory for the stroke
// Do it very poorly first (we could reuse the buffer)
ptArray = (POINT*)ExternAlloc(ulPointCount*sizeof(POINT));
if (!ptArray)
{
// Remove the last stroke from the stroke array
wisphrc->ulCurrentStrokeCount--;
return E_OUTOFMEMORY;
}
// Get the points from the packets
for (index = 0; index < ulPointCount; index++, pLongs += (pPacketDesc->cbPacketSize)/sizeof(long))
{
// Feed the ptArray (array of points)
ptArray[index].x = *(pLongs+ulXIndex);
ptArray[index].y = *(pLongs+ulYIndex);
}
// TO DO, for now I transform the points so they
// they are in the ink coordinates. It is up to
// the recognizer team to decide what they should
// use: raw ink or transformed ink
Transform(pXForm, ptArray, ulPointCount);
if (wisphrc->bIsBoxed)
{
if (HwxInput(wisphrc->hrc, ptArray, stInfo.cPnt, stInfo.dwTick))
hres = HRCR_OK;
else
hres = HRCR_ERROR;
}
else
{
hres = AddPenInputHRC(wisphrc->hrc, ptArray, NULL, 0, &stInfo);
}
if ( hres != HRCR_OK)
{
hr = E_FAIL;
// Remove the last stroke from the stroke array
wisphrc->ulCurrentStrokeCount--;
ExternFree(ptArray);
return hr;
}
ExternFree(ptArray);
temp = vrc->pLattice->nRealStrokes;
InterlockedExchange(&(wisphrc->uAbort), temp);
}
else
{
if (wisphrc->bIsBoxed)
{
if (HwxInput(wisphrc->hrc, (POINT*)pPacket, stInfo.cPnt, stInfo.dwTick))
hres = HRCR_OK;
else
hres = HRCR_ERROR;
}
else
{
hres = AddPenInputHRC(wisphrc->hrc, (POINT*)pPacket, NULL, 0, &stInfo);
}
if (hres != HRCR_OK)
{
hr = E_FAIL;
// Remove the last stroke from the stroke array
wisphrc->ulCurrentStrokeCount--;
return hr;
}
temp = vrc->pLattice->nRealStrokes;
InterlockedExchange(&(wisphrc->uAbort), temp);
}
ptArray = NULL;
return hr;
}
HRESULT WINAPI GetBestResultString(HRECOCONTEXT hrc, ULONG *pcwSize, WCHAR* pszBestResult)
{
struct WispContext *wisphrc;
HRESULT hr = S_OK;
VRC *vrc = NULL;
ULONG i = 0;
// find the handle and validate the correpsonding pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (NULL == wisphrc)
{
return E_INVALIDARG;
}
if (IsBadWritePtr(pcwSize, sizeof(ULONG)))
{
return E_POINTER;
}
// check the string pointer if needed
if ( pszBestResult &&
IsBadWritePtr (pszBestResult, (*pcwSize) * sizeof (*pszBestResult))
)
{
return E_POINTER;
}
vrc = (VRC*)wisphrc->hrc;
if (!vrc)
{
*pcwSize = 0;
return S_OK;
}
if (!vrc->pLatticePath)
{
*pcwSize = 0;
return S_OK;
}
if (!pszBestResult)
{
*pcwSize = vrc->pLatticePath->nChars;
return S_OK;
}
// Make the length realistic
if (*pcwSize > (ULONG)vrc->pLatticePath->nChars)
{
*pcwSize = vrc->pLatticePath->nChars;
}
// Is the buffer too small?
if (*pcwSize < (ULONG)vrc->pLatticePath->nChars)
{
hr = TPC_S_TRUNCATED;
}
for (i = 0; i < *pcwSize; i++)
{
pszBestResult[i] = vrc->pLatticePath->pElem[i].wChar;
}
return hr;
}
//
// GetBestAlternate
//
// This function create the best alternate from the best segmentation
//
// Parameters:
// hrc [in] : the reco context
// pHrcAlt [out] : pointer to the handle of the alternate
/////////////////
HRESULT WINAPI GetBestAlternate(HRECOCONTEXT hrc, HRECOALT* pHrcAlt)
{
struct WispContext *wisphrc;
HRESULT hr = S_OK;
ULONG cbSize = 0;
struct WispAlternate *pWispAlt = NULL;
VRC *vrc = NULL;
ULONG i = 0;
// find the handle and validate the correpsonding pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (NULL == wisphrc)
{
return E_INVALIDARG;
}
// First get the number of characters in the string
vrc = (VRC*)wisphrc->hrc;
if (!vrc)
{
return TPC_E_NOT_RELEVANT;
}
if (!vrc->pLatticePath)
{
// There is no ink
return TPC_E_NOT_RELEVANT;
}
cbSize = vrc->pLatticePath->nChars;
// Create the alternate
pWispAlt = (struct WispAlternate*)ExternAlloc(sizeof(struct WispAlternate));
if (!pWispAlt)
{
return E_OUTOFMEMORY;
}
ZeroMemory(pWispAlt, sizeof(struct WispAlternate));
pWispAlt->iNumberOfColumns = cbSize;
pWispAlt->iLength = cbSize;
pWispAlt->OriginalRecoRange.iwcBegin = 0;
pWispAlt->OriginalRecoRange.cCount = cbSize;
pWispAlt->hrc = hrc;
if (cbSize)
{
pWispAlt->pColumnIndex = ExternAlloc(sizeof(ULONG)*cbSize);
if (!pWispAlt->pColumnIndex)
{
ExternFree(pWispAlt);
return E_OUTOFMEMORY;
}
// Initialize the column index array
for (i = 0; i<cbSize; i++)
{
pWispAlt->pColumnIndex[i] = vrc->pLatticePath->pElem[i].iStroke;
}
pWispAlt->pIndexInColumn = ExternAlloc(sizeof(ULONG)*cbSize);
if (!pWispAlt->pIndexInColumn)
{
ExternFree(pWispAlt->pColumnIndex);
ExternFree(pWispAlt);
return E_OUTOFMEMORY;
}
// The best alternate doe not always have the index 0 in the alternate column
// Initialize the index in column array
for (i = 0; i<cbSize; i++)
{
pWispAlt->pIndexInColumn[i] = vrc->pLatticePath->pElem[i].iAlt;
}
}
// create a tpg handle
*pHrcAlt = (HRECOALT)CreateTpgHandle(TPG_HRECOALT, pWispAlt);
if (0 == *pHrcAlt)
{
ExternFree (pWispAlt->pIndexInColumn);
ExternFree (pWispAlt->pColumnIndex);
ExternFree (pWispAlt);
return E_OUTOFMEMORY;
}
return S_OK;
}
// internal implementation: destroy the wispalternate structure
HRESULT DestroyAlternateInternal(struct WispAlternate *wisphrcalt)
{
ExternFree(wisphrcalt->pColumnIndex);
ExternFree(wisphrcalt->pIndexInColumn);
ExternFree(wisphrcalt);
return S_OK;
}
//
// DestroyAlternate
//
// This function destroys an alternate, freeing the allocated memory
//
// Parameters:
// hrcalt [in] : handle of the alternate to be destroyed
/////////////////
HRESULT WINAPI DestroyAlternate(HRECOALT hrcalt)
{
struct WispAlternate *wisphrcalt;
wisphrcalt = (struct WispAlternate *) DestroyTpgHandle (hrcalt, TPG_HRECOALT);
if (NULL == wisphrcalt)
{
return E_INVALIDARG;
}
return DestroyAlternateInternal (wisphrcalt);
}
HRESULT WINAPI SetGuide(HRECOCONTEXT hrc, const RECO_GUIDE* pGuide, ULONG iIndex)
{
struct WispContext *wisphrc;
HWXGUIDE hwxGuide;
HRESULT hr = S_OK;
BOOL bGuideAlreadySet = FALSE;
RECO_GUIDE rgOldGuide;
ULONG uiOldIndex = 0;
BOOL bIsOldGuideBox = FALSE;
BOOL bIsHRCAlreadyCreated = FALSE;
// find the handle and validate the correpsonding pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (NULL == wisphrc)
{
return E_INVALIDARG;
}
if (pGuide != NULL && IsBadReadPtr(pGuide, sizeof(RECO_GUIDE)))
{
return E_POINTER;
}
if (pGuide != NULL)
{
if ((pGuide->cHorzBox < 0 || pGuide->cVertBox < 0) || // invalid
(pGuide->cHorzBox == 0 && pGuide->cVertBox > 0) || // horizontal lined mode
(pGuide->cHorzBox > 0 && pGuide->cVertBox == 0) || // vertical lined mode
(g_pProbTable == NULL && pGuide->cHorzBox == 0 && pGuide->cVertBox == 0)) // free mode not allowed sometimes
{
return E_INVALIDARG;
}
}
if (pGuide == NULL && g_pProbTable == NULL)
{
// Can't do free mode, but got a NULL guide, so return an error.
return E_INVALIDARG;
}
// Is there already an HRC
if (wisphrc->hrc)
{
bIsHRCAlreadyCreated = TRUE;
}
// Save the old values in case the call to the
// recognizer fails
if (wisphrc->pGuide)
{
bGuideAlreadySet = TRUE;
rgOldGuide = *(wisphrc->pGuide);
uiOldIndex = wisphrc->uiGuideIndex;
bIsOldGuideBox = wisphrc->bIsBoxed;
}
// If there was no guide already present, allocate one
if (!wisphrc->pGuide)
wisphrc->pGuide = ExternAlloc(sizeof(RECO_GUIDE));
if (!wisphrc->pGuide)
return E_OUTOFMEMORY;
// If the guide is NULL, then treat it as all zeros (free mode)
if (pGuide != NULL)
{
*(wisphrc->pGuide) = *pGuide;
}
else
{
ZeroMemory(wisphrc->pGuide, sizeof(RECO_GUIDE));
}
wisphrc->uiGuideIndex = iIndex;
// Check if we are in box mode or free input mode
if (wisphrc->pGuide->cHorzBox && wisphrc->pGuide->cVertBox)
{
// We are in the box api mode
// We need to have a proper conversion
ZeroMemory(&hwxGuide, sizeof(HWXGUIDE));
hwxGuide.cHorzBox = wisphrc->pGuide->cHorzBox;
hwxGuide.cVertBox = wisphrc->pGuide->cVertBox;
hwxGuide.cxBox = wisphrc->pGuide->cxBox;
hwxGuide.cyBox = wisphrc->pGuide->cyBox;
hwxGuide.xOrigin = wisphrc->pGuide->xOrigin;
hwxGuide.yOrigin = wisphrc->pGuide->yOrigin;
hwxGuide.cxOffset = wisphrc->pGuide->cxBase ;
hwxGuide.cyOffset = 0;
hwxGuide.cxWriting = wisphrc->pGuide->cxBox - (2 * wisphrc->pGuide->cxBase) ;
if (wisphrc->pGuide->cyBase > 0) {
hwxGuide.cyWriting = wisphrc->pGuide->cyBase ;
} else {
hwxGuide.cyWriting = wisphrc->pGuide->cyBox ;
}
hwxGuide.cyMid = 0 ;
hwxGuide.cyBase = 0 ;
hwxGuide.nDir = HWX_HORIZONTAL ;
// Is the hrc already created
if (bIsHRCAlreadyCreated)
{
// Are we already in box mode?
if (!wisphrc->bIsBoxed)
{
// We need to switch to a box hrc if possible
if (wisphrc->ulCurrentStrokeCount == 0)
{
// Destroy the previous context
DestroyHRC(wisphrc->hrc);
wisphrc->hrc = NULL;
}
else
{
hr = E_FAIL;
}
}
}
wisphrc->bIsBoxed = TRUE;
if (SUCCEEDED(hr) && !wisphrc->hrc)
{
hr = CreateHRCinContext(wisphrc);
if (FAILED(hr))
hr = E_FAIL;
}
if (SUCCEEDED(hr))
{
if (HwxSetGuide(wisphrc->hrc, &hwxGuide))
{
if (TRUE == HwxSetAbort(wisphrc->hrc, &(wisphrc->uAbort)))
{
return S_OK;
}
else
{
hr = E_FAIL;
}
}
else
{
hr = E_INVALIDARG;
}
}
}
else
{
wisphrc->bIsBoxed = FALSE;
if (!wisphrc->hrc)
{
// We need to switch to a free hrc if possible
if (wisphrc->ulCurrentStrokeCount == 0)
{
// Destroy the previous context
HwxDestroy(wisphrc->hrc);
wisphrc->hrc = NULL;
}
else
{
hr = E_FAIL;
}
}
hr = CreateHRCinContext(wisphrc);
if (FAILED(hr))
hr = E_FAIL;
// we are in the free api mode
if (SUCCEEDED(hr))
{
if (HRCR_OK == SetGuideHRC(wisphrc->hrc, (GUIDE *)wisphrc->pGuide, iIndex))
return S_OK;
hr = E_INVALIDARG;
}
}
// The calls did not succeed.
// If we allocated an hrc, destroy it
if (!bIsHRCAlreadyCreated && wisphrc->hrc)
{
if (wisphrc->bIsBoxed)
{
HwxDestroy(wisphrc->hrc);
}
else
{
DestroyHRC(wisphrc->hrc);
}
wisphrc->hrc = NULL;
}
// Set back the old guide
if (bGuideAlreadySet)
{
*(wisphrc->pGuide) = rgOldGuide;
wisphrc->bIsBoxed = bIsOldGuideBox;
wisphrc->uiGuideIndex = uiOldIndex;
}
else
{
ExternFree(wisphrc->pGuide);
wisphrc->pGuide = NULL;
wisphrc->bIsBoxed = FALSE;
}
return hr;
}
HRESULT WINAPI GetGuide(HRECOCONTEXT hrc, RECO_GUIDE* pGuide, ULONG *piIndex)
{
struct WispContext *wisphrc;
// find the handle and validate the correpsonding pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (NULL == wisphrc)
{
return E_INVALIDARG;
}
if (IsBadWritePtr(pGuide, sizeof(RECO_GUIDE)))
{
return E_POINTER;
}
if (IsBadWritePtr(piIndex, sizeof(ULONG)))
{
return E_POINTER;
}
if (!wisphrc->pGuide)
{
return S_FALSE;
}
if (wisphrc->pGuide)
{
*pGuide = *(wisphrc->pGuide);
}
if (piIndex)
{
*piIndex = wisphrc->uiGuideIndex;
}
return S_OK;
}
HRESULT WINAPI AdviseInkChange(HRECOCONTEXT hrc, BOOL bNewStroke)
{
struct WispContext *wisphrc;
// find the handle and validate the correpsonding pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (NULL == wisphrc)
{
return E_INVALIDARG;
}
InterlockedIncrement(&(wisphrc->uAbort));
return S_OK;
}
HRESULT WINAPI SetCACMode(HRECOCONTEXT hrc, int iMode)
{
HRESULT hr = S_OK;
struct WispContext *wisphrc;
VRC *vrc;
HRECOCONTEXT CloneHrc = NULL;
HRC OldHrc = NULL;
int i = 0, j = 0;
int iCACMode = 0;
// find the handle and validate the correpsonding pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (NULL == wisphrc)
{
return E_INVALIDARG;
}
if (!wisphrc->bIsBoxed)
{
return E_FAIL;
}
if (iMode != CAC_FULL && iMode != CAC_PREFIX && iMode != CAC_RANDOM)
{
return E_INVALIDARG;
}
vrc = (VRC*)wisphrc->hrc;
OldHrc = wisphrc->hrc;
wisphrc->hrc = NULL;
// Create the new context
wisphrc->hrc = HwxCreate(OldHrc);
if (!wisphrc->hrc)
{
wisphrc->hrc = OldHrc;
return E_FAIL;
}
if (FALSE == HwxSetAbort(wisphrc->hrc, &(wisphrc->uAbort)))
{
ASSERT(0);
}
// Set the CAC mode
if (iMode == CAC_FULL)
{
iCACMode = HWX_PARTIAL_ALL;
}
else
if (iMode == CAC_PREFIX)
{
iCACMode = HWX_PARTIAL_ORDER;
}
else
if (iMode == CAC_RANDOM)
{
iCACMode = HWX_PARTIAL_FREE;
}
if (!HwxSetPartial(wisphrc->hrc, iCACMode))
{
// Put things back together
HwxDestroy(wisphrc->hrc);
wisphrc->hrc = ((struct WispContext*)OldHrc)->hrc;
return E_FAIL;
}
wisphrc->bIsCAC = TRUE;
wisphrc->iCACMode = iMode;
wisphrc->bCACEndInk = FALSE;
// TO DO
// TO DO
//
// We probably need to store the original ink, not use the smoothed and merged ink that
// is store in the Lattice...
// We need to get the ink from the old context, if there was an old context
if (vrc != NULL)
{
for (i = 0; i < vrc->pLattice->nStrokes; i++)
{
// We need to reorder the strokes to have them in the same order
for (j = 0; j < vrc->pLattice->nStrokes; j++)
{
if (vrc->pLattice->pStroke[j].iOrder == i)
{
// Add the Stroke to the new context
if (!HwxInput(wisphrc->hrc, vrc->pLattice->pStroke[j].pts, vrc->pLattice->pStroke[j].nInk, vrc->pLattice->pStroke[j].timeStart))
{
hr = E_FAIL;
}
break;
}
}
}
wisphrc->uAbort = vrc->pLattice->nStrokes;
if (vrc->fBoxedInput)
HwxDestroy(OldHrc);
else
DestroyHRC(OldHrc);
}
else
{
wisphrc->uAbort = 0;
}
return hr;
}
HRESULT WINAPI EndInkInput(HRECOCONTEXT hrc)
{
struct WispContext *wisphrc;
// find the handle and validate the correpsonding pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (NULL == wisphrc)
{
return E_INVALIDARG;
}
if (wisphrc->bIsBoxed)
{
if (HwxEndInput(wisphrc->hrc))
return S_OK;
}
else
{
if (HRCR_OK == EndPenInputHRC(wisphrc->hrc))
return S_OK;
}
if (!wisphrc->ulCurrentStrokeCount)
{
return S_OK; // We do not have ink yet
}
return E_FAIL;
}
// Given a recognition context, create a new one which has no ink in it, but
// is otherwise identical. An error is returned if there are any allocation
// problems (which should be the only types of errors).
HRESULT WINAPI CloneContext(HRECOCONTEXT hrc, HRECOCONTEXT* pCloneHrc)
{
struct WispContext *pWispContext = NULL;
struct WispContext *wisphrc;
HRESULT hRes = S_OK, hr = S_OK;
// find the handle and validate the correpsonding pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (NULL == wisphrc)
{
return E_INVALIDARG;
}
if (IsBadWritePtr(pCloneHrc, sizeof(HRECOCONTEXT)))
{
return E_POINTER;
}
pWispContext = (struct WispContext*)ExternAlloc(sizeof(struct WispContext));
if (!pWispContext)
{
return E_OUTOFMEMORY;
}
// Did we already create a context???
if (!wisphrc->hrc)
{
// The context was not already created
memcpy(pWispContext, wisphrc, sizeof(struct WispContext));
// If a guide was created, then we would have a context
ASSERT(!wisphrc->pGuide);
pWispContext->pGuide = NULL;
// You can't get a lattice until after processing has been done (in a context)
ASSERT(!wisphrc->pLattice);
pWispContext->pLattice = NULL;
pWispContext->pLatticeProperties = NULL;
pWispContext->pLatticePropertyValues = NULL;
pWispContext->ppLatticeProperties = NULL;
// Copy the text context
if (wisphrc->bHasTextContext)
{
pWispContext->bHasTextContext = TRUE;
pWispContext->wszBefore = Externwcsdup(wisphrc->wszBefore);
pWispContext->wszAfter = Externwcsdup(wisphrc->wszAfter);
if (pWispContext->wszBefore == NULL || pWispContext->wszAfter == NULL)
{
ExternFree(pWispContext->wszBefore);
ExternFree(pWispContext->wszAfter);
ExternFree(pWispContext);
return E_OUTOFMEMORY;
}
}
else
{
pWispContext->bHasTextContext = FALSE;
pWispContext->wszBefore = NULL;
pWispContext->wszAfter = NULL;
}
// Copy factoid setting
if (wisphrc->wszFactoid)
{
pWispContext->wszFactoid = Externwcsdup(wisphrc->wszFactoid);
if (pWispContext->wszFactoid == NULL)
{
ExternFree(pWispContext->wszAfter);
ExternFree(pWispContext->wszBefore);
ExternFree(pWispContext);
return E_OUTOFMEMORY;
}
}
else
{
pWispContext->wszFactoid = NULL;
}
}
else
{
// Depending of whether we are in box mode create the hwx hrc
if (!wisphrc->bIsBoxed)
{
pWispContext->bIsBoxed = FALSE;
pWispContext->hrc = CreateCompatibleHRC(wisphrc->hrc, NULL);
}
else
{
pWispContext->bIsBoxed = TRUE;
pWispContext->hrc = HwxCreate(wisphrc->hrc);
}
if (!pWispContext->hrc)
{
hr = E_OUTOFMEMORY;
}
// Set the context variables
if (SUCCEEDED(hr) && wisphrc->bHasTextContext)
{
pWispContext->bHasTextContext = TRUE;
pWispContext->wszBefore = Externwcsdup(wisphrc->wszBefore);
pWispContext->wszAfter = Externwcsdup(wisphrc->wszAfter);
if (pWispContext->wszBefore == NULL || pWispContext->wszAfter == NULL)
{
hr = E_OUTOFMEMORY;
}
}
else
{
pWispContext->bHasTextContext = FALSE;
pWispContext->wszBefore = NULL;
pWispContext->wszAfter = NULL;
}
// Copy flags
pWispContext->dwFlags = wisphrc->dwFlags;
// Copy factoid setting
if (SUCCEEDED(hr) && wisphrc->wszFactoid)
{
pWispContext->wszFactoid = Externwcsdup(wisphrc->wszFactoid);
if (pWispContext->wszFactoid == NULL)
{
hr = E_OUTOFMEMORY;
}
}
else
{
pWispContext->wszFactoid = NULL;
}
// Set the guide for the Wisp structure
if (SUCCEEDED(hr) && wisphrc->pGuide)
{
pWispContext->pGuide = ExternAlloc(sizeof(RECO_GUIDE));
if (!pWispContext->pGuide)
{
hr = E_OUTOFMEMORY;
}
else
{
*(pWispContext->pGuide) = *(wisphrc->pGuide);
pWispContext->uiGuideIndex = wisphrc->uiGuideIndex;
}
}
else
{
pWispContext->pGuide = NULL;
}
// Set the abort for hwx
pWispContext->uAbort = 0;
if (SUCCEEDED(hr) && pWispContext->bIsBoxed)
{
if (!HwxSetAbort(pWispContext->hrc, &(pWispContext->uAbort)))
{
hr = E_FAIL;
}
}
pWispContext->ulCurrentStrokeCount = 0;
pWispContext->bCACEndInk = FALSE;
pWispContext->bIsCAC = FALSE;
// Set the CAC Mode
if (SUCCEEDED(hr) && wisphrc->bIsCAC)
{
pWispContext->bIsCAC = TRUE;
pWispContext->iCACMode = wisphrc->iCACMode;
}
}
// Clean the lattice
pWispContext->pLattice = NULL;
pWispContext->pLatticeProperties = NULL;
pWispContext->pLatticePropertyValues = NULL;
pWispContext->ppLatticeProperties = NULL;
if (SUCCEEDED(hr))
{
// create a tpg handle
*pCloneHrc = (HRECOCONTEXT)CreateTpgHandle(TPG_HRECOCONTEXT, pWispContext);
if (NULL == (*pCloneHrc))
{
hr = E_OUTOFMEMORY;
}
}
if (!SUCCEEDED(hr))
{
hRes = DestroyContextInternal(pWispContext);
ASSERT(SUCCEEDED(hRes));
}
return hr;
}
// ResetContext
// This function keeps the settings on the passed reco context
// but purges it of the ink it contains. If the EndInkInput
// had been called on the reco context, Reset context will
// now allow more ink to be entered.
//
// Parameter:
// hrc [in] : the handle to the reco context
/////////////////////////////////////////////////////////
HRESULT WINAPI ResetContext(HRECOCONTEXT hrc)
{
struct WispContext *wisphrc;
HRESULT hr = S_OK;
HRC hrcold = NULL;
// find the handle and validate the correpsonding pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (NULL == wisphrc)
{
return E_INVALIDARG;
}
if (!wisphrc->hrc)
{
return S_OK;
}
// Save the old HRC (in case of an error), and put in the new one
hrcold = wisphrc->hrc;
if (!wisphrc->bIsBoxed)
{
wisphrc->hrc = CreateCompatibleHRC(wisphrc->hrc, NULL);
}
else
{
wisphrc->hrc = HwxCreate(wisphrc->hrc);
}
if (!wisphrc->hrc)
{
wisphrc->hrc = hrcold;
return E_FAIL;
}
// If there was a guide, put it back
if (SUCCEEDED(hr) && wisphrc->pGuide)
{
hr = SetGuide(hrc, wisphrc->pGuide, wisphrc->uiGuideIndex);
}
if (SUCCEEDED(hr) && wisphrc->bIsCAC)
{
hr = SetCACMode(hrc, wisphrc->iCACMode);
}
if (SUCCEEDED(hr) && wisphrc->bHasTextContext)
{
hr = SetTextContext(hrc,
wcslen(wisphrc->wszBefore), wisphrc->wszBefore,
wcslen(wisphrc->wszAfter), wisphrc->wszAfter);
}
if (SUCCEEDED(hr))
{
hr = SetFlags(hrc, wisphrc->dwFlags);
}
if (SUCCEEDED(hr))
{
if (wisphrc->wszFactoid)
hr = SetFactoid(hrc, wcslen(wisphrc->wszFactoid), wisphrc->wszFactoid);
else
hr = SetFactoid(hrc, 0, wisphrc->wszFactoid);
}
if (FAILED(hr))
{
// Something went wrong. Restore the context to its original state.
if (!wisphrc->bIsBoxed)
{
DestroyHRC(wisphrc->hrc);
}
else
{
HwxDestroy(wisphrc->hrc);
}
wisphrc->hrc = hrcold;
return hr;
}
// These changes are done last, because they can't be undone easily.
// All error cases have already been taken care of above.
wisphrc->ulCurrentStrokeCount = 0;
wisphrc->uAbort = 0;
wisphrc->bCACEndInk = FALSE;
if (wisphrc->pLattice)
{
hr = FreeRecoLattice(wisphrc);
}
wisphrc->pLattice = NULL;
if (!wisphrc->bIsBoxed)
{
DestroyHRC(hrcold);
}
else
{
HwxDestroy(hrcold);
}
return hr;
}
// Sets the prefix and suffix context for the recognition context. Can
// return errors on memory allocation failure. Note that this function
// is called with the strings pointing at the strings already in the HRC,
// so we need to be careful not to free the old strings before copying them.
HRESULT WINAPI SetTextContext(HRECOCONTEXT hrc, ULONG cwcBefore, const WCHAR *pwcBefore, ULONG cwcAfter, const WCHAR *pwcAfter)
{
HRESULT hr = S_OK;
struct WispContext *wisphrc;
WCHAR *wszBefore, *wszAfter;
// find the handle and validate the correpsonding pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (NULL == wisphrc)
{
return E_INVALIDARG;
}
if ( IsBadReadPtr(pwcBefore, cwcBefore * sizeof(WCHAR)) ||
IsBadReadPtr(pwcAfter, cwcAfter * sizeof(WCHAR))
)
{
return E_POINTER;
}
wszBefore = ExternAlloc((cwcBefore + 1) * sizeof(WCHAR));
if (wszBefore == NULL)
{
return E_OUTOFMEMORY;
}
wszAfter = ExternAlloc((cwcAfter + 1) * sizeof(WCHAR));
if (wszAfter == NULL)
{
ExternFree(wszBefore);
return E_OUTOFMEMORY;
}
memcpy(wszBefore, pwcBefore, cwcBefore * sizeof(WCHAR));
wszBefore[cwcBefore] = 0;
memcpy(wszAfter, pwcAfter, cwcAfter * sizeof(WCHAR));
wszAfter[cwcAfter] = 0;
// If we have a context already, then try to set this context.
// The only errors are memory allocation errors, so we don't need
// to create a context here to make sure the call will succeed.
if (wisphrc->hrc)
{
if (!SetHwxCorrectionContext(wisphrc->hrc, wszBefore, wszAfter))
{
hr = E_FAIL;
}
}
// If everything went okay, then we can update the context.
if (SUCCEEDED(hr))
{
wisphrc->bHasTextContext = TRUE;
ExternFree(wisphrc->wszBefore);
ExternFree(wisphrc->wszAfter);
wisphrc->wszBefore = wszBefore;
wisphrc->wszAfter = wszAfter;
}
return hr;
}
// Create an alternate (returned by setting the pointer ppAlt). The contents of
// the alternate are determined by pAltStruct and pdbList.
HRESULT CreateDifBreakAlternate(DifBreakList* pdbList, DifBreakAltStruct *pAltStruct, struct WispAlternate **ppAlt)
{
int i = 0;
VRC *vrc = pAltStruct->vrc;
DiffBreakElement *pCur = NULL;
*ppAlt = (struct WispAlternate*)ExternAlloc(sizeof(struct WispAlternate));
if (!*ppAlt)
return E_OUTOFMEMORY;
ZeroMemory(*ppAlt, sizeof(struct WispAlternate));
// Initialize the new alternate structure
(*ppAlt)->iLength = (*ppAlt)->iNumberOfColumns = pdbList->iColumnCount;
(*ppAlt)->pColumnIndex = (int*)ExternAlloc(sizeof(int)*(*ppAlt)->iNumberOfColumns);
if (!(*ppAlt)->pColumnIndex)
{
ExternFree(*ppAlt);
return E_OUTOFMEMORY;
}
(*ppAlt)->pIndexInColumn = (int*)ExternAlloc(sizeof(int)*(*ppAlt)->iNumberOfColumns);
if (!(*ppAlt)->pIndexInColumn)
{
ExternFree((*ppAlt)->pColumnIndex);
ExternFree(*ppAlt);
return E_OUTOFMEMORY;
}
(*ppAlt)->OriginalRecoRange.iwcBegin = pAltStruct->iFirstChar;
(*ppAlt)->OriginalRecoRange.cCount = pAltStruct->iLastChar -
pAltStruct->iFirstChar + 1;
pCur = pdbList->pFirst;
for (i = 0; i < pdbList->iColumnCount; i++)
{
// Add the ColumnIndex
(*ppAlt)->pColumnIndex[i] = pCur->iColumn;
(*ppAlt)->pIndexInColumn[i] = pCur->iIndex;
pCur = pCur->pNext;
}
return S_OK;
}
BOOL AddToDefSegList(DifBreakList* pdbList, DifBreakAltStruct *pAltStruct)
{
AltRank *pAltRank = NULL;
HRESULT hr = S_OK, hRes = S_OK;
AltRankList *pAltRankList = pAltStruct->paltRankList;
AltRank *pPrev = NULL, *pCur;
UINT i = 0;
DiffBreakElement *pCurrent = NULL;
int j = 0;
// Doesn't make sense to add alternates to a list when no alternates are allowed.
ASSERT(pAltStruct->ulMax > 0);
if (pAltStruct->ulMax == 0)
{
return TRUE;
}
// Is the score even interesting?
if (pAltRankList->ulSize == pAltStruct->ulMax &&
!pdbList->bCurrentPath &&
pAltRankList->pLast != NULL &&
pAltRankList->pLast->fScore >= pdbList->score)
return TRUE;
// Is the decomposition interesting (depending on the recognition mode)
// For now yes, everyting is interesting!
// Create the alternate
pAltRank = (AltRank*)ExternAlloc(sizeof(AltRank));
if (!pAltRank)
return FALSE;
pAltRank->fScore = pdbList->score;
// All paths created here are not on the current path
pAltRank->bCurrentPath = pdbList->bCurrentPath;
pAltRank->next = NULL;
// Add the new alternate at the current location
hr = CreateDifBreakAlternate(pdbList, pAltStruct, &(pAltRank->wispalt));
if (FAILED(hr))
{
ExternFree(pAltRank);
return FALSE;
}
if (!pAltRankList->pFirst)
{
// Add at the start of the location
pAltRankList->pFirst = pAltRank;
pAltRankList->pLast = pAltRank;
pAltRankList->ulSize = 1;
return TRUE;
}
// If the new alternate is the current path, then it goes to the top of the list.
// If not, and the current top of list is not on the current path, then compare scores.
if (pdbList->bCurrentPath ||
(!pAltRankList->pFirst->bCurrentPath && pAltRankList->pFirst->fScore < pdbList->score))
{
// Add at the start of the location
pAltRank->next = pAltRankList->pFirst;
pAltRankList->pFirst = pAltRank;
if (pAltRankList->ulSize == pAltStruct->ulMax)
{
// Delete the last element
hRes = DestroyAlternateInternal(pAltRankList->pLast->wispalt);
ASSERT(SUCCEEDED(hRes));
ExternFree(pAltRankList->pLast);
// Get a pointer to the last element
pCur = pAltRankList->pFirst;
while(pCur->next != pAltRankList->pLast)
pCur = pCur->next;
pAltRankList->pLast = pCur;
pCur->next = NULL;
}
else
{
pAltRankList->ulSize++;
}
return TRUE;
}
pCur = pAltRankList->pFirst;
// Insert the link at the right location
for (i = 0; i < pAltRankList->ulSize - 1; i++)
{
pPrev = pCur;
pCur = pCur->next;
if (pCur->fScore < pdbList->score)
{
// insert at the pPrev
pAltRank->next = pCur;
pPrev->next = pAltRank;
if (pAltRankList->ulSize == pAltStruct->ulMax)
{
// Delete the last element
HRESULT hrDA = DestroyAlternateInternal(pAltRankList->pLast->wispalt);
ASSERT(SUCCEEDED(hrDA));
ExternFree(pAltRankList->pLast);
// Get a pointer to the last element
pCur = pAltRankList->pFirst;
while(pCur->next != pAltRankList->pLast)
pCur = pCur->next;
pAltRankList->pLast = pCur;
pCur->next = NULL;
}
else
{
pAltRankList->ulSize++;
}
return TRUE;
}
}
// We are actually adding at the end of the list
pAltRank->next = NULL;
pAltRankList->pLast->next = pAltRank;
pAltRankList->pLast = pAltRank;
pAltRankList->ulSize++; // obviously we still have room
return TRUE;
}
/*
static float GetScore(LATTICE *pLattice, int iStroke, int iAlt)
{
if (pLattice->fUseGuide)
{
return pLattice->pAltList[iStroke].alts[iAlt].logProb;
}
else
{
return pLattice->pAltList[iStroke].alts[iAlt].logProb * pLattice->pAltList[iStroke].alts[iAlt].nStrokes;
}
}
*/
BOOL GetRecDifSegAltList(int iCurrentStroke, int iCurrentIndex, DifBreakList* pdbList, DifBreakAltStruct *pAltStruct)
{
int iNextStroke = 0;
int i = 0, j = 0, l = 0;
DiffBreakElement dbElement;
DiffBreakElement dbSpaceElement;
float fOriginalScore = pdbList->score;
BOOL bOriginalCurrentPath = pdbList->bCurrentPath;
BOOL bSomethingAdded = FALSE;
BOOL bMainSeg = FALSE;
int iNumberOfStrokes = 0;
BOOL bAllBreakSkip = FALSE;
int iNextNextStroke = 0;
BOOL bSameBreak = FALSE;
BOOL bOkay = TRUE;
iNextStroke = iCurrentStroke -
pAltStruct->vrc->pLattice->pAltList[iCurrentStroke].alts[iCurrentIndex].nStrokes;
// Check if we are at the end (we include uiFirstIndex)
if (pAltStruct->iMode == LARGE_BREAKS)
{
if (pAltStruct->vrc->pLattice->pAltList[iCurrentStroke].alts[iCurrentIndex].nStrokes
> iCurrentStroke-pAltStruct->iFirstStroke)
{
// Yes this is a last (or rather "first") stroke
// But does this stroke correspond to the start of a stroke from the main
// segmentation?
bMainSeg = FALSE;
for (j = pAltStruct->iLastChar; j>=0; j--)
{
if (pAltStruct->vrc->pLatticePath->pElem[j].iStroke -
pAltStruct->vrc->pLatticePath->pElem[j].nStrokes ==
iNextStroke)
{
bMainSeg = TRUE;
pAltStruct->iFirstChar = j;
break;
}
}
// Add this to the stroke list
if (bMainSeg)
return AddToDefSegList(pdbList, pAltStruct);
}
}
else
{
if (pAltStruct->vrc->pLattice->pAltList[iCurrentStroke].alts[iCurrentIndex].nStrokes
== iCurrentStroke-pAltStruct->iFirstStroke+1)
{
// We are at the end
for (j = pAltStruct->iLastChar; j>=0; j--)
{
if (pAltStruct->vrc->pLatticePath->pElem[j].iStroke -
pAltStruct->vrc->pLatticePath->pElem[j].nStrokes ==
iNextStroke)
{
pAltStruct->iFirstChar = j;
return AddToDefSegList(pdbList, pAltStruct);
}
}
// This is an error case
return FALSE;
}
if (pAltStruct->vrc->pLattice->pAltList[iCurrentStroke].alts[iCurrentIndex].nStrokes
> iCurrentStroke-pAltStruct->iFirstStroke+1)
{
// Not an error, we just stepped back too far in the lattice.
return TRUE;
}
}
// We are not at the end (or start) of the alternate, dig deeper
// First, see if we need a space
if (pAltStruct->vrc->pLattice->pAltList[iNextStroke].fSpaceAfterStroke)
{
dbSpaceElement.iColumn = iNextStroke;
dbSpaceElement.iIndex = SPACE_ALT_ID;
dbSpaceElement.pNext = pdbList->pFirst;
pdbList->iColumnCount++;
pdbList->pFirst = &dbSpaceElement;
}
// Then add on the placeholder for the current character
dbElement.iColumn = iNextStroke;
dbElement.pNext = pdbList->pFirst;
pdbList->iColumnCount++;
pdbList->pFirst = &dbElement;
// In the case of ALT_BREAKS_SAME, get the number of strokes of the best result's column
if (pAltStruct->iMode == ALT_BREAKS_SAME)
{
iNumberOfStrokes = -1;
for (i = 0; i < pAltStruct->vrc->pLattice->pAltList[iNextStroke].nUsed; i++)
{
if (pAltStruct->vrc->pLattice->pAltList[iNextStroke].alts[i].fCurrentPath)
{
iNumberOfStrokes = pAltStruct->vrc->pLattice->pAltList[iNextStroke].alts[i].nStrokes;
break;
}
}
ASSERT(iNumberOfStrokes>0);
// If we don't find the current path, something has gone wrong. The
// rest of the code will behave sensibly, though, so continue.
}
for (i = 0; i < pAltStruct->vrc->pLattice->pAltList[iNextStroke].nUsed; i++)
{
// TBD:
// Here we should have an optimization to know if
// we should continue processing the alternates with the
// same decomposition
if (pAltStruct->iMode == ALT_BREAKS_SAME)
if (pAltStruct->vrc->pLattice->pAltList[iNextStroke].alts[i].nStrokes != iNumberOfStrokes)
continue;
// If we have been on the current path so far and are still on it with this
// node, then we are staying on the current path
pdbList->bCurrentPath = bOriginalCurrentPath &&
pAltStruct->vrc->pLattice->pAltList[iNextStroke].alts[i].fCurrentPath;
// Only need to skip alternates if we are trying to get one of each
// segmentation. And we never need to skip the current path, since we
// always want to return that segmentation.
if (pAltStruct->iMode == ALT_BREAKS_UNIQUE && !pdbList->bCurrentPath)
{
bAllBreakSkip = FALSE;
// Did we already go over an alternate with the same number of strokes?
for (l = 0; l<i; l++)
{
if (pAltStruct->vrc->pLattice->pAltList[iNextStroke].alts[i].nStrokes ==
pAltStruct->vrc->pLattice->pAltList[iNextStroke].alts[l].nStrokes)
{
bAllBreakSkip = TRUE;
break;
}
}
if (bAllBreakSkip)
continue;
// If we have been on the current path so far, but are now considering a
// character off the current path,
// then skip it if there is a currrent path character later in the alt
// list with the same number of strokes.
if (!pdbList->bCurrentPath && bOriginalCurrentPath)
{
for (l = i + 1; l < pAltStruct->vrc->pLattice->pAltList[iNextStroke].nUsed; l++)
{
if (pAltStruct->vrc->pLattice->pAltList[iNextStroke].alts[l].fCurrentPath &&
pAltStruct->vrc->pLattice->pAltList[iNextStroke].alts[i].nStrokes ==
pAltStruct->vrc->pLattice->pAltList[iNextStroke].alts[l].nStrokes)
{
bAllBreakSkip = TRUE;
break;
}
}
}
if (bAllBreakSkip) continue;
}
dbElement.iIndex = i;
pdbList->score = fOriginalScore +
pAltStruct->vrc->pLattice->pAltList[iNextStroke].alts[i].logProb;
// GetScore(pAltStruct->vrc->pLattice, iNextStroke, i);
if (!GetRecDifSegAltList(iNextStroke, i, pdbList, pAltStruct))
bOkay = FALSE;
}
pdbList->iColumnCount--;
pdbList->pFirst = dbElement.pNext;
// Unwind the space if necessary
if (pAltStruct->vrc->pLattice->pAltList[iNextStroke].fSpaceAfterStroke)
{
pdbList->iColumnCount--;
pdbList->pFirst = dbSpaceElement.pNext;
}
pdbList->score = fOriginalScore;
pdbList->bCurrentPath = bOriginalCurrentPath;
return bOkay;
}
HRESULT GetDifSegAltList(VRC *vrc, int iLastStroke, int iFirstStroke, ULONG ulMax, AltRankList *pAltRankList, int iMode, int iFirstChar, int iLastChar)
{
HRESULT hr = S_OK;
int iStroke = 0;
int i = 0, j = 0, l = 0;
DifBreakList dbList;
DiffBreakElement dbElement;
BOOL bGoodStart = FALSE;
BOOL bAllBreakSkip = FALSE;
DifBreakAltStruct altStruct;
int iNumberOfStrokes = 0;
// Get the last Column alternates, they should contain uiLastStroke
// For each of these alternate, get the complete alternate list, stopping
// at uiFirstStroke.
// Initialize the data
altStruct.iFirstStroke = iFirstStroke;
altStruct.iFirstChar = iFirstChar;
altStruct.iLastChar = iLastChar;
altStruct.iMode = iMode;
altStruct.ulMax = ulMax;
altStruct.vrc = vrc;
altStruct.paltRankList = pAltRankList;
altStruct.paltRankList->pFirst = altStruct.paltRankList->pLast = NULL;
altStruct.paltRankList->ulSize = 0;
dbList.iColumnCount = 1;
dbList.pFirst = &dbElement;
dbList.score = 0.0;
// The starting last stroke should no be further away than 35 strokes from
// the uiLastStroke
if (iMode == LARGE_BREAKS)
iStroke = (vrc->pLattice->nStrokes > iLastStroke + 35 ? iLastStroke + 35 : vrc->pLattice->nStrokes - 1);
else
iStroke = iLastStroke;
while (iStroke >= iLastStroke)
{
// The stroke has to be one of the main decomposition
if (iMode == LARGE_BREAKS)
{
bGoodStart = FALSE;
for (i = 0; i < vrc->pLattice->pAltList[iStroke].nUsed; i++)
{
if (vrc->pLattice->pAltList[iStroke].alts[i].fCurrentPath)
{
bGoodStart = TRUE;
// Get the character number in the best alternate string
for (j = 0; j < vrc->pLatticePath->nChars; j++)
{
if (vrc->pLatticePath->pElem[j].iStroke == iStroke)
{
altStruct.iLastChar = j;
break;
}
}
break;
}
}
}
else
{
altStruct.iLastChar = iLastChar;
bGoodStart = TRUE;
}
if (bGoodStart)
{
// In the case of ALT_BREAKS_SAME, get the number of strokes of the best result's column
if (iMode == ALT_BREAKS_SAME)
{
iNumberOfStrokes = -1;
for (i = 0; i < vrc->pLattice->pAltList[iStroke].nUsed; i++)
{
if (vrc->pLattice->pAltList[iStroke].alts[i].fCurrentPath)
{
iNumberOfStrokes = vrc->pLattice->pAltList[iStroke].alts[i].nStrokes;
break;
}
}
ASSERT(iNumberOfStrokes>0);
if (iNumberOfStrokes <= 0)
hr = E_UNEXPECTED;
}
// Search if there is an alternate that contains uiLastStroke
for (i = 0; i < vrc->pLattice->pAltList[iStroke].nUsed; i++)
{
if (iMode == ALT_BREAKS_SAME)
if (vrc->pLattice->pAltList[iStroke].alts[i].nStrokes != iNumberOfStrokes)
continue;
if (iMode == ALT_BREAKS_UNIQUE && !vrc->pLattice->pAltList[iStroke].alts[i].fCurrentPath)
{
// Did we already go over an alternate with the same number of strokes?
bAllBreakSkip = FALSE;
for (l = 0; l<i; l++)
{
if (vrc->pLattice->pAltList[iStroke].alts[i].nStrokes ==
vrc->pLattice->pAltList[iStroke].alts[l].nStrokes)
{
bAllBreakSkip = TRUE;
break;
}
}
if (bAllBreakSkip) continue;
// If we are considering a character which is not on the current path,
// then skip it if there is a current path character later in the alt
// list with the same number of strokes.
if (!vrc->pLattice->pAltList[iStroke].alts[i].fCurrentPath)
{
for (l = i + 1; l < vrc->pLattice->pAltList[iStroke].nUsed; l++)
{
if (vrc->pLattice->pAltList[iStroke].alts[l].fCurrentPath &&
vrc->pLattice->pAltList[iStroke].alts[i].nStrokes ==
vrc->pLattice->pAltList[iStroke].alts[l].nStrokes)
{
bAllBreakSkip = TRUE;
break;
}
}
}
if (bAllBreakSkip) continue;
}
if (vrc->pLattice->pAltList[iStroke].alts[i].nStrokes > iStroke-iLastStroke)
{
dbElement.iColumn = iStroke;
dbElement.iIndex = i;
dbElement.pNext = NULL;
dbList.bCurrentPath = vrc->pLattice->pAltList[iStroke].alts[i].fCurrentPath;
// We found one that contains uiLastStroke
if (!GetRecDifSegAltList(iStroke, i, &dbList, &altStruct))
{
hr = E_OUTOFMEMORY;
}
}
}
}
iStroke--;
}
// If something went wrong, then clean up before returning
if (!SUCCEEDED(hr))
{
AltRank *pCur = pAltRankList->pFirst;
while (pCur != NULL)
{
AltRank *pNext = pCur->next;
DestroyAlternateInternal(pCur->wispalt);
ExternFree(pCur);
pCur = pNext;
}
pAltRankList->pFirst = pAltRankList->pLast = NULL;
pAltRankList->ulSize = 0;
}
return hr;
}
HRESULT FitAlternateToRecoRange(VRC *vrc, struct WispAlternate *wispalt, RECO_RANGE recoRange)
{
HRESULT hr = S_OK;
int *newColumns = NULL;
int *newIndexes = NULL;
int iCurrent = 0, j = 0;
UINT i = 0;
int iNumberOfColumns = 0;
// Return straight away if the reco range is already good
if (recoRange.iwcBegin == wispalt->OriginalRecoRange.iwcBegin &&
recoRange.cCount == wispalt->OriginalRecoRange.cCount)
return S_OK;
// Allocate the new arrays
iNumberOfColumns = wispalt->iNumberOfColumns + recoRange.cCount - wispalt->OriginalRecoRange.cCount;
newColumns = (int*)ExternAlloc(sizeof(int)*iNumberOfColumns);
if (!newColumns)
return E_OUTOFMEMORY;
newIndexes = (int*)ExternAlloc(sizeof(int)*iNumberOfColumns);
if (!newIndexes)
{
ExternFree(newColumns);
return E_OUTOFMEMORY;
}
iCurrent = 0;
// Copy the first elements of the array
for (i = recoRange.iwcBegin; i < wispalt->OriginalRecoRange.iwcBegin; i++)
{
// Fill with the information from the best result
newColumns[iCurrent] = vrc->pLatticePath->pElem[i].iStroke;
newIndexes[iCurrent] = vrc->pLatticePath->pElem[i].iAlt;
iCurrent++;
}
// Copy the existing alternate information
for (j = 0; j < wispalt->iNumberOfColumns; j++)
{
newColumns[iCurrent] = wispalt->pColumnIndex[j];
newIndexes[iCurrent] = wispalt->pIndexInColumn[j];
iCurrent++;
}
// Copy what follows with the information from the best result
for (i = wispalt->OriginalRecoRange.iwcBegin + wispalt->OriginalRecoRange.cCount;
i < recoRange.iwcBegin + recoRange.cCount; i++)
{
newColumns[iCurrent] = vrc->pLatticePath->pElem[i].iStroke;
newIndexes[iCurrent] = vrc->pLatticePath->pElem[i].iAlt;
iCurrent++;
}
ASSERT (iCurrent == iNumberOfColumns);
// Swap the arrays
ExternFree(wispalt->pColumnIndex);
ExternFree(wispalt->pIndexInColumn);
wispalt->pColumnIndex = newColumns;
wispalt->pIndexInColumn = newIndexes;
wispalt->iLength = iCurrent;
wispalt->iNumberOfColumns = iCurrent;
return hr;
}
// GetAlternateList
//
// This function returns alternates of the best result
//
// Parameters:
// hrc [in] : The handle to the reco context
// pRecoRange [in, out] : Pointer to a RECO_RANGE that contains the range we want to get
// the alternates for. This range comes bck modified to
// reflect the range we actually used.
// pSize [in, out] : The number of alternates. If phrcalt is NULL then this function returns
// the number of alternates it can return - Note we may return an arbitrary
// number with an HRESULT S_FALSE if we think that the number of alternate
// is too long to compute.
// phrcalt [out] : Array of alternates used to return the alternate list
// iBreak [in] : Mode for querying alternates: ALT_BREAKS_SAME, ALT_BREAKS_FULL or ALT_BREAKS_UNIQUE
/////////////////
HRESULT WINAPI GetAlternateList(HRECOCONTEXT hrc, RECO_RANGE* pRecoRange, ULONG*pSize, HRECOALT *phrcalt, ALT_BREAKS iBreak)
{
HRESULT hr = S_OK;
struct WispContext *wisphrc;
VRC *vrc = NULL;
RECO_RANGE recoRange, widestRecoRange;
ULONG i = 0;
ULONG iAlt;
int j = 0;
int iColumnIndex = 0;
FLOAT fCurrentScore = 0.0;
BOOL bSomethingAdded = FALSE;
AltRank *pCur = NULL, *pTemp1 = NULL, *pTemp2 = NULL;
ULONG ulAltCountSameStrokeCount = 0;
AltRankList altRankList;
int iFirstStroke = 0;
int iLastStroke = 0;
// find the handle and validate the correpsonding pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (NULL == wisphrc)
{
return E_INVALIDARG;
}
if (pRecoRange != NULL && IsBadReadPtr(pRecoRange, sizeof(RECO_RANGE)))
{
return E_POINTER;
}
if (IsBadWritePtr(pSize, sizeof(ULONG)))
{
return E_POINTER;
}
if (phrcalt && IsBadWritePtr(phrcalt, (*pSize) * sizeof(*phrcalt)))
{
return E_POINTER;
}
if (iBreak != ALT_BREAKS_FULL &&
// iBreak != LARGE_BREAKS &&
iBreak != ALT_BREAKS_UNIQUE &&
iBreak != ALT_BREAKS_SAME)
{
return E_INVALIDARG;
}
vrc = (VRC*)wisphrc->hrc;
if (!vrc || !vrc->pLatticePath)
{
// There is no ink
*pSize = 0;
return TPC_E_NOT_RELEVANT;
}
// Check the reco range to see if it is valid
if (pRecoRange)
{
recoRange = *pRecoRange;
if (!recoRange.cCount) return E_INVALIDARG;
if (recoRange.iwcBegin + recoRange.cCount > (ULONG)vrc->pLatticePath->nChars)
return E_INVALIDARG;
}
else
{
recoRange.iwcBegin = 0;
recoRange.cCount = vrc->pLatticePath->nChars;
}
// First trim spaces (if any) from the beginning and end of the reco range
while (recoRange.cCount > 0 && vrc->pLatticePath->pElem[recoRange.iwcBegin].iAlt == SPACE_ALT_ID)
{
recoRange.iwcBegin++;
recoRange.cCount--;
}
while (recoRange.cCount > 0 && vrc->pLatticePath->pElem[recoRange.iwcBegin + recoRange.cCount - 1].iAlt == SPACE_ALT_ID)
{
recoRange.cCount--;
}
// If the range only contained spaces, then return an error
if (recoRange.cCount == 0)
{
return TPC_E_NOT_RELEVANT;
}
// If there aren't any results, error
if (!vrc->pLatticePath->nChars)
{
*pSize = 0;
return TPC_E_NOT_RELEVANT;
}
// If we are passed a buffer for alternates but it has size zero, just
// return immediately. (Some of the code for handling alternates doesn't
// work with a buffer size of zero.)
if (phrcalt != NULL && *pSize == 0)
{
return S_OK;
}
// If we're in single segmentation mode and have asked for full breaks, then
// switch to same breaks.
if ((wisphrc->dwFlags & RECOFLAG_SINGLESEG) != 0 && iBreak == ALT_BREAKS_FULL)
{
iBreak = ALT_BREAKS_SAME;
}
widestRecoRange = recoRange;
if (iBreak == ALT_BREAKS_FULL || iBreak == LARGE_BREAKS)
{
// Get the number of alternates
if (!phrcalt)
{
*pSize = 50; //We need to find a way how to calculate the real count easily...
return S_FALSE;
}
iLastStroke = vrc->pLatticePath->pElem[recoRange.iwcBegin+recoRange.cCount-1].iStroke;
iFirstStroke = vrc->pLatticePath->pElem[recoRange.iwcBegin].iStroke -
vrc->pLatticePath->pElem[recoRange.iwcBegin].nStrokes + 1;
hr = GetDifSegAltList(vrc, iLastStroke, iFirstStroke, *pSize, &altRankList, iBreak, recoRange.iwcBegin, recoRange.iwcBegin+recoRange.cCount-1);
if (FAILED(hr))
{
return hr;
}
// Copy the info from the list to the array
*pSize = altRankList.ulSize;
if (altRankList.ulSize == 0) return S_OK;
// TBD: Adjust the alternates to fit the "widest" returned
// alternate
// First find the widest alternate (widestRecoRange)
if (iBreak == LARGE_BREAKS)
{
pCur = altRankList.pFirst;
widestRecoRange = pCur->wispalt->OriginalRecoRange;
for (i = 0; i < *pSize; i++)
{
// Check the start point
if (widestRecoRange.iwcBegin > pCur->wispalt->OriginalRecoRange.iwcBegin)
{
widestRecoRange.cCount += widestRecoRange.iwcBegin -
pCur->wispalt->OriginalRecoRange.iwcBegin;
widestRecoRange.iwcBegin = pCur->wispalt->OriginalRecoRange.iwcBegin;
}
// Check the end point
if (widestRecoRange.iwcBegin + widestRecoRange.cCount <
pCur->wispalt->OriginalRecoRange.iwcBegin +
pCur->wispalt->OriginalRecoRange.cCount)
{
widestRecoRange.cCount = pCur->wispalt->OriginalRecoRange.iwcBegin
+ pCur->wispalt->OriginalRecoRange.cCount
- widestRecoRange.iwcBegin;
}
// Go to the next
pCur = pCur->next;
}
pCur = altRankList.pFirst;
// Then call on each alternate the "fit" function
for (i = 0; i < *pSize; i++)
{
hr = FitAlternateToRecoRange(vrc, pCur->wispalt, widestRecoRange);
// Go to the next
pCur = pCur->next;
}
}
pCur = altRankList.pFirst;
pTemp1 = altRankList.pFirst;
}
if (iBreak == ALT_BREAKS_UNIQUE || iBreak == ALT_BREAKS_SAME)
{
if (iBreak == ALT_BREAKS_UNIQUE && !phrcalt)
{
// Get the number of alternates
*pSize = 50; //We need to find a way how to calculate the real count easily... Impossible?
// If we're pretending there is only one segmentation...
if (wisphrc->dwFlags & RECOFLAG_SINGLESEG)
{
*pSize = 1;
}
return S_FALSE;
}
if (!vrc->pLatticePath)
{
*pSize = 0;
return hr;
}
// Get the number of alternates
if (!phrcalt)
{
*pSize = 1;
for (i = recoRange.iwcBegin; i < recoRange.iwcBegin + recoRange.cCount; i++)
{
iColumnIndex = vrc->pLatticePath->pElem[i].iStroke;
// We need to get the number of alternates with the same number of strokes!!!
ulAltCountSameStrokeCount = 0;
for (j = 0; j < vrc->pLattice->pAltList[iColumnIndex].nUsed; j++)
{
if (vrc->pLattice->pAltList[iColumnIndex].alts[j].nStrokes ==
vrc->pLatticePath->pElem[i].nStrokes)
ulAltCountSameStrokeCount++;
}
*pSize *= ulAltCountSameStrokeCount;
}
return S_OK;
}
// If we're in single segmentation mode and have asked for unique breaks, then
// we just want to return the best path. Easiest way to do this is to
// ask for same breaks with one alternate.
if ((wisphrc->dwFlags & RECOFLAG_SINGLESEG) != 0 && iBreak == ALT_BREAKS_UNIQUE)
{
if (*pSize > 1)
{
*pSize = 1;
}
iBreak = ALT_BREAKS_SAME;
}
// Get the alternates
// Create a list of alternates
iLastStroke = vrc->pLatticePath->pElem[recoRange.iwcBegin+recoRange.cCount-1].iStroke;
iFirstStroke = vrc->pLatticePath->pElem[recoRange.iwcBegin].iStroke -
vrc->pLatticePath->pElem[recoRange.iwcBegin].nStrokes + 1;
hr = GetDifSegAltList(vrc, iLastStroke, iFirstStroke, *pSize, &altRankList, iBreak, recoRange.iwcBegin, recoRange.iwcBegin+recoRange.cCount-1);
if (FAILED(hr))
{
return hr;
}
// Copy the info from the list to the array
*pSize = altRankList.ulSize;
pCur = altRankList.pFirst;
pTemp1 = altRankList.pFirst;
if (altRankList.ulSize == 0) return S_OK;
}
for (i = 0; i < *pSize; i++)
{
// Allocate the memory for the pRecoRange array
pCur->wispalt->OriginalRecoRange = recoRange;
pCur->wispalt->hrc = hrc;
// create a tpg handle
phrcalt[i] = (HRECOALT)CreateTpgHandle(TPG_HRECOALT, pCur->wispalt);
// if we fail we'll have to destroy all the other handles
if (phrcalt[i] == NULL)
{
for (iAlt = 0; iAlt < i; iAlt++)
{
DestroyTpgHandle(phrcalt[iAlt], TPG_HRECOALT);
}
// And also destroy the alternate list
while (pTemp1)
{
pTemp2 = pTemp1->next;
DestroyAlternateInternal(pTemp1->wispalt);
ExternFree(pTemp1);
pTemp1 = pTemp2;
}
return E_OUTOFMEMORY;
}
// Go to the next
pCur = pCur->next;
}
// Get rid of the linked list which previous held all the alternates
while (pTemp1)
{
pTemp2 = pTemp1->next;
ExternFree(pTemp1);
pTemp1 = pTemp2;
}
if (pRecoRange)
*pRecoRange = widestRecoRange;
return hr;
}
HRESULT WINAPI Process(HRECOCONTEXT hrc, BOOL *pbPartialProcessing)
{
struct WispContext *wisphrc;
HRESULT hr = S_OK;
// find the handle and validate the correpsonding pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (NULL == wisphrc)
{
return E_INVALIDARG;
}
if (IsBadWritePtr(pbPartialProcessing, sizeof(BOOL)))
return E_POINTER;
*pbPartialProcessing = FALSE;
if (!wisphrc->hrc)
{
return S_OK; // There is no ink
}
// We should call the HwxProcess if there is a Guide
if (wisphrc->bIsBoxed)
{
if (wisphrc->bIsCAC)
{
hr = EndInkInput(hrc);
if (FAILED(hr)) return hr;
wisphrc->bCACEndInk = TRUE;
}
if (HwxProcess(wisphrc->hrc))
{
// Test wether the result is valid or invalid
// the result can be invalid if the call to Process was
// interrupted by a call to AdviseInkChanged
if (wisphrc->uAbort != (ULONG)((VRC*)wisphrc->hrc)->pLattice->nRealStrokes)
return TPC_S_INTERRUPTED;
return hr;
}
}
else
{
if (HRCR_OK == ProcessHRC(wisphrc->hrc, 0))
return S_OK;
}
return E_FAIL;
}
HRESULT WINAPI SetFactoid(HRECOCONTEXT hrc, ULONG cwcFactoid, const WCHAR* pwcFactoid)
{
struct WispContext *wisphrc;
HRESULT hr = S_OK;
WCHAR *wszOldFactoid;
// find the handle and validate the correpsonding pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (NULL == wisphrc)
{
return E_INVALIDARG;
}
// Save the old factoid so it can be restored if there is an error
wszOldFactoid = wisphrc->wszFactoid;
if (pwcFactoid)
{
// validate pointer if not null
if (IsBadReadPtr (pwcFactoid, cwcFactoid * sizeof (*pwcFactoid)))
{
return E_POINTER;
}
wisphrc->wszFactoid = (WCHAR*)ExternAlloc(sizeof(WCHAR)*(cwcFactoid+1));
if (!wisphrc->wszFactoid)
{
wisphrc->wszFactoid = wszOldFactoid;
return E_OUTOFMEMORY;
}
memcpy(wisphrc->wszFactoid, pwcFactoid, cwcFactoid * sizeof(WCHAR));
wisphrc->wszFactoid[cwcFactoid] = 0;
}
else
{
wisphrc->wszFactoid = NULL;
}
// If we have an HRC already, set the factoid in it.
if (wisphrc->hrc != NULL)
{
switch (SetHwxFactoid(wisphrc->hrc, wisphrc->wszFactoid))
{
case HRCR_OK:
hr = S_OK;
break;
case HRCR_UNSUPPORTED:
hr = TPC_E_INVALID_PROPERTY;
break;
case HRCR_CONFLICT:
hr = TPC_E_OUT_OF_ORDER_CALL;
break;
case HRCR_ERROR:
default:
hr = E_FAIL;
break;
}
}
else
{
// Try to create an HRC to test out the factoid setting,
// then destroy it immediately.
hr = CreateHRCinContext(wisphrc);
// Destroy the HRC if we succeeded in creating one.
if (wisphrc->hrc != NULL)
{
if (wisphrc->bIsBoxed)
HwxDestroy(wisphrc->hrc);
else
DestroyHRC(wisphrc->hrc);
wisphrc->hrc = NULL;
}
}
if (SUCCEEDED(hr))
{
ExternFree(wszOldFactoid);
}
else
{
ExternFree(wisphrc->wszFactoid);
wisphrc->wszFactoid = wszOldFactoid;
}
return hr;
}
HRESULT WINAPI SetFlags(HRECOCONTEXT hrc, DWORD dwFlags)
{
struct WispContext *wisphrc;
DWORD dwOldFlags;
HRESULT hr;
// find the handle and validate the correpsonding pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (NULL == wisphrc)
{
return E_INVALIDARG;
}
dwOldFlags = wisphrc->dwFlags;
wisphrc->dwFlags = dwFlags;
if (wisphrc->hrc)
{
if (SetHwxFlags(wisphrc->hrc, dwFlags))
hr = S_OK;
else
hr = E_INVALIDARG;
}
else
{
// Try to create an HRC to set out the flag setting,
// then destroy it immediately.
hr = CreateHRCinContext(wisphrc);
// Destroy the HRC if we succeeded in creating one.
if (wisphrc->hrc != NULL)
{
if (wisphrc->bIsBoxed)
HwxDestroy(wisphrc->hrc);
else
DestroyHRC(wisphrc->hrc);
wisphrc->hrc = NULL;
}
}
if (FAILED(hr))
{
wisphrc->dwFlags = dwOldFlags;
}
return hr;
}
HRESULT WINAPI IsStringSupported(HRECOCONTEXT hrc, ULONG cwcString, const WCHAR *pwcString)
{
struct WispContext *wisphrc;
WCHAR *tempBuffer;
ULONG ulSize = 0;
HRESULT hr = S_OK;
BOOL fCreatedHRC = FALSE;
// find the handle and validate the correpsonding pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (NULL == wisphrc)
{
return E_INVALIDARG;
}
if (IsBadReadPtr(pwcString, cwcString * sizeof(*pwcString)))
{
return E_POINTER;
}
// We need to have a valid HRC to check the factoid
if (!wisphrc->hrc)
{
hr = CreateHRCinContext(wisphrc);
if (FAILED(hr))
{
// Failure might mean we actually made the
// HRC, but a flag setting or factoid setting failed.
// So destroy the HRC if it was created.
if (wisphrc->hrc != NULL)
{
if (wisphrc->bIsBoxed)
HwxDestroy(wisphrc->hrc);
else
DestroyHRC(wisphrc->hrc);
wisphrc->hrc = NULL;
}
return E_FAIL;
}
fCreatedHRC = TRUE;
}
tempBuffer = (WCHAR *) ExternAlloc((cwcString + 1) * sizeof(*tempBuffer));
if (!tempBuffer)
return E_OUTOFMEMORY;
memcpy(tempBuffer, pwcString, cwcString * sizeof(WCHAR));
tempBuffer[cwcString] = 0;
if (IsWStringSupportedHRC(wisphrc->hrc, tempBuffer))
hr = S_OK;
else
hr = S_FALSE;
ExternFree(tempBuffer);
if (fCreatedHRC)
{
if (wisphrc->bIsBoxed)
HwxDestroy(wisphrc->hrc);
else
DestroyHRC(wisphrc->hrc);
wisphrc->hrc = NULL;
}
return hr;
}
int _cdecl CompareWCHAR(const void *arg1, const void *arg2)
{
int wch1 = *((WCHAR *) arg1);
int wch2 = *((WCHAR *) arg2);
return (wch1 - wch2);
}
// GetUnicodeRanges
//
// Parameters:
// hrec [in] : Handle to the recognizer
// pcRanges [in/out] : Count of ranges
// pcr [out] : Array of character ranges
////////////////////////////////////////////////////////////////////////////////
HRESULT WINAPI GetUnicodeRanges(HRECOGNIZER hrec,
ULONG *pcRanges,
CHARACTER_RANGE *pcr)
{
struct WispRec *pRec;
WCHAR *aw;
int cChar, i;
ULONG cRange, iRange = 0;
HRESULT hr = S_OK;
// Check the recognizer handle
pRec = (struct WispRec*)FindTpgHandle((HANDLE)hrec, TPG_HRECOGNIZER);
if (NULL == pRec)
{
return E_INVALIDARG;
}
if (IsBadWritePtr(pcRanges, sizeof(ULONG)))
{
return E_POINTER;
}
if (pcr != NULL && IsBadWritePtr(pcr, sizeof(CHARACTER_RANGE) * (*pcRanges)))
{
return E_POINTER;
}
cChar = g_locRunInfo.cCodePoints - 1;
aw = (WCHAR *) ExternAlloc(cChar * sizeof(WCHAR));
if (!aw)
{
return E_OUTOFMEMORY;
}
for (i = 1; i < g_locRunInfo.cCodePoints; i++)
{
aw[i - 1] = LocRunDense2Unicode(&g_locRunInfo, (WCHAR) i);
}
if (cChar == 0)
{
cRange = 0;
}
else
{
qsort((void*)aw, (size_t)cChar, sizeof(WCHAR), CompareWCHAR);
// count the ranges
cRange = 1;
for (i = 1; i < cChar; i++)
{
if (aw[i] > aw[i - 1] + 1)
cRange++;
}
}
if (!pcr) // Need only a count of ranges
{
*pcRanges = cRange;
goto cleanup;
}
if (*pcRanges < cRange)
{
hr = TPC_E_INSUFFICIENT_BUFFER;
goto cleanup;
}
if (*pcRanges > cRange)
{
*pcRanges = cRange;
}
if (*pcRanges > 0)
{
// convert the array of Unicode values to an array of CHARACTER_RANGEs
pcr[iRange].wcLow = aw[0];
pcr[iRange].cChars = 1;
for (i = 1; i < cChar; i++)
{
if (aw[i] == aw[i - 1] + 1)
pcr[iRange].cChars++;
else
{
if (iRange >= (*pcRanges) - 1)
{
break;
}
iRange++;
pcr[iRange].wcLow = aw[i];
pcr[iRange].cChars = 1;
}
}
ASSERT(iRange == (*pcRanges) - 1);
}
cleanup:
ExternFree(aw);
return hr;
}
// GetEnabledUnicodeRanges
//
// Parameters:
// hrc [in] : Handle to the recognition context
// pcRanges [in/out] : Count of ranges
// pcr [out] : Array of character ranges
////////////////////////////////////////////////////////////////////////////////
HRESULT WINAPI GetEnabledUnicodeRanges(HRECOCONTEXT hrc,
ULONG *pcRanges,
CHARACTER_RANGE *pcr)
{
VRC *pVRC;
CHARSET charset;
WCHAR *aw;
int cChar, i;
ULONG cRange, iRange = 0;
HRESULT hr = S_OK;
BOOL fCreatedHRC = FALSE;
struct WispContext *wisphrc;
// validate the correpsonding hrc pointer
wisphrc = (struct WispContext *) FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (wisphrc == NULL)
{
return E_INVALIDARG;
}
if (IsBadWritePtr(pcRanges, sizeof(ULONG)))
{
return E_POINTER;
}
if (pcr != NULL && IsBadWritePtr(pcr, sizeof(CHARACTER_RANGE) * *(pcRanges)))
{
return E_POINTER;
}
cChar = 0;
aw = (WCHAR *) ExternAlloc((g_locRunInfo.cCodePoints - 1) * sizeof(WCHAR));
if (!aw)
return E_OUTOFMEMORY;
// If we have an HRC, the factoid should be set already. If not, we'll have
// to make one.
if (wisphrc->hrc == NULL)
{
fCreatedHRC = TRUE;
hr = CreateHRCinContext(wisphrc);
}
pVRC = (VRC *) wisphrc->hrc;
if (SUCCEEDED(hr) && pVRC != NULL)
{
charset.recmask = pVRC->pLattice->alcFactoid;
charset.pbAllowedChars = pVRC->pLattice->pbFactoidChars;
for (i = 1; i < g_locRunInfo.cCodePoints; i++)
{
if (IsAllowedChar(&g_locRunInfo, &charset, (WCHAR) i))
{
aw[cChar++] = LocRunDense2Unicode(&g_locRunInfo, (WCHAR) i);
}
}
}
if (fCreatedHRC)
{
// Destroy the HRC if we created one.
if (wisphrc->hrc != NULL)
{
if (wisphrc->bIsBoxed)
HwxDestroy(wisphrc->hrc);
else
DestroyHRC(wisphrc->hrc);
wisphrc->hrc = NULL;
}
}
if (cChar == 0)
{
cRange = 0;
}
else
{
qsort((void*)aw, (size_t)cChar, sizeof(WCHAR), CompareWCHAR);
// count the ranges
cRange = 1;
for (i = 1; i < cChar; i++)
{
if (aw[i] > aw[i - 1] + 1)
cRange++;
}
}
if (!pcr) // Need only a count of ranges
{
*pcRanges = cRange;
goto cleanup;
}
if (*pcRanges < cRange)
{
hr = TPC_E_INSUFFICIENT_BUFFER;
goto cleanup;
}
if (*pcRanges > cRange)
{
*pcRanges = cRange;
}
if (*pcRanges > 0)
{
// convert the array of Unicode values to an array of CHARACTER_RANGEs
pcr[iRange].wcLow = aw[0];
pcr[iRange].cChars = 1;
for (i = 1; i < cChar; i++)
{
if (aw[i] == aw[i - 1] + 1)
pcr[iRange].cChars++;
else
{
if (iRange >= (*pcRanges) - 1)
{
break;
}
iRange++;
pcr[iRange].wcLow = aw[i];
pcr[iRange].cChars = 1;
}
}
ASSERT(iRange == (*pcRanges) - 1);
}
cleanup:
ExternFree(aw);
return hr;
}
// SetEnabledUnicodeRanges
//
// Parameters:
// hrc [in] : Handle to the recognition context
// pcRanges [in/out] : Count of ranges
// pcr [out] : Array of character ranges
////////////////////////////////////////////////////////////////////////////////
HRESULT WINAPI SetEnabledUnicodeRanges(HRECOCONTEXT hrc,
ULONG cRanges,
CHARACTER_RANGE *pcr)
{
struct WispContext *wisphrc;
// validate the correpsonding hrc pointer
wisphrc = (struct WispContext *) FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (wisphrc == NULL)
{
return E_INVALIDARG;
}
if (IsBadReadPtr(pcr, sizeof(CHARACTER_RANGE) * cRanges))
{
return E_POINTER;
}
return E_NOTIMPL;
}
////////////////////////
// IAlternate
////////////////////////
HRESULT WINAPI GetString(HRECOALT hrcalt, RECO_RANGE *pRecoRange, ULONG* pcSize, WCHAR* szString)
{
struct WispContext *wisphrc;
struct WispAlternate *wispalt;
VRC *vrc = NULL;
HRESULT hr = S_OK;
ULONG i = 0, ulSize = 0;
// find the handle and validate the correpsonding pointer
wispalt = (struct WispAlternate*)FindTpgHandle((HANDLE)hrcalt, TPG_HRECOALT);
if (NULL == wispalt)
{
return E_INVALIDARG;
}
// validate the correpsonding hrc pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)wispalt->hrc, TPG_HRECOCONTEXT);
if (wisphrc == NULL)
{
return E_INVALIDARG;
}
if (pRecoRange && IsBadWritePtr(pRecoRange, sizeof(RECO_RANGE)))
{
return E_POINTER;
}
if (IsBadWritePtr(pcSize, sizeof(ULONG)))
{
return E_POINTER;
}
// if the string pointer is not null, validate it
if (szString && IsBadWritePtr(szString, (*pcSize) * sizeof (*szString)))
{
return E_POINTER;
}
vrc = (VRC*)wisphrc->hrc;
if (!vrc)
{
return E_POINTER;
}
if (pRecoRange)
{
pRecoRange->iwcBegin = wispalt->OriginalRecoRange.iwcBegin;
pRecoRange->cCount = wispalt->OriginalRecoRange.cCount;
}
ulSize = (ULONG)wispalt->iLength;
if (!szString)
{
*pcSize = ulSize;
return S_OK;
}
if (*pcSize > ulSize)
{
*pcSize = ulSize;
}
if (*pcSize < ulSize)
{
hr = TPC_S_TRUNCATED;
}
// Fill the string
for (i = 0; i<*pcSize; i++)
{
// Fill the characters in the string
if (wispalt->pIndexInColumn[i] == SPACE_ALT_ID)
{
szString[i] = SYM_SPACE;
}
else
if (vrc->pLattice->pAltList[wispalt->pColumnIndex[i]].alts[wispalt->pIndexInColumn[i]].wChar != SYM_UNKNOWN)
{
szString[i] = LocRunDense2Unicode(&g_locRunInfo,
vrc->pLattice->pAltList[wispalt->pColumnIndex[i]].alts[wispalt->pIndexInColumn[i]].wChar);
}
else
{
szString[i] = SYM_UNKNOWN;
}
}
return hr;
}
HRESULT WINAPI GetStrokeRanges(HRECOALT hrcalt, RECO_RANGE* pRecoRange, ULONG* pcRanges, STROKE_RANGE* pStrokeRange)
{
HRESULT hr = S_OK;
RECO_RANGE recoRange;
struct WispContext *wisphrc;
struct WispAlternate *wispalt;
VRC *vrc;
ULONG ulStrokeCount = 0, ulCurrentIndex = 0;
ULONG i = 0;
int j = 0;
int k = 0;
ULONG *StrokeArray = NULL;
ULONG ulStrokeRangesCount = 0;
ULONG iCurrentStrokeRange = 0;
// find the handle and validate the corresponding pointer
wispalt = (struct WispAlternate*)FindTpgHandle((HANDLE)hrcalt, TPG_HRECOALT);
if (NULL == wispalt)
{
return E_INVALIDARG;
}
// validate the corresponding hrc pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)wispalt->hrc, TPG_HRECOCONTEXT);
if (wisphrc == NULL)
{
return E_INVALIDARG;
}
vrc = (VRC *) wisphrc->hrc;
if (vrc == NULL)
{
return E_INVALIDARG;
}
if (IsBadReadPtr(pRecoRange, sizeof(RECO_RANGE)))
{
return E_POINTER;
}
if (IsBadWritePtr(pcRanges, sizeof(ULONG)))
{
return E_POINTER;
}
// validate pointer if not null
if (pStrokeRange && IsBadWritePtr(pStrokeRange, (*pcRanges) * sizeof (*pStrokeRange)))
{
return E_POINTER;
}
recoRange = *pRecoRange;
if (!recoRange.cCount)
{
*pcRanges = 0;
return S_OK;
}
if (recoRange.iwcBegin + recoRange.cCount > (ULONG)wispalt->iLength)
return E_INVALIDARG;
// Get the number of strokes
for (i = recoRange.iwcBegin; i < recoRange.iwcBegin + recoRange.cCount; i++)
{
// Make sure we're not looking at a space
if (wispalt->pIndexInColumn[i] != SPACE_ALT_ID)
{
// There might be some stroke that have been merged!
// We need to examine every single column to know if strokes have been merged
// (and also how many times)
for (j = 0; j < vrc->pLattice->pAltList[wispalt->pColumnIndex[i]].alts[wispalt->pIndexInColumn[i]].nStrokes; j++)
{
ulStrokeCount += vrc->pLattice->pStroke[wispalt->pColumnIndex[i]-j].iLast -
vrc->pLattice->pStroke[wispalt->pColumnIndex[i]-j].iOrder + 1;
}
}
}
// If there aren't any strokes, then exit early.
// (The rest of this function behaves badly if there are no strokes or no ranges.)
if (ulStrokeCount == 0)
{
*pcRanges = 0;
return S_OK;
}
// Allocate the array of strokes
StrokeArray = (ULONG*)ExternAlloc(sizeof(ULONG)*ulStrokeCount);
if (!StrokeArray)
{
ASSERT(StrokeArray);
return E_OUTOFMEMORY;
}
// Get the array of strokes
ulCurrentIndex = 0;
for (i = recoRange.iwcBegin; i < recoRange.iwcBegin + recoRange.cCount; i++)
{
// Make sure we're not looking at a space
if (wispalt->pIndexInColumn[i] != SPACE_ALT_ID)
{
// This loop goes backwards so we get the strokes in order
for (j = vrc->pLattice->pAltList[wispalt->pColumnIndex[i]].alts[wispalt->pIndexInColumn[i]].nStrokes - 1; j >= 0; j--)
{
// There might more than one stroke here
// because of the possibility of a stroke merge!!!
for (k = vrc->pLattice->pStroke[wispalt->pColumnIndex[i]-j].iOrder;
k <= vrc->pLattice->pStroke[wispalt->pColumnIndex[i]-j].iLast;
k++)
{
StrokeArray[ulCurrentIndex] = k;
ulCurrentIndex++;
}
}
}
}
// Sort the array
SlowSort(StrokeArray, ulStrokeCount);
// Get the number of STROKE_RANGES needed
ulStrokeRangesCount = 1;
for (i = 1; i<ulStrokeCount; i++)
{
if (StrokeArray[i-1]+1!=StrokeArray[i]) ulStrokeRangesCount++;
}
// Return the count is this is all that is asked
if (!pStrokeRange)
{
*pcRanges = ulStrokeRangesCount;
ExternFree(StrokeArray);
return S_OK;
}
if (*pcRanges < ulStrokeRangesCount)
{
ExternFree(StrokeArray);
return TPC_E_INSUFFICIENT_BUFFER;
}
// Fill in the Strokes
iCurrentStrokeRange = 0;
pStrokeRange[iCurrentStrokeRange].iStrokeBegin = StrokeArray[0];
pStrokeRange[ulStrokeRangesCount-1].iStrokeEnd = StrokeArray[ulStrokeCount-1];
for(i = 1; i < ulStrokeCount; i++)
{
if (StrokeArray[i-1]+1!=StrokeArray[i])
{
pStrokeRange[iCurrentStrokeRange].iStrokeEnd = StrokeArray[i-1];
iCurrentStrokeRange++;
if (iCurrentStrokeRange == ulStrokeRangesCount) break;
pStrokeRange[iCurrentStrokeRange].iStrokeBegin = StrokeArray[i];
}
}
*pcRanges = ulStrokeRangesCount;
ExternFree(StrokeArray);
return hr;
}
typedef struct AltScore
{
float flScore;
int iAlt;
BOOL fCurrentPath;
} AltScore;
int __cdecl CompareAltScore(const void *p1, const void *p2)
{
const AltScore *pAlt1 = (const AltScore *) p1;
const AltScore *pAlt2 = (const AltScore *) p2;
if (pAlt1->fCurrentPath) return -1;
if (pAlt2->fCurrentPath) return 1;
if (pAlt1->flScore > pAlt2->flScore) return -1;
if (pAlt1->flScore < pAlt2->flScore) return 1;
return 0;
}
HRESULT WINAPI GetSegmentAlternateList(HRECOALT hrcalt, RECO_RANGE* pRecoRange, ULONG *pcAlts, HRECOALT* pAlts)
{
HRESULT hr = S_OK;
struct WispAlternate *wispalt;
struct WispContext *wisphrc;
VRC *vrc;
ULONG ulMaxAlt = 0;
struct WispAlternate *pWispAlt = NULL;
int i = 0;
int j = 0;
ULONG ulCurrentIndex = 0;
// find the handle and validate the correpsonding pointer
wispalt = (struct WispAlternate*)FindTpgHandle((HANDLE)hrcalt, TPG_HRECOALT);
if (NULL == wispalt)
{
return E_INVALIDARG;
}
// validate the corresponding hrc pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)wispalt->hrc, TPG_HRECOCONTEXT);
if (wisphrc == NULL)
{
return E_INVALIDARG;
}
vrc = (VRC *) wisphrc->hrc;
if (vrc == NULL)
{
return E_INVALIDARG;
}
if (IsBadWritePtr(pRecoRange, sizeof(RECO_RANGE)))
{
return E_POINTER;
}
if (IsBadWritePtr(pcAlts, sizeof(ULONG)))
{
return E_POINTER;
}
if (pAlts && IsBadWritePtr(pAlts, (*pcAlts) * sizeof (*pAlts)))
{
return E_POINTER;
}
// Check that the pRecoRange is valid:
if (pRecoRange->cCount == 0 ||
pRecoRange->iwcBegin + pRecoRange->cCount > (ULONG)wispalt->iLength)
{
return E_INVALIDARG;
}
// Get the number of alternates for this character (with the same number of strokes!!!)
ulMaxAlt = 0;
// if this char is a space
if (wispalt->pIndexInColumn[pRecoRange->iwcBegin] == SPACE_ALT_ID)
{
if (!pAlts)
{
*pcAlts = 1;
}
if (pAlts && *pcAlts > 0)
{
pWispAlt = (struct WispAlternate *)ExternAlloc(sizeof(struct WispAlternate));
if (!pWispAlt)
{
return E_OUTOFMEMORY;
}
pWispAlt->hrc = wispalt->hrc;
pWispAlt->iLength = 1;
pWispAlt->iNumberOfColumns = 1;
pWispAlt->OriginalRecoRange = *pRecoRange;
pWispAlt->pColumnIndex = NULL;
pWispAlt->pIndexInColumn = NULL;
pWispAlt->pColumnIndex = ExternAlloc(sizeof(int));
pWispAlt->pIndexInColumn = ExternAlloc(sizeof(int));
if (!pWispAlt->pColumnIndex || !pWispAlt->pIndexInColumn)
{
// Problem allocating memory, unallocate the array
HRESULT hrDA = DestroyAlternateInternal(pWispAlt);
ASSERT(SUCCEEDED(hrDA));
return E_OUTOFMEMORY;
}
pWispAlt->pColumnIndex[0] = wispalt->pColumnIndex[pRecoRange->iwcBegin];
pWispAlt->pIndexInColumn[0] = SPACE_ALT_ID;
pAlts[0] = (HRECOALT) CreateTpgHandle(TPG_HRECOALT, pWispAlt);
if (pAlts[0] == NULL)
{
// Problem allocating memory, unallocate the array
HRESULT hrDA = DestroyAlternateInternal(pWispAlt);
ASSERT(SUCCEEDED(hrDA));
return E_OUTOFMEMORY;
}
*pcAlts = 1;
}
}
else
{
AltScore *pAltScores;
int iCurrentPath = -1;
for (i = 0; i < vrc->pLattice->pAltList[wispalt->pColumnIndex[pRecoRange->iwcBegin]].nUsed; i++)
{
if (vrc->pLattice->pAltList[wispalt->pColumnIndex[pRecoRange->iwcBegin]].alts[i].nStrokes ==
vrc->pLatticePath->pElem[pRecoRange->iwcBegin].nStrokes)
ulMaxAlt++;
}
if (!pAlts)
{
*pcAlts = ulMaxAlt;
return S_OK;
}
pAltScores = (AltScore *) ExternAlloc(sizeof(AltScore) * ulMaxAlt);
if (pAltScores == NULL)
{
return E_OUTOFMEMORY;
}
ulCurrentIndex = 0;
for (i = 0; i < vrc->pLattice->pAltList[wispalt->pColumnIndex[pRecoRange->iwcBegin]].nUsed; i++)
{
// Do the stuff only when we have the same number of strokes
if (vrc->pLattice->pAltList[wispalt->pColumnIndex[pRecoRange->iwcBegin]].alts[i].nStrokes ==
vrc->pLatticePath->pElem[pRecoRange->iwcBegin].nStrokes)
{
pAltScores[ulCurrentIndex].fCurrentPath = vrc->pLattice->pAltList[wispalt->pColumnIndex[pRecoRange->iwcBegin]].alts[i].fCurrentPath;
pAltScores[ulCurrentIndex].iAlt = i;
pAltScores[ulCurrentIndex].flScore =
vrc->pLattice->pAltList[wispalt->pColumnIndex[pRecoRange->iwcBegin]].alts[i].logProbPath;
// GetScore(vrc->pLattice, wispalt->pColumnIndex[pRecoRange->iwcBegin], i);
ulCurrentIndex++;
}
}
qsort(pAltScores, ulMaxAlt, sizeof(AltScore), CompareAltScore);
if (*pcAlts>ulMaxAlt) *pcAlts = ulMaxAlt;
// Fill in the array of alternates
for (i = 0; i < (int)(*pcAlts); i++)
{
// Create an alternate
pWispAlt = (struct WispAlternate *)ExternAlloc(sizeof(struct WispAlternate));
if (!pWispAlt)
{
// Problem allocating memory, unallocate the array
ExternFree(pAltScores);
for (j = 0; j < i; j++)
{
HRESULT hrDA = DestroyAlternate(pAlts[j]);
ASSERT(SUCCEEDED(hrDA));
}
return E_OUTOFMEMORY;
}
pWispAlt->hrc = wispalt->hrc;
pWispAlt->iLength = 1;
pWispAlt->iNumberOfColumns = 1;
pWispAlt->OriginalRecoRange = *pRecoRange;
pWispAlt->pColumnIndex = NULL;
pWispAlt->pIndexInColumn = NULL;
pWispAlt->pColumnIndex = ExternAlloc(sizeof(int));
pWispAlt->pIndexInColumn = ExternAlloc(sizeof(int));
if (!pWispAlt->pColumnIndex || !pWispAlt->pIndexInColumn)
{
// Problem allocating memory, unallocate the array
ExternFree(pAltScores);
for (j = 0; j < i; j++)
{
HRESULT hrDA = DestroyAlternate(pAlts[j]);
ASSERT(SUCCEEDED(hrDA));
}
return E_OUTOFMEMORY;
}
pWispAlt->pColumnIndex[0] = wispalt->pColumnIndex[pRecoRange->iwcBegin];
pWispAlt->pIndexInColumn[0] = pAltScores[i].iAlt;
pAlts[i] = CreateTpgHandle(TPG_HRECOALT, pWispAlt);
if (pAlts[i] == NULL)
{
// Problem allocating memory, unallocate the array
ExternFree(pAltScores);
for (j = 0; j < i; j++)
{
HRESULT hrDA = DestroyAlternate(pAlts[j]);
ASSERT(SUCCEEDED(hrDA));
}
return E_OUTOFMEMORY;
}
}
ExternFree(pAltScores);
}
pRecoRange->cCount = 1;
return hr;
}
HRESULT WINAPI GetMetrics(HRECOALT hrcalt, RECO_RANGE* pRecoRange, LINE_METRICS lm, LINE_SEGMENT* pls)
{
struct WispAlternate *wispalt;
struct WispContext *wisphrc;
VRC *vrc;
HRESULT hr = S_OK;
ULONG index = 0;
LONG lPrevChar = 0;
float flTotalY = 0;
int cCharacters = 0;
// find the handle and validate the correpsonding pointer
wispalt = (struct WispAlternate*)FindTpgHandle((HANDLE)hrcalt, TPG_HRECOALT);
if (NULL == wispalt)
{
return E_INVALIDARG;
}
// validate the corresponding hrc pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)wispalt->hrc, TPG_HRECOCONTEXT);
if (wisphrc == NULL)
{
return E_INVALIDARG;
}
vrc = (VRC *) wisphrc->hrc;
if (vrc == NULL)
{
return E_INVALIDARG;
}
if (IsBadWritePtr(pRecoRange, sizeof(RECO_RANGE)))
{
return E_POINTER;
}
if (IsBadWritePtr(pls, sizeof(LINE_SEGMENT)))
{
return E_POINTER;
}
if (pRecoRange->cCount == 0 ||
pRecoRange->iwcBegin+pRecoRange->cCount > (ULONG)wispalt->iLength)
{
return E_INVALIDARG;
}
// First trim spaces (if any) from the beginning and end of the reco range
while (pRecoRange->cCount > 0 && wispalt->pIndexInColumn[pRecoRange->iwcBegin] == SPACE_ALT_ID)
{
pRecoRange->iwcBegin++;
pRecoRange->cCount--;
}
while (pRecoRange->cCount > 0 && wispalt->pIndexInColumn[pRecoRange->iwcBegin + pRecoRange->cCount - 1] == SPACE_ALT_ID)
{
pRecoRange->cCount--;
}
// If the range only contained spaces, then return an error
if (pRecoRange->cCount == 0)
{
return TPC_E_NOT_RELEVANT;
}
index = 0;
lPrevChar = 0;
// Right now we only work from left to right, top to bottom so we will compare the x coordinates
// of two consecutive writing boxes to know if we have a new line
while (index < pRecoRange->cCount)
{
int iColumn = wispalt->pColumnIndex[pRecoRange->iwcBegin+index];
int iIndexInColumn = wispalt->pIndexInColumn[pRecoRange->iwcBegin+index];
// Skip over spaces in the range
if (iIndexInColumn == SPACE_ALT_ID)
{
index++;
continue;
}
// Check if we switched to a new line
if (index > 0 &&
lPrevChar > vrc->pLattice->pAltList[iColumn].alts[iIndexInColumn].writingBox.left)
{
// Looks like we moved to a new line, modify the reco range to end here and exit the loop.
pRecoRange->cCount = index;
// Back up over spaces until we reach the actual end of the previous line
while (pRecoRange->cCount > 0 && wispalt->pIndexInColumn[pRecoRange->iwcBegin + pRecoRange->cCount - 1] == SPACE_ALT_ID)
{
pRecoRange->cCount--;
}
break;
}
lPrevChar = vrc->pLattice->pAltList[iColumn].alts[iIndexInColumn].writingBox.left;
switch(lm)
{
case LM_BASELINE:
case LM_DESCENDER:
flTotalY += vrc->pLattice->pAltList[iColumn].alts[iIndexInColumn].writingBox.bottom;
break;
case LM_MIDLINE:
flTotalY += (vrc->pLattice->pAltList[iColumn].alts[iIndexInColumn].writingBox.bottom +
vrc->pLattice->pAltList[iColumn].alts[iIndexInColumn].writingBox.top) / 2;
break;
case LM_ASCENDER:
flTotalY += vrc->pLattice->pAltList[iColumn].alts[iIndexInColumn].writingBox.top;
break;
default:
ASSERT(!lm);
return E_INVALIDARG;
}
index++;
cCharacters++;
}
// Average the y positions
pls->PtA.y = (LONG) (flTotalY / cCharacters);
pls->PtB.y = pls->PtA.y;
// Set the x range based on the updated reco range
pls->PtA.x = vrc->pLattice->pAltList[wispalt->pColumnIndex[pRecoRange->iwcBegin]].alts[wispalt->pIndexInColumn[pRecoRange->iwcBegin]].writingBox.left;
pls->PtB.x = vrc->pLattice->pAltList[wispalt->pColumnIndex[pRecoRange->iwcBegin+pRecoRange->cCount-1]].alts[wispalt->pIndexInColumn[pRecoRange->iwcBegin+pRecoRange->cCount-1]].writingBox.right;
return hr;
}
HRESULT WINAPI GetGuideIndex(HRECOALT hrcalt, RECO_RANGE* pRecoRange, ULONG *piIndex)
{
struct WispAlternate *wispalt;
struct WispContext *wisphrc;
VRC *vrc;
// find the handle and validate the correpsonding pointer
wispalt = (struct WispAlternate*)FindTpgHandle((HANDLE)hrcalt, TPG_HRECOALT);
if (NULL == wispalt)
{
return E_INVALIDARG;
}
// validate the corresponding hrc pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)wispalt->hrc, TPG_HRECOCONTEXT);
if (wisphrc == NULL)
{
return E_INVALIDARG;
}
vrc = (VRC *) wisphrc->hrc;
if (vrc == NULL)
{
return E_INVALIDARG;
}
if (IsBadWritePtr(pRecoRange, sizeof(RECO_RANGE)))
{
return E_POINTER;
}
if (IsBadWritePtr(piIndex, sizeof(ULONG)))
{
return E_POINTER;
}
if (!pRecoRange->cCount)
{
return E_INVALIDARG;
}
if (pRecoRange->iwcBegin + pRecoRange->cCount > (ULONG)wispalt->iLength)
{
return E_INVALIDARG;
}
if (!wisphrc->bIsBoxed)
{
return TPC_E_NOT_RELEVANT;
}
// Ok we are clean
pRecoRange->cCount = 1;
// Find the Guide index for this character
*piIndex = wisphrc->uiGuideIndex;
*piIndex += vrc->pLattice->pStroke[wispalt->pColumnIndex[pRecoRange->iwcBegin]].iBox;
// We should not have any spaces in boxed mode. But just in case, let's try to deal with
// them in a reasonable way, by assuming the space comes in the box immediately after
// the box containing the stroke.
if (wispalt->pIndexInColumn[pRecoRange->iwcBegin] == SPACE_ALT_ID)
{
(*piIndex)++;
}
return S_OK;
}
// If the specified character is a space or on the current path, return medium
// confidence. Otherwise return poor.
CONFIDENCE_LEVEL GetConfidenceLevelInternal(VRC *vrc, int iColumn, int iAlt)
{
if (iAlt == SPACE_ALT_ID || vrc->pLattice->pAltList[iColumn].alts[iAlt].fCurrentPath)
{
return CFL_INTERMEDIATE;
}
else
{
return CFL_POOR;
}
}
HRESULT WINAPI GetConfidenceLevel(HRECOALT hrcalt, RECO_RANGE* pRecoRange, CONFIDENCE_LEVEL* pcl)
{
struct WispAlternate *wispalt;
struct WispContext *wisphrc;
VRC *vrc;
// find the handle and validate the correpsonding pointer
wispalt = (struct WispAlternate*)FindTpgHandle((HANDLE)hrcalt, TPG_HRECOALT);
if (NULL == wispalt)
{
return E_INVALIDARG;
}
// validate the corresponding hrc pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)wispalt->hrc, TPG_HRECOCONTEXT);
if (wisphrc == NULL)
{
return E_INVALIDARG;
}
vrc = (VRC *) wisphrc->hrc;
// Check the parameters
if (pRecoRange != NULL)
{
if (IsBadWritePtr(pRecoRange, sizeof(RECO_RANGE)))
{
return E_POINTER;
}
if (!pRecoRange->cCount)
{
return E_INVALIDARG;
}
if (pRecoRange->iwcBegin + pRecoRange->cCount > (ULONG)wispalt->iLength)
{
return E_INVALIDARG;
}
}
if (IsBadWritePtr(pcl, sizeof(CONFIDENCE_LEVEL)))
{
return E_POINTER;
}
#ifndef ENABLE_CONFIDENCE_LEVEL
// Ok we are clean
return E_NOTIMPL;
#else
if (pRecoRange != NULL)
{
// We only return confidence for single characters
pRecoRange->cCount = 1;
// If the specified character is a space or on the current path, return medium
// confidence. Otherwise return poor.
*pcl = GetConfidenceLevelInternal(vrc, wispalt->pColumnIndex[pRecoRange->iwcBegin], wispalt->pIndexInColumn[pRecoRange->iwcBegin]);
}
else
{
// If the first character is a space or on the current path, return medium
// confidence. Otherwise return poor.
*pcl = GetConfidenceLevelInternal(vrc, wispalt->pColumnIndex[0], wispalt->pIndexInColumn[0]);
}
return S_OK;
#endif
}
HRESULT WINAPI GetPropertyRanges(HRECOALT hrcalt, const GUID *pPropertyGuid, ULONG* pcRanges, RECO_RANGE* pRecoRange)
{
struct WispAlternate *wispalt;
struct WispContext *wisphrc;
VRC *vrc;
// find the handle and validate the correpsonding pointer
wispalt = (struct WispAlternate*)FindTpgHandle((HANDLE)hrcalt, TPG_HRECOALT);
if (NULL == wispalt)
{
return E_INVALIDARG;
}
// validate the corresponding hrc pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)wispalt->hrc, TPG_HRECOCONTEXT);
if (wisphrc == NULL)
{
return E_INVALIDARG;
}
vrc = (VRC *) wisphrc->hrc;
if (IsBadReadPtr(pPropertyGuid, sizeof(GUID)))
{
return E_POINTER;
}
if (IsBadWritePtr(pcRanges, sizeof(ULONG)))
{
return E_POINTER;
}
if (pRecoRange != NULL && IsBadWritePtr(pRecoRange, sizeof(RECO_RANGE) * (*pcRanges)))
{
return E_POINTER;
}
if (IsEqualGUID(pPropertyGuid, &GUID_LINEMETRICS))
{
return TPC_E_NOT_RELEVANT;
}
#ifdef ENABLE_CONFIDENCE_LEVEL
if (IsEqualGUID(pPropertyGuid, &GUID_CONFIDENCELEVEL))
{
CONFIDENCE_LEVEL clPrev, clThis;
int iRange = 0;
int i;
for (i = 0; i < wispalt->iLength; i++)
{
clThis = GetConfidenceLevelInternal(vrc, wispalt->pColumnIndex[i], wispalt->pIndexInColumn[i]);
if (i == 0 || (clPrev != clThis))
{
iRange++;
}
clPrev = clThis;
}
if (pRecoRange != NULL && *pcRanges < (ULONG) iRange)
{
return TPC_E_INSUFFICIENT_BUFFER;
}
*pcRanges = iRange;
if (pRecoRange != NULL)
{
iRange = 0;
for (i = 0; i < wispalt->iLength; i++)
{
clThis = GetConfidenceLevelInternal(vrc, wispalt->pColumnIndex[i], wispalt->pIndexInColumn[i]);
if (i == 0 || (clPrev != clThis))
{
pRecoRange[iRange].iwcBegin = i;
pRecoRange[iRange].cCount = 1;
iRange++;
}
else
{
pRecoRange[iRange - 1].cCount++;
}
clPrev = clThis;
}
}
return S_OK;
}
#endif
return TPC_E_INVALID_PROPERTY;
}
HRESULT WINAPI GetRangePropertyValue(HRECOALT hrcalt, const GUID *pPropertyGuid, RECO_RANGE* pRecoRange, ULONG*pcbSize, BYTE* pProperty)
{
struct WispAlternate *wispalt;
struct WispContext *wisphrc;
VRC *vrc;
// find the handle and validate the correpsonding pointer
wispalt = (struct WispAlternate*)FindTpgHandle((HANDLE)hrcalt, TPG_HRECOALT);
if (NULL == wispalt)
{
return E_INVALIDARG;
}
// validate the corresponding hrc pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)wispalt->hrc, TPG_HRECOCONTEXT);
if (wisphrc == NULL)
{
return E_INVALIDARG;
}
vrc = (VRC *) wisphrc->hrc;
if (IsBadReadPtr(pPropertyGuid, sizeof(GUID)))
{
return E_POINTER;
}
if (IsBadWritePtr(pRecoRange, sizeof(RECO_RANGE)))
{
return E_POINTER;
}
if (IsBadWritePtr(pcbSize, sizeof(ULONG)))
{
return E_POINTER;
}
if (pProperty != NULL && IsBadWritePtr(pProperty, *pcbSize))
{
return E_POINTER;
}
if (IsEqualGUID(pPropertyGuid, &GUID_LINEMETRICS))
{
HRESULT hr = S_OK;
LINE_SEGMENT baseline, midline;
if (pProperty == NULL)
{
*pcbSize = sizeof(LATTICE_METRICS);
}
else if (*pcbSize < sizeof(LATTICE_METRICS))
{
return TPC_E_INSUFFICIENT_BUFFER;
}
*pcbSize = sizeof(LATTICE_METRICS);
hr = GetMetrics(hrcalt, pRecoRange, LM_BASELINE, &baseline);
if (SUCCEEDED(hr))
{
hr = GetMetrics(hrcalt, pRecoRange, LM_MIDLINE, &midline);
}
if (SUCCEEDED(hr) && pProperty != NULL)
{
LATTICE_METRICS *plm = (LATTICE_METRICS *) pProperty;
plm->lsBaseline = baseline;
plm->iMidlineOffset = (short)(midline.PtA.y - baseline.PtA.y);
}
return hr;
}
#ifdef ENABLE_CONFIDENCE_LEVEL
if (IsEqualGUID(pPropertyGuid, &GUID_CONFIDENCELEVEL))
{
CONFIDENCE_LEVEL cl;
int iStart = pRecoRange->iwcBegin;
int iLimit = pRecoRange->iwcBegin + pRecoRange->cCount;
int i;
if (pProperty == NULL)
{
*pcbSize = sizeof(CONFIDENCE_LEVEL);
}
else if (*pcbSize < sizeof(CONFIDENCE_LEVEL))
{
return TPC_E_INSUFFICIENT_BUFFER;
}
*pcbSize = sizeof(CONFIDENCE_LEVEL);
cl = GetConfidenceLevelInternal(vrc, wispalt->pColumnIndex[iStart],
wispalt->pIndexInColumn[iStart]);
for (i = iStart + 1; i < iLimit; i++)
{
if (GetConfidenceLevelInternal(vrc, wispalt->pColumnIndex[i], wispalt->pIndexInColumn[i]) != cl)
{
pRecoRange->cCount = i - iStart;
break;
}
}
if (pProperty != NULL)
{
*((CONFIDENCE_LEVEL *) pProperty) = cl;
}
return S_OK;
}
#endif
return TPC_E_INVALID_PROPERTY;
}
void SortLatticeElements(RECO_LATTICE_ELEMENT *pStartElement, RECO_LATTICE_ELEMENT *pCurrent)
{
RECO_LATTICE_ELEMENT rleTemp;
BOOL bSwap = TRUE;
int iElementCount = pCurrent - pStartElement;
int i = 0, count = 0;
// For now just a quick bubble sort
count = 1;
while (bSwap)
{
bSwap = FALSE;
for (i = 0; i < iElementCount-count; i++)
{
if (pStartElement[i].score > pStartElement[i+1].score)
{
// swap
rleTemp = pStartElement[i];
pStartElement[i] = pStartElement[i+1];
pStartElement[i+1] = rleTemp;
bSwap = TRUE;
}
}
count++;
}
}
// GetLatticePtr
//
// Description: This method creates a Lattice structure for
// the recognition context and returns a pointer to it. The
// structure is going to be freed when the recognition
// context is destoyed or when a new call to GetLatticePtr
// is issued.
HRESULT WINAPI GetLatticePtr(HRECOCONTEXT hrc, RECO_LATTICE **ppLattice)
{
BOOL fNextColumnSpace = FALSE;
HRESULT hr = S_OK;
struct WispContext *wisphrc;
RECO_LATTICE_ELEMENT *pCurrent = NULL, *pStartElement = NULL, rleInPath;
int *pMapToLatticeColumn = NULL;
VRC *vrc = NULL;
int i = 0, j = 0, k = 0;
ULONG ulElementCount = 0, ulRealElementCount = 0;
ULONG ulMaxStroke = 0;
ULONG *pCurrentStroke = NULL;
ULONG ulBestResultIndex = 0;
RECO_LATTICE_ELEMENT *pCur = NULL;
int iStroke;
int iExternalColumn;
BYTE *pCurrentPropertyValue = NULL;
RECO_LATTICE_PROPERTY *pCurrentProperty = NULL;
RECO_LATTICE_PROPERTY *pConfidencePropStart = NULL;
RECO_LATTICE_PROPERTY **ppCurrentProperty = NULL;
LATTICE_METRICS *pLatticeMetrics;
FLOAT flScore;
// validate and destroy the handle & return the pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (NULL == wisphrc)
{
return E_INVALIDARG;
}
// Check the parameters
if (IsBadWritePtr(ppLattice, sizeof(RECO_LATTICE*)))
{
return E_POINTER;
}
*ppLattice = NULL;
// We should only do this if the lattice is dirty!
if (wisphrc->pLattice)
{
hr = FreeRecoLattice(wisphrc);
ASSERT(SUCCEEDED(hr));
hr = S_OK;
}
// Do we have results?
if (!wisphrc->hrc)
{
return TPC_E_NOT_RELEVANT;
}
vrc = (VRC*) wisphrc->hrc;
if (!vrc->pLatticePath)
{
return TPC_E_NOT_RELEVANT;
}
// Allocate the lattice
wisphrc->pLattice = (RECO_LATTICE*)ExternAlloc(sizeof(RECO_LATTICE));
if (!wisphrc->pLattice)
{
return E_OUTOFMEMORY;
}
// Initialize the RECO_LATTICE structure
ZeroMemory(wisphrc->pLattice, sizeof(RECO_LATTICE));
wisphrc->pLattice->pGuidProperties = NULL;
wisphrc->pLattice->ulPropertyCount = 0;
wisphrc->pLattice->ulColumnCount = vrc->pLattice->nStrokes;
wisphrc->pLattice->ulBestResultColumnCount = vrc->pLatticePath->nChars;
// Add columns to the lattice for each space
for (i = 0; i < vrc->pLattice->nStrokes; i++)
{
if (vrc->pLattice->pAltList[i].fSpaceAfterStroke)
{
wisphrc->pLattice->ulColumnCount++;
}
}
// For now we have only two properties: the GUID_CONFIDENCELEVEL and GUID_LINEMETRICS
wisphrc->pLattice->ulPropertyCount = 1;
#ifdef ENABLE_CONFIDENCE_LEVEL
wisphrc->pLattice->ulPropertyCount++;
#endif
wisphrc->pLattice->pGuidProperties = (GUID *) ExternAlloc(wisphrc->pLattice->ulPropertyCount * sizeof(GUID));
if (wisphrc->pLattice->pGuidProperties == NULL)
{
HRESULT hrFRL = FreeRecoLattice(wisphrc);
ASSERT(SUCCEEDED(hrFRL));
return E_OUTOFMEMORY;
}
wisphrc->pLattice->pGuidProperties[0] = GUID_LINEMETRICS;
#ifdef ENABLE_CONFIDENCE_LEVEL
wisphrc->pLattice->pGuidProperties[1] = GUID_CONFIDENCELEVEL;
#endif
if (wisphrc->pLattice->ulColumnCount)
{
// Allocating the array of LatticeColumns
wisphrc->pLattice->pLatticeColumns =
ExternAlloc(wisphrc->pLattice->ulColumnCount * sizeof(RECO_LATTICE_COLUMN));
if (wisphrc->pLattice->pLatticeColumns)
{
ZeroMemory(wisphrc->pLattice->pLatticeColumns,
wisphrc->pLattice->ulColumnCount * sizeof(RECO_LATTICE_COLUMN));
}
// Allocate the arrays for the best result
wisphrc->pLattice->pulBestResultColumns = (ULONG*)
ExternAlloc(vrc->pLatticePath->nChars * sizeof(ULONG));
wisphrc->pLattice->pulBestResultIndexes = (ULONG*)
ExternAlloc(vrc->pLatticePath->nChars * sizeof(ULONG));
if (!wisphrc->pLattice->pLatticeColumns ||
!wisphrc->pLattice->pulBestResultColumns ||
!wisphrc->pLattice->pulBestResultIndexes)
{
HRESULT hrFRL = FreeRecoLattice(wisphrc);
ASSERT(SUCCEEDED(hrFRL));
return E_OUTOFMEMORY;
}
// Allocating the array of Strokes
wisphrc->pLattice->pLatticeColumns[0].pStrokes =
ExternAlloc(vrc->pLattice->nRealStrokes * sizeof(ULONG));
if (!wisphrc->pLattice->pLatticeColumns[0].pStrokes)
{
HRESULT hrFRL = FreeRecoLattice(wisphrc);
ASSERT(SUCCEEDED(hrFRL));
return E_OUTOFMEMORY;
}
// Do corrections for the merged strokes - Annoying detail!
j = 0;
for (i = 0; i < vrc->pLattice->nStrokes; i++)
{
if (vrc->pLattice->pStroke[i].iLast != vrc->pLattice->pStroke[i].iOrder)
{
//There has been Stroke merging
// Add the Stroke list for this merge stroke
for (k = vrc->pLattice->pStroke[i].iOrder; k <= vrc->pLattice->pStroke[i].iLast; k++)
{
wisphrc->pLattice->pLatticeColumns[0].pStrokes[j] = k;
j++;
}
}
else
{
// No stroke merging for this stroke
wisphrc->pLattice->pLatticeColumns[0].pStrokes[j] =
vrc->pLattice->pStroke[i].iOrder;
j++;
}
}
// Count the number of Lattice elements
for (i = 0; i < vrc->pLattice->nStrokes; i++)
{
unsigned int ulElements = vrc->pLattice->pAltList[i].nUsed;
// For each column count the elements
if ((wisphrc->dwFlags & RECOFLAG_SINGLESEG) != 0)
{
int nStrokes = -1;
ulElements = 0;
for (j = 0; j < vrc->pLattice->pAltList[i].nUsed; j++)
{
if (vrc->pLattice->pAltList[i].alts[j].fCurrentPath)
{
nStrokes = vrc->pLattice->pAltList[i].alts[j].nStrokes;
break;
}
}
for (j = 0; j < vrc->pLattice->pAltList[i].nUsed; j++)
{
if (nStrokes == vrc->pLattice->pAltList[i].alts[j].nStrokes)
{
ulElements++;
}
}
}
ulElementCount += ulElements;
ulRealElementCount += ulElements;
// Add an element for each space
if (vrc->pLattice->pAltList[i].fSpaceAfterStroke)
{
ulElementCount++;
}
}
// Create the elements if needed
if (ulElementCount)
{
wisphrc->pLattice->pLatticeColumns[0].pLatticeElements
= ExternAlloc(ulElementCount*sizeof(RECO_LATTICE_ELEMENT));
if (!wisphrc->pLattice->pLatticeColumns[0].pLatticeElements)
{
HRESULT hrFRL = FreeRecoLattice(wisphrc);
ASSERT(SUCCEEDED(hrFRL));
return E_OUTOFMEMORY;
}
ZeroMemory(wisphrc->pLattice->pLatticeColumns[0].pLatticeElements,
ulElementCount*sizeof(RECO_LATTICE_ELEMENT));
pCurrent = wisphrc->pLattice->pLatticeColumns[0].pLatticeElements;
// Let's do the line metrics and the confidence levels
pCurrentProperty =
(RECO_LATTICE_PROPERTY *) ExternAlloc((3 + ulRealElementCount) * sizeof(RECO_LATTICE_PROPERTY));
wisphrc->pLatticeProperties = pCurrentProperty;
pCurrentPropertyValue =
(BYTE *) ExternAlloc(3 * sizeof(CONFIDENCE_LEVEL) + ulRealElementCount * sizeof(LATTICE_METRICS));
wisphrc->pLatticePropertyValues = pCurrentPropertyValue;
// Allocate property lists for each element. The non-spaces (real elements) each have two
// properties, and the spaces have one property.
#ifdef ENABLE_CONFIDENCE_LEVEL
ppCurrentProperty =
(RECO_LATTICE_PROPERTY **) ExternAlloc((ulElementCount + ulRealElementCount) * sizeof(RECO_LATTICE_PROPERTY *));
#else
ppCurrentProperty =
(RECO_LATTICE_PROPERTY **) ExternAlloc(ulRealElementCount * sizeof(RECO_LATTICE_PROPERTY *));
#endif
wisphrc->ppLatticeProperties = ppCurrentProperty;
if (!pCurrentProperty || !pCurrentPropertyValue || !ppCurrentProperty)
{
HRESULT hrFRL = FreeRecoLattice(wisphrc);
ASSERT(SUCCEEDED(hrFRL));
return E_OUTOFMEMORY;
}
// Fill the RECO_LATTICE_PROPERTY array to contain the confidence level
pConfidencePropStart = pCurrentProperty;
pCurrentProperty->guidProperty = GUID_CONFIDENCELEVEL;
pCurrentProperty->cbPropertyValue = sizeof(CONFIDENCE_LEVEL);
pCurrentProperty->pPropertyValue = pCurrentPropertyValue;
*( (CONFIDENCE_LEVEL*)pCurrentPropertyValue) = CFL_STRONG;
pCurrentPropertyValue += sizeof(CONFIDENCE_LEVEL);
pCurrentProperty++;
// next value
pCurrentProperty->guidProperty = GUID_CONFIDENCELEVEL;
pCurrentProperty->cbPropertyValue = sizeof(CONFIDENCE_LEVEL);
pCurrentProperty->pPropertyValue = pCurrentPropertyValue;
*( (CONFIDENCE_LEVEL*)pCurrentPropertyValue) = CFL_INTERMEDIATE;
pCurrentPropertyValue += sizeof(CONFIDENCE_LEVEL);
pCurrentProperty++;
// next value
pCurrentProperty->guidProperty = GUID_CONFIDENCELEVEL;
pCurrentProperty->cbPropertyValue = sizeof(CONFIDENCE_LEVEL);
pCurrentProperty->pPropertyValue = pCurrentPropertyValue;
*( (CONFIDENCE_LEVEL*)pCurrentPropertyValue) = CFL_POOR;
pCurrentPropertyValue += sizeof(CONFIDENCE_LEVEL);
pCurrentProperty++;
}
// Allocate space for the mapping
pMapToLatticeColumn = (int *) ExternAlloc(sizeof(int) * vrc->pLattice->nStrokes);
if (pMapToLatticeColumn == NULL)
{
HRESULT hrFRL = FreeRecoLattice(wisphrc);
ASSERT(SUCCEEDED(hrFRL));
return E_OUTOFMEMORY;
}
// Fill in mapping from internal lattice columns to the newly created lattice columns.
// Note that this mapping always points to columns related to strokes, not to spaces.
j = 0;
for (i = 0; i < vrc->pLattice->nStrokes; i++)
{
pMapToLatticeColumn[i] = j;
j++;
// Add a column for each space
if (vrc->pLattice->pAltList[i].fSpaceAfterStroke)
{
j++;
}
}
ASSERT( wisphrc->pLattice->ulColumnCount == j );
// Initialize the lattice columns
pCurrentStroke = wisphrc->pLattice->pLatticeColumns[0].pStrokes;
iExternalColumn = 0;
for (i = 0; i < vrc->pLattice->nStrokes; i++)
{
int iStartStroke = i, iEndStroke = vrc->pLattice->nStrokes;
ASSERT(pMapToLatticeColumn[i] == iExternalColumn);
rleInPath.type = RECO_TYPE_WSTRING;
ulMaxStroke = 0;
pStartElement = pCurrent;
// If we're pretending to have a single segmentation, then find the next
// element on the best path, and restrict the search for elements starting
// here to that column.
if ((wisphrc->dwFlags & RECOFLAG_SINGLESEG) != 0)
{
BOOL fFound = FALSE;
for (j = i; j < vrc->pLattice->nStrokes && !fFound; j++)
{
for (k = 0; k < vrc->pLattice->pAltList[j].nUsed && !fFound; k++)
{
if (vrc->pLattice->pAltList[j].alts[k].fCurrentPath)
{
// Make sure this element links up to the starting column we
// are at now. If it doesn't, then the current stroke is in
// the middle of a best path element, so this column will
// be empty.
if (j + 1 - vrc->pLattice->pAltList[j].alts[k].nStrokes != i)
{
goto NoElementsInColumn;
}
iStartStroke = j;
iEndStroke = j + 1;
fFound = TRUE;
}
}
}
if (!fFound)
{
goto NoElementsInColumn;
}
}
// Find all elements that start at this columns #
// This could probably be optimized
for (j = iStartStroke; j < iEndStroke; j++)
{
// Go through each alt
for (k = 0; k < vrc->pLattice->pAltList[j].nUsed; k++)
{
if (j + 1 - vrc->pLattice->pAltList[j].alts[k].nStrokes == i)
{
// This one starts at the right location
// Set up the properties. There are two properties for each
// character, the line metrics and the confidence level.
pCurrent->epProp.cProperties = 1;
ASSERT(pCurrent->epProp.apProps == NULL);
pCurrent->epProp.apProps = ppCurrentProperty;
*ppCurrentProperty = pCurrentProperty;
ppCurrentProperty++;
pCurrentProperty->guidProperty = GUID_LINEMETRICS;
pCurrentProperty->cbPropertyValue = sizeof(LATTICE_METRICS);
pCurrentProperty->pPropertyValue = pCurrentPropertyValue;
pCurrentProperty++;
pLatticeMetrics = (LATTICE_METRICS *) pCurrentPropertyValue;
pCurrentPropertyValue += sizeof(LATTICE_METRICS);
pLatticeMetrics->lsBaseline.PtA.x = vrc->pLattice->pAltList[j].alts[k].writingBox.left;
pLatticeMetrics->lsBaseline.PtA.y = vrc->pLattice->pAltList[j].alts[k].writingBox.bottom;
pLatticeMetrics->lsBaseline.PtB.x = vrc->pLattice->pAltList[j].alts[k].writingBox.right;
pLatticeMetrics->lsBaseline.PtB.y = vrc->pLattice->pAltList[j].alts[k].writingBox.bottom;
pLatticeMetrics->iMidlineOffset =
(SHORT) ((vrc->pLattice->pAltList[j].alts[k].writingBox.top -
vrc->pLattice->pAltList[j].alts[k].writingBox.bottom) / 2);
#ifdef ENABLE_CONFIDENCE_LEVEL
switch (GetConfidenceLevelInternal(vrc, i, k))
{
case CFL_STRONG:
pCurrent->epProp.cProperties++;
*ppCurrentProperty = pConfidencePropStart;
ppCurrentProperty++;
break;
case CFL_INTERMEDIATE:
pCurrent->epProp.cProperties++;
*ppCurrentProperty = pConfidencePropStart + 1;
ppCurrentProperty++;
break;
case CFL_POOR:
pCurrent->epProp.cProperties++;
*ppCurrentProperty = pConfidencePropStart + 2;
ppCurrentProperty++;
break;
}
#endif
// Get the character
if (vrc->pLattice->pAltList[j].alts[k].wChar == SYM_UNKNOWN)
{
pCurrent->pData = (void*) SYM_UNKNOWN;
}
else
{
pCurrent->pData = (void*)(LocRunDense2Unicode(&g_locRunInfo,
vrc->pLattice->pAltList[j].alts[k].wChar));
}
pCurrent->ulNextColumn = pMapToLatticeColumn[j] + 1;
// Count up the number of real strokes used by this alternate
pCurrent->ulStrokeNumber = 0;
// For each merged stroke in this alternate
for (iStroke = j; iStroke > j - vrc->pLattice->pAltList[j].alts[k].nStrokes; iStroke--)
{
// Add the number of real strokes contained in this merged stroke
pCurrent->ulStrokeNumber +=
vrc->pLattice->pStroke[iStroke].iLast -
vrc->pLattice->pStroke[iStroke].iOrder + 1;
}
if (ulMaxStroke < pCurrent->ulStrokeNumber)
ulMaxStroke = pCurrent->ulStrokeNumber;
pCurrent->type = RECO_TYPE_WCHAR;
flScore = -1024 *
vrc->pLattice->pAltList[j].alts[k].logProb;
// GetScore(vrc->pLattice, j, k);
if (flScore > INT_MAX)
{
flScore = (FLOAT) INT_MAX;
}
pCurrent->score = (int) flScore;
// Is it part of the best result?
if (vrc->pLattice->pAltList[j].alts[k].fCurrentPath)
{
// Yes, strore the column
wisphrc->pLattice->pulBestResultColumns[ulBestResultIndex] = iExternalColumn;
ASSERT(rleInPath.type == RECO_TYPE_WSTRING);
rleInPath = *pCurrent;
}
pCurrent++;
}
}
}
// We need to sort that list!
SortLatticeElements(pStartElement, pCurrent);
// Is there an element from the best result in this column?
if (rleInPath.type != RECO_TYPE_WSTRING)
{
// find its index in the column
for (pCur = pStartElement; pCur < pCurrent; pCur++)
{
if (!memcmp(pCur, &rleInPath, sizeof(RECO_LATTICE_ELEMENT)))
break;
}
ASSERT(pCur != pCurrent);
if (pCur != pCurrent)
{
wisphrc->pLattice->pulBestResultIndexes[ulBestResultIndex] = pCur - pStartElement;
ulBestResultIndex++;
}
}
NoElementsInColumn:
// Fill in the Reco Column information
wisphrc->pLattice->pLatticeColumns[iExternalColumn].key = iExternalColumn;
wisphrc->pLattice->pLatticeColumns[iExternalColumn].cpProp.cProperties = 0;
wisphrc->pLattice->pLatticeColumns[iExternalColumn].cpProp.apProps = NULL;
wisphrc->pLattice->pLatticeColumns[iExternalColumn].cStrokes = ulMaxStroke;
wisphrc->pLattice->pLatticeColumns[iExternalColumn].pStrokes = pCurrentStroke;
wisphrc->pLattice->pLatticeColumns[iExternalColumn].cLatticeElements = pCurrent-pStartElement;
wisphrc->pLattice->pLatticeColumns[iExternalColumn].pLatticeElements = pStartElement;
// Jump to the next "current" stroke : Always the annoying detail!
pCurrentStroke += vrc->pLattice->pStroke[i].iLast -
vrc->pLattice->pStroke[i].iOrder + 1;
// The new Start is:
pStartElement = pCurrent;
iExternalColumn++;
if (vrc->pLattice->pAltList[i].fSpaceAfterStroke)
{
// If there is a space, then it must be on the current path (because spaces are only
// created on the current path). This simplifies the code a lot.
pStartElement = pCurrent;
// Set up the properties. For spaces, the only property that applies is the
// confidence level.
pCurrent->epProp.cProperties = 0;
ASSERT(pCurrent->epProp.apProps == NULL);
pCurrent->epProp.apProps = ppCurrentProperty;
#ifdef ENABLE_CONFIDENCE_LEVEL
switch (GetConfidenceLevelInternal(vrc, i, SPACE_ALT_ID))
{
case CFL_STRONG:
pCurrent->epProp.cProperties++;
*ppCurrentProperty = pConfidencePropStart;
ppCurrentProperty++;
break;
case CFL_INTERMEDIATE:
pCurrent->epProp.cProperties++;
*ppCurrentProperty = pConfidencePropStart + 1;
ppCurrentProperty++;
break;
case CFL_POOR:
pCurrent->epProp.cProperties++;
*ppCurrentProperty = pConfidencePropStart + 2;
ppCurrentProperty++;
break;
}
#endif
pCurrent->pData = (void*) SYM_SPACE;
pCurrent->ulNextColumn = iExternalColumn + 1;
pCurrent->ulStrokeNumber = 0;
pCurrent->type = RECO_TYPE_WCHAR;
pCurrent->score = 0;
wisphrc->pLattice->pulBestResultColumns[ulBestResultIndex] = iExternalColumn;
wisphrc->pLattice->pulBestResultIndexes[ulBestResultIndex] = 0;
ulBestResultIndex++;
pCurrent++;
// Fill in the Reco Column information
wisphrc->pLattice->pLatticeColumns[iExternalColumn].key = iExternalColumn;
wisphrc->pLattice->pLatticeColumns[iExternalColumn].cpProp.cProperties = 0;
wisphrc->pLattice->pLatticeColumns[iExternalColumn].cpProp.apProps = NULL;
wisphrc->pLattice->pLatticeColumns[iExternalColumn].cStrokes = 0;
wisphrc->pLattice->pLatticeColumns[iExternalColumn].pStrokes = pCurrentStroke;
wisphrc->pLattice->pLatticeColumns[iExternalColumn].cLatticeElements = 1;
wisphrc->pLattice->pLatticeColumns[iExternalColumn].pLatticeElements = pStartElement;
// The new Start is:
pStartElement = pCurrent;
iExternalColumn++;
}
}
// Check the number of elements in the best path
ASSERT(ulBestResultIndex == (ULONG)vrc->pLatticePath->nChars);
ASSERT(iExternalColumn == wisphrc->pLattice->ulColumnCount);
ASSERT(pCurrentStroke - wisphrc->pLattice->pLatticeColumns[0].pStrokes == vrc->pLattice->nRealStrokes);
}
if (SUCCEEDED(hr))
*ppLattice = wisphrc->pLattice;
ExternFree(pMapToLatticeColumn);
return hr;
}
// Lists of properties
static const ULONG CONTEXT_PROPERTIES_COUNT = 1;
// {1ABC3828-BDF1-4ef3-8F2C-0751EC0DE742}
static const GUID GUID_ENABLE_IFELANG3 = { 0x1abc3828, 0xbdf1, 0x4ef3, { 0x8f, 0x2c, 0x7, 0x51, 0xec, 0xd, 0xe7, 0x42 } };
// GetContextPropertyList
// Return a list of properties supported on the context
//
// Parameters:
// hrc [in] : Handle to the recognition context
// pcProperties [in/out] : Number of properties supported
// pPropertyGUIDS [out] : List of properties supported
HRESULT WINAPI GetContextPropertyList(HRECOCONTEXT hrc,
ULONG* pcProperties,
GUID* pPropertyGUIDS)
{
if (NULL == (HRC *)FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT) )
{
return E_POINTER;
}
if ( IsBadWritePtr(pcProperties, sizeof(ULONG)) )
return E_POINTER;
if (pPropertyGUIDS == NULL) // Need only the count
{
*pcProperties = CONTEXT_PROPERTIES_COUNT;
return S_OK;
}
if (*pcProperties < CONTEXT_PROPERTIES_COUNT)
return TPC_E_INSUFFICIENT_BUFFER;
*pcProperties = CONTEXT_PROPERTIES_COUNT;
if ( IsBadWritePtr(pPropertyGUIDS, CONTEXT_PROPERTIES_COUNT * sizeof(GUID)) )
return E_POINTER;
pPropertyGUIDS[0] = GUID_ENABLE_IFELANG3;
return S_OK;
}
// GetContextPropertyValue
// Return a property of the context, currently no properties are supported
//
// Parameters:
// hrc [in] : Handle to the recognition context
// pGuid [in] : Property GUID
// pcbSize [in/out] : Size of the property buffer (in BYTEs)
// pProperty [out] : Value of the desired property
HRESULT WINAPI GetContextPropertyValue(HRECOCONTEXT hrc,
GUID *pGuid,
ULONG *pcbSize,
BYTE *pProperty)
{
struct WispContext *wisphrc;
// find the handle and validate the correpsonding pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (wisphrc == NULL)
{
return E_POINTER;
}
if ( IsBadReadPtr(pGuid, sizeof(GUID)) )
return E_POINTER;
if ( IsBadWritePtr(pcbSize, sizeof(ULONG)) )
return E_POINTER;
if ( IsEqualGUID(pGuid, &GUID_ENABLE_IFELANG3) )
{
BOOL *pb = (BOOL *) pProperty;
if (pProperty == NULL)
{
*pcbSize = sizeof(BOOL);
return S_OK;
}
if (*pcbSize < sizeof(BOOL))
{
return TPC_E_INSUFFICIENT_BUFFER;
}
*pcbSize = sizeof(BOOL);
#ifdef USE_IFELANG3
*pb = LatticeIFELang3Available();
#else
*pb = FALSE;
#endif
return S_OK;
}
return TPC_E_INVALID_PROPERTY;
}
// SetContextPropertyValue
// Set a property of the context (currently only GUID_ENABLE_IFELANG3)
//
// Parameters:
// hrc [in] : Handle to the recognition context
// pGuid [in] : Property GUID
// pcbSize [in] : Size of the property buffer (in BYTEs)
// pProperty [in] : Value of the desired property
HRESULT WINAPI SetContextPropertyValue(HRECOCONTEXT hrc,
GUID *pGuid,
ULONG cbSize,
BYTE *pProperty)
{
struct WispContext *wisphrc;
// find the handle and validate the correpsonding pointer
wisphrc = (struct WispContext*)FindTpgHandle((HANDLE)hrc, TPG_HRECOCONTEXT);
if (wisphrc == NULL)
{
return E_POINTER;
}
if ( IsBadReadPtr(pGuid, sizeof(GUID)) )
return E_POINTER;
if ( IsBadReadPtr(pProperty, cbSize) )
return E_POINTER;
if ( IsEqualGUID(pGuid, &GUID_ENABLE_IFELANG3) )
{
BOOL *pb = (BOOL *) pProperty;
if (cbSize != sizeof(BOOL))
{
return E_INVALIDARG;
}
if (*pb)
{
#ifdef USE_IFELANG3
// If already enabled, return S_FALSE
if (LatticeIFELang3Available())
{
return S_FALSE;
}
return LatticeConfigIFELang3() ? S_OK : E_FAIL;
#else
return E_FAIL;
#endif
}
else
{
#ifdef USE_IFELANG3
// If already disabled, return S_FALSE
if (!LatticeIFELang3Available())
{
return S_FALSE;
}
return LatticeUnconfigIFELang3() ? S_OK : E_FAIL;
#else
return S_FALSE;
#endif
}
}
return TPC_E_INVALID_PROPERTY;
}
/////////////////////////////////////////////////////////////////
// Registration information
//
//
#define FULL_PATH_VALUE L"Recognizer dll"
#define RECO_LANGUAGES L"Recognized Languages"
#define RECO_CAPABILITIES L"Recognizer Capability Flags"
#define RECO_MANAGER_KEY L"CLSID\\{DE815B00-9460-4F6E-9471-892ED2275EA5}\\InprocServer32"
#define CLSID_KEY L"CLSID"
/////////////////////////////////////////////////////////////////////////////
// DllRegisterServer - Adds entries to the system registry
// This recognizer GUID is going to be
// {6D0087D7-61D2-495f-9293-5B7B1C3FCEAB}
// Each recognizer HAS to have a different GUID
STDAPI DllRegisterServer(void)
{
HKEY hKeyReco = NULL;
HKEY hKeyRecoManager = NULL;
LONG lRes = 0;
HKEY hkeyMyReco = NULL;
DWORD dwLength = 0, dwType = 0, dwSize = 0;
DWORD dwDisposition;
WCHAR szRecognizerPath[MAX_PATH];
WCHAR *RECO_SUBKEY = NULL, *RECOGNIZER_SUBKEY = NULL;
WCHAR *RECOPROC_SUBKEY = NULL, *RECOCLSID_SUBKEY = NULL;
RECO_ATTRS recoAttr;
HRESULT hr = S_OK;
HRECOGNIZER hrec;
if (FAILED(CreateRecognizer(NULL, &hrec)))
{
return E_FAIL;
}
hr = GetRecoAttributes(hrec, &recoAttr);
if (FAILED(hr))
{
return E_FAIL;
}
if (FAILED(DestroyRecognizer(hrec)))
{
return E_FAIL;
}
if (recoAttr.awLanguageId[0] == MAKELANGID(LANG_JAPANESE, SUBLANG_NEUTRAL))
{
RECO_SUBKEY = L"Software\\Microsoft\\TPG\\System Recognizers\\{6D4087D7-61D2-495f-9293-5B7B1C3FCEAB}";
RECOGNIZER_SUBKEY = L"CLSID\\{6D4087D7-61D2-495f-9293-5B7B1C3FCEAB}\\InprocServer32";
RECOPROC_SUBKEY = L"{6D4087D7-61D2-495f-9293-5B7B1C3FCEAB}\\InprocServer32";
RECOCLSID_SUBKEY = L"{6D4087D7-61D2-495f-9293-5B7B1C3FCEAB}";
}
if (recoAttr.awLanguageId[0] == MAKELANGID(LANG_KOREAN, SUBLANG_NEUTRAL))
{
RECO_SUBKEY = L"Software\\Microsoft\\TPG\\System Recognizers\\{6D5087D7-61D2-495f-9293-5B7B1C3FCEAB}";
RECOGNIZER_SUBKEY = L"CLSID\\{6D5087D7-61D2-495f-9293-5B7B1C3FCEAB}\\InprocServer32";
RECOPROC_SUBKEY = L"{6D5087D7-61D2-495f-9293-5B7B1C3FCEAB}\\InprocServer32";
RECOCLSID_SUBKEY = L"{6D5087D7-61D2-495f-9293-5B7B1C3FCEAB}";
}
if (recoAttr.awLanguageId[0] == MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED))
{
RECO_SUBKEY = L"Software\\Microsoft\\TPG\\System Recognizers\\{6D6087D7-61D2-495f-9293-5B7B1C3FCEAB}";
RECOGNIZER_SUBKEY = L"CLSID\\{6D6087D7-61D2-495f-9293-5B7B1C3FCEAB}\\InprocServer32";
RECOPROC_SUBKEY = L"{6D6087D7-61D2-495f-9293-5B7B1C3FCEAB}\\InprocServer32";
RECOCLSID_SUBKEY = L"{6D6087D7-61D2-495f-9293-5B7B1C3FCEAB}";
}
if (recoAttr.awLanguageId[0] == MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL))
{
RECO_SUBKEY = L"Software\\Microsoft\\TPG\\System Recognizers\\{6D7087D7-61D2-495f-9293-5B7B1C3FCEAB}";
RECOGNIZER_SUBKEY = L"CLSID\\{6D7087D7-61D2-495f-9293-5B7B1C3FCEAB}\\InprocServer32";
RECOPROC_SUBKEY = L"{6D7087D7-61D2-495f-9293-5B7B1C3FCEAB}\\InprocServer32";
RECOCLSID_SUBKEY = L"{6D7087D7-61D2-495f-9293-5B7B1C3FCEAB}";
}
// Write the path to this dll in the registry under
// the recognizer subkey
// Wipe out the previous values
lRes = RegDeleteKeyW(HKEY_LOCAL_MACHINE, RECO_SUBKEY);
// Create the new key
lRes = RegCreateKeyExW(HKEY_LOCAL_MACHINE, RECO_SUBKEY, 0, NULL,
REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkeyMyReco, &dwDisposition);
ASSERT(lRes == ERROR_SUCCESS);
if (lRes != ERROR_SUCCESS)
{
if (hkeyMyReco)
RegCloseKey(hkeyMyReco);
return E_FAIL;
}
// Get the current path
// Try to get the path of the RecoObj.dll
// It should be the same as the one for the RecoCom.dll
dwLength = GetModuleFileNameW((HMODULE)g_hInstanceDllCode, szRecognizerPath, MAX_PATH);
if (dwLength == 0 || (dwLength == MAX_PATH && szRecognizerPath[MAX_PATH - 1] != 0))
{
RegCloseKey(hkeyMyReco);
return E_FAIL;
}
// Write the path to the dll as a value
lRes = RegSetValueExW(hkeyMyReco, FULL_PATH_VALUE, 0, REG_SZ,
(BYTE*)szRecognizerPath, sizeof(WCHAR)*(wcslen(szRecognizerPath)+1));
ASSERT(lRes == ERROR_SUCCESS);
if (lRes != ERROR_SUCCESS)
{
RegCloseKey(hkeyMyReco);
return E_FAIL;
}
// Add the reco attribute information
lRes = RegSetValueExW(hkeyMyReco, RECO_LANGUAGES, 0, REG_BINARY,
(BYTE*)recoAttr.awLanguageId, 64 * sizeof(WORD));
ASSERT(lRes == ERROR_SUCCESS);
if (lRes != ERROR_SUCCESS)
{
RegCloseKey(hkeyMyReco);
return E_FAIL;
}
lRes = RegSetValueExW(hkeyMyReco, RECO_CAPABILITIES, 0, REG_DWORD,
(BYTE*)&(recoAttr.dwRecoCapabilityFlags), sizeof(DWORD));
ASSERT(lRes == ERROR_SUCCESS);
if (lRes != ERROR_SUCCESS)
{
RegCloseKey(hkeyMyReco);
return E_FAIL;
}
RegCloseKey(hkeyMyReco);
return S_OK;
}
/////////////////////////////////////////////////////////////////////////////
// DllUnregisterServer - Removes entries from the system registry
STDAPI DllUnregisterServer(void)
{
LONG lRes1 = 0;
// get language id
WCHAR *RECO_SUBKEY = NULL, *RECOGNIZER_SUBKEY = NULL;
WCHAR *RECOPROC_SUBKEY = NULL, *RECOCLSID_SUBKEY = NULL;
RECO_ATTRS recoAttr;
HRESULT hr = S_OK;
HRECOGNIZER hrec;
if (FAILED(CreateRecognizer(NULL, &hrec)))
{
return E_FAIL;
}
hr = GetRecoAttributes(hrec, &recoAttr);
if (FAILED(hr))
{
return E_FAIL;
}
if (FAILED(DestroyRecognizer(hrec)))
{
return E_FAIL;
}
if (recoAttr.awLanguageId[0] == MAKELANGID(LANG_JAPANESE, SUBLANG_NEUTRAL))
{
RECO_SUBKEY = L"Software\\Microsoft\\TPG\\System Recognizers\\{6D4087D7-61D2-495f-9293-5B7B1C3FCEAB}";
RECOGNIZER_SUBKEY = L"CLSID\\{6D4087D7-61D2-495f-9293-5B7B1C3FCEAB}\\InprocServer32";
RECOPROC_SUBKEY = L"{6D4087D7-61D2-495f-9293-5B7B1C3FCEAB}\\InprocServer32";
RECOCLSID_SUBKEY = L"{6D4087D7-61D2-495f-9293-5B7B1C3FCEAB}";
}
if (recoAttr.awLanguageId[0] == MAKELANGID(LANG_KOREAN, SUBLANG_NEUTRAL))
{
RECO_SUBKEY = L"Software\\Microsoft\\TPG\\System Recognizers\\{6D5087D7-61D2-495f-9293-5B7B1C3FCEAB}";
RECOGNIZER_SUBKEY = L"CLSID\\{6D5087D7-61D2-495f-9293-5B7B1C3FCEAB}\\InprocServer32";
RECOPROC_SUBKEY = L"{6D5087D7-61D2-495f-9293-5B7B1C3FCEAB}\\InprocServer32";
RECOCLSID_SUBKEY = L"{6D5087D7-61D2-495f-9293-5B7B1C3FCEAB}";
}
if (recoAttr.awLanguageId[0] == MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED))
{
RECO_SUBKEY = L"Software\\Microsoft\\TPG\\System Recognizers\\{6D6087D7-61D2-495f-9293-5B7B1C3FCEAB}";
RECOGNIZER_SUBKEY = L"CLSID\\{6D6087D7-61D2-495f-9293-5B7B1C3FCEAB}\\InprocServer32";
RECOPROC_SUBKEY = L"{6D6087D7-61D2-495f-9293-5B7B1C3FCEAB}\\InprocServer32";
RECOCLSID_SUBKEY = L"{6D6087D7-61D2-495f-9293-5B7B1C3FCEAB}";
}
if (recoAttr.awLanguageId[0] == MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL))
{
RECO_SUBKEY = L"Software\\Microsoft\\TPG\\System Recognizers\\{6D7087D7-61D2-495f-9293-5B7B1C3FCEAB}";
RECOGNIZER_SUBKEY = L"CLSID\\{6D7087D7-61D2-495f-9293-5B7B1C3FCEAB}\\InprocServer32";
RECOPROC_SUBKEY = L"{6D7087D7-61D2-495f-9293-5B7B1C3FCEAB}\\InprocServer32";
RECOCLSID_SUBKEY = L"{6D7087D7-61D2-495f-9293-5B7B1C3FCEAB}";
}
// Wipe out the registry information
lRes1 = RegDeleteKeyW(HKEY_LOCAL_MACHINE, RECO_SUBKEY);
// Try to erase the local machine\software\microsoft\tpg\recognizer
// if necessary (don't care if it fails)
RegDeleteKeyW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\TPG\\System Recognizers");
RegDeleteKeyW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\TPG");
if (lRes1 != ERROR_SUCCESS && lRes1 != ERROR_FILE_NOT_FOUND)
{
return E_FAIL;
}
return S_OK ;
}
/*************************************************
* NAME: validateTpgHandle
*
* Generic function to validate a pointer obtained from a WISP
* style handle. For now function checks the memory
* is writable
*
* RETURNS
* TRUE if the pointer passes a minimal validation
*
*************************************************/
BOOL validateTpgHandle(void *pPtr, int type)
{
BOOL bRet = FALSE;
switch (type)
{
case TPG_HRECOCONTEXT:
{
if (0 == IsBadWritePtr(pPtr, sizeof(struct WispContext)))
{
bRet = TRUE;
}
break;
}
case TPG_HRECOGNIZER:
{
if (0 == IsBadWritePtr(pPtr, sizeof(struct WispRec)))
{
bRet = TRUE;
}
break;
}
case TPG_HRECOALT:
{
if (0 == IsBadWritePtr(pPtr, sizeof(struct WispAlternate)))
{
bRet = TRUE;
}
break;
}
default:
break;
}
return bRet;
}
Reference in a new issue Copy permalink