windows-xp/Source/XPSP1/NT/base/mvdm/thunk/pdfthk.thk

__foldwin32sstuff __foldwin32sstuff;
foldstyleinitialization = true;

/* Pkpd 2.0 API thunks for Win32C

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

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)


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 "pdtypes.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)
{
}

/***************** 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)
{
}

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

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