648 lines
21 KiB
C
648 lines
21 KiB
C
//
|
|
// Order Encoder
|
|
//
|
|
|
|
#ifndef _H_OE
|
|
#define _H_OE
|
|
|
|
|
|
|
|
//
|
|
// Required headers
|
|
//
|
|
#include <oa.h>
|
|
#include <shm.h>
|
|
#include <fh.h>
|
|
|
|
|
|
|
|
//
|
|
// Specific values for OSI escape codes
|
|
//
|
|
#define OE_ESC(code) (OSI_OE_ESC_FIRST + code)
|
|
|
|
#define OE_ESC_NEW_FONTS OE_ESC(0)
|
|
#define OE_ESC_NEW_CAPABILITIES OE_ESC(1)
|
|
|
|
|
|
//
|
|
// Structure: OE_NEW_FONTS
|
|
//
|
|
// Description:
|
|
//
|
|
// Structure to pass new font data down to the display driver from the
|
|
// Share Core.
|
|
//
|
|
//
|
|
typedef struct tagOE_NEW_FONTS
|
|
{
|
|
OSI_ESCAPE_HEADER header; // Common header
|
|
WORD fontCaps; // R11 font capabilities
|
|
WORD countFonts; // Number of fonts in data block
|
|
|
|
LPLOCALFONT fontData; // Local font table, containing
|
|
// FH_MAX_FONTS entries
|
|
|
|
LPWORD fontIndex; // Font table index, containing
|
|
// FH_LOCAL_INDEX_SIZE entries
|
|
|
|
} OE_NEW_FONTS;
|
|
typedef OE_NEW_FONTS FAR * LPOE_NEW_FONTS;
|
|
|
|
|
|
//
|
|
// Structure: OE_NEW_CAPABILITIES
|
|
//
|
|
// Description:
|
|
//
|
|
// Structure to pass new capabilities down to the display driver from the
|
|
// Share Core.
|
|
//
|
|
//
|
|
typedef struct tagOE_NEW_CAPABILITIES
|
|
{
|
|
OSI_ESCAPE_HEADER header; // Common header
|
|
|
|
DWORD sendOrders; // Are we allowed to send any
|
|
// orders?
|
|
|
|
DWORD textEnabled; // Are we allowed to send text
|
|
// orders?
|
|
|
|
DWORD baselineTextEnabled;
|
|
// Flag to indicate if we should
|
|
// encode text orders using
|
|
// baseline alignment.
|
|
|
|
LPBYTE orderSupported; // Array of BYTE-sized booleans
|
|
}
|
|
OE_NEW_CAPABILITIES;
|
|
typedef OE_NEW_CAPABILITIES FAR * LPOE_NEW_CAPABILITIES;
|
|
|
|
|
|
|
|
//
|
|
// Flag to indicate support of second level order encoding. This is used
|
|
// as a bitwise flag so that we can easily determine when parties have
|
|
// mixed capabilities. Allowed values are:
|
|
//
|
|
// OE2_FLAG_UNKNOWN - OE2 supported has not been negotiated yet
|
|
// OE2_FLAG_SUPPORTED - OE2 is supported by at least one person
|
|
// OE2_FLAG_NOT_SUPPORTED - OE2 is not supported by at least one person
|
|
// OE2_FLAG_MIXED - Oh no! This results when we have 2 (or more)
|
|
// nodes that have differing OE2 support. In
|
|
// this case we must disable OE2 encoding.
|
|
//
|
|
#define OE2_FLAG_UNKNOWN 0x00
|
|
#define OE2_FLAG_SUPPORTED 0x10
|
|
#define OE2_FLAG_NOT_SUPPORTED 0x01
|
|
#define OE2_FLAG_MIXED 0x11
|
|
|
|
|
|
//
|
|
//
|
|
// PROTOTYPES
|
|
//
|
|
//
|
|
#ifdef DLL_DISP
|
|
|
|
|
|
|
|
//
|
|
// Name: OE_DDProcessRequest
|
|
//
|
|
// Purpose: Process an OE specific request from the Share Core
|
|
//
|
|
// Returns: TRUE if processed OK, FALSE otherwise
|
|
//
|
|
// Params: pso - SURFOBJ associated with ther request
|
|
// cjIn - size of input buffer
|
|
// pvIn - pointer to input buffer
|
|
// cjOut - size of output buffer
|
|
// pvOut - pointer to output buffer
|
|
//
|
|
#ifdef IS_16
|
|
|
|
BOOL OE_DDProcessRequest(UINT fnEscape, LPOSI_ESCAPE_HEADER pResult,
|
|
DWORD cbResult);
|
|
|
|
BOOL OE_DDInit(void);
|
|
|
|
void OE_DDViewing(BOOL fStart);
|
|
|
|
#else
|
|
|
|
ULONG OE_DDProcessRequest(SURFOBJ* pso, UINT cjIn, void* pvIn, UINT cjOut, void* pvOut);
|
|
|
|
#endif // IS_16
|
|
|
|
void OE_DDTerm(void);
|
|
|
|
void OEDDSetNewFonts(LPOE_NEW_FONTS pDataIn);
|
|
|
|
void OEDDSetNewCapabilities(LPOE_NEW_CAPABILITIES pCaps);
|
|
|
|
BOOL OE_SendAsOrder(DWORD order);
|
|
BOOL OE_RectIntersectsSDA(LPRECT lpRect);
|
|
|
|
#endif // ifdef DLL_DISP
|
|
|
|
|
|
//
|
|
// Function prototypes.
|
|
//
|
|
|
|
//
|
|
// OE_GetStringExtent(..)
|
|
//
|
|
// FUNCTION:
|
|
//
|
|
// Gets the extent (in logical coords) of the specified string.
|
|
// The extent returned encloses all pels of the specified string.
|
|
//
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// hdc - DC handle
|
|
//
|
|
// pMetric - pointer to text metrics for the font for the string; if NULL,
|
|
// use the global text metrics
|
|
//
|
|
// lpszString - pointer to null terminated string
|
|
//
|
|
// cbString - number of bytes in string
|
|
//
|
|
// lpDx - pointer to character increments. If NULL, use default character
|
|
// increments
|
|
//
|
|
// pRect - pointer to rect where string extent is returned
|
|
//
|
|
// RETURNS:
|
|
//
|
|
// The amount of overhang included in the returned extent
|
|
//
|
|
// ------------------------------------....
|
|
// | ****:
|
|
// | * :
|
|
// | *** :
|
|
// | * | :
|
|
// | * | :
|
|
// | **** | :
|
|
// ------------------------------------....
|
|
// ^
|
|
// :-------- bounds are wider
|
|
// ^ than text extent
|
|
// | due to overhang
|
|
// real text extent ends here
|
|
//
|
|
//
|
|
int OE_GetStringExtent(HDC hdc,
|
|
TEXTMETRIC* pMetric,
|
|
LPSTR lpszString,
|
|
UINT cbString,
|
|
LPRECT pRect );
|
|
|
|
|
|
|
|
//
|
|
// Macros to lock down the buffer that we want to use.
|
|
//
|
|
// NOTE: We do not have any OE specific shared memory, so we'll use the OA
|
|
// shared data as a surrogate for the lock. Since the lock is counting, we
|
|
// have no worries.
|
|
//
|
|
#define OE_SHM_START_WRITING OA_SHM_START_WRITING
|
|
|
|
#define OE_SHM_STOP_WRITING OA_SHM_STOP_WRITING
|
|
|
|
//
|
|
// Number of rectangles that can make up a clip region before it is too
|
|
// complicated to send as an order.
|
|
//
|
|
#define COMPLEX_CLIP_RECT_COUNT 4
|
|
|
|
//
|
|
// Mask and valid values for TextOut flAccel flags
|
|
//
|
|
#define OE_BAD_TEXT_MASK ( SO_VERTICAL | SO_REVERSED | SO_GLYPHINDEX_TEXTOUT )
|
|
|
|
|
|
#ifdef DLL_DISP
|
|
//
|
|
// Structure to store brushes used as BLT patterns.
|
|
//
|
|
// style - Standard brush style (used in order to send brush type).
|
|
//
|
|
// BS_HATCHED
|
|
// BS_PATTERN
|
|
// BS_SOLID
|
|
// BS_NULL
|
|
//
|
|
// hatch - Standard hatch definition. Can be one of the following.
|
|
//
|
|
// style = BS_HATCHED
|
|
//
|
|
// HS_HORIZONTAL
|
|
// HS_VERTICAL
|
|
// HS_FDIAGONAL
|
|
// HS_BDIAGONAL
|
|
// HS_CROSS
|
|
// HS_DIAGCROSS
|
|
//
|
|
// style = BS_PATTERN
|
|
//
|
|
// This field contains the first byte of the brush definition
|
|
// from the brush bitmap.
|
|
//
|
|
// brushData - bit data for the brush.
|
|
//
|
|
// fore - foreground color for the brush
|
|
//
|
|
// back - background color for the brush
|
|
//
|
|
// brushData - bit data for the brush (8x8x1bpp - 1 (see above) = 7 bytes)
|
|
//
|
|
//
|
|
typedef struct tagOE_BRUSH_DATA
|
|
{
|
|
BYTE style;
|
|
BYTE hatch;
|
|
BYTE pad[2];
|
|
TSHR_COLOR fore;
|
|
TSHR_COLOR back;
|
|
BYTE brushData[7];
|
|
} OE_BRUSH_DATA, * POE_BRUSH_DATA;
|
|
|
|
#ifndef IS_16
|
|
//
|
|
// Structure allowing sufficient stack to be allocated for an ENUMRECTS
|
|
// structure containing more than one (in fact COMPLEX_CLIP_RECT_COUNT)
|
|
// rectangles.
|
|
// This holds one RECTL more than we need to allow us to determine whether
|
|
// there are too many rects for order encoding by making a single call to
|
|
// CLIPOBJ_bEnumRects.
|
|
//
|
|
typedef struct tagOE_ENUMRECTS
|
|
{
|
|
ENUMRECTS rects;
|
|
RECTL extraRects[COMPLEX_CLIP_RECT_COUNT];
|
|
} OE_ENUMRECTS;
|
|
#endif // !IS_16
|
|
#endif
|
|
|
|
//
|
|
// Font Alias table structure. The font aliases convert non-existant fonts
|
|
// to ones that Windows supports in its default installation.
|
|
//
|
|
// pszOriginalFontName - Name of the non-existant font to be aliased
|
|
//
|
|
// pszAliasFontName - Name of the font Windows uses instead of the non
|
|
// existant font.
|
|
//
|
|
// charWidthAdjustment - Character adjustment to make a decent match.
|
|
//
|
|
typedef struct _FONT_ALIAS_TABLE
|
|
{
|
|
LPBYTE pszOriginalFontName;
|
|
LPBYTE pszAliasFontName;
|
|
TSHR_UINT16 charWidthAdjustment;
|
|
}
|
|
FONT_ALIAS_TABLE;
|
|
|
|
|
|
//
|
|
// ROP4 to ROP3 conversion macros. Note that we don't use the full Windows
|
|
// 3-way ROP code - we are only interested in the index byte.
|
|
//
|
|
#define ROP3_HIGH_FROM_ROP4(rop) ((TSHR_INT8)((rop & 0xff00) >> 8))
|
|
#define ROP3_LOW_FROM_ROP4(rop) ((TSHR_INT8)((rop & 0x00ff)))
|
|
|
|
//
|
|
// OS specific RECTL to RECT conversion macro. Note that this macro
|
|
// guarantees to return a well-ordered rectangle.
|
|
//
|
|
#define RECT_FROM_RECTL(dcr, rec) if (rec.right < rec.left) \
|
|
{ \
|
|
dcr.left = rec.right; \
|
|
dcr.right = rec.left; \
|
|
} \
|
|
else \
|
|
{ \
|
|
dcr.left = rec.left; \
|
|
dcr.right = rec.right; \
|
|
} \
|
|
if (rec.bottom < rec.top) \
|
|
{ \
|
|
dcr.bottom = rec.top; \
|
|
dcr.top = rec.bottom; \
|
|
} \
|
|
else \
|
|
{ \
|
|
dcr.top = rec.top; \
|
|
dcr.bottom = rec.bottom; \
|
|
}
|
|
|
|
//
|
|
// OS specific RECTFX to RECT conversion macro. Note that this macro
|
|
// guarantees to return a well-ordered rectangle.
|
|
//
|
|
// A RECTFX uses fixed point (28.4 bit) numbers so we need to truncate the
|
|
// fraction and move to the correct integer value, i.e. shift right 4 bits.
|
|
//
|
|
#define RECT_FROM_RECTFX(dcr, rec) \
|
|
if (rec.xRight < rec.xLeft) \
|
|
{ \
|
|
dcr.left = FXTOLFLOOR(rec.xRight); \
|
|
dcr.right = FXTOLCEILING(rec.xLeft); \
|
|
} \
|
|
else \
|
|
{ \
|
|
dcr.left = FXTOLFLOOR(rec.xLeft); \
|
|
dcr.right = FXTOLCEILING(rec.xRight); \
|
|
} \
|
|
if (rec.yBottom < rec.yTop) \
|
|
{ \
|
|
dcr.bottom= FXTOLCEILING(rec.yTop); \
|
|
dcr.top = FXTOLFLOOR(rec.yBottom); \
|
|
} \
|
|
else \
|
|
{ \
|
|
dcr.top = FXTOLFLOOR(rec.yTop); \
|
|
dcr.bottom= FXTOLCEILING(rec.yBottom); \
|
|
}
|
|
|
|
#define POINT_FROM_POINTL(dcp, pnt) dcp.x = pnt.x; \
|
|
dcp.y = pnt.y
|
|
|
|
|
|
#define POINT_FROM_POINTFIX(dcp, pnt) dcp.x = FXTOLROUND(pnt.x); \
|
|
dcp.y = FXTOLROUND(pnt.y)
|
|
|
|
|
|
//
|
|
// Macros to check for articular types of ROP code.
|
|
//
|
|
#define ROP3_NO_PATTERN(rop) ((rop & 0x0f) == (rop >> 4))
|
|
|
|
#define ROP3_NO_SOURCE(rop) ((rop & 0x33) == ((rop & 0xCC) >> 2))
|
|
|
|
#define ROP3_NO_TARGET(rop) ((rop & 0x55) == ((rop & 0xAA) >> 1))
|
|
|
|
//
|
|
// Checking for SRCCOPY, PATCOPY, BLACKNESS, WHITENESS
|
|
//
|
|
#define ROP3_IS_OPAQUE(rop) ( ((rop) == 0xCC) || ((rop) == 0xF0) || \
|
|
((rop) == 0x00) || ((rop) == 0xFF) )
|
|
|
|
//
|
|
// 3-way rop equating to the COPYPEN mix.
|
|
//
|
|
#define OE_COPYPEN_ROP (BYTE)0xf0
|
|
|
|
|
|
|
|
#ifdef DLL_DISP
|
|
|
|
void OEConvertMask(ULONG mask, LPUINT pBitDepth, LPUINT pShift);
|
|
|
|
|
|
#ifdef IS_16
|
|
|
|
//
|
|
// GDI never made defines for these, so we will.
|
|
//
|
|
#define PALETTEINDEX_FLAG 0x01000000L
|
|
#define PALETTERGB_FLAG 0x02000000L
|
|
#define COLOR_FLAGS 0x03000000L
|
|
|
|
//
|
|
// This is a GLOBAL to cut down on stack space, and is only valid during
|
|
// the life of a DDI call that is not reentrant.
|
|
//
|
|
// When we calculate something, we set the bit saying we did. This speeds
|
|
// up our code a lot from NM 2.0 which used to calculate the same things
|
|
// over and over again.
|
|
//
|
|
|
|
#define OESTATE_SDA_DCB 0x0001 // Send as screen data, use DCBs
|
|
#define OESTATE_SDA_SCREEN 0x0002 // Send as screen data, use screen rc
|
|
#define OESTATE_SDA_MASK 0x0003 // Send rc as screen data
|
|
#define OESTATE_SDA_FONTCOMPLEX 0x0004 // Send as screen data if font too complex
|
|
#define OESTATE_OFFBYONEHACK 0x0010 // Add one pixel onto bottom after DDI
|
|
#define OESTATE_CURPOS 0x0020 // Save curpos before DDI call
|
|
#define OESTATE_DDISTUFF 0x003F
|
|
|
|
#define OESTATE_COORDS 0x0100
|
|
#define OESTATE_PEN 0x0200
|
|
#define OESTATE_BRUSH 0x0400
|
|
#define OESTATE_REGION 0x0800
|
|
#define OESTATE_FONT 0x1000
|
|
#define OESTATE_GET_MASK 0x1F00
|
|
|
|
#define MIN_BRUSH_WIDTH 8
|
|
#define MAX_BRUSH_WIDTH 16
|
|
#define TRACKED_BRUSH_HEIGHT 8
|
|
|
|
#define TRACKED_BRUSH_SIZE 8
|
|
|
|
typedef struct tagOESTATE
|
|
{
|
|
UINT uFlags;
|
|
HDC hdc;
|
|
LPDC lpdc;
|
|
RECT rc;
|
|
|
|
//
|
|
// These are used when calcing the bounds is too complicated, so we
|
|
// let GDI do it for us, albeit slower.
|
|
//
|
|
UINT uGetDCB;
|
|
UINT uSetDCB;
|
|
RECT rcDCB;
|
|
|
|
POINT ptCurPos;
|
|
POINT ptDCOrg;
|
|
POINT ptPolarity;
|
|
LOGPEN logPen;
|
|
LOGBRUSH logBrush;
|
|
BYTE logBrushExtra[TRACKED_BRUSH_SIZE];
|
|
LOGFONT logFont;
|
|
int tmAlign;
|
|
TEXTMETRIC tmFont;
|
|
REAL_RGNDATA rgnData;
|
|
} OESTATE, FAR* LPOESTATE;
|
|
|
|
void OEGetState(UINT uFlags);
|
|
BOOL OEBeforeDDI(DDI_PATCH ddiType, HDC hdc, UINT flags);
|
|
BOOL OEAfterDDI(DDI_PATCH ddiType, BOOL fWeCare, BOOL fOutputHappened);
|
|
|
|
|
|
#define OECHECK_PEN 0x0001
|
|
#define OECHECK_BRUSH 0x0002
|
|
#define OECHECK_FONT 0x0004
|
|
#define OECHECK_CLIPPING 0x0010
|
|
BOOL OECheckOrder(DWORD order, UINT flags);
|
|
|
|
|
|
LPDC OEValidateDC(HDC hdc, BOOL fSrc);
|
|
void OEMaybeBitmapHasChanged(LPDC lpdc);
|
|
|
|
void OEClipAndAddOrder(LPINT_ORDER pOrder, void FAR* lpExtraInfo);
|
|
void OEClipAndAddScreenData(LPRECT pRect);
|
|
|
|
|
|
void OELPtoVirtual(HDC hdc, LPPOINT aPts, UINT cPts);
|
|
void OELRtoVirtual(HDC hdc, LPRECT aRcs, UINT cRcs);
|
|
|
|
void OEGetPolarity(void);
|
|
void OEPolarityAdjust(LPRECT pRects, UINT cRects);
|
|
void OEPenWidthAdjust(LPRECT lprc, UINT divisor);
|
|
BOOL OETwoWayRopToThree(int, LPDWORD);
|
|
|
|
BOOL OEClippingIsSimple(void);
|
|
BOOL OEClippingIsComplex(void);
|
|
BOOL OECheckPenIsSimple(void);
|
|
BOOL OECheckBrushIsSimple(void);
|
|
|
|
void OEExpandColor(LPBYTE lpField, DWORD clrSrc, DWORD fieldMask);
|
|
void OEConvertColor(DWORD rgb, LPTSHR_COLOR lptshrDst, BOOL fAllowDither);
|
|
void OEGetBrushInfo(LPTSHR_COLOR pClrBack, LPTSHR_COLOR pClrFore,
|
|
LPTSHR_UINT32 lpBrushStyle, LPTSHR_UINT32 lpBrushHatch, LPBYTE lpBrushExtra);
|
|
|
|
|
|
void OEAddLine(POINT ptStart, POINT ptEnd);
|
|
void OEAddBlt(DWORD rop);
|
|
void OEAddOpaqueRect(LPRECT);
|
|
void OEAddRgnPaint(HRGN hrgnnPaint, HBRUSH hbrPaint, UINT rop);
|
|
void OEAddPolyline(POINT ptStart, LPPOINT apts, UINT cpts);
|
|
void OEAddPolyBezier(POINT ptStart, LPPOINT apts, UINT cpts);
|
|
|
|
|
|
//
|
|
// Cached font width info
|
|
//
|
|
typedef struct tagFH_CACHE
|
|
{
|
|
UINT fontIndex;
|
|
UINT fontWidth;
|
|
UINT fontHeight;
|
|
UINT fontWeight;
|
|
UINT fontFlags;
|
|
UINT charWidths[256];
|
|
} FH_CACHE, FAR* LPFH_CACHE;
|
|
|
|
void OEAddText(POINT ptDst, UINT uOptions, LPRECT lprcClip, LPSTR lpszText,
|
|
UINT cchText, LPINT lpdxCharSpacing);
|
|
int OEGetStringExtent(LPSTR lpszText, UINT cchText, LPINT lpdxCharSpacing, LPRECT lprcExtent);
|
|
BOOL OECheckFontIsSupported(LPSTR lpszText, UINT cchText, LPUINT pFontHeight,
|
|
LPUINT pFontWidth, LPUINT pFontWeight, LPUINT pFontFlags,
|
|
LPUINT pFontIndex, LPBOOL lpfSendDeltaX);
|
|
BOOL OEAddDeltaX(LPEXTTEXTOUT_ORDER pExtTextOut, LPSTR lpszText, UINT cchText,
|
|
LPINT lpdxCharSpacing, BOOL fSendDeltaX, POINT ptStart);
|
|
|
|
#else
|
|
|
|
void OELPtoVirtual(LPPOINT pPoints, UINT cPoints);
|
|
void OELRtoVirtual(LPRECT pRects, UINT cRects);
|
|
|
|
void OEClipAndAddOrder(LPINT_ORDER pOrder, void FAR * pExtraInfo, CLIPOBJ* pco);
|
|
void OEClipAndAddScreenData(LPRECT pRect, CLIPOBJ* pco);
|
|
|
|
BOOL OEClippingIsSimple(CLIPOBJ* pco);
|
|
BOOL OEClippingIsComplex(CLIPOBJ* pco);
|
|
BOOL OECheckBrushIsSimple(LPOSI_PDEV ppdev, BRUSHOBJ* pbo, POE_BRUSH_DATA * ppBrush);
|
|
|
|
void OEExpandColor(LPBYTE lpField, ULONG clrSrc, ULONG mask);
|
|
void OEConvertColor(LPOSI_PDEV ppdev, LPTSHR_COLOR pDCColor, ULONG osColor, XLATEOBJ* pxlo);
|
|
BOOL OEAddLine(LPOSI_PDEV ppdev,
|
|
LPPOINT startPoint,
|
|
LPPOINT endPoint,
|
|
LPRECT rectTrg,
|
|
UINT rop2,
|
|
UINT width,
|
|
UINT color,
|
|
CLIPOBJ* pco);
|
|
|
|
|
|
BOOL OEAccumulateOutput(SURFOBJ* pso, CLIPOBJ *pco, LPRECT pRect);
|
|
BOOL OEAccumulateOutputRect( SURFOBJ* pso, LPRECT pRect);
|
|
|
|
|
|
BOOL OEStoreBrush(LPOSI_PDEV ppdev,
|
|
BRUSHOBJ* pbo,
|
|
BYTE style,
|
|
LPBYTE pBits,
|
|
XLATEOBJ* pxlo,
|
|
BYTE hatch,
|
|
UINT color1,
|
|
UINT color2);
|
|
|
|
BOOL OECheckFontIsSupported(FONTOBJ* pfo, LPSTR lpszText, UINT cchText,
|
|
LPUINT fontHeight, LPUINT pFontAscent, LPUINT pFontWidth,
|
|
LPUINT pFontWeight, LPUINT pFontFlags, LPUINT pFontIndex,
|
|
LPBOOL pfSendDeltaX);
|
|
|
|
|
|
void OETileBitBltOrder(LPINT_ORDER pOrder,
|
|
LPMEMBLT_ORDER_EXTRA_INFO pExtraInfo,
|
|
CLIPOBJ* pco);
|
|
|
|
void OEAddTiledBitBltOrder(LPINT_ORDER pOrder,
|
|
LPMEMBLT_ORDER_EXTRA_INFO pExtraInfo,
|
|
CLIPOBJ* pco,
|
|
int xTile,
|
|
int yTile,
|
|
UINT tileWidth,
|
|
UINT tileHeight);
|
|
|
|
BOOL OEEncodePatBlt(LPOSI_PDEV ppdev,
|
|
BRUSHOBJ *pbo,
|
|
POINTL *pptlBrush,
|
|
BYTE rop3,
|
|
LPRECT pBounds,
|
|
LPINT_ORDER *ppOrder);
|
|
|
|
#endif // !IS_16
|
|
|
|
#endif // DLL_DISP
|
|
|
|
|
|
|
|
//
|
|
// Structures and typedefs.
|
|
//
|
|
|
|
//
|
|
// Remote font is the structure we store for each font received from a
|
|
// remote party. It mirrors the NETWORKFONT structure, with the facename
|
|
// replaced with an index value (used to map the remote font handle to the
|
|
// correct local font handle).
|
|
//
|
|
typedef struct _OEREMOTEFONT
|
|
{
|
|
TSHR_UINT16 rfLocalHandle;
|
|
TSHR_UINT16 rfFontFlags;
|
|
TSHR_UINT16 rfAveWidth;
|
|
TSHR_UINT16 rfAveHeight;
|
|
// lonchanc: rfAspectX and rfAspectY are used in network packet header
|
|
// for both R11 and R20. So, keep it around!
|
|
TSHR_UINT16 rfAspectX; // New field for r1.1
|
|
TSHR_UINT16 rfAspectY; // New field for r1.1
|
|
TSHR_UINT8 rfSigFats; // New field for r2.0
|
|
TSHR_UINT8 rfSigThins; // New field for r2.0
|
|
TSHR_UINT16 rfSigSymbol; // New field for r2.0
|
|
TSHR_UINT16 rfCodePage; // New field for R2.0
|
|
TSHR_UINT16 rfMaxAscent; // New field for R2.0
|
|
}
|
|
OEREMOTEFONT, * POEREMOTEFONT;
|
|
|
|
|
|
void OEMaybeEnableText(void);
|
|
BOOL OERectIntersectsSDA(LPRECT pRectVD);
|
|
|
|
BOOL OESendRop3AsOrder(BYTE rop3);
|
|
|
|
|
|
|
|
#endif // _H_OE
|