5390 lines
153 KiB
C
5390 lines
153 KiB
C
// 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;
|
|
}
|