windows-nt/Source/XPSP1/NT/base/mvdm/thunk/pwfthk.thk

__foldwin32sstuff __foldwin32sstuff;
foldstyleinitialization = true;

/* Pen Windows 2.0 API thunks for Win32C

The following APIs are *not* implemented in the 32-bit version:

Misc APIs:
   BOOL ShowKeyboard(HWND, UINT, LPPOINT, LPSKBINFO)
   BOOL DictionarySearch(LPRC, LPSYE, INT, LPSYV, INT)

Pendata APIs:
   LPPENDATA BeginEnumStrokes(HPENDATA)
   HPENDATA CompactPenData(HPENDATA hpndt, UINT fuTrim)
   HPENDATA CreatePenData(LPPENINFO lppeninfo, INT cbOem, UINT uScale, UINT gmemFlags)
   VOID DrawPenData(HDC hdc, LPRECT lprect, HPENDATA hpndt)
   LPPENDATA EndEnumStrokes(HPENDATA hpndt)
   BOOL GetPenDataStroke(LPPNDT lppndt, UINT wStroke, LPPOINT FAR *lprgpt, LPVOID FAR *lprgoem, LPSTROKEINFO lpsi)

Pen Driver APIs:
   AddPenEvent
   BOOL EndPenCollection(REC)
   REC GetPenHwData(LPPOINT, LPVOID, INT, UINT, LPSTROKEINFO)
   REC GetPenHwEventData(UINT, UINT, LPPOINT, LPVOID, INT, LPSTROKEINFO)
   ProcessPenEvent
   BOOL SetPenHook(HKP, LPFNRAWHOOK)
   VOID UpdatePenInfo(LPPENINFO)

Gesture API:
   BOOL ExecuteGesture(HWND, SYV, LPRCRESULT)

Util API:
   UINT IsPenAware()

RC1 APIs:
   VOID EmulatePen(BOOL)
   UINT EnumSymbols(LPSYG, UINT, ENUMPROC, LPVOID)
   VOID FirstSymbolFromGraph(LPSYG, LPSYV, INT, LPINT)
   UINT GetGlobalRC(LPRC, LPSTR, LPSTR, INT)
   INT GetSymbolCount(LPSYG)
   INT GetSymbolMaxLength(LPSYG)
   VOID InitRC(HWND, LPRC)
   REC ProcessWriting(HWND, LPRC);   
   REC Recognize(LPRC)
   REC RecognizeData(LPRC, HPENDATA)
   UINT SetGlobalRC(LPRC, LPSTR, LPSTR)
   BOOL SetRecogHook(UINT, UINT, HWND)
   BOOL TrainContext(LPRCRESULT, LPSYE, INT, LPSYC, INT)
   BOOL TrainInk(LPRC, HPENDATA, LPSYV)
   VOID CloseRecognizer(VOID)
   UINT ConfigRecognizer(UINT, WPARAM, LPARAM)
   BOOL InitRecognizer(LPRC)
   REC RecognizeDataInternal(LPRC, HPENDATA, LPFUNCRESULTS)
   REC RecognizeInternal(LPRC, LPFUNCRESULTS)
   BOOL TrainContextInternal(LPRCRESULT, LPSYE, INT, LPSYC, INT)
   BOOL TrainInkInternal(LPRC, HPENDATA, LPSYV)

Virtual Event APIs:
   VOID AtomicVirtualEvent(BOOL)
   VOID PostVirtualKeyEvent(UINT, BOOL)
   VOID PostVirtualMouseEvent(UINT, INT, INT)


Notes:
- the format is:
   BOOL Foo(HDC, INT, INT)
   {
   }

- countof is only required for "packable" arrays - those whose elements
are not of fixed size. (DWORD, ALC, SYV, HRCRESULT are all fixed size).

*/

enablemapdirect3216 = true;
flatthunks = true;

#include "types.thk"      /* \win\core\thunk\types.thk */
#include "pwtypes.thk"


/* The following thunk script orders the APIs as in penwin.h: */

/***************** Pendata APIs *********************************************/

HPENDATA AddPointsPenDataTW(HPENDATA hpndt, LPPOINT rgpt, LPVOID rgoem, UINT cpt, LPSTROKEINFO lpsi)
{
   cpt = countof rgpt;
   // Note: no need to worry about rgoem because it is supposed to be an
   // array of WORD's. No no repacking, simply map ptr.
}

INT CompressPenData(HPENDATA hpndt, UINT fuFlags, DWORD dwReserved)
{
}

HPENDATA CreatePenDataEx(LPPENINFO lppeninfo, UINT uScale, UINT fuOptions, UINT gmemFlags)
{
}

HRGN CreatePenDataRegion(HPENDATA hpndt, UINT uType)
{
}

BOOL DestroyPenData(HPENDATA hpndt)
{
}

DWORD GetAnimateTWAddr(VOID); // reqd. for animate proc callback below

INT DrawPenDataExTW(HDC hdc, LPRECT lprect,
   HPENDATA hpndt, UINT iStrkFirst, UINT StrkLast,
   UINT iPntFirst, UINT iPntLast, DWORD lpfnAnimate, // use DWORD instead of ANIMATEPROC
   LPANIMATEINFO lpai, UINT fuFlags)
{
}

HPENDATA DuplicatePenData(HPENDATA hpndt, UINT gmemFlags)
{
}

INT ExtractPenDataPoints(HPENDATA hpndt, UINT iStrk, UINT iPnt, UINT cpt, LPPOINT rgpt, LPVOID rgoem, UINT fuOption)
{
   rgpt = output;
   rgoem = output;
   cpt = countof rgpt;
   // Note: no need to worry about rgoem because it is supposed to be an
   // array of WORD's. No no repacking, simply map ptr.
}

INT ExtractPenDataStrokesTW(HPENDATA hpndtSrc, UINT fuExtract, LPARAM lParam, LPHPENDATA lphpndtNew, UINT gmemFlags)
{
   lphpndtNew = output;
}

INT GetPenDataAttributesTW(HPENDATA hpndt, LPVOID lpvBuffer, UINT uOption)
{
   lpvBuffer = output;
}

BOOL GetPenDataInfo(HPENDATA hpndt, LPPENDATAHEADER lppdh, LPPENINFO lppeninfo, DWORD dwReserved)
{
   lppdh = output;
   lppeninfo = output;
}

BOOL GetPointsFromPenData(HPENDATA hpndt, UINT wStroke, UINT ipt, UINT cpt, LPPOINT rgpt)
{
   rgpt = output;
   cpt = countof rgpt;
}

INT GetStrokeAttributesTW(HPENDATA hpndt, UINT iStrk, LPVOID lpvBuffer, UINT uOption)
{
   lpvBuffer = output;
}

INT GetStrokeTableAttributes(HPENDATA hpndt, UINT iTblEntry, LPVOID lpvBuffer, UINT uOption)
{
   lpvBuffer = output;
}

INT HitTestPenData(HPENDATA hpndt, LPPOINT lppt, UINT dThresh, LPUINT lpiStrk, LPUINT lpiPnt)
{
   lpiStrk = inout;
   lpiPnt = inout;
}

INT InsertPenData(HPENDATA hpndtDst, HPENDATA hpndtSrc, UINT iStrk)
{
}

INT InsertPenDataPoints(HPENDATA hpndt, UINT iStrk, UINT iPnt, UINT cpt, LPPOINT rgpt, LPVOID rgoem)
{
   cpt = countof rgpt;
   // Note: no need to worry about rgoem because it is supposed to be an
   // array of WORD's. No no repacking, simply map ptr.
}

INT InsertPenDataStrokeTW(HPENDATA hpndt, UINT iStrk, LPPOINT rgpt, LPVOID rgoem, UINT cpt, LPSTROKEINFO lpsi)
{
   cpt = countof rgpt;
   // Note: no need to worry about rgoem because it is supposed to be an
   // array of WORD's. No no repacking, simply map ptr.
}
   
BOOL MetricScalePenData(HPENDATA hpndt, UINT wPndtNew)
{
}

BOOL OffsetPenData(HPENDATA hpndt, INT dx, INT dy)
{
}

LONG PenDataFromBuffer(LPHPENDATA lphpndt, UINT gmemFlags, LPBYTE lpBuffer, LONG cbBuf, LPDWORD lpdwState)
{
   lphpndt = output;
   lpdwState = inout;
}

LONG PenDataToBuffer(HPENDATA hpndt, LPBYTE lpBuffer, LONG cbBuf, LPDWORD lpdwState)
{
   lpBuffer = output;
   lpdwState = inout;
}

BOOL RedisplayPenData(HDC hdc, HPENDATA hpndt, LPPOINT lpDelta, LPPOINT lpExt, INT nInkWidth, DWORD rgbColor)
{
}

INT RemovePenDataStrokes(HPENDATA hpndt, UINT iStrk, UINT cStrk)
{
}

BOOL ResizePenData(HPENDATA hpndt, LPRECT lprct)
{
}

INT SetStrokeAttributesTW(HPENDATA hpndt, UINT iStrk, LPARAM lParam, UINT uOption)
{
}

INT SetStrokeTableAttributesTW(HPENDATA hpndt, UINT iTblEntry, LPARAM lParam, UINT uOption)
{
}

INT TrimPenData(HPENDATA hpndt, DWORD dwTrimOptions, DWORD dwReserved)
{
}

/***************** Pen Driver APIs ******************************************/

BOOL GetPenAsyncState(UINT wPDK)
{
}

BOOL IsPenEvent(UINT message, LONG lExtraInfo)
{
}

/***************** Recog APIs ***********************************************/

INT AddPenDataHRC(HRC hrc, HPENDATA hpndt)
{
}

INT AddPenInputHRCTW(HRC hrc, LPPOINT rgpt, LPVOID rgoem, UINT cpt, UINT fuoem, LPSTROKEINFO lpsi)
{
   cpt = countof rgpt;
   // Note: no need to worry about rgoem because it is supposed to be an
   // array of WORD's. No no repacking, simply map ptr.
}

INT AddWordsHWLTW(HWL hwl, DWORD /* LPSTR */ lpsz, UINT uType)
{
}

INT ConfigHRECTW(HREC hrec, UINT uSubFunction, WPARAM wParam, LPARAM lParam)
{
}


HRC CreateCompatibleHRC(HRC hrcTemplate, HREC hrec)
{
} 

HWL CreateHWLTW(HREC hrec, DWORD /* LPSTR */ lpsz, UINT uType, DWORD dwReserved)
{
}

HINKSET CreateInksetHRCRESULT(HRCRESULT hresult, UINT iSyv, UINT cSyv)
{
}

HPENDATA CreatePenDataHRC(HRC hrc)
{
}

INT DestroyHRC(HRC hrc)
{
} 

INT DestroyHRCRESULT(HRCRESULT hresult)
{
}

INT DestroyHWL(HWL hwl)
{
}

INT EnableGestureSetHRC(HRC hrc, SYV syv, BOOL fEnable)
{
}

INT EnableSystemDictionaryHRC(HRC hrc, BOOL fEnable)
{
}

INT EndPenInputHRC(HRC hrc)
{
}

INT GetAlphabetHRC(HRC hrc, LPALC lpalc, LPBYTE rgbfAlc)
{
   lpalc = output;
   rgbfAlc = output;
}

INT GetAlphabetPriorityHRC(HRC hrc, LPALC lpalc, LPBYTE rgbfAlc)
{
   lpalc = output;
   rgbfAlc = output;
}

INT GetAlternateWordsHRCRESULT(HRCRESULT hresult, UINT iSyv, UINT cSyv, LPHRCRESULT rghrcresults, UINT cResults)
{
   rghrcresults = output;
}

INT GetBoxMappingHRCRESULT(HRCRESULT hresult, UINT iSyv, UINT cSyv, LPUINT rgi)
{
   rgi = output;
   cSyv = countof rgi;
}

INT GetBoxResultsHRCTW(HRC hrc, INT cAlt, INT iSyv, UINT cBoxRes, 
   LPVOID /* LPBOXRESULTS */ lpBR, BOOL fGetInkset)
{
   lpBR = output;
}

INT GetGuideHRC(HRC hrc, LPGUIDE lpguide, LPUINT lpu)
{
   lpguide = output;
   lpu = output;
}

INT GetHotspotsHRCRESULT(HRCRESULT hrcresult, UINT iSyv, LPPOINT rgpt, UINT cpt)
{
   rgpt = output;
   cpt = countof rgpt;
}

HREC GetHRECFromHRC(HRC hrc)
{
}

INT GetInternationalHRC(HRC hrc, LPUINT lpuCountry, LPSTR lpszLangCode, LPUINT lpfuFlags, LPUINT lpuDir)
{
   lpuCountry = output;
   lpszLangCode = output;
   lpfuFlags = output;
   lpuDir = output;
}

INT GetMaxResultsHRC(HRC hrc)
{
}

INT GetResultsHRC(HRC hrc, UINT uType, LPHRCRESULT rghrcresults, UINT cResults)
{
   rghrcresults = output;
}

INT GetSymbolCountHRCRESULT(HRCRESULT hresult)
{
}

INT GetSymbolsHRCRESULT(HRCRESULT hresult, UINT iSyv, LPSYV rgsyv, UINT cSyv)
{
   rgsyv = output;
}

INT GetWordlistHRC(HRC hrc, LPHWL lphwl)
{
   lphwl = output;
}

INT GetWordlistCoercionHRC(HRC hrc)
{
}

INT ProcessHRC(HRC hrc, DWORD dwTimeMax)
{
}

INT ReadHWLTW(HWL hwl, WORD /* HFILE */ hfile)
{
}

INT SetAlphabetHRC(HRC hrc, ALC alc, LPBYTE rgbfAlc)
{
}

INT SetAlphabetPriorityHRC(HRC hrc, ALC alc, LPBYTE rgbfAlc)
{
}

INT SetBoxAlphabetHRC(HRC hrc, LPALC rgalc, UINT cAlc)
{
}

INT SetGuideHRC(HRC hrc, LPGUIDE lpguide, UINT nFirstVisible)
{
}

INT SetInternationalHRC(HRC hrc, UINT uCountry, LPCSTR lpszLangCode, UINT fuFlags, UINT uDir)
{
}

INT SetMaxResultsHRC(HRC hrc, UINT cMaxResults)
{
}

DWORD GetResultsHookAddr(VOID); // reqd. for results hook proc callback below

HRECHOOK SetResultsHookHRECTW(HREC hrec, DWORD /* HRCRESULTHOOKPROC */ lpfnHook)
{
}

INT SetWordlistCoercionHRC(HRC hrc, UINT uCoercion)
{
}

INT SetWordlistHRC(HRC hrc, HWL hwl)
{
}

INT TrainHREC(HREC hrec, LPSYV rgsyv, UINT cSyv, HPENDATA hpndt, UINT uConflict)
{
}

INT UnhookResultsHookHRECTW(HREC hrec, DWORD /* HRECHOOK */ hHook)
{
}

INT WriteHWLTW(HWL hwl, WORD /* HFILE */ hfile)
{
}

HREC InstallRecognizer(LPSTR lpszRecogName)
{
}

VOID UninstallRecognizer(HREC hrec)
{
}

/***************** Inkset APIs **********************************************/

BOOL AddInksetInterval(HINKSET hinkset, LPINTERVAL lpiNew)
{
}
 
HINKSET CreateInkset(UINT gmemFlags)
{
}

BOOL DestroyInkset(HINKSET hinkset)
{
}

INT GetInksetInterval(HINKSET hinkset, UINT uIndex, LPINTERVAL lpi)
{
   lpi = output;
}

INT GetInksetIntervalCount(HINKSET hinkset)
{
}

/***************** Symbol APIs **********************************************/

INT CharacterToSymbol(LPSTR lpstr, UINT cSyv, LPSYV rgsyv)
{
   rgsyv = output;
}

BOOL SymbolToCharacter(LPSYV rgsyv, UINT cSyv, LPSTR lpstr, LPINT lpnConv)
{
   cSyv = countof rgsyv;
   lpstr = output;
   lpnConv = output;
}

/***************** Inkput APIs **********************************************/

INT DoDefaultPenInput(HWND hwnd, UINT wEventRef)
{
}

INT GetPenInput(HPCM hpcm, LPPOINT rgpt, LPVOID rgoem, UINT fuoemFlags, UINT cpt, LPSTROKEINFO lpsi)
{
   rgpt = output;
   rgoem = output;
   lpsi = inout;   
   cpt = countof rgpt;
   // Note: no need to worry about rgoem because it is supposed to be an
   // array of WORD's. No no repacking, simply map ptr.
}

INT PeekPenInput(HPCM hpcm, UINT idEvent, LPPOINT rgpt, LPVOID lpoem, UINT fuoemFlags)
{
   rgpt = output;
   lpoem = output;
}

INT StartInking(HPCM hpcm, UINT idEvent, LPINKINGINFO lpI)
{
}

HPCM StartPenInput(HWND hwnd, UINT idEvent, LPPCMINFO lppcmInfo, LPINT lpiErrRet)
{
   lpiErrRet = output;
}

INT StopInking(HPCM hpcm)
{
}

INT StopPenInput(HPCM hpcm, UINT idEvent, INT nTermReason)
{
}

/***************** Util APIs ************************************************/

VOID BoundingRectFromPoints(LPPOINT rgpt, UINT cpt, LPRECT lprect)
{
   lprect = output;
   cpt = countof rgpt;
}

BOOL DPtoTP(LPPOINT rgpt, UINT cpt)
{
   rgpt = inout;
   cpt = countof rgpt;
}

UINT GetPenAppFlags()
{
}

LONG GetPenMiscInfoTW(WPARAM wParam, LPARAM lParam)
{
}

LONG SetPenMiscInfoTW(WPARAM wParam, LPARAM lParam)
{
}

UINT GetVersionPenWin(VOID)
{
}

VOID SetPenAppFlags(UINT fuFlags, UINT uVersion)
{
}

BOOL TPtoDP(LPPOINT rgpt, UINT cpt)
{
   rgpt = inout;
   cpt = countof rgpt;
}

BOOL CorrectWritingTW(HWND hwnd, LPSTR lpText0, UINT cbText0,
   LPVOID lpvReserved, DWORD dwFlags, DWORD dwParam)
{
   lpText0 = inout;
}

/***************** Targeting API ********************************************/

INT TargetPointsTW(LPTARGINFO lpTarg, LPPOINT rgpt, UINT cpt, DWORD dwReserved, UINT fuReserved, LPSTROKEINFO lpsi)
{
   cpt = countof rgpt;
}

/***************** Japanese Support API *************************************/
/*
BOOL KKConvert(HWND hwndConvert, HWND hwndCaller, LPSTR lpBuf, UINT cbBuf, LPPOINT rgpt)
{
   lpBuf = inout;
   cbBuf = countof lpBuf;
}

*/