mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3635 lines
99 KiB
3635 lines
99 KiB
//
|
|
// T.SHARE protocol
|
|
//
|
|
|
|
#ifndef _H_T_SHARE
|
|
#define _H_T_SHARE
|
|
|
|
|
|
//
|
|
// TSHARE PROTOCOL STRUCTURES
|
|
// These are defined in a way that keeps the offsets and total sizes the
|
|
// same, regardless of whether this header is included in 32-bit code,
|
|
// 16-bit code, big-endian code, etc.
|
|
//
|
|
// We make special types to avoid inadvertenly altering something else and
|
|
// breaking the structure. The TSHR_ prefix helps make this clear.
|
|
//
|
|
|
|
|
|
////////////////////////////////
|
|
//
|
|
// BASIC TYPES
|
|
//
|
|
////////////////////////////////
|
|
|
|
typedef char TSHR_CHAR;
|
|
typedef TSHR_CHAR FAR* LPTSHR_CHAR;
|
|
typedef TSHR_CHAR UNALIGNED FAR* LPTSHR_CHAR_UA;
|
|
|
|
|
|
typedef signed char TSHR_INT8;
|
|
typedef TSHR_INT8 FAR* LPTSHR_INT8;
|
|
typedef TSHR_INT8 UNALIGNED FAR* LPTSHR_INT8_UA;
|
|
|
|
typedef BYTE TSHR_UINT8;
|
|
typedef TSHR_UINT8 FAR* LPTSHR_UINT8;
|
|
typedef TSHR_UINT8 UNALIGNED FAR * LPTSHR_UINT8_UA;
|
|
|
|
|
|
typedef short TSHR_INT16;
|
|
typedef TSHR_INT16 FAR* LPTSHR_INT16;
|
|
typedef TSHR_INT16 UNALIGNED FAR * LPTSHR_INT16_UA;
|
|
|
|
typedef unsigned short TSHR_UINT16;
|
|
typedef TSHR_UINT16 FAR* LPTSHR_UINT16;
|
|
typedef TSHR_UINT16 UNALIGNED FAR * LPTSHR_UINT16_UA;
|
|
|
|
|
|
typedef long TSHR_INT32;
|
|
typedef TSHR_INT32 FAR* LPTSHR_INT32;
|
|
typedef TSHR_INT32 UNALIGNED FAR * LPTSHR_INT32_UA;
|
|
|
|
typedef unsigned long TSHR_UINT32;
|
|
typedef TSHR_UINT32 FAR* LPTSHR_UINT32;
|
|
typedef TSHR_UINT32 UNALIGNED FAR * LPTSHR_UINT32_UA;
|
|
|
|
// TSHR_PERSONID
|
|
typedef TSHR_UINT32 TSHR_PERSONID;
|
|
typedef TSHR_PERSONID * LPTSHR_PERSONID;
|
|
|
|
|
|
|
|
// TSHR_POINT16 -- POINT with WORD fields
|
|
|
|
typedef struct tagTSHR_POINT16
|
|
{
|
|
TSHR_INT16 x;
|
|
TSHR_INT16 y;
|
|
}
|
|
TSHR_POINT16;
|
|
typedef TSHR_POINT16 FAR * LPTSHR_POINT16;
|
|
|
|
|
|
|
|
// TSHR_POINT32 -- POINT with DWORD fields
|
|
|
|
typedef struct tagTSHR_POINT32
|
|
{
|
|
TSHR_INT32 x;
|
|
TSHR_INT32 y;
|
|
}
|
|
TSHR_POINT32;
|
|
typedef TSHR_POINT32 FAR * LPTSHR_POINT32;
|
|
|
|
|
|
|
|
// Conversion Macros
|
|
_inline void TSHR_POINT16_FROM_POINT(LPTSHR_POINT16 pPt16, POINT pt)
|
|
{
|
|
pPt16->x = (TSHR_INT16)pt.x;
|
|
pPt16->y = (TSHR_INT16)pt.y;
|
|
}
|
|
|
|
_inline void POINT_FROM_TSHR_POINT16(LPPOINT pPt, TSHR_POINT16 pt16)
|
|
{
|
|
pPt->x = pt16.x;
|
|
pPt->y = pt16.y;
|
|
}
|
|
|
|
|
|
|
|
// TSHR_RECT16 -- RECT with WORD fields
|
|
|
|
typedef struct tagTSHR_RECT16
|
|
{
|
|
TSHR_INT16 left;
|
|
TSHR_INT16 top;
|
|
TSHR_INT16 right;
|
|
TSHR_INT16 bottom;
|
|
}
|
|
TSHR_RECT16;
|
|
typedef TSHR_RECT16 FAR * LPTSHR_RECT16;
|
|
|
|
|
|
// TSHR_RECT32 -- RECT with DWORD fields
|
|
|
|
typedef struct tagTSHR_RECT32
|
|
{
|
|
TSHR_INT32 left;
|
|
TSHR_INT32 top;
|
|
TSHR_INT32 right;
|
|
TSHR_INT32 bottom;
|
|
}
|
|
TSHR_RECT32;
|
|
typedef TSHR_RECT32 FAR * LPTSHR_RECT32;
|
|
|
|
|
|
|
|
// Conversion Macros
|
|
#ifdef IS_16
|
|
#define TSHR_RECT16_FROM_RECT(lprcTshr, rc) \
|
|
CopyRect((LPRECT)lprcTshr, &rc)
|
|
|
|
#define RECT_FROM_TSHR_RECT16(lprc, tshrrc) \
|
|
CopyRect(lprc, (LPRECT)&tshrrc)
|
|
|
|
#else
|
|
_inline void TSHR_RECT16_FROM_RECT(LPTSHR_RECT16 pRect16, RECT rect)
|
|
{
|
|
pRect16->left = (TSHR_INT16)rect.left;
|
|
pRect16->top = (TSHR_INT16)rect.top;
|
|
pRect16->right = (TSHR_INT16)rect.right;
|
|
pRect16->bottom = (TSHR_INT16)rect.bottom;
|
|
}
|
|
|
|
__inline void RECT_FROM_TSHR_RECT16(LPRECT pRect, TSHR_RECT16 rect16)
|
|
{
|
|
pRect->left = rect16.left;
|
|
pRect->top = rect16.top;
|
|
pRect->right = rect16.right;
|
|
pRect->bottom = rect16.bottom;
|
|
}
|
|
#endif // IS_16
|
|
|
|
|
|
|
|
//
|
|
// TSHR_RGBQUAD
|
|
// =======
|
|
// rgbBlue : blue value.
|
|
// rgbGreen : green value.
|
|
//
|
|
// rgbRed : red value.
|
|
// rgbReserved : reserved.
|
|
//
|
|
typedef struct tagTSHR_RGBQUAD
|
|
{
|
|
TSHR_UINT8 rgbBlue;
|
|
TSHR_UINT8 rgbGreen;
|
|
TSHR_UINT8 rgbRed;
|
|
TSHR_UINT8 rgbReserved;
|
|
}
|
|
TSHR_RGBQUAD;
|
|
typedef TSHR_RGBQUAD FAR * LPTSHR_RGBQUAD;
|
|
|
|
|
|
//
|
|
// TSHR_COLOR
|
|
// =======
|
|
// red : red value.
|
|
// green : green value.
|
|
// blue : blue value.
|
|
//
|
|
typedef struct tagTSHR_COLOR
|
|
{
|
|
TSHR_UINT8 red;
|
|
TSHR_UINT8 green;
|
|
TSHR_UINT8 blue;
|
|
}
|
|
TSHR_COLOR;
|
|
typedef TSHR_COLOR FAR * LPTSHR_COLOR;
|
|
|
|
|
|
//
|
|
// TSHR_COLORS
|
|
// ========
|
|
// fg : foreground color.
|
|
// bg : background color.
|
|
//
|
|
typedef struct tagTSHR_COLORS
|
|
{
|
|
TSHR_COLOR fg;
|
|
TSHR_COLOR bg;
|
|
}
|
|
TSHR_COLORS;
|
|
typedef TSHR_COLORS FAR * LPTSHR_COLORS;
|
|
|
|
|
|
//
|
|
// BITMAPINFO_ours
|
|
// ===============
|
|
// bmiHeader :
|
|
// bmiColors :
|
|
//
|
|
typedef struct tagBITMAPINFO_ours
|
|
{
|
|
BITMAPINFOHEADER bmiHeader;
|
|
TSHR_RGBQUAD bmiColors[256];
|
|
}
|
|
BITMAPINFO_ours;
|
|
|
|
|
|
|
|
#define TSHR_RGBQUAD_TO_TSHR_COLOR(TshrRGBQuad, TshrColor) \
|
|
TshrColor.red = TshrRGBQuad.rgbRed; \
|
|
TshrColor.green = TshrRGBQuad.rgbGreen; \
|
|
TshrColor.blue = TshrRGBQuad.rgbBlue
|
|
|
|
#define TSHR_COLOR_TO_PALETTEENTRY(TshrColor, pe) \
|
|
pe.peGreen = TshrColor.green; \
|
|
pe.peRed = TshrColor.red; \
|
|
pe.peBlue = TshrColor.blue; \
|
|
pe.peFlags = 0
|
|
|
|
#define TSHR_RGBQUAD_TO_PALETTEENTRY(TshrRGBQuad, pe) \
|
|
pe.peRed = TshrRGBQuad.rgbRed; \
|
|
pe.peGreen = TshrRGBQuad.rgbGreen; \
|
|
pe.peBlue = TshrRGBQuad.rgbBlue; \
|
|
pe.peFlags = 0
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// DATE
|
|
// =======
|
|
// day : day of the month (1-31).
|
|
// month : month (1-12).
|
|
// year : year (e.g. 1996).
|
|
//
|
|
typedef struct tagTSHR_DATE
|
|
{
|
|
TSHR_UINT8 day;
|
|
TSHR_UINT8 month;
|
|
TSHR_UINT16 year;
|
|
} TSHR_DATE;
|
|
typedef TSHR_DATE FAR * LPTSHR_DATE;
|
|
|
|
|
|
//
|
|
// TSHR_TIME
|
|
// =======
|
|
// hour : hour (0-23).
|
|
// min : minute (0-59).
|
|
// sec : seconds (0-59).
|
|
// hundredths : hundredths of a second (0-99).
|
|
//
|
|
typedef struct tagTSHR_TIME
|
|
{
|
|
TSHR_UINT8 hour;
|
|
TSHR_UINT8 min;
|
|
TSHR_UINT8 sec;
|
|
TSHR_UINT8 hundredths;
|
|
}
|
|
TSHR_TIME;
|
|
typedef TSHR_TIME FAR * LPTSHR_TIME;
|
|
|
|
|
|
|
|
//
|
|
// Maximum length of a person name
|
|
//
|
|
#define TSHR_MAX_PERSON_NAME_LEN 48
|
|
|
|
|
|
|
|
//
|
|
// Common person information: This is an ObMan object
|
|
//
|
|
typedef struct tagTSHR_PERSON_DATA
|
|
{
|
|
char personName[TSHR_MAX_PERSON_NAME_LEN];
|
|
TSHR_PERSONID personHandle; // Call manager ID
|
|
}
|
|
TSHR_PERSON_DATA;
|
|
typedef TSHR_PERSON_DATA * PTSHR_PERSON_DATA;
|
|
|
|
|
|
|
|
|
|
////////////////////////////////
|
|
//
|
|
// CAPABILITIES
|
|
//
|
|
////////////////////////////////
|
|
|
|
|
|
//
|
|
// Version numbers.
|
|
//
|
|
#define CAPS_VERSION_20 0x0200 // NM 2.x
|
|
#define CAPS_VERSION_30 0x0300 // NM 3.0
|
|
#define CAPS_VERSION_OLDEST_SUPPORTED CAPS_VERSION_20
|
|
#define CAPS_VERSION_CURRENT CAPS_VERSION_30
|
|
|
|
//
|
|
// Operating system and operating system version numbers.
|
|
//
|
|
#define CAPS_WINDOWS 0x0001
|
|
|
|
#define CAPS_WINDOWS_31 0x0001
|
|
#define CAPS_WINDOWS_95 0x0002
|
|
#define CAPS_WINDOWS_NT 0x0003
|
|
|
|
//
|
|
// Logical capabilities field values.
|
|
//
|
|
#define CAPS_UNDEFINED 0
|
|
#define CAPS_SUPPORTED 1
|
|
#define CAPS_UNSUPPORTED 2
|
|
|
|
//
|
|
// Number of order fields in the orders array. This must never change
|
|
// because the fields within the capabilities structure must never move.
|
|
// If more orders fields are required then they must be added to the end of
|
|
// the capabilities structure.
|
|
//
|
|
#define CAPS_MAX_NUM_ORDERS 32
|
|
|
|
//
|
|
// String length of the driver name field in the capabilities structure.
|
|
// This allows for an 8.3 driver name (eg VGA.DRV), a NULL, and padding.
|
|
//
|
|
#define CAPS_DRIVER_NAME_LENGTH 16
|
|
|
|
//
|
|
// Capabilities (group structures) IDs currently defined. Each ID
|
|
// corresponds to a different PROTCAPS structure. (See below).
|
|
//
|
|
#define CAPS_ID_GENERAL 1
|
|
#define CAPS_ID_SCREEN 2
|
|
#define CAPS_ID_ORDERS 3
|
|
#define CAPS_ID_BITMAPCACHE 4
|
|
#define CAPS_UNUSED_HCA 5
|
|
#define CAPS_UNUSED_FE 6
|
|
#define CAPS_UNUSED_AWC 7
|
|
#define CAPS_ID_CM 8
|
|
#define CAPS_ID_SC 9
|
|
#define CAPS_ID_PM 10
|
|
#define CAPS_UNUSED_SWL 11 // Used to be for regional window stuff
|
|
|
|
|
|
|
|
|
|
//
|
|
// Capabilities structure header.
|
|
//
|
|
typedef struct tagPROTCAPSHEADER
|
|
{
|
|
TSHR_UINT16 capID;
|
|
TSHR_UINT16 capSize;
|
|
}
|
|
PROTCAPSHEADER;
|
|
|
|
|
|
//
|
|
// Structure passed to CPC_RegisterCapabilities and returned by
|
|
// CPC_EnumerateCapabilities. The data field is of variable length (but
|
|
// always ends dword aligned).
|
|
//
|
|
typedef struct tagPROTCAPS
|
|
{
|
|
PROTCAPSHEADER header;
|
|
TSHR_UINT32 data[1];
|
|
}
|
|
PROTCAPS;
|
|
typedef PROTCAPS *PPROTCAPS;
|
|
|
|
|
|
|
|
//
|
|
// Structure returned by CPC_GetCombinedCapabilities and as part of a
|
|
// NET_EV_PERSON_ADD event.
|
|
//
|
|
typedef struct tagPROTCOMBINEDCAPS_HEADER
|
|
{
|
|
TSHR_UINT16 numCapabilities;
|
|
TSHR_UINT16 pad1;
|
|
}
|
|
PROTCOMBINEDCAPS_HEADER;
|
|
typedef PROTCOMBINEDCAPS_HEADER * PPROTCOMBINEDCAPS_HEADER;
|
|
|
|
typedef struct tagPROTCOMBINEDCAPS
|
|
{
|
|
PROTCOMBINEDCAPS_HEADER header;
|
|
PROTCAPS capabilities[1];
|
|
}
|
|
PROTCOMBINEDCAPS;
|
|
typedef PROTCOMBINEDCAPS * PPROTCOMBINEDCAPS;
|
|
typedef PPROTCOMBINEDCAPS * PPPROTCOMBINEDCAPS;
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Curent capabilities structure (corresponding to the generic structures
|
|
// defined above)....
|
|
//
|
|
// Note that these must be DWORD padded in size for the current code to
|
|
// work correctly on all platforms.
|
|
//
|
|
//
|
|
|
|
|
|
//
|
|
// AS type flags
|
|
//
|
|
#define AS_SERVICE 0x0001
|
|
#define AS_UNATTENDED 0x0002
|
|
|
|
//
|
|
// General capabilities.
|
|
//
|
|
typedef struct tagPROTCAPS_GENERAL
|
|
{
|
|
PROTCAPSHEADER header;
|
|
TSHR_UINT16 OS;
|
|
TSHR_UINT16 OSVersion;
|
|
TSHR_UINT16 version;
|
|
TSHR_UINT16 supportsDOS6Compression; // OBSOLETE
|
|
TSHR_UINT16 genCompressionType; // OBSOLETE
|
|
TSHR_UINT16 typeFlags; // NEW FOR 3.0
|
|
TSHR_UINT16 supportsCapsUpdate; // almost OBSOLETE
|
|
TSHR_UINT16 supportsRemoteUnshare; // OBSOLETE
|
|
|
|
// NEW FOR NM 2.0 NT && NM 2.1 WIN95
|
|
TSHR_UINT16 genCompressionLevel;
|
|
TSHR_UINT16 pad1;
|
|
}
|
|
PROTCAPS_GENERAL;
|
|
typedef PROTCAPS_GENERAL *PPROTCAPS_GENERAL;
|
|
|
|
#define PROTCAPS_GENERAL_SIZE_NM20 FIELD_OFFSET(PROTCAPS_GENERAL, genCompressionLevel)
|
|
|
|
|
|
//
|
|
// Values for genCompressionLevel
|
|
//
|
|
// Level 0 : Only GDC_PKZIP compression is allowed in entire share session
|
|
// (genCompressionType indicates if a node supports it)
|
|
// Bit 15 (PT_COMPRESSED) of packetType field is used to
|
|
// indicate if a packet is compressed.
|
|
//
|
|
// Level 1 : Each nodes genCompressionType indicates which compression
|
|
// algorithms it can use to DECOMPRESS packets.
|
|
// A node can compress a packet with any compression algorithm
|
|
// that the receiving node(s) can decompress with.
|
|
// The top byte of packetType indicates which compression
|
|
// algorithm a packet ahs been compressed with.
|
|
//
|
|
// If the genCompressionLevel field is not present in a nodes GENERAL
|
|
// capabilities then that node is assumed to be use level 0.
|
|
//
|
|
#define CAPS_GEN_COMPRESSION_LEVEL_0 ((TSHR_UINT16)0x0000)
|
|
#define CAPS_GEN_COMPRESSION_LEVEL_1 ((TSHR_UINT16)0x0001)
|
|
|
|
//
|
|
// Bitmap capabilities.
|
|
//
|
|
typedef struct tagPROTCAPS_SCREEN
|
|
{
|
|
PROTCAPSHEADER header;
|
|
TSHR_UINT16 capsBPP;
|
|
TSHR_UINT16 capsSupports1BPP; // OBSOLETE 3.0
|
|
TSHR_UINT16 capsSupports4BPP; // Almost OBSOLETE
|
|
TSHR_UINT16 capsSupports8BPP; // Almost OBSOLETE
|
|
TSHR_UINT16 capsScreenWidth;
|
|
TSHR_UINT16 capsScreenHeight;
|
|
|
|
//
|
|
// Need to keep this field unused for NM 2.0 interop.
|
|
// Can be reused when only care about NM 2.1 and above.
|
|
//
|
|
TSHR_UINT16 capsSupportsV1Compression; // OBSOLETE
|
|
|
|
TSHR_UINT16 capsSupportsDesktopResize;
|
|
TSHR_UINT16 capsSupportsV2Compression; // OBSOLETE
|
|
|
|
//
|
|
// NM 2.1 and earlier did NOT zero-init the caps structures. Therefore
|
|
// old pad fields can't be recovered until we only care about NM 3.0
|
|
// compatibility and above.
|
|
//
|
|
TSHR_UINT16 pad1;
|
|
|
|
// NEW FOR NM 3.0
|
|
TSHR_UINT16 capsSupports24BPP;
|
|
TSHR_UINT16 pad2; // INIT THIS TO 0 ALWAYS; THEN IT CAN BE USED IN THE FUTURE
|
|
}
|
|
PROTCAPS_SCREEN;
|
|
typedef PROTCAPS_SCREEN *PPROTCAPS_SCREEN;
|
|
|
|
#define PROTCAPS_SCREEN_SIZE_NM21 FIELD_OFFSET(PROTCAPS_SCREEN, capsSupportsTrueColor)
|
|
|
|
|
|
|
|
//
|
|
// Orders capabilities.
|
|
//
|
|
typedef struct tagPROTCAPS_ORDERS
|
|
{
|
|
PROTCAPSHEADER header;
|
|
TSHR_CHAR capsDisplayDriver[CAPS_DRIVER_NAME_LENGTH]; // OBSOLETE
|
|
TSHR_UINT32 capsSaveBitmapSize;
|
|
TSHR_UINT16 capsSaveBitmapXGranularity;
|
|
TSHR_UINT16 capsSaveBitmapYGranularity;
|
|
TSHR_UINT16 capsSaveBitmapMaxSaveLevel; // OBSOLETE
|
|
TSHR_UINT16 capsMaxOrderlevel;
|
|
TSHR_UINT16 capsNumFonts; // OBSOLETE
|
|
TSHR_UINT16 capsEncodingLevel; // See below
|
|
BYTE capsOrders[CAPS_MAX_NUM_ORDERS];
|
|
TSHR_UINT16 capsfFonts; // only introduced at r1.1
|
|
TSHR_UINT16 pad1; // For DWORD alignment
|
|
|
|
//
|
|
// The size of the SSI save bitmap.
|
|
//
|
|
TSHR_UINT32 capsSendSaveBitmapSize; // OBSOLETE
|
|
//
|
|
// The size of the SSI receive bitmap.
|
|
//
|
|
TSHR_UINT32 capsReceiveSaveBitmapSize; // OBSOLETE
|
|
TSHR_UINT16 capsfSendScroll; // OBSOLETE
|
|
|
|
// NEW FOR NM 2.0 NT && NM 2.1 WIN95
|
|
TSHR_UINT16 pad2;
|
|
}
|
|
PROTCAPS_ORDERS;
|
|
typedef PROTCAPS_ORDERS *PPROTCAPS_ORDERS;
|
|
|
|
#define PROTCAPS_ORDERS_SIZE_NM20 FIELD_OFFSET(PROTCAPS_ORDERS, pad2)
|
|
|
|
|
|
|
|
//
|
|
// Define the size of the bitmap used for the SaveBitmap order.
|
|
// These dimensions must be multiples of the granularity values below.
|
|
//
|
|
#define TSHR_SSI_BITMAP_WIDTH 400
|
|
#define TSHR_SSI_BITMAP_HEIGHT 400
|
|
#define TSHR_SSI_BITMAP_SIZE (TSHR_SSI_BITMAP_WIDTH * TSHR_SSI_BITMAP_HEIGHT)
|
|
|
|
#define TSHR_SSI_BITMAP_X_GRANULARITY 1
|
|
#define TSHR_SSI_BITMAP_Y_GRANULARITY 20
|
|
|
|
|
|
//
|
|
//
|
|
// These flags can be set in the capsfFonts fields. See also the defines
|
|
// below related to these flags (which must be updated when a new flag
|
|
// is defined).
|
|
//
|
|
#define CAPS_FONT_ASPECT 0x0001
|
|
#define CAPS_FONT_SIGNATURE 0x0002
|
|
#define CAPS_FONT_CODEPAGE 0x0004
|
|
#define CAPS_FONT_RESERVED1 0x0008 // Reserved for future BiDi support
|
|
#define CAPS_FONT_OLD_NEED_X 0x0010
|
|
#define CAPS_FONT_NEED_X_SOMETIMES 0x0020
|
|
#define CAPS_FONT_NEED_X_ALWAYS 0x0040
|
|
#define CAPS_FONT_R20_SIGNATURE 0x0080
|
|
#define CAPS_FONT_EM_HEIGHT 0x0100
|
|
#define CAPS_FONT_ALLOW_BASELINE 0x0200
|
|
|
|
//
|
|
// How the CAPS_FONT_XXX flags should be combined when adding a person to
|
|
// the share.
|
|
//
|
|
//
|
|
// AND these flags... the capability is relevant only if ALL parties
|
|
// have it
|
|
//
|
|
#define CAPS_FONT_AND_FLAGS ( CAPS_FONT_ASPECT \
|
|
| CAPS_FONT_SIGNATURE \
|
|
| CAPS_FONT_R20_SIGNATURE \
|
|
| CAPS_FONT_EM_HEIGHT \
|
|
| CAPS_FONT_CODEPAGE \
|
|
| CAPS_FONT_RESERVED1 \
|
|
| CAPS_FONT_ALLOW_BASELINE )
|
|
//
|
|
// OR these flags... the capability is relevant if ANY ONE party
|
|
// requires it.
|
|
//
|
|
#define CAPS_FONT_OR_FLAGS ( CAPS_FONT_OLD_NEED_X \
|
|
| CAPS_FONT_NEED_X_SOMETIMES \
|
|
| CAPS_FONT_NEED_X_ALWAYS )
|
|
|
|
//
|
|
// Which of the CAPS_FONT_XXX flags should be switched on/off in the
|
|
// combined received capabilities when a person joins the call who does not
|
|
// have the capsfFonts field.
|
|
//
|
|
#define CAPS_FONT_OFF_FLAGS ( CAPS_FONT_ASPECT \
|
|
| CAPS_FONT_SIGNATURE \
|
|
| CAPS_FONT_CODEPAGE \
|
|
| CAPS_FONT_RESERVED1 \
|
|
| CAPS_FONT_ALLOW_BASELINE )
|
|
#define CAPS_FONT_ON_FLAGS ( 0 )
|
|
|
|
#ifdef _DEBUG // for assertion
|
|
#define CAPS_FONT_R11_TEST_FLAGS ( CAPS_FONT_ASPECT \
|
|
| CAPS_FONT_SIGNATURE \
|
|
| CAPS_FONT_CODEPAGE \
|
|
| CAPS_FONT_RESERVED1 )
|
|
#endif
|
|
|
|
#define CAPS_FONT_R20_TEST_FLAGS ( CAPS_FONT_R20_SIGNATURE \
|
|
| CAPS_FONT_EM_HEIGHT )
|
|
|
|
//
|
|
// Level of order encoding support (capsEncodingLevel)
|
|
//
|
|
// These flags specify the types of order encoding and the level of
|
|
// negotiation supported. The flags and their meanings are as follows.
|
|
//
|
|
// CAPS_ENCODING_BASE_OE
|
|
// - The base OE protocol is supported. R1.1 does not support this.
|
|
// CAPS_ENCODING_OE2_NEGOTIABLE
|
|
// - We can negotiate whether OE2 is supported. R1.1 does not support this.
|
|
// CAPS_ENCODING_OE2_DISABLED
|
|
// - OE2 is disabled on this machine. This flag is apparently upside down
|
|
// so that we can support R1,1, which will set it to 0 (because the
|
|
// capability didn;t exist in R1.1).
|
|
// CAPS_ENCODING_ALIGNED_OE
|
|
// - The aligned OE protocol is supported. R1.1 does not support this.
|
|
//
|
|
//
|
|
#define CAPS_ENCODING_BASE_OE 0x0001
|
|
#define CAPS_ENCODING_OE2_NEGOTIABLE 0x0002
|
|
#define CAPS_ENCODING_OE2_DISABLED 0x0004
|
|
#define CAPS_ENCODING_ALIGNED_OE 0x0008
|
|
|
|
//
|
|
// Encoding level
|
|
//
|
|
#define CAPS_ENCODING_DCGC20 ( CAPS_ENCODING_BASE_OE \
|
|
| CAPS_ENCODING_OE2_NEGOTIABLE)
|
|
//
|
|
// Encoding level supported by Millennium codebase
|
|
//
|
|
#define CAPS_ENCODING_DEFAULT ( CAPS_ENCODING_OE2_NEGOTIABLE )
|
|
|
|
//
|
|
// Bitmap Cache capabilities.
|
|
//
|
|
typedef struct tagPROTCAPS_BITMAPCACHE_DETAILS
|
|
{
|
|
TSHR_UINT16 capsSmallCacheNumEntries;
|
|
TSHR_UINT16 capsSmallCacheCellSize;
|
|
TSHR_UINT16 capsMediumCacheNumEntries;
|
|
TSHR_UINT16 capsMediumCacheCellSize;
|
|
TSHR_UINT16 capsLargeCacheNumEntries;
|
|
TSHR_UINT16 capsLargeCacheCellSize;
|
|
}
|
|
PROTCAPS_BITMAPCACHE_DETAILS;
|
|
|
|
typedef struct tagPROTCAPS_BITMAPCACHE
|
|
{
|
|
PROTCAPSHEADER header;
|
|
|
|
//
|
|
// The following fields (which MUST immediately follow the header) are
|
|
// used by the point to point R1.1 implementation only {
|
|
//
|
|
PROTCAPS_BITMAPCACHE_DETAILS r11Obsolete; // OBSOLETE
|
|
|
|
//
|
|
// } end of fields used by point to point implementation only.
|
|
//
|
|
// The rest of this structure is only used by the multi-party code.
|
|
//
|
|
|
|
PROTCAPS_BITMAPCACHE_DETAILS sender;
|
|
PROTCAPS_BITMAPCACHE_DETAILS receiver; // OBSOLETE
|
|
}
|
|
PROTCAPS_BITMAPCACHE;
|
|
typedef PROTCAPS_BITMAPCACHE *PPROTCAPS_BITMAPCACHE;
|
|
|
|
|
|
|
|
|
|
//
|
|
// CM capabilities.
|
|
//
|
|
typedef struct tagPROTCAPS_CM
|
|
{
|
|
PROTCAPSHEADER header;
|
|
TSHR_UINT16 capsSupportsColorCursors;
|
|
TSHR_UINT16 capsCursorCacheSize;
|
|
}
|
|
PROTCAPS_CM;
|
|
typedef PROTCAPS_CM * PPROTCAPS_CM;
|
|
|
|
#define TSHR_CM_CACHE_ENTRIES 25
|
|
|
|
|
|
|
|
|
|
//
|
|
// PM capabilities.
|
|
//
|
|
typedef struct tagPROTCAPS_PM
|
|
{
|
|
PROTCAPSHEADER header;
|
|
TSHR_UINT16 capsColorTableCacheSize;
|
|
|
|
// NEW FOR NM 2.0 NT && NM 2.1 WIN95
|
|
TSHR_UINT16 pad1;
|
|
}
|
|
PROTCAPS_PM;
|
|
typedef PROTCAPS_PM * PPROTCAPS_PM;
|
|
|
|
#define PROTCAPS_PM_SIZE_NM20 FIELD_OFFSET(PROTCAPS_PM, pad1)
|
|
|
|
|
|
#define TSHR_PM_CACHE_ENTRIES 6
|
|
|
|
|
|
|
|
|
|
//
|
|
// SC capabilities.
|
|
//
|
|
typedef struct tagPROTCAPS_SC
|
|
{
|
|
PROTCAPSHEADER header;
|
|
TSHR_PERSONID gccID;
|
|
}
|
|
PROTCAPS_SC;
|
|
typedef PROTCAPS_SC * PPROTCAPS_SC;
|
|
|
|
|
|
|
|
|
|
// If you add a PROTCAPS_ strcuture to CPCALLCAPS, update the count
|
|
#define PROTCAPS_COUNT 7
|
|
|
|
typedef struct tagCPCALLCAPS
|
|
{
|
|
PROTCOMBINEDCAPS_HEADER header;
|
|
PROTCAPS_GENERAL general;
|
|
PROTCAPS_SCREEN screen;
|
|
PROTCAPS_ORDERS orders;
|
|
PROTCAPS_BITMAPCACHE bitmaps;
|
|
PROTCAPS_CM cursor;
|
|
PROTCAPS_PM palette;
|
|
PROTCAPS_SC share;
|
|
}
|
|
CPCALLCAPS;
|
|
typedef CPCALLCAPS * PCPCALLCAPS;
|
|
|
|
|
|
|
|
#if 0
|
|
//
|
|
// New 3.0 CAPS. We've accumulated a lot of obsolete or garbage caps. This
|
|
// is a condensed new basic set. Note that orders is separated from general
|
|
// since it is the most likely one to be periodically added to.
|
|
// * General
|
|
// * Orders
|
|
// * Hosting
|
|
//
|
|
|
|
#define ASCAPS_GENERAL 0
|
|
#define ASCAPS_ORDERS 1
|
|
#define ASCAPS_HOSTING 2
|
|
|
|
typedef struct tagTSHRCAPS_GENERAL
|
|
{
|
|
PROTCAPSHEADER header;
|
|
|
|
TSHR_UINT16 protVersion;
|
|
TSHR_UINT16 asMode; // Unattended, streaming, service, no host, no view, etc.
|
|
|
|
TSHR_UINT16 gccPersonID; // GCC node ID;
|
|
TSHR_UINT16 pktCompression; // None, PKZIP, PersistPKZIP
|
|
|
|
TSHR_UINT16 protBPPs; // Color depths supported (4, 8, 24)
|
|
TSHR_UINT16 screenBPP;
|
|
TSHR_UINT16 screenWidth;
|
|
TSHR_UINT16 screenHeight;
|
|
}
|
|
TSHRCAPS_GENERAL;
|
|
typedef TSHRCAPS_GENERAL * PTSHRCAPS_GENERAL;
|
|
|
|
|
|
typedef struct tagTSHRCAPS_ORDERS
|
|
{
|
|
PROTCAPSHEADER header;
|
|
|
|
}
|
|
TSHRCAPS_ORDERS;
|
|
typedef TSHRCAPS_ORDERS * PTSHRCAPS_ORDERS;
|
|
|
|
|
|
|
|
typedef struct tagTSHRCAPS_HOSTING
|
|
{
|
|
PROTCAPSHEADER header;
|
|
|
|
//
|
|
// These are zero if the host doesn't have such a thing, and viewers
|
|
// should not therefore allocate memory for the caches.
|
|
//
|
|
TSHR_UINT32 ssiSaveBitsPixels;
|
|
TSHR_UINT16 ssiSaveBitsXGranularity;
|
|
TSHR_UINT16 ssiSaveBitsYGranularity;
|
|
|
|
TSHR_UINT16 cmCursorCacheEntries;
|
|
TSHR_UINT16 fhGlyphSetCacheEntries;
|
|
TSHR_UINT16 pmPaletteCacheEntries;
|
|
TSHR_UINT16 pad1;
|
|
|
|
TSHR_UINT16 sbcSmallBmpCacheEntries;
|
|
TSHR_UINT16 sbcSmallBmpCacheBytes;
|
|
TSHR_UINT16 sbcMediumBmpCacheEntries;
|
|
TSHR_UINT16 sbcMediumBmpCacheEntries;
|
|
TSHR_UINT16 sbcLargeBmpCacheEntries;
|
|
TSHR_UINT16 sbcLargeBmpCacheBytes;
|
|
}
|
|
TSHRCAPS_HOSTING;
|
|
typedef TSHRCAPS_HOSTING * PTSHRCAPS_HOSTING;
|
|
|
|
|
|
typedef struct tagTSHRCAPS_ORDERS
|
|
{
|
|
PROTCAPSHEADER header;
|
|
|
|
TSHR_UINT16 ordCompression; // Encoding types
|
|
|
|
TSHR_UINT16 fhFontMatching; // Font matching
|
|
TSHR_UINT32 localeID;
|
|
TSHR_UINT16 fhInternational; // International text stuff
|
|
|
|
TSHR_UINT16 ordNumOrders; // Size of orders array
|
|
TSHR_UINT8 ordOrders[CAPS_MAX_NUM_ORDERS];
|
|
}
|
|
TSHRCAPS_ORDERS;
|
|
typedef TSHRCAPS_ORDERS * PTSHRCAPS_ORDERS;
|
|
|
|
#endif
|
|
|
|
////////////////////////////////
|
|
//
|
|
// ORDERS
|
|
//
|
|
////////////////////////////////
|
|
|
|
|
|
//
|
|
//
|
|
// COM_ORDER_HEADER
|
|
//
|
|
// Any orders supplied to the accumulation functions must have
|
|
// the following fields filled in:
|
|
//
|
|
// cbOrderDataLength
|
|
// The length in bytes of the order data (i.e. EXCLUDING the
|
|
// header - which is always a fixed size).
|
|
//
|
|
// fOrderFlags
|
|
// This can hold a combination of the following flags:
|
|
//
|
|
// OF_SPOILER - the order can spoil earlier SPOILABLE ones that it
|
|
// overlaps
|
|
//
|
|
// OF_SPOILABLE - the order can be spoilt by SPOILER orders that overlap
|
|
// it
|
|
//
|
|
// OF_BLOCKER - no orders before this one may be spoilt
|
|
//
|
|
// OF_PRIVATE - a private order (used by bitmap caching code)
|
|
//
|
|
// OF_NOTCLIPPED - this flag is set by OD2 on the DECODING side of the
|
|
// order processing to indicate that the order is not
|
|
// clipped. ie the rectangle is the bounding rectangle
|
|
// but does not result in any clipping taking place.
|
|
// THIS FLAG IS NOT TRANSMITTED ACROSS THE NETWORK.
|
|
//
|
|
// OF_INTERNAL - the order is an internal order, and should not be sent
|
|
// over the wire. An internal order is used to pass data
|
|
// from the device driver to the share core.
|
|
//
|
|
// OF_DESTROP - the order has a ROP which relies on the contents of the
|
|
// destination (relies on what is already on the screen).
|
|
//
|
|
// rcsDst
|
|
// The bounding rectangle of the order in INCLUSIVE screen (pel) coords.
|
|
//
|
|
//
|
|
typedef struct tagCOM_ORDER_HEADER
|
|
{
|
|
TSHR_UINT16 cbOrderDataLength;
|
|
TSHR_UINT16 fOrderFlags;
|
|
TSHR_RECT16 rcsDst;
|
|
}
|
|
COM_ORDER_HEADER;
|
|
typedef COM_ORDER_HEADER FAR * LPCOM_ORDER_HEADER;
|
|
|
|
|
|
//
|
|
// COM_ORDER_HEADER fOrderFlags values
|
|
//
|
|
#define OF_SPOILER 0x0001
|
|
#define OF_SPOILABLE 0x0002
|
|
#define OF_BLOCKER 0x0004
|
|
#define OF_PRIVATE 0x0008
|
|
#define OF_NOTCLIPPED 0x0010
|
|
#define OF_SPOILT 0x0020
|
|
#define OF_INTERNAL 0x0040
|
|
#define OF_DESTROP 0x0080
|
|
|
|
|
|
//
|
|
// Each type of order's structure is the bytes in abOrderData[].
|
|
//
|
|
typedef struct tagCOM_ORDER
|
|
{
|
|
COM_ORDER_HEADER OrderHeader;
|
|
BYTE abOrderData[1];
|
|
}
|
|
COM_ORDER;
|
|
typedef COM_ORDER FAR * LPCOM_ORDER;
|
|
typedef COM_ORDER UNALIGNED FAR * LPCOM_ORDER_UA;
|
|
|
|
|
|
//
|
|
// Macro to calculate a basic common order size (including the Order
|
|
// Header).
|
|
//
|
|
#define COM_ORDER_SIZE(pOrder) \
|
|
(pOrder->OrderHeader.cbOrderDataLength + sizeof(COM_ORDER_HEADER))
|
|
|
|
|
|
|
|
|
|
//
|
|
// The various drawing order structures have the following design objectives
|
|
//
|
|
// the first field - type - is common to all orders.
|
|
// field ordering is kept as regular as possible amongst similar
|
|
// orders so that compression may find more regular sequences
|
|
// fields are naturally aligned (dwords on dword boundaries etc)
|
|
// fields are reordered so to preserve alignment rather than add
|
|
// padding
|
|
// padding is added as a last resort.
|
|
// variable sized data comes at the end of the structure.
|
|
//
|
|
// All rectangles are inclusive of start and end points.
|
|
//
|
|
// All points are in screen coordinates, with (0,0) at top left.
|
|
//
|
|
// Interpretation of individual field values is as in Windows
|
|
// in particular pens, brushes and font are as defined for Windows 3.1
|
|
//
|
|
|
|
|
|
|
|
//
|
|
// Orders - the high word is used as an index into a table
|
|
// - the low word is a 2 character ASCII type descriptor and is the
|
|
// only part actually passed in the order.
|
|
//
|
|
#define ORD_DSTBLT_INDEX 0x0000
|
|
#define ORD_PATBLT_INDEX 0x0001
|
|
#define ORD_SCRBLT_INDEX 0x0002
|
|
#define ORD_MEMBLT_INDEX 0x0003
|
|
#define ORD_MEM3BLT_INDEX 0x0004
|
|
#define ORD_TEXTOUT_INDEX 0x0005
|
|
#define ORD_EXTTEXTOUT_INDEX 0x0006
|
|
#define ORD_RECTANGLE_INDEX 0x0007
|
|
#define ORD_LINETO_INDEX 0x0008
|
|
#define ORD_UNUSED_INDEX 0x0009
|
|
#define ORD_OPAQUERECT_INDEX 0x000A
|
|
#define ORD_SAVEBITMAP_INDEX 0x000B
|
|
#define ORD_RESERVED_INDEX 0x000C
|
|
#define ORD_MEMBLT_R2_INDEX 0x000D
|
|
#define ORD_MEM3BLT_R2_INDEX 0x000E
|
|
#define ORD_POLYGON_INDEX 0x000F
|
|
#define ORD_PIE_INDEX 0x0010
|
|
#define ORD_ELLIPSE_INDEX 0x0011
|
|
#define ORD_ARC_INDEX 0x0012
|
|
#define ORD_CHORD_INDEX 0x0013
|
|
#define ORD_POLYBEZIER_INDEX 0x0014
|
|
#define ORD_ROUNDRECT_INDEX 0x0015
|
|
//
|
|
// It IS OK to use order 000C! These numbers don't clash with OE2_* in
|
|
// aoe2int.h. Replace ORD_RESERVED_INDEX (0xC) for the next new order.
|
|
//
|
|
// NOTE: When you use this index, OE_GetLocalOrderSupport must be updated
|
|
// to allow the order.
|
|
//
|
|
|
|
#define ORD_DSTBLT_TYPE 0x4244 // "DB"
|
|
#define ORD_PATBLT_TYPE 0x4250 // "PB"
|
|
#define ORD_SCRBLT_TYPE 0x4253 // "SB"
|
|
#define ORD_MEMBLT_TYPE 0x424d // "MB"
|
|
#define ORD_MEM3BLT_TYPE 0x4233 // "3B"
|
|
#define ORD_TEXTOUT_TYPE 0x4f54 // "TO"
|
|
#define ORD_EXTTEXTOUT_TYPE 0x5445 // "ET"
|
|
#define ORD_RECTANGLE_TYPE 0x5452 // "RT"
|
|
#define ORD_LINETO_TYPE 0x544c // "LT"
|
|
#define ORD_OPAQUERECT_TYPE 0x524f // "OR"
|
|
#define ORD_SAVEBITMAP_TYPE 0x5653 // "SV"
|
|
#define ORD_MEMBLT_R2_TYPE 0x434d // "MC"
|
|
#define ORD_MEM3BLT_R2_TYPE 0x4333 // "3C"
|
|
#define ORD_POLYGON_TYPE 0x4750 // "PG"
|
|
#define ORD_PIE_TYPE 0x4950 // "PI"
|
|
#define ORD_ELLIPSE_TYPE 0x4c45 // "EL"
|
|
#define ORD_ARC_TYPE 0x5241 // "AR"
|
|
#define ORD_CHORD_TYPE 0x4443 // "CD"
|
|
#define ORD_POLYBEZIER_TYPE 0x5A50 // "PZ"
|
|
#define ORD_ROUNDRECT_TYPE 0x5252 // "RR"
|
|
|
|
|
|
#define ORD_DSTBLT MAKELONG(ORD_DSTBLT_TYPE, ORD_DSTBLT_INDEX)
|
|
#define ORD_PATBLT MAKELONG(ORD_PATBLT_TYPE, ORD_PATBLT_INDEX)
|
|
#define ORD_SCRBLT MAKELONG(ORD_SCRBLT_TYPE, ORD_SCRBLT_INDEX)
|
|
#define ORD_MEMBLT MAKELONG(ORD_MEMBLT_TYPE, ORD_MEMBLT_INDEX)
|
|
#define ORD_MEM3BLT MAKELONG(ORD_MEM3BLT_TYPE, ORD_MEM3BLT_INDEX)
|
|
#define ORD_TEXTOUT MAKELONG(ORD_TEXTOUT_TYPE, ORD_TEXTOUT_INDEX)
|
|
#define ORD_EXTTEXTOUT MAKELONG(ORD_EXTTEXTOUT_TYPE, ORD_EXTTEXTOUT_INDEX)
|
|
#define ORD_RECTANGLE MAKELONG(ORD_RECTANGLE_TYPE, ORD_RECTANGLE_INDEX)
|
|
#define ORD_LINETO MAKELONG(ORD_LINETO_TYPE, ORD_LINETO_INDEX)
|
|
#define ORD_OPAQUERECT MAKELONG(ORD_OPAQUERECT_TYPE, ORD_OPAQUERECT_INDEX)
|
|
#define ORD_SAVEBITMAP MAKELONG(ORD_SAVEBITMAP_TYPE, ORD_SAVEBITMAP_INDEX)
|
|
#define ORD_MEMBLT_R2 MAKELONG(ORD_MEMBLT_R2_TYPE, ORD_MEMBLT_R2_INDEX)
|
|
#define ORD_MEM3BLT_R2 MAKELONG(ORD_MEM3BLT_R2_TYPE, ORD_MEM3BLT_R2_INDEX)
|
|
#define ORD_POLYGON MAKELONG(ORD_POLYGON_TYPE, ORD_POLYGON_INDEX)
|
|
#define ORD_PIE MAKELONG(ORD_PIE_TYPE, ORD_PIE_INDEX)
|
|
#define ORD_ELLIPSE MAKELONG(ORD_ELLIPSE_TYPE, ORD_ELLIPSE_INDEX)
|
|
#define ORD_ARC MAKELONG(ORD_ARC_TYPE, ORD_ARC_INDEX)
|
|
#define ORD_CHORD MAKELONG(ORD_CHORD_TYPE, ORD_CHORD_INDEX)
|
|
#define ORD_POLYBEZIER MAKELONG(ORD_POLYBEZIER_TYPE, ORD_POLYBEZIER_INDEX)
|
|
#define ORD_ROUNDRECT MAKELONG(ORD_ROUNDRECT_TYPE, ORD_ROUNDRECT_INDEX)
|
|
|
|
|
|
//
|
|
// The following order is special - support is not negotiated by the
|
|
// capsOrders field in the orders capabilities structure.
|
|
// The high words start at 32, ie after CAPS_MAX_NUM_ORDERS.
|
|
//
|
|
// ORD_NUM_INTERNAL_ORDERS is the number of orders we use internally - this
|
|
// include all CAPS_MAX_NUM_ORDERS, plus any of these special orders.
|
|
//
|
|
#define ORD_DESKSCROLL_INDEX 0x0020
|
|
#define ORD_DESKSCROLL_TYPE 0x5344 // "DS"
|
|
#define ORD_DESKSCROLL MAKELONG(ORD_DESKSCROLL_TYPE, ORD_DESKSCROLL_INDEX)
|
|
|
|
#define INTORD_COLORTABLE_INDEX 0x000C
|
|
#define INTORD_COLORTABLE_TYPE 0x5443 // "CT"
|
|
#define INTORD_COLORTABLE MAKELONG(INTORD_COLORTABLE_TYPE, INTORD_COLORTABLE_INDEX)
|
|
|
|
#define ORD_NUM_INTERNAL_ORDERS 33
|
|
#define ORD_NUM_LEVEL_1_ORDERS 22
|
|
|
|
#define ORD_LEVEL_1_ORDERS 1
|
|
|
|
//
|
|
// The maximum length of string which we will send as an order (either as
|
|
// TextOut or ExtTextOut) when a delta X array is supplied or not.
|
|
//
|
|
//
|
|
// NOTE: THESE MUST TOTAL LESS THAN 256 BECAUSE THE TOTAL ENCODED SIZE
|
|
// MUST FIT IN ONE BYTE.
|
|
//
|
|
// STRING_LEN_WITHOUT_DELTAS -- 1 byte per char
|
|
// STRING_LEN_WITH_DELTAS -- 1 byte per char + 1 byte per delta
|
|
// ORD_MAX_POLYGON_POINTS -- 4 bytes per point (2 each coord)
|
|
// ORD_MAX_POLYBEZIER_POINTS -- 4 bytes per point (2 each coord)
|
|
//
|
|
#define ORD_MAX_STRING_LEN_WITHOUT_DELTAS 255
|
|
#define ORD_MAX_STRING_LEN_WITH_DELTAS 127
|
|
#define ORD_MAX_POLYGON_POINTS 63
|
|
#define ORD_MAX_POLYBEZIER_POINTS 63
|
|
|
|
//
|
|
// Direction codes for arc drawing orders (pie, arc, chord).
|
|
// Specifies direction that pie, arc, and chord figures are drawn.
|
|
//
|
|
#define ORD_ARC_COUNTERCLOCKWISE 1
|
|
#define ORD_ARC_CLOCKWISE 2
|
|
|
|
//
|
|
// Fill-mode codes for polygon drawing.
|
|
//
|
|
// Alternate fills area between odd-numbered and even-numbered polygon
|
|
// sides on each scan line.
|
|
//
|
|
// Winding fills any region with a nonzero winding value.
|
|
//
|
|
#define ORD_FILLMODE_ALTERNATE 1
|
|
#define ORD_FILLMODE_WINDING 2
|
|
|
|
//
|
|
// DstBlt (Destination only Screen Blt)
|
|
//
|
|
typedef struct _DSTBLT_ORDER
|
|
{
|
|
TSHR_UINT16 type; // holds "DB" - ORD_DSTBLT
|
|
TSHR_INT16 pad1;
|
|
|
|
TSHR_INT32 nLeftRect; // x upper left
|
|
TSHR_INT32 nTopRect; // y upper left
|
|
TSHR_INT32 nWidth; // dest width
|
|
TSHR_INT32 nHeight; // dest height
|
|
|
|
TSHR_UINT8 bRop; // ROP
|
|
TSHR_UINT8 pad2[3];
|
|
} DSTBLT_ORDER, FAR * LPDSTBLT_ORDER;
|
|
|
|
//
|
|
// PatBlt (Pattern to Screen Blt)
|
|
//
|
|
typedef struct _PATBLT_ORDER
|
|
{
|
|
TSHR_UINT16 type; // holds "PB" - ORD_PATBLT
|
|
TSHR_INT16 pad1;
|
|
|
|
TSHR_INT32 nLeftRect; // x upper left
|
|
TSHR_INT32 nTopRect; // y upper left
|
|
TSHR_INT32 nWidth; // dest width
|
|
TSHR_INT32 nHeight; // dest height
|
|
|
|
TSHR_UINT32 bRop; // ROP
|
|
|
|
TSHR_COLOR BackColor;
|
|
TSHR_UINT8 pad2;
|
|
TSHR_COLOR ForeColor;
|
|
TSHR_UINT8 pad3;
|
|
|
|
TSHR_INT32 BrushOrgX;
|
|
TSHR_INT32 BrushOrgY;
|
|
TSHR_UINT32 BrushStyle;
|
|
TSHR_UINT32 BrushHatch;
|
|
TSHR_UINT8 BrushExtra[7];
|
|
TSHR_UINT8 pad4;
|
|
|
|
} PATBLT_ORDER, FAR * LPPATBLT_ORDER;
|
|
|
|
//
|
|
// ScrBlt (Screen to Screen Blt)
|
|
//
|
|
typedef struct _SCRBLT_ORDER
|
|
{
|
|
TSHR_UINT16 type; // holds "SB" - ORD_SCRBLT
|
|
TSHR_INT16 pad1;
|
|
|
|
TSHR_INT32 nLeftRect; // x upper left
|
|
TSHR_INT32 nTopRect; // y upper left
|
|
TSHR_INT32 nWidth; // dest width
|
|
TSHR_INT32 nHeight; // dest height
|
|
|
|
TSHR_UINT32 bRop; // ROP
|
|
|
|
TSHR_INT32 nXSrc;
|
|
TSHR_INT32 nYSrc;
|
|
|
|
} SCRBLT_ORDER, FAR * LPSCRBLT_ORDER;
|
|
|
|
//
|
|
// @@@ The common parts of MEMBLT_ORDER / MEMBLT_R2_ORDER and MEM3BLT_ORDER
|
|
// / MEM3BLT_R2_ORDER should be merged into a single structure. There is
|
|
// code which assumes that the common fields have the same types which goes
|
|
// wrong if these are not the same.
|
|
//
|
|
|
|
|
|
//
|
|
// Define the structure for Bitmap Cache Orders.
|
|
// These are sent in Order Packets as "private" orders.
|
|
//
|
|
|
|
//
|
|
// Define the possible Bitmap Cache Packet Types.
|
|
//
|
|
#define BMC_PT_BITMAP_BITS_UNCOMPRESSED 0
|
|
#define BMC_PT_COLOR_TABLE 1
|
|
#define BMC_PT_BITMAP_BITS_COMPRESSED 2
|
|
|
|
|
|
//
|
|
// NOTE: avoid unions to get structure size / alignment correct.
|
|
//
|
|
|
|
|
|
// Structure: BMC_BITMAP_BITS_DATA
|
|
//
|
|
// Description: This is the part of the bitmap bits order which is common
|
|
// to both R1 and R2 protocols.
|
|
//
|
|
typedef struct tagBMC_BITMAP_BITS_DATA
|
|
{
|
|
TSHR_UINT8 bmcPacketType; // One of:
|
|
// BMC_PT_BITMAP_BITS_COMPRESSED
|
|
// BMC_PT_BITMAP_BITS_UNCOMPRESSED
|
|
TSHR_UINT8 cacheID; // Cache ID
|
|
// lonchanc: do not remove iCacheEntryR1 for backward compatibility
|
|
TSHR_UINT8 iCacheEntryR1; // Cache index (only used for R1
|
|
// protocol
|
|
TSHR_UINT8 cxSubBitmapWidth; // Bitmap width
|
|
TSHR_UINT8 cySubBitmapHeight; // Bitmap height
|
|
TSHR_UINT8 bpp; // Number of bits per pel of bitmap
|
|
TSHR_UINT16 cbBitmapBits; // Number of bytes of data required to
|
|
// send the bits.
|
|
}
|
|
BMC_BITMAP_BITS_DATA;
|
|
typedef BMC_BITMAP_BITS_DATA FAR * PBMC_BITMAP_BITS_DATA;
|
|
typedef BMC_BITMAP_BITS_DATA UNALIGNED FAR * PBMC_BITMAP_BITS_DATA_UA;
|
|
|
|
|
|
|
|
|
|
// Structure: BMC_BITMAP_BITS_ORDER_R2
|
|
//
|
|
// Description: The data which is sent across the wire for an R2 bitmap
|
|
// bits order. The data field is the start of an array of bytes of length
|
|
// header.cbBitmapBits
|
|
//
|
|
// We need a 16 bit cache index in R2. We could add another 8 bit entry
|
|
// and merge with the R1 field, but in the interests of protocol
|
|
// cleanliness we should add a whole 16 bit field and make the R1 index
|
|
// "reserved" in the protocol documentation.
|
|
//
|
|
//
|
|
typedef struct tagBMC_BITMAP_BITS_ORDER_R2
|
|
{
|
|
BMC_BITMAP_BITS_DATA header; // Common header information
|
|
TSHR_UINT16 iCacheEntryR2; // R2 cache index. The high
|
|
// byte is a color table
|
|
// index, and the low byte
|
|
// is the bitmap bits cache
|
|
// index.
|
|
TSHR_UINT8 data[2]; // Start of the bitmap bits.
|
|
}
|
|
BMC_BITMAP_BITS_ORDER_R2;
|
|
typedef BMC_BITMAP_BITS_ORDER_R2 FAR * PBMC_BITMAP_BITS_ORDER_R2;
|
|
typedef BMC_BITMAP_BITS_ORDER_R2 UNALIGNED FAR * PBMC_BITMAP_BITS_ORDER_R2_UA;
|
|
|
|
|
|
//
|
|
// Structure sent for color data. The data field is the first entry in an
|
|
// array of colorTableSize entries.
|
|
//
|
|
typedef struct tagBMC_COLOR_TABLE_ORDER
|
|
{
|
|
TSHR_UINT8 bmcPacketType; // BMC_PT_COLORTABLE
|
|
TSHR_UINT8 index; // Color table cache index
|
|
TSHR_UINT16 colorTableSize; // Number of entries in the
|
|
// color table being sent.
|
|
TSHR_RGBQUAD data[1]; // Start of an array of color table
|
|
// entries.
|
|
}
|
|
BMC_COLOR_TABLE_ORDER;
|
|
typedef BMC_COLOR_TABLE_ORDER FAR * PBMC_COLOR_TABLE_ORDER;
|
|
typedef BMC_COLOR_TABLE_ORDER UNALIGNED FAR * PBMC_COLOR_TABLE_ORDER_UA;
|
|
|
|
|
|
|
|
//
|
|
// MemBlt (Memory to Screen Blt)
|
|
// R1 protocol
|
|
//
|
|
typedef struct _MEMBLT_ORDER
|
|
{
|
|
TSHR_UINT16 type; // holds "MB" - ORD_MEMBLT
|
|
|
|
TSHR_UINT16 cacheId;
|
|
|
|
TSHR_INT32 nLeftRect; // x upper left
|
|
TSHR_INT32 nTopRect; // y upper left
|
|
TSHR_INT32 nWidth; // dest width
|
|
TSHR_INT32 nHeight; // dest height
|
|
|
|
TSHR_UINT32 bRop; // ROP
|
|
|
|
TSHR_INT32 nXSrc;
|
|
TSHR_INT32 nYSrc;
|
|
|
|
}
|
|
MEMBLT_ORDER, FAR * LPMEMBLT_ORDER;
|
|
|
|
|
|
//
|
|
// MemBltR2 (Memory to Screen Blt for R2 protocol)
|
|
// Added cache index
|
|
//
|
|
typedef struct _MEMBLT_R2_ORDER
|
|
{
|
|
TSHR_UINT16 type; // holds "MC" - ORD_MEMBLT
|
|
|
|
TSHR_UINT16 cacheId;
|
|
|
|
TSHR_INT32 nLeftRect; // x upper left
|
|
TSHR_INT32 nTopRect; // y upper left
|
|
TSHR_INT32 nWidth; // dest width
|
|
TSHR_INT32 nHeight; // dest height
|
|
|
|
TSHR_UINT32 bRop; // ROP
|
|
|
|
TSHR_INT32 nXSrc;
|
|
TSHR_INT32 nYSrc;
|
|
|
|
TSHR_UINT16 cacheIndex;
|
|
|
|
} MEMBLT_R2_ORDER, FAR * LPMEMBLT_R2_ORDER;
|
|
|
|
|
|
//
|
|
// Mem3Blt (Memory Pattern to Screen 3 way ROP Blt)
|
|
//
|
|
typedef struct _MEM3BLT_ORDER
|
|
{
|
|
TSHR_UINT16 type; // holds "MB" - ORD_MEMBLT
|
|
|
|
TSHR_UINT16 cacheId;
|
|
|
|
TSHR_INT32 nLeftRect; // x upper left
|
|
TSHR_INT32 nTopRect; // y upper left
|
|
TSHR_INT32 nWidth; // dest width
|
|
TSHR_INT32 nHeight; // dest height
|
|
|
|
TSHR_UINT32 bRop; // ROP
|
|
|
|
TSHR_INT32 nXSrc;
|
|
TSHR_INT32 nYSrc;
|
|
|
|
TSHR_COLOR BackColor;
|
|
TSHR_UINT8 pad1;
|
|
TSHR_COLOR ForeColor;
|
|
TSHR_UINT8 pad2;
|
|
|
|
TSHR_INT32 BrushOrgX;
|
|
TSHR_INT32 BrushOrgY;
|
|
TSHR_UINT32 BrushStyle;
|
|
TSHR_UINT32 BrushHatch;
|
|
TSHR_UINT8 BrushExtra[7];
|
|
TSHR_UINT8 pad3;
|
|
|
|
} MEM3BLT_ORDER, FAR * LPMEM3BLT_ORDER;
|
|
|
|
//
|
|
// Mem3Blt (Memory to Screen Blt) for R2 (multipoint) protocols
|
|
// Add a cache index field rather than using nXSrc.
|
|
//
|
|
typedef struct _MEM3BLT_R2_ORDER
|
|
{
|
|
TSHR_UINT16 type; // holds "MB" - ORD_MEMBLT
|
|
|
|
TSHR_UINT16 cacheId;
|
|
|
|
TSHR_INT32 nLeftRect; // x upper left
|
|
TSHR_INT32 nTopRect; // y upper left
|
|
TSHR_INT32 nWidth; // dest width
|
|
TSHR_INT32 nHeight; // dest height
|
|
|
|
TSHR_UINT32 bRop; // ROP
|
|
|
|
TSHR_INT32 nXSrc;
|
|
TSHR_INT32 nYSrc;
|
|
|
|
TSHR_COLOR BackColor;
|
|
TSHR_UINT8 pad1;
|
|
TSHR_COLOR ForeColor;
|
|
TSHR_UINT8 pad2;
|
|
|
|
TSHR_INT32 BrushOrgX;
|
|
TSHR_INT32 BrushOrgY;
|
|
TSHR_UINT32 BrushStyle;
|
|
TSHR_UINT32 BrushHatch;
|
|
TSHR_UINT8 BrushExtra[7];
|
|
TSHR_UINT8 pad3;
|
|
|
|
TSHR_UINT16 cacheIndex;
|
|
|
|
} MEM3BLT_R2_ORDER, FAR * LPMEM3BLT_R2_ORDER;
|
|
|
|
//
|
|
// Variable length text structure as used by TextOut and ExtTextOut orders
|
|
//
|
|
typedef struct tagVARIABLE_STRING
|
|
{
|
|
TSHR_UINT32 len;
|
|
TSHR_CHAR string[ORD_MAX_STRING_LEN_WITHOUT_DELTAS];
|
|
TSHR_UINT8 pad;
|
|
} VARIABLE_STRING;
|
|
|
|
//
|
|
// Variable length position deltas as used by ExtTextOut.
|
|
//
|
|
typedef struct tagVARIABLE_DELTAX
|
|
{
|
|
TSHR_UINT32 len;
|
|
TSHR_INT32 deltaX[ORD_MAX_STRING_LEN_WITH_DELTAS];
|
|
} VARIABLE_DELTAX, FAR * LPVARIABLE_DELTAX;
|
|
|
|
//
|
|
// Variable length point array used by Polygon.
|
|
//
|
|
typedef struct tagVARIABLE_POINTS
|
|
{
|
|
TSHR_UINT32 len; // byte count of point array
|
|
TSHR_POINT16 aPoints[ORD_MAX_POLYGON_POINTS];
|
|
} VARIABLE_POINTS, FAR * LPVARIABLE_POINTS;
|
|
|
|
//
|
|
// Variable length point array used by PolyBezier.
|
|
//
|
|
typedef struct tagVARIABLE_BEZIERPOINTS
|
|
{
|
|
TSHR_UINT32 len; // byte count of point array
|
|
TSHR_POINT16 aPoints[ORD_MAX_POLYBEZIER_POINTS];
|
|
} VARIABLE_BEZIERPOINTS, FAR * LPVARIABLE_BEZIERPOINTS;
|
|
|
|
//
|
|
// The common part of the TEXTOUT and EXTTEXTOUT orders
|
|
//
|
|
typedef struct tagCOMMON_TEXTORDER
|
|
{
|
|
TSHR_INT32 BackMode; // background mix mode
|
|
|
|
TSHR_INT32 nXStart; // X location of string
|
|
TSHR_INT32 nYStart; // Y location of string
|
|
|
|
TSHR_COLOR BackColor; // background color
|
|
TSHR_UINT8 pad2;
|
|
TSHR_COLOR ForeColor; // foreground color
|
|
TSHR_UINT8 pad3;
|
|
|
|
TSHR_INT32 CharExtra; // extra character spacing
|
|
TSHR_INT32 BreakExtra; // justification break amount
|
|
TSHR_INT32 BreakCount; // justification break count
|
|
|
|
TSHR_INT32 FontHeight;
|
|
TSHR_INT32 FontWidth;
|
|
TSHR_UINT32 FontWeight;
|
|
TSHR_UINT32 FontFlags;
|
|
TSHR_UINT32 FontIndex;
|
|
} COMMON_TEXTORDER, FAR * LPCOMMON_TEXTORDER;
|
|
|
|
//
|
|
// TextOut
|
|
//
|
|
typedef struct _TEXTOUT_ORDER
|
|
{
|
|
TSHR_UINT16 type; // holds "TO" - ORD_TEXTOUT
|
|
TSHR_INT16 pad1;
|
|
|
|
COMMON_TEXTORDER common;
|
|
|
|
//
|
|
// The following variable data occurs here. (Remember to change the
|
|
// code in OD2CalculateTextOutBounds if you change these).
|
|
//
|
|
VARIABLE_STRING variableString;
|
|
|
|
} TEXTOUT_ORDER, FAR * LPTEXTOUT_ORDER;
|
|
|
|
|
|
//
|
|
// ExtTextOut
|
|
//
|
|
typedef struct _EXTTEXTOUT_ORDER
|
|
{
|
|
TSHR_UINT16 type; // holds "ET" - ORD_EXTTEXTOUT
|
|
TSHR_INT16 pad1;
|
|
|
|
COMMON_TEXTORDER common;
|
|
|
|
TSHR_UINT16 fuOptions; // option flags
|
|
TSHR_UINT16 pad4;
|
|
|
|
TSHR_RECT32 rectangle;
|
|
|
|
//
|
|
// The following variable data occurs here.
|
|
//
|
|
// char[cbString] - the string of chars to be output
|
|
// TSHR_INT32[cbString] - X deltas for the string
|
|
//
|
|
// (Remember to change the code in OD2CalculateExtTextOutBounds if you
|
|
// change these).
|
|
//
|
|
VARIABLE_STRING variableString;
|
|
|
|
VARIABLE_DELTAX variableDeltaX;
|
|
|
|
} EXTTEXTOUT_ORDER, FAR * LPEXTTEXTOUT_ORDER;
|
|
|
|
//
|
|
// Rectangle
|
|
//
|
|
typedef struct _RECTANGLE_ORDER
|
|
{
|
|
TSHR_UINT16 type; // holds "RT" - ORD_RECTANGLE
|
|
TSHR_INT16 pad1;
|
|
|
|
TSHR_INT32 BackMode; // background mix mode
|
|
|
|
TSHR_INT32 nLeftRect; // x left
|
|
TSHR_INT32 nTopRect; // y top
|
|
TSHR_INT32 nRightRect; // x right
|
|
TSHR_INT32 nBottomRect; // y bottom
|
|
|
|
TSHR_COLOR BackColor; // background color
|
|
TSHR_UINT8 pad2;
|
|
TSHR_COLOR ForeColor; // foreground color
|
|
TSHR_UINT8 pad3;
|
|
|
|
TSHR_INT32 BrushOrgX;
|
|
TSHR_INT32 BrushOrgY;
|
|
TSHR_UINT32 BrushStyle;
|
|
TSHR_UINT32 BrushHatch;
|
|
TSHR_UINT8 BrushExtra[7];
|
|
TSHR_UINT8 pad4;
|
|
|
|
TSHR_UINT32 ROP2; // drawing mode
|
|
|
|
TSHR_UINT32 PenStyle;
|
|
TSHR_UINT32 PenWidth; // always 1 - field retained for
|
|
// backwards compatibility
|
|
TSHR_COLOR PenColor;
|
|
TSHR_UINT8 pad5;
|
|
} RECTANGLE_ORDER, FAR * LPRECTANGLE_ORDER;
|
|
|
|
//
|
|
// LineTo
|
|
//
|
|
typedef struct _LINETO_ORDER
|
|
{
|
|
TSHR_UINT16 type; // holds "LT" - ORD_LINETO
|
|
TSHR_INT16 pad1;
|
|
|
|
TSHR_INT32 BackMode; // background mix mode
|
|
|
|
TSHR_INT32 nXStart; // x line start
|
|
TSHR_INT32 nYStart; // y line start
|
|
TSHR_INT32 nXEnd; // x line end
|
|
TSHR_INT32 nYEnd; // y line end
|
|
|
|
TSHR_COLOR BackColor; // background color
|
|
TSHR_UINT8 pad2;
|
|
|
|
TSHR_UINT32 ROP2; // drawing mode
|
|
|
|
TSHR_UINT32 PenStyle;
|
|
TSHR_UINT32 PenWidth; // always 1 - field retained for
|
|
// backwards compatibility
|
|
TSHR_COLOR PenColor;
|
|
TSHR_UINT8 pad3;
|
|
} LINETO_ORDER, FAR * LPLINETO_ORDER;
|
|
|
|
//
|
|
// OpaqueRect
|
|
//
|
|
typedef struct _OPAQUE_RECT
|
|
{
|
|
TSHR_UINT16 type; // holds "OR" - ORD_OPAQUERECT
|
|
TSHR_INT16 pad1;
|
|
|
|
TSHR_INT32 nLeftRect; // x upper left
|
|
TSHR_INT32 nTopRect; // y upper left
|
|
TSHR_INT32 nWidth; // dest width
|
|
TSHR_INT32 nHeight; // dest height
|
|
|
|
TSHR_COLOR Color; // opaque color
|
|
TSHR_UINT8 pad2;
|
|
} OPAQUERECT_ORDER, FAR * LPOPAQUERECT_ORDER;
|
|
|
|
//
|
|
// SaveBitmap (incorporating RestoreBitmap)
|
|
//
|
|
#define SV_SAVEBITS 0
|
|
#define SV_RESTOREBITS 1
|
|
|
|
typedef struct _SAVEBITMAP_ORDER
|
|
{
|
|
TSHR_UINT16 type; // holds "SV" - ORD_SAVEBITMAP
|
|
TSHR_INT16 pad1;
|
|
|
|
TSHR_UINT32 SavedBitmapPosition;
|
|
|
|
TSHR_INT32 nLeftRect; // x left
|
|
TSHR_INT32 nTopRect; // y top
|
|
TSHR_INT32 nRightRect; // x right
|
|
TSHR_INT32 nBottomRect; // y bottom
|
|
|
|
TSHR_UINT32 Operation; // SV_xxxxxxxx
|
|
} SAVEBITMAP_ORDER, FAR * LPSAVEBITMAP_ORDER;
|
|
|
|
//
|
|
// Desktop scroll order
|
|
//
|
|
// The desktop order is special - it is a non-private order which is second
|
|
// level encoded, BUT support is not negotiated via its own entry in the
|
|
// capsOrdesr array in the orders capabilities.
|
|
//
|
|
// (Sending support is determined via a number of factors - at r2.x receive
|
|
// support for ORD_SCRBLT implies support for ORD_DESKSCROLL as well).
|
|
//
|
|
//
|
|
typedef struct _DESKSCROLL_ORDER
|
|
{
|
|
TSHR_UINT16 type; // holds "DS" - ORD_DESKSCROLL
|
|
TSHR_INT16 pad1;
|
|
|
|
TSHR_INT32 xOrigin;
|
|
TSHR_INT32 yOrigin;
|
|
} DESKSCROLL_ORDER, FAR * LPDESKSCROLL_ORDER;
|
|
|
|
|
|
//
|
|
// Polygon
|
|
//
|
|
typedef struct _POLYGON_ORDER
|
|
{
|
|
TSHR_UINT16 type; // holds "PG" - ORD_POLYGON
|
|
TSHR_INT16 pad1;
|
|
|
|
TSHR_INT32 BackMode; // background mix mode
|
|
|
|
TSHR_COLOR BackColor; // background color
|
|
TSHR_UINT8 pad2;
|
|
TSHR_COLOR ForeColor; // foreground color
|
|
TSHR_UINT8 pad3;
|
|
|
|
TSHR_INT32 BrushOrgX;
|
|
TSHR_INT32 BrushOrgY;
|
|
TSHR_UINT32 BrushStyle;
|
|
TSHR_UINT32 BrushHatch;
|
|
TSHR_UINT8 BrushExtra[7];
|
|
TSHR_UINT8 pad4;
|
|
|
|
TSHR_UINT32 ROP2; // drawing mode
|
|
|
|
TSHR_UINT32 PenStyle;
|
|
TSHR_UINT32 PenWidth; // always 1 - field retained for
|
|
// backwards compatibility
|
|
TSHR_COLOR PenColor;
|
|
TSHR_UINT8 pad5;
|
|
|
|
TSHR_UINT32 FillMode; // ORD_FILLMODE_ALTERNATE or
|
|
// ORD_FILLMODE_WINDING
|
|
|
|
//
|
|
// The following variable data occurs here.
|
|
//
|
|
VARIABLE_POINTS variablePoints;
|
|
|
|
} POLYGON_ORDER, FAR * LPPOLYGON_ORDER;
|
|
|
|
|
|
//
|
|
// Pie
|
|
//
|
|
typedef struct _PIE_ORDER
|
|
{
|
|
TSHR_UINT16 type; // holds "PI" - ORD_PIE
|
|
TSHR_INT16 pad1;
|
|
|
|
TSHR_INT32 BackMode; // background mix mode
|
|
|
|
TSHR_INT32 nLeftRect; // x left of bounding box
|
|
TSHR_INT32 nTopRect; // y top of bounding box
|
|
TSHR_INT32 nRightRect; // x right of bounding box
|
|
TSHR_INT32 nBottomRect; // y bottom of bounding box
|
|
TSHR_INT32 nXStart; // x of starting point
|
|
TSHR_INT32 nYStart; // y of starting point
|
|
TSHR_INT32 nXEnd; // x of ending point
|
|
TSHR_INT32 nYEnd; // y of ending point
|
|
|
|
TSHR_COLOR BackColor; // background color
|
|
TSHR_UINT8 pad2;
|
|
|
|
TSHR_COLOR ForeColor; // foreground color
|
|
TSHR_UINT8 pad3;
|
|
|
|
|
|
TSHR_INT32 BrushOrgX;
|
|
TSHR_INT32 BrushOrgY;
|
|
TSHR_UINT32 BrushStyle;
|
|
TSHR_UINT32 BrushHatch;
|
|
TSHR_UINT8 BrushExtra[7];
|
|
TSHR_UINT8 pad4;
|
|
|
|
TSHR_UINT32 ROP2; // drawing mode
|
|
|
|
TSHR_UINT32 PenStyle;
|
|
TSHR_UINT32 PenWidth; // always 1 - field retained for
|
|
// backwards compatibility
|
|
TSHR_COLOR PenColor;
|
|
TSHR_UINT8 pad5;
|
|
|
|
TSHR_UINT32 ArcDirection; // ORD_ARC_COUNTERCLOCKWISE or
|
|
// ORD_ARC_CLOCKWISE
|
|
} PIE_ORDER, FAR * LPPIE_ORDER;
|
|
|
|
|
|
//
|
|
// Ellipse
|
|
//
|
|
typedef struct _ELLIPSE_ORDER
|
|
{
|
|
TSHR_UINT16 type; // holds "EL" - ORD_ELLIPSE
|
|
TSHR_INT16 pad1;
|
|
|
|
TSHR_INT32 BackMode; // background mix mode
|
|
|
|
TSHR_INT32 nLeftRect; // x left of bounding box
|
|
TSHR_INT32 nTopRect; // y top of bounding box
|
|
TSHR_INT32 nRightRect; // x right of bounding box
|
|
TSHR_INT32 nBottomRect; // y bottom of bounding box
|
|
|
|
TSHR_COLOR BackColor; // background color
|
|
TSHR_UINT8 pad2;
|
|
|
|
TSHR_COLOR ForeColor; // foreground color
|
|
TSHR_UINT8 pad3;
|
|
|
|
TSHR_INT32 BrushOrgX;
|
|
TSHR_INT32 BrushOrgY;
|
|
TSHR_UINT32 BrushStyle;
|
|
TSHR_UINT32 BrushHatch;
|
|
TSHR_UINT8 BrushExtra[7];
|
|
TSHR_UINT8 pad4;
|
|
|
|
TSHR_UINT32 ROP2; // drawing mode
|
|
|
|
TSHR_UINT32 PenStyle;
|
|
TSHR_UINT32 PenWidth; // always 1 - field retained for
|
|
// backwards compatibility
|
|
TSHR_COLOR PenColor;
|
|
TSHR_UINT8 pad5;
|
|
} ELLIPSE_ORDER, FAR * LPELLIPSE_ORDER;
|
|
|
|
|
|
//
|
|
// Arc
|
|
//
|
|
typedef struct _ARC_ORDER
|
|
{
|
|
TSHR_UINT16 type; // holds "AR" - ORD_ARC
|
|
TSHR_INT16 pad1;
|
|
|
|
TSHR_INT32 BackMode; // background mix mode
|
|
|
|
TSHR_INT32 nLeftRect; // x left of bounding box
|
|
TSHR_INT32 nTopRect; // y top of bounding box
|
|
TSHR_INT32 nRightRect; // x right of bounding box
|
|
TSHR_INT32 nBottomRect; // y bottom of bounding box
|
|
TSHR_INT32 nXStart; // x of starting point
|
|
TSHR_INT32 nYStart; // y of starting point
|
|
TSHR_INT32 nXEnd; // x of ending point
|
|
TSHR_INT32 nYEnd; // y of ending point
|
|
|
|
TSHR_COLOR BackColor; // background color
|
|
TSHR_UINT8 pad2;
|
|
|
|
TSHR_UINT32 ROP2; // drawing mode
|
|
|
|
TSHR_UINT32 PenStyle;
|
|
TSHR_UINT32 PenWidth; // always 1 - field retained for
|
|
// backwards compatibility
|
|
TSHR_COLOR PenColor;
|
|
TSHR_UINT8 pad3;
|
|
|
|
TSHR_UINT32 ArcDirection; // AD_COUNTERCLOCKWISE or AS_CLOCKWISE
|
|
} ARC_ORDER, FAR * LPARC_ORDER;
|
|
|
|
|
|
//
|
|
// Chord
|
|
//
|
|
typedef struct _CHORD_ORDER
|
|
{
|
|
TSHR_UINT16 type; // holds "CD" - ORD_CHORD
|
|
TSHR_INT16 pad1;
|
|
|
|
TSHR_INT32 BackMode; // background mix mode
|
|
|
|
TSHR_INT32 nLeftRect; // x left of bounding box
|
|
TSHR_INT32 nTopRect; // y top of bounding box
|
|
TSHR_INT32 nRightRect; // x right of bounding box
|
|
TSHR_INT32 nBottomRect; // y bottom of bounding box
|
|
TSHR_INT32 nXStart; // x of starting point
|
|
TSHR_INT32 nYStart; // y of starting point
|
|
TSHR_INT32 nXEnd; // x of ending point
|
|
TSHR_INT32 nYEnd; // y of ending point
|
|
|
|
TSHR_COLOR BackColor; // background color
|
|
TSHR_UINT8 pad2;
|
|
|
|
TSHR_COLOR ForeColor; // foreground color
|
|
TSHR_UINT8 pad3;
|
|
|
|
TSHR_INT32 BrushOrgX;
|
|
TSHR_INT32 BrushOrgY;
|
|
TSHR_UINT32 BrushStyle;
|
|
TSHR_UINT32 BrushHatch;
|
|
TSHR_UINT8 BrushExtra[7];
|
|
TSHR_UINT8 pad4;
|
|
|
|
TSHR_UINT32 ROP2; // drawing mode
|
|
|
|
TSHR_UINT32 PenStyle;
|
|
TSHR_UINT32 PenWidth; // always 1 - field retained for
|
|
// backwards compatibility
|
|
TSHR_COLOR PenColor;
|
|
TSHR_UINT8 pad5;
|
|
|
|
TSHR_UINT32 ArcDirection; // AD_COUNTERCLOCKWISE or AD_CLOCKWISE
|
|
} CHORD_ORDER, FAR * LPCHORD_ORDER;
|
|
|
|
|
|
//
|
|
// PolyBezier
|
|
//
|
|
typedef struct _POLYBEZIER_ORDER
|
|
{
|
|
TSHR_UINT16 type; // holds "PZ" - ORD_POLYBEZIER
|
|
TSHR_INT16 pad1;
|
|
|
|
TSHR_INT32 BackMode; // background mix mode
|
|
|
|
TSHR_COLOR BackColor; // background color
|
|
TSHR_UINT8 pad2;
|
|
|
|
TSHR_COLOR ForeColor; // foreground color
|
|
TSHR_UINT8 pad3;
|
|
|
|
TSHR_UINT32 ROP2; // drawing mode
|
|
|
|
TSHR_UINT32 PenStyle;
|
|
TSHR_UINT32 PenWidth; // always 1 - field retained for
|
|
// backwards compatibility
|
|
TSHR_COLOR PenColor;
|
|
TSHR_UINT8 pad4;
|
|
|
|
//
|
|
// The following variable data occurs here.
|
|
//
|
|
VARIABLE_BEZIERPOINTS variablePoints;
|
|
|
|
} POLYBEZIER_ORDER, FAR * LPPOLYBEZIER_ORDER;
|
|
|
|
|
|
//
|
|
// RoundRect
|
|
//
|
|
typedef struct _ROUNDRECT_ORDER
|
|
{
|
|
TSHR_UINT16 type; // holds "RR" - ORD_ROUNDRECT
|
|
TSHR_INT16 pad1;
|
|
|
|
TSHR_INT32 BackMode; // background mix mode
|
|
|
|
TSHR_INT32 nLeftRect; // x left
|
|
TSHR_INT32 nTopRect; // y top
|
|
TSHR_INT32 nRightRect; // x right
|
|
TSHR_INT32 nBottomRect; // y bottom
|
|
|
|
TSHR_INT32 nEllipseWidth; // ellipse width
|
|
TSHR_INT32 nEllipseHeight; // ellipse height
|
|
|
|
TSHR_COLOR BackColor; // background color
|
|
TSHR_UINT8 pad2;
|
|
TSHR_COLOR ForeColor; // foreground color
|
|
TSHR_UINT8 pad3;
|
|
|
|
TSHR_INT32 BrushOrgX;
|
|
TSHR_INT32 BrushOrgY;
|
|
TSHR_UINT32 BrushStyle;
|
|
TSHR_UINT32 BrushHatch;
|
|
TSHR_UINT8 BrushExtra[7];
|
|
TSHR_UINT8 pad4;
|
|
|
|
TSHR_UINT32 ROP2; // drawing mode
|
|
|
|
TSHR_UINT32 PenStyle;
|
|
TSHR_UINT32 PenWidth; // always 1 - field retained for
|
|
// backwards compatibility
|
|
TSHR_COLOR PenColor;
|
|
TSHR_UINT8 pad5;
|
|
}
|
|
ROUNDRECT_ORDER, FAR * LPROUNDRECT_ORDER;
|
|
|
|
|
|
|
|
////////////////////////////////
|
|
//
|
|
// ORDER ENCODING
|
|
//
|
|
////////////////////////////////
|
|
|
|
|
|
//
|
|
// Overview of Second Order Encoding
|
|
//
|
|
// Second order encoding works by only sending over the network the fields
|
|
// in an order which have changed since the last time the order was sent.
|
|
// A copy of the last example of each order sent is maintained at the
|
|
// encoding end and at the decoding end. Whilst encoding, the fields in
|
|
// the order being encoded are checked against the fields in the copy of
|
|
// the last order of this type encoded. The data in the field is only
|
|
// encoded if it has changed. The decoding end then only needs to copy the
|
|
// changed fields into its copy of the order.
|
|
//
|
|
|
|
|
|
//
|
|
// Encoded Order types.
|
|
//
|
|
// Note that most of these agree with the ORD_XXXXX defines, but not all,
|
|
// which is probably a mistake. However it doesn't matter since the code
|
|
// does not assume equivalence. It is unfortunately too late to change
|
|
// since the the shipping code uses the 2 sets of numbers:
|
|
//
|
|
// - the OE2 protocol uses these numbers
|
|
// - the capabilities structure uses the ORD_XXXXX numbers.
|
|
//
|
|
// Since this split exists, the DESKTOP SCROLL order, whose highword places
|
|
// it outside the CAPS_MAX_NUM_ORDERS range, is also mapped to a different
|
|
// number, so that the OE2 values have no gaps.
|
|
//
|
|
#define OE2_DSTBLT_ORDER (HIWORD(ORD_DSTBLT))
|
|
#define OE2_PATBLT_ORDER (HIWORD(ORD_PATBLT))
|
|
#define OE2_SCRBLT_ORDER (HIWORD(ORD_SCRBLT))
|
|
#define OE2_MEMBLT_ORDER (HIWORD(ORD_MEMBLT))
|
|
#define OE2_MEM3BLT_ORDER (HIWORD(ORD_MEM3BLT))
|
|
#define OE2_TEXTOUT_ORDER (HIWORD(ORD_TEXTOUT))
|
|
#define OE2_EXTTEXTOUT_ORDER (HIWORD(ORD_EXTTEXTOUT))
|
|
// 0x07 was FastFrame, which is no longer supported.
|
|
#define OE2_RECTANGLE_ORDER 0x08
|
|
#define OE2_LINETO_ORDER 0x09
|
|
#define OE2_OPAQUERECT_ORDER (HIWORD(ORD_OPAQUERECT))
|
|
#define OE2_SAVEBITMAP_ORDER (HIWORD(ORD_SAVEBITMAP))
|
|
#define OE2_DESKSCROLL_ORDER 0x0c
|
|
#define OE2_MEMBLT_R2_ORDER (HIWORD(ORD_MEMBLT_R2))
|
|
#define OE2_MEM3BLT_R2_ORDER (HIWORD(ORD_MEM3BLT_R2))
|
|
#define OE2_POLYGON_ORDER (HIWORD(ORD_POLYGON))
|
|
#define OE2_PIE_ORDER (HIWORD(ORD_PIE))
|
|
#define OE2_ELLIPSE_ORDER (HIWORD(ORD_ELLIPSE))
|
|
#define OE2_ARC_ORDER (HIWORD(ORD_ARC))
|
|
#define OE2_CHORD_ORDER (HIWORD(ORD_CHORD))
|
|
#define OE2_POLYBEZIER_ORDER (HIWORD(ORD_POLYBEZIER))
|
|
#define OE2_ROUNDRECT_ORDER (HIWORD(ORD_ROUNDRECT))
|
|
#define OE2_UNKNOWN_ORDER 0xFF
|
|
|
|
|
|
//
|
|
// #defines used to extract fields from a pointer to one of the text orders
|
|
//
|
|
#define TEXTFIELD(order) ((TEXTOUT_ORDER*)(order->abOrderData))
|
|
#define EXTTEXTFIELD(order) ((EXTTEXTOUT_ORDER*)(order->abOrderData))
|
|
|
|
//
|
|
// Number of order types.
|
|
//
|
|
#define OE2_NUM_TYPES 22
|
|
|
|
//
|
|
// Constants defining the number of changeable fields in an ORDER
|
|
// (including the "type" field which is always a word at the beginning of
|
|
// each order)
|
|
//
|
|
#define OE2_NUM_DSTBLT_FIELDS 6
|
|
#define OE2_NUM_PATBLT_FIELDS 13
|
|
#define OE2_NUM_SCRBLT_FIELDS 8
|
|
#define OE2_NUM_MEMBLT_FIELDS 9
|
|
#define OE2_NUM_MEM3BLT_FIELDS 16
|
|
#define OE2_NUM_TEXTOUT_FIELDS 15
|
|
#define OE2_NUM_EXTTEXTOUT_FIELDS 22
|
|
#define OE2_NUM_RECTANGLE_FIELDS 17
|
|
#define OE2_NUM_LINETO_FIELDS 11
|
|
#define OE2_NUM_OPAQUERECT_FIELDS 6
|
|
#define OE2_NUM_SAVEBITMAP_FIELDS 7
|
|
#define OE2_NUM_DESKSCROLL_FIELDS 3
|
|
#define OE2_NUM_MEMBLT_R2_FIELDS 10
|
|
#define OE2_NUM_MEM3BLT_R2_FIELDS 17
|
|
#define OE2_NUM_POLYGON_FIELDS 15
|
|
#define OE2_NUM_PIE_FIELDS 22
|
|
#define OE2_NUM_ELLIPSE_FIELDS 17
|
|
#define OE2_NUM_ARC_FIELDS 16
|
|
#define OE2_NUM_CHORD_FIELDS 22
|
|
#define OE2_NUM_POLYBEZIER_FIELDS 9
|
|
#define OE2_NUM_ROUNDRECT_FIELDS 19
|
|
|
|
|
|
//
|
|
// ControlFlags:
|
|
//
|
|
// Information about how the order is encoded. (See OE2_CF_XXX flags
|
|
// description).
|
|
//
|
|
// EncodedOrder:
|
|
//
|
|
// Contains N bytes of flags followed by an array of bytes containing the
|
|
// fields which have changed since this order was last encoded. (If there
|
|
// are M fields in the order then N is M/8). The position of each bit set
|
|
// in the flags gives the relative position of the entry for a field in the
|
|
// encoding table (if the first bit is set, then the entry is the first one
|
|
// in the encoding table etc.)
|
|
//
|
|
//
|
|
typedef struct tagDCEO2ORDER
|
|
{
|
|
BYTE ControlFlags;
|
|
BYTE EncodedOrder[1];
|
|
}
|
|
DCEO2ORDER;
|
|
typedef DCEO2ORDER FAR * PDCEO2ORDER;
|
|
|
|
|
|
|
|
//
|
|
// FLAGS USED INTERNALLY BY OE2
|
|
//
|
|
// The encoded order (DCEO2ORDER) Flags field contains information
|
|
// about which fields in the ORDER HEADER need updating
|
|
// These control bits are the same for all orders and have the following
|
|
// values:
|
|
//
|
|
#define OE2_CF_STANDARD_ENC 0x01U // standard encoding follows...
|
|
#define OE2_CF_UNENCODED 0x02U // not encoded
|
|
#define OE2_CF_BOUNDS 0x04U // bounding (clip) rectangle supplied
|
|
#define OE2_CF_TYPE_CHANGE 0x08U // type of order different from previous
|
|
#define OE2_CF_DELTACOORDS 0x10U // coords are TSHR_INT8 deltas from previous
|
|
#define OE2_CF_RESERVED1 0x20U //
|
|
#define OE2_CF_RESERVED2 0x40U //
|
|
#define OE2_CF_RESERVED3 0x80U //
|
|
|
|
|
|
//
|
|
// Flags use by OE2EncodeBounds and OE2DecodeBounds to indicate how the
|
|
// four coordinates in the bounding rectangle were encoded relative the the
|
|
// previous bounding rectangle. The encoding used is a byte of flags
|
|
// followed by a variable number of 16bit coordinate values and 8bit delta
|
|
// coordinate values (which may be interleaved). See functions for more
|
|
// information.
|
|
//
|
|
#define OE2_BCF_LEFT 0x01
|
|
#define OE2_BCF_TOP 0x02
|
|
#define OE2_BCF_RIGHT 0x04
|
|
#define OE2_BCF_BOTTOM 0x08
|
|
#define OE2_BCF_DELTA_LEFT 0x10
|
|
#define OE2_BCF_DELTA_TOP 0x20
|
|
#define OE2_BCF_DELTA_RIGHT 0x40
|
|
#define OE2_BCF_DELTA_BOTTOM 0x80
|
|
|
|
//
|
|
// OE2ETFIELD entry flag types.
|
|
//
|
|
#define OE2_ETF_FIXED 0x01
|
|
#define OE2_ETF_VARIABLE 0x02
|
|
#define OE2_ETF_COORDINATES 0x04
|
|
#define OE2_ETF_DATA 0x08
|
|
|
|
//
|
|
// Define the maximum sizes of fields within encoded orders.
|
|
//
|
|
#define OE2_CONTROL_FLAGS_FIELD_SIZE 1
|
|
#define OE2_TYPE_FIELD_SIZE 1
|
|
#define OE2_MAX_FIELD_FLAG_BYTES 4
|
|
#define OE2_MAX_ADDITIONAL_BOUNDS_BYTES 1
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////
|
|
//
|
|
// T.SHARE PACKETS, FLOW CONTROL
|
|
//
|
|
//////////////////////////////////////////
|
|
|
|
//
|
|
// Maximum size of application packets (bytes).
|
|
// NOTE:
|
|
// Packet size can not just change. There are no caps for it currently.
|
|
// Moreover, even though theoretically the field size is a WORD, flow
|
|
// control uses the high bit to determine flow packets.
|
|
//
|
|
|
|
|
|
//
|
|
// HEADER in front of TSHR_FLO_CONTROL/S20PACKETs
|
|
//
|
|
|
|
typedef struct tagTSHR_NET_PKT_HEADER
|
|
{
|
|
TSHR_UINT16 pktLength;
|
|
}
|
|
TSHR_NET_PKT_HEADER;
|
|
typedef TSHR_NET_PKT_HEADER * PTSHR_NET_PKT_HEADER;
|
|
|
|
|
|
//
|
|
// Packet types:
|
|
// S20 packets have pktLength < TSHR_PKT_FLOW
|
|
// FLO packets have pktLength == TSHR_PKT_FLOW
|
|
//
|
|
#define TSHR_PKT_FLOW 0x8000
|
|
|
|
|
|
// WE'RE STUCK WITH THIS OUTGOING VALUE BECAUSE OF FLOW CONTROL! IT ASSUMES
|
|
// PACKETS of size > MG_PKT_FLOW are flow control packets. Back level dudes
|
|
// are hosted because of it...
|
|
|
|
#define TSHR_MAX_SEND_PKT 32000
|
|
|
|
|
|
|
|
typedef struct TSHR_FLO_CONTROL
|
|
{
|
|
TSHR_UINT16 packetType;
|
|
TSHR_UINT8 stream;
|
|
TSHR_UINT8 pingPongID;
|
|
TSHR_UINT16 userID;
|
|
}
|
|
TSHR_FLO_CONTROL;
|
|
typedef TSHR_FLO_CONTROL * PTSHR_FLO_CONTROL;
|
|
|
|
|
|
//
|
|
// TSHR_FLO_CONTROL packetType values
|
|
//
|
|
#define PACKET_TYPE_NOPING 0x0040
|
|
#define PACKET_TYPE_PING 0x0041
|
|
#define PACKET_TYPE_PONG 0x0042
|
|
#define PACKET_TYPE_PANG 0x0043
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////
|
|
//
|
|
// T.SHARE CONTROL PACKETS
|
|
//
|
|
//////////////////////////////////////////
|
|
|
|
//
|
|
// CORRELATORS
|
|
//
|
|
// Most S20 messsages contain a correlator field. This field is used
|
|
// to identify which share the message belongs to and is used to
|
|
// resolve races at share start up and discard stale messages received.
|
|
//
|
|
// A correlator is a 32 bit number which contains two parts. The first
|
|
// 16 bits (the low word in Intel format) contains the user ID of the
|
|
// party which created the share. The second 16 bits contains a count
|
|
// supplied by the party which created the share (ie the first share
|
|
// they create is 1 the second 2 etc). This should ensure unique
|
|
// correlators for every share created for a long enough period to
|
|
// ensure no stale data is left.
|
|
//
|
|
// A new correlator is always present on a create message. All
|
|
// respond, delete and leave messages must contain the correct
|
|
// correlator for the share. A join message does not contain a
|
|
// correlator. A party which issues a join message will find out the
|
|
// share's correlator on the first respond message they receive.
|
|
//
|
|
// Respond messages also contain the user ID of the party which sent
|
|
// out the original create or join to which they are responding. There
|
|
// is one exception when a `sweep-up' respond is sent which contains
|
|
// zero in the originator field. This respond is sent by a party which
|
|
// is joining a share as soon as they receive the first response (and
|
|
// therefore know the share correlator). This sweep-up respond handles
|
|
// simultaneous joiners where a party was joining when it too received
|
|
// a join message. When this happens the party ignores the join and
|
|
// will later receive a sweep-up respond message which they will
|
|
// process.
|
|
//
|
|
|
|
|
|
typedef struct tagS20PACKETHEADER
|
|
{
|
|
TSHR_UINT16 packetType;
|
|
TSHR_UINT16 user;
|
|
}
|
|
S20PACKETHEADER;
|
|
typedef S20PACKETHEADER * PS20PACKETHEADER;
|
|
|
|
|
|
//
|
|
// S20PACKETHEADER packetType values
|
|
//
|
|
// A single bit means that this version will only interoperate
|
|
// with itself. More than one bit indicates cross version
|
|
// interoperability.
|
|
//
|
|
// IN NM 4.0, GET RID OF S20_2X_VERSION SUPPORT!
|
|
//
|
|
#define S20_PACKET_TYPE_MASK 0x000F
|
|
#define S20_2X_VERSION 0x0010
|
|
#define S20_30_VERSION 0x0020
|
|
|
|
#define S20_CURRENT_VERSION S20_30_VERSION
|
|
#define S20_ALL_VERSIONS (S20_2X_VERSION | S20_30_VERSION)
|
|
|
|
#define S20_CREATE 1
|
|
#define S20_JOIN 2
|
|
#define S20_RESPOND 3
|
|
#define S20_DELETE 4
|
|
#define S20_LEAVE 5
|
|
#define S20_END 6
|
|
#define S20_DATA 7
|
|
#define S20_COLLISION 8
|
|
|
|
|
|
|
|
//
|
|
// To create the share
|
|
//
|
|
typedef struct tagS20CREATEPACKET
|
|
{
|
|
S20PACKETHEADER header;
|
|
|
|
TSHR_UINT32 correlator;
|
|
TSHR_UINT16 lenName;
|
|
TSHR_UINT16 lenCaps;
|
|
TSHR_UINT8 data[1]; // Name & Caps
|
|
}
|
|
S20CREATEPACKET;
|
|
typedef S20CREATEPACKET * PS20CREATEPACKET;
|
|
|
|
|
|
|
|
//
|
|
// To join a share created by somebody else
|
|
//
|
|
typedef struct tagS20JOINPACKET
|
|
{
|
|
S20PACKETHEADER header;
|
|
|
|
TSHR_UINT16 lenName;
|
|
TSHR_UINT16 lenCaps;
|
|
TSHR_UINT8 data[1]; // Name & Caps
|
|
}
|
|
S20JOINPACKET;
|
|
typedef S20JOINPACKET * PS20JOINPACKET;
|
|
|
|
|
|
|
|
|
|
//
|
|
// To respond to a create packet
|
|
//
|
|
typedef struct tagS20RESPONDPACKET
|
|
{
|
|
S20PACKETHEADER header;
|
|
|
|
TSHR_UINT32 correlator;
|
|
TSHR_UINT16 originator;
|
|
TSHR_UINT16 lenName;
|
|
TSHR_UINT16 lenCaps;
|
|
TSHR_UINT8 data[1]; // Name & Caps
|
|
}
|
|
S20RESPONDPACKET;
|
|
typedef S20RESPONDPACKET * PS20RESPONDPACKET;
|
|
|
|
|
|
|
|
|
|
//
|
|
// To remove a person from a share (if the creator can't join the person in)
|
|
//
|
|
typedef struct tagS20DELETEPACKET
|
|
{
|
|
S20PACKETHEADER header;
|
|
|
|
TSHR_UINT32 correlator;
|
|
TSHR_UINT16 target;
|
|
TSHR_UINT16 lenName; // OBSOLETE - no name/caps at end
|
|
TSHR_UINT8 data[1];
|
|
}
|
|
S20DELETEPACKET;
|
|
typedef S20DELETEPACKET * PS20DELETEPACKET;
|
|
|
|
|
|
|
|
//
|
|
// To leave a share yourself
|
|
//
|
|
typedef struct tagS20LEAVEPACKET
|
|
{
|
|
S20PACKETHEADER header;
|
|
|
|
TSHR_UINT32 correlator;
|
|
}
|
|
S20LEAVEPACKET;
|
|
typedef S20LEAVEPACKET * PS20LEAVEPACKET;
|
|
|
|
|
|
|
|
|
|
//
|
|
// To end a share you created
|
|
//
|
|
typedef struct tagS20ENDPACKET
|
|
{
|
|
S20PACKETHEADER header;
|
|
|
|
TSHR_UINT32 correlator;
|
|
TSHR_UINT16 lenName; // OBSOLETE - no name/caps at end
|
|
TSHR_UINT8 data[1];
|
|
}
|
|
S20ENDPACKET;
|
|
typedef S20ENDPACKET * PS20ENDPACKET;
|
|
|
|
|
|
//
|
|
// To tell somebody creating a share that one already exists
|
|
//
|
|
typedef struct tagS20COLLISIONPACKET
|
|
{
|
|
S20PACKETHEADER header;
|
|
TSHR_UINT32 correlator;
|
|
}
|
|
S20COLLISIONPACKET;
|
|
typedef S20COLLISIONPACKET * PS20COLLISIONPACKET;
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////
|
|
//
|
|
// T.SHARE DATA PACKETS
|
|
//
|
|
/////////////////////////////////
|
|
|
|
|
|
//
|
|
// Data sent when in share (this structure is followed by the different
|
|
// packets described below)
|
|
//
|
|
typedef struct tagDATAPACKETHEADER
|
|
{
|
|
TSHR_UINT8 dataType; // DT_ identifier
|
|
TSHR_UINT8 compressionType;
|
|
TSHR_UINT16 compressedLength;
|
|
}
|
|
DATAPACKETHEADER;
|
|
typedef DATAPACKETHEADER * PDATAPACKETHEADER;
|
|
|
|
|
|
//
|
|
// DATAPACKETHEADER dataType values
|
|
//
|
|
|
|
#define DT_UP 0x02
|
|
#define DT_UNUSED_USR_FH_10 0x09 // OBSOLETE
|
|
#define DT_UNUSED_USR_FH_11 0x0A // OBSOLETE
|
|
#define DT_FH 0x0B
|
|
|
|
#define DT_CA 0x14 // OLD (2.x)
|
|
#define DT_CA30 0x15 // NEW (3.0)
|
|
#define DT_HET30 0x16 // NEW (3.0)
|
|
#define DT_AWC 0x17
|
|
#define DT_SWL 0x18
|
|
#define DT_HET 0x19 // OLD (2.x)
|
|
#define DT_UNUSED_DS 0x1A // OBSOLETE
|
|
#define DT_CM 0x1B
|
|
#define DT_IM 0x1C
|
|
#define DT_UNUSED_HCA 0x1D // OBSOLETE
|
|
#define DT_UNUSED_SC 0x1E // OBSOLETE
|
|
#define DT_SNI 0x1F
|
|
#define DT_CPC 0x20
|
|
|
|
|
|
//
|
|
// DATAPACKETHEADER compressionType values
|
|
//
|
|
// There are two formats for this field.
|
|
//
|
|
// If all nodes participating in the share session have the capability
|
|
// genCompressionLevel >= 1 then the compressionType is a one of the
|
|
// following 8bit integers.
|
|
//
|
|
// Otherwise the the packet is compressed with GCT_PKZIP if the top bit is
|
|
// set and the packet is not compressed if it is not set. The remaining
|
|
// bits are undefined (and will NOT be all zero)
|
|
//
|
|
//
|
|
// Note: Each of these values has a GCT_... value associated with it.
|
|
// These values indicate which bit of the GCT_... values this
|
|
// compression type represents. Eg. a value of 5 here pairs with the
|
|
// value 0x0010 (ie bit 5 set)
|
|
//
|
|
#define CT_NONE 0
|
|
#define CT_PKZIP 1
|
|
#define CT_PERSIST_PKZIP 2
|
|
#define CT_OLD_COMPRESSED 0x80
|
|
|
|
|
|
|
|
|
|
typedef struct tagS20DATAPACKET
|
|
{
|
|
S20PACKETHEADER header;
|
|
|
|
TSHR_UINT32 correlator;
|
|
TSHR_UINT8 ackID; // OBSOLETE
|
|
TSHR_UINT8 stream;
|
|
TSHR_UINT16 dataLength;
|
|
|
|
DATAPACKETHEADER data;
|
|
// data specific to DT_ type follows here
|
|
}
|
|
S20DATAPACKET;
|
|
typedef S20DATAPACKET * PS20DATAPACKET;
|
|
|
|
|
|
//
|
|
// S20DATAPACKET stream values
|
|
//
|
|
//
|
|
// The streams and priotities used by AppSharing
|
|
//
|
|
#define PROT_STR_INVALID 0
|
|
#define PROT_STR_UPDATES 1 // SNI_STREAM_LOW
|
|
#define PROT_STR_MISC 2
|
|
#define PROT_STR_UNUSED 3 // NOT USED!
|
|
#define PROT_STR_INPUT 4
|
|
#define NUM_PROT_STR 5
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// DT_AWC
|
|
// Active Window packets
|
|
//
|
|
|
|
typedef struct tagAWCPACKET
|
|
{
|
|
S20DATAPACKET header;
|
|
|
|
TSHR_UINT16 msg;
|
|
TSHR_UINT16 token; // OBSOLETE
|
|
UINT_PTR data1;
|
|
UINT_PTR data2;
|
|
}
|
|
AWCPACKET;
|
|
typedef AWCPACKET *PAWCPACKET;
|
|
|
|
|
|
|
|
|
|
//
|
|
// AWCPACKET msg values
|
|
//
|
|
#define AWC_MSG_INVALID 0x0000
|
|
#define AWC_MSG_ACTIVE_CHANGE_LOCAL 0x0001
|
|
#define AWC_MSG_ACTIVE_CHANGE_SHARED 0x0002
|
|
#define AWC_MSG_ACTIVE_CHANGE_INVISIBLE 0x0003
|
|
#define AWC_MSG_ACTIVE_CHANGE_CAPTURED 0x0004 // OBSOLETE
|
|
#define AWC_MSG_ACTIVATE_WINDOW 0x8001
|
|
#define AWC_MSG_CLOSE_WINDOW 0x8002 // OBSOLETE
|
|
#define AWC_MSG_RESTORE_WINDOW 0x8003
|
|
#define AWC_MSG_TASKBAR_RBUTTON 0x8004 // OBSOLETE
|
|
#define AWC_MSG_SAS 0x8005
|
|
#define AWC_MSG_SYSCOMMAND_HELPKEYS 0x8011 // OBSOLETE
|
|
#define AWC_MSG_SYSCOMMAND_HELPINDEX 0x8012 // OBSOLETE
|
|
#define AWC_MSG_SYSCOMMAND_HELPEXTENDED 0x8013 // OBSOLETE
|
|
|
|
|
|
|
|
//
|
|
// DT_CA
|
|
// OLD Control Arbitration packets
|
|
//
|
|
|
|
typedef struct tagCAPACKET
|
|
{
|
|
S20DATAPACKET header;
|
|
|
|
TSHR_UINT16 msg;
|
|
TSHR_UINT16 data1;
|
|
UINT_PTR data2;
|
|
}
|
|
CAPACKET;
|
|
typedef CAPACKET *PCAPACKET;
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// CAPACKET msg values, 2.x
|
|
// These are all broadcasted, control is global
|
|
//
|
|
#define CA_MSG_NOTIFY_STATE 0 // NEW FOR NM 3.0
|
|
#define CA_OLDMSG_REQUEST_CONTROL 1 // NM 2.x
|
|
#define CA_OLDMSG_GRANTED_CONTROL 2 // NM 2.x
|
|
#define CA_OLDMSG_DETACH 3 // NM 2.x
|
|
#define CA_OLDMSG_COOPERATE 4 // NM 2.x
|
|
|
|
|
|
//
|
|
// Notification (broadcast) packet
|
|
//
|
|
typedef struct tagCANOTPACKET
|
|
{
|
|
S20DATAPACKET header;
|
|
|
|
TSHR_UINT16 msg;
|
|
TSHR_UINT16 state;
|
|
UINT_PTR controllerID;
|
|
}
|
|
CANOTPACKET;
|
|
typedef CANOTPACKET * PCANOTPACKET;
|
|
|
|
//
|
|
// CA_MSG_NOTIFY_STATE
|
|
// state - controllable or not
|
|
// controllerID - controller net ID or 0 if nobody
|
|
//
|
|
|
|
// state flags:
|
|
#define CASTATE_ALLOWCONTROL 0x0001
|
|
|
|
|
|
|
|
|
|
//
|
|
// CA_OLDMSG_REQUEST_CONTROL
|
|
// Broadcasted to request taking of global control
|
|
// data1 - unused
|
|
// data2 - unused
|
|
//
|
|
|
|
//
|
|
// CA_OLDMSG_GRANTED_CONTROL
|
|
// Broadcasted by node(s) who think they own the control token, when they
|
|
// grant the control token to node who asked for it via REQUEST.
|
|
// data1 - netID of person given control
|
|
// data2 - control token generation
|
|
//
|
|
|
|
//
|
|
// CA_OLDMSG_DETACH
|
|
// Broadcasted when node stops collaborating
|
|
// data1 - unused
|
|
// data2 - unused
|
|
//
|
|
|
|
//
|
|
// CA_OLDMSG_COOPERATE
|
|
// Broadcasted when node starts collaborating
|
|
// data1 - unused
|
|
// data2 - unused
|
|
//
|
|
|
|
|
|
|
|
|
|
//
|
|
// DT_CA30
|
|
// NEW Control packets
|
|
//
|
|
|
|
|
|
//
|
|
// These are PRIVATE SEND packets, on PROT_STR_INPUT, from one node to another.
|
|
// They go out in order, and are queued if not able to send for retry later.
|
|
//
|
|
|
|
//
|
|
// Common header for CA30 packets.
|
|
//
|
|
typedef struct tagCA30PACKETHEADER
|
|
{
|
|
S20DATAPACKET header;
|
|
TSHR_UINT32 msg;
|
|
}
|
|
CA30PACKETHEADER;
|
|
typedef CA30PACKETHEADER * PCA30PACKETHEADER;
|
|
|
|
|
|
//
|
|
// CA30PACKETHEADER msg values
|
|
//
|
|
#define CA_REQUEST_TAKECONTROL 1 // From viewer to host
|
|
#define CA_REPLY_REQUEST_TAKECONTROL 2 // From host to viewer
|
|
#define CA_REQUEST_GIVECONTROL 3 // From host to viewer
|
|
#define CA_REPLY_REQUEST_GIVECONTROL 4 // From viewer to host
|
|
#define CA_PREFER_PASSCONTROL 5 // From controller to host
|
|
|
|
#define CA_INFORM_RELEASEDCONTROL 0x8001 // From controller to host
|
|
#define CA_INFORM_REVOKEDCONTROL 0x8002 // From host to controller
|
|
#define CA_INFORM_PAUSEDCONTROL 0x8003 // From host to controller
|
|
#define CA_INFORM_UNPAUSEDCONTROL 0x8004 // From host to controller
|
|
|
|
|
|
//
|
|
// REPLY packet result values
|
|
//
|
|
#define CARESULT_CONFIRMED 0
|
|
#define CARESULT_DENIED 1
|
|
#define CARESULT_DENIED_BUSY 2
|
|
#define CARESULT_DENIED_USER 3
|
|
#define CARESULT_DENIED_WRONGSTATE 4
|
|
#define CARESULT_DENIED_TIMEDOUT 5
|
|
|
|
|
|
|
|
//
|
|
// ALL packets also have a CA30PACKETHEADER in front of them.
|
|
//
|
|
|
|
|
|
//
|
|
// CA_REQUEST_TAKECONTROL
|
|
// Sender is viewer
|
|
// Receiver is host
|
|
// viewerControlID - unique viewer request ID
|
|
//
|
|
// Receiver should reply with CA_REPLY_REQUEST_TAKECONTROL
|
|
// Sender should cancel with CA_INFORM_RELEASEDCONTROL
|
|
//
|
|
typedef struct tagCA_RTC_PACKET
|
|
{
|
|
TSHR_UINT32 viewerControlID;
|
|
}
|
|
CA_RTC_PACKET;
|
|
typedef CA_RTC_PACKET * PCA_RTC_PACKET;
|
|
|
|
|
|
|
|
//
|
|
// CA_REPLY_REQUEST_TAKECONTROL
|
|
// Sender is host
|
|
// Receiver is viewer, who sent original TAKECONTROL request
|
|
// viewerControlID - viewer request ID from TAKECONTROL request
|
|
// hostControlID - unique host request ID
|
|
// result - CARESULT value, success or failure
|
|
//
|
|
typedef struct tagCA_REPLY_RTC_PACKET
|
|
{
|
|
TSHR_UINT32 viewerControlID;
|
|
TSHR_UINT32 result;
|
|
TSHR_UINT32 hostControlID;
|
|
}
|
|
CA_REPLY_RTC_PACKET;
|
|
typedef CA_REPLY_RTC_PACKET * PCA_REPLY_RTC_PACKET;
|
|
|
|
|
|
|
|
|
|
//
|
|
// CA_PREFER_PASSCONTROL
|
|
// Sender is controller
|
|
// Receiver is host
|
|
// viewerControlID - controller request ID from take operation
|
|
// hostControlID - host request ID from reply to take operation.
|
|
// mcsPassTo - MCS ID of viewer to pass to
|
|
//
|
|
// No reply is required
|
|
// Sender is not in control when this gets out
|
|
// Receiver can then, if he chooses, turn around and ask 3rd party to control
|
|
//
|
|
typedef struct tagCA_PPC_PACKET
|
|
{
|
|
TSHR_UINT32 viewerControlID;
|
|
TSHR_UINT32 hostControlID;
|
|
UINT_PTR mcsPassTo;
|
|
}
|
|
CA_PPC_PACKET;
|
|
typedef CA_PPC_PACKET * PCA_PPC_PACKET;
|
|
|
|
|
|
|
|
|
|
//
|
|
// CA_REQUEST_GIVECONTROL
|
|
// Sender is host
|
|
// Receiver is viewer
|
|
// hostControlID - unique host request ID
|
|
// mcsPassFrom - person passing control, zero if none
|
|
//
|
|
// Receiver should reply with CA_REPLY_REQUEST_GIVECONTROL
|
|
// Sender should cancel with CA_INFORM_REVOKEDCONTROL
|
|
//
|
|
typedef struct tagCA_RGC_PACKET
|
|
{
|
|
TSHR_UINT32 hostControlID;
|
|
UINT_PTR mcsPassFrom;
|
|
}
|
|
CA_RGC_PACKET;
|
|
typedef CA_RGC_PACKET * PCA_RGC_PACKET;
|
|
|
|
|
|
|
|
//
|
|
// CA_REPLY_REQUEST_GIVECONTROL
|
|
// Sender is viewer
|
|
// Receiver is host, who sent original TAKECONTROL invite
|
|
// hostControlID - host request ID from TAKECONTROL invite
|
|
// mcsPassFrom - person passing us control, 0 if none
|
|
// result - CARESULT value, success or failure
|
|
// viewerControlID - unique viewer request ID
|
|
//
|
|
typedef struct tagCA_REPLY_RGC_PACKET
|
|
{
|
|
TSHR_UINT32 hostControlID;
|
|
TSHR_UINT32 mcsPassFrom;
|
|
TSHR_UINT32 result;
|
|
TSHR_UINT32 viewerControlID;
|
|
}
|
|
CA_REPLY_RGC_PACKET;
|
|
typedef CA_REPLY_RGC_PACKET * PCA_REPLY_RGC_PACKET;
|
|
|
|
|
|
|
|
|
|
//
|
|
// INFORM packets
|
|
// These are sent to cancel a REQUEST packet, or after the control
|
|
// operation has completed, to terminate it. If cancelling, then the
|
|
// other party's controlID will be zero since we won't have heard back from
|
|
// them yet to get it.
|
|
//
|
|
typedef struct tagCA_INFORM_PACKET
|
|
{
|
|
TSHR_UINT32 viewerControlID;
|
|
TSHR_UINT32 hostControlID;
|
|
}
|
|
CA_INFORM_PACKET;
|
|
typedef CA_INFORM_PACKET * PCA_INFORM_PACKET;
|
|
|
|
|
|
//
|
|
// CA_INFORM_RELEASEDCONTROL
|
|
// Sender is controller
|
|
// Receiver is host
|
|
// viewerControlID - viewer request ID from
|
|
// REQUEST_TAKECONTROL
|
|
// REPLY_REQUEST_GIVECONTROL
|
|
// hostControlID - host request ID from
|
|
// REPLY_REQUEST_TAKECONTROL
|
|
// REQUEST_GIVECONTROL
|
|
//
|
|
// If viewer is cancelling REQUEST_TAKECONTROL then hostControlID is 0
|
|
//
|
|
|
|
//
|
|
// CA_INFORM_REVOKEDCONTROL
|
|
// Sender is host
|
|
// Receiver is controller
|
|
// viewerControlID - viewer request ID from
|
|
// REQUEST_TAKECONTROL
|
|
// REPLY_REQUEST_GIVECONTROL
|
|
// hostControlID - host request ID from
|
|
// REPLY_REQUEST_TAKECONTROL
|
|
// REQUEST_GIVECONTROL
|
|
//
|
|
// If host is cancelling REQUEST_GIVECONTROL then viewerControlID is 0
|
|
//
|
|
|
|
//
|
|
// CA_INFORM_PAUSEDCONTROL
|
|
// CA_INFORM_UNPAUSEDCONTROL
|
|
// Sender is host
|
|
// Receiver is controller
|
|
// viewerControlID - viewer request ID from
|
|
// REQUEST_TAKECONTROL
|
|
// REPLY_REQUEST_GIVECONTROL
|
|
// hostControlID - host request ID from
|
|
// REPLY_REQUEST_TAKECONTROL
|
|
// REQUEST_GIVECONTROL
|
|
//
|
|
|
|
|
|
|
|
//
|
|
// DT_CM
|
|
// Cursor shape/position packets
|
|
// There are three types of shape packets: mono bitmaps, color cached,
|
|
// constant IDs
|
|
//
|
|
|
|
|
|
typedef struct tagCMPACKETHEADER
|
|
{
|
|
S20DATAPACKET header;
|
|
|
|
TSHR_UINT16 type;
|
|
TSHR_UINT16 flags;
|
|
}
|
|
CMPACKETHEADER;
|
|
typedef CMPACKETHEADER * PCMPACKETHEADER;
|
|
|
|
|
|
|
|
|
|
//
|
|
// CMPACKETHEADER type values
|
|
//
|
|
#define CM_CURSOR_ID 1
|
|
#define CM_CURSOR_MONO_BITMAP 2
|
|
#define CM_CURSOR_MOVE 3
|
|
#define CM_CURSOR_BITMAP_COMPRESSED 4 // OBSOLETE
|
|
#define CM_CURSOR_COLORTABLE 5 // OBSOLETE
|
|
#define CM_CURSOR_COLOR_BITMAP 6
|
|
#define CM_CURSOR_COLOR_CACHE 7
|
|
|
|
|
|
//
|
|
// CMPACKETHEADER sync flag values
|
|
//
|
|
#define CM_SYNC_CURSORPOS 0x0001
|
|
//
|
|
// This will be set if, when we played back input, the cursor
|
|
// didn't end up where it was asked to go. This could happen if an
|
|
// app clips the cursor or snaps it. As such, we mark this field
|
|
// when we send a notification of our current pos so that the controller
|
|
// knows to move his cursor to be in line with ours.
|
|
//
|
|
|
|
|
|
|
|
//
|
|
// type CM_CURSOR_ID
|
|
//
|
|
// This packet is sent when the cursor has changed and it is now one of
|
|
// the system cursors.
|
|
//
|
|
typedef struct tagCMPACKETID
|
|
{
|
|
CMPACKETHEADER header;
|
|
|
|
TSHR_UINT32 idc;
|
|
}
|
|
CMPACKETID;
|
|
typedef CMPACKETID * PCMPACKETID;
|
|
|
|
|
|
|
|
|
|
//
|
|
// CMPACKETID idc values
|
|
//
|
|
#define CM_IDC_NULL 0
|
|
#define CM_IDC_ARROW 32512
|
|
|
|
|
|
//
|
|
// type CM_CURSOR_MONO_BITMAP
|
|
//
|
|
// This packet is sent when the cursor has changed and it is now an
|
|
// application defined mono cursor.
|
|
//
|
|
// The cursor size cannot be greater than 32x32.
|
|
typedef struct tagCMPACKETMONOBITMAP
|
|
{
|
|
CMPACKETHEADER header;
|
|
|
|
TSHR_UINT16 xHotSpot;
|
|
TSHR_UINT16 yHotSpot;
|
|
TSHR_UINT16 width;
|
|
TSHR_UINT16 height;
|
|
TSHR_UINT16 cbBits;
|
|
BYTE aBits[1];
|
|
}
|
|
CMPACKETMONOBITMAP;
|
|
typedef CMPACKETMONOBITMAP * PCMPACKETMONOBITMAP;
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// type CM_CURSOR_COLOR_BITMAP
|
|
//
|
|
// This packet is sent when the cursor has changed and it is now an
|
|
// application defined color cursor.
|
|
//
|
|
typedef struct tagCMPACKETCOLORBITMAP
|
|
{
|
|
CMPACKETHEADER header;
|
|
|
|
TSHR_UINT16 cacheIndex;
|
|
TSHR_UINT16 xHotSpot;
|
|
TSHR_UINT16 yHotSpot;
|
|
TSHR_UINT16 cxWidth;
|
|
TSHR_UINT16 cyHeight;
|
|
TSHR_UINT16 cbANDMask;
|
|
TSHR_UINT16 cbXORBitmap;
|
|
BYTE aBits[1];
|
|
}
|
|
CMPACKETCOLORBITMAP;
|
|
typedef CMPACKETCOLORBITMAP * PCMPACKETCOLORBITMAP;
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// type CM_CURSOR_COLOR_CACHE
|
|
//
|
|
// This packet is sent out when the cursor changes and the new
|
|
// definition resides in the cache.
|
|
//
|
|
//
|
|
typedef struct tagCMPACKETCOLORCACHE
|
|
{
|
|
CMPACKETHEADER header;
|
|
|
|
TSHR_UINT16 cacheIndex;
|
|
}
|
|
CMPACKETCOLORCACHE;
|
|
typedef CMPACKETCOLORCACHE * PCMPACKETCOLORCACHE;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// type CM_CURSOR_MOVE
|
|
//
|
|
// This packet is sent whenever the CM is told that the application has
|
|
// moved the cursor.
|
|
//
|
|
typedef struct tagCMPACKETMOVE
|
|
{
|
|
CMPACKETHEADER header;
|
|
|
|
TSHR_UINT16 xPos;
|
|
TSHR_UINT16 yPos;
|
|
}
|
|
CMPACKETMOVE;
|
|
typedef CMPACKETMOVE * PCMPACKETMOVE;
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// DT_CPC
|
|
// Capabilities change packet
|
|
//
|
|
typedef struct tagCPCPACKET
|
|
{
|
|
S20DATAPACKET header;
|
|
|
|
PROTCAPS caps;
|
|
}
|
|
CPCPACKET;
|
|
typedef CPCPACKET * PCPCPACKET;
|
|
|
|
|
|
|
|
|
|
//
|
|
// DT_FH
|
|
// Supported local font list packet
|
|
//
|
|
|
|
|
|
|
|
//
|
|
// The NETWORKFONT is the font description which is sent across the network
|
|
// when negotiating font support.
|
|
//
|
|
|
|
//
|
|
// Flags for the nfFontFlags field
|
|
//
|
|
#define NF_FIXED_PITCH 0x0001
|
|
#define NF_FIXED_SIZE 0x0002
|
|
#define NF_ITALIC 0x0004
|
|
#define NF_UNDERLINE 0x0008
|
|
#define NF_STRIKEOUT 0x0010
|
|
|
|
#define NF_OEM_CHARSET 0x0020
|
|
#define NF_RESERVED1 0x0040 // Reserved for future BiDi support
|
|
#define NF_TRUE_TYPE 0x0080
|
|
#define NF_BASELINE 0x0100
|
|
|
|
#define NF_PRE_R11 (NF_FIXED_PITCH | NF_FIXED_SIZE | \
|
|
NF_ITALIC | NF_UNDERLINE | NF_STRIKEOUT)
|
|
|
|
//
|
|
// Mask for local-only font flags - that must not flow on the wire.
|
|
//
|
|
#define NF_LOCAL (NF_OEM_CHARSET | NF_TRUE_TYPE)
|
|
|
|
//
|
|
// A special value for the signature field which means no signature.
|
|
//
|
|
#define NF_NO_SIGNATURE 0
|
|
|
|
//
|
|
// The FH_FACESIZE is equal to the Windows specific constant LF_FACESIZE.
|
|
//
|
|
#define FH_FACESIZE 32
|
|
|
|
|
|
//
|
|
// SFRFONT
|
|
// Let us define these things more fully...
|
|
// nfFaceName font face name (not family name, not style)
|
|
// nfFontFlags see above
|
|
// nfAveWidth in Windows set to tmAveCharWidth
|
|
// nfAveHeight NOT THE AVERAGE HEIGHT but the height of a character with
|
|
// full ascender (but no accent) AND descender. There is no
|
|
// such character but never mind.
|
|
// Windows: set to tmHeight - tmInternalLeading
|
|
// nfAspectX
|
|
// nfAspectY
|
|
// nfSignature: in R11 set to an obscure checksum
|
|
// in R20 set to two one-byte values and one two byte value.
|
|
// Based on the widths of the actual text for fixed width
|
|
// fonts and on 16x16 scalable fonts. .
|
|
// (The 16x16 is effectively part of the protocol)
|
|
// nfSigFats the sum of the widths (in pels) of the chars
|
|
// 0-9,@-Z,$,%,&. divided by two: the fat chars
|
|
// nfSigThins the sum of the widths (in pels) of the chars
|
|
// 0x20->0x7F EXCLUDING those summed in nfSigFats.
|
|
// Again - divided by two. The thin chars.
|
|
// nfSigSymbol The sum of the widths (in pels) of the chars
|
|
// x80->xFF.
|
|
// nfCodePage: new use in R20: code page (not charset)
|
|
// This field is set to 0 for ANSI (meaning WINDOWS ANSI)
|
|
// is set to 255 for OEM (meaning Windows OEM font)
|
|
// is set to the defined codepage if known
|
|
// is set to 0xFFFF when not known.
|
|
//
|
|
// nfMaxAscent: The height of a character with no descender, plus any
|
|
// internal leading.
|
|
// = tmAscent in windows
|
|
// For fixed size fonts we send the values you would expect.
|
|
// For scalable fonts, we get the tmAscent (or equivalent) for
|
|
// a very large font (say height-by-width of 100x100). The
|
|
// size selected must be the same on ALL platforms so is
|
|
// effectively part of the protocol - hence is defined in
|
|
// this file as NF_MAXASCENT_HEIGHT and .._WIDTH.
|
|
//
|
|
//
|
|
#define NF_CP_WIN_ANSI 0
|
|
#define NF_CP_WIN_SYMBOL 2
|
|
#define NF_CP_WIN_OEM 255
|
|
#define NF_CP_UNKNOWN 0xFFFF
|
|
|
|
//
|
|
// Define the start and end point of the ASCII sub-range
|
|
//
|
|
#define NF_ASCII_FIRST 0x20
|
|
#define NF_ASCII_LAST 0x7F
|
|
#define NF_ASCII_ZERO 0x30
|
|
#define NF_ASCII_Z 0x5B
|
|
#define NF_ASCII_DOLLAR 0x24
|
|
#define NF_ASCII_PERCENT 0x25
|
|
#define NF_ASCII_AMPERSAND 0x26
|
|
|
|
|
|
//
|
|
// The height/width of the font to ask for when getting the metrics info
|
|
// for scalable fonts.
|
|
// These (in particular the height) are CHARACTER SIZES not CELL sizes.
|
|
// This is because the font protocol exchanges character sizes not cell
|
|
// sizes. (The char height is the cell height minus any internal leading.)
|
|
//
|
|
#define NF_METRICS_HEIGHT 100
|
|
#define NF_METRICS_WIDTH 100
|
|
|
|
//
|
|
// The wire-format font information structure
|
|
//
|
|
typedef struct tagNETWORKFONT
|
|
{
|
|
TSHR_CHAR nfFaceName[FH_FACESIZE];
|
|
TSHR_UINT16 nfFontFlags;
|
|
TSHR_UINT16 nfAveWidth;
|
|
TSHR_UINT16 nfAveHeight;
|
|
TSHR_UINT16 nfAspectX; // New field for r1.1
|
|
TSHR_UINT16 nfAspectY; // New field for r1.1
|
|
TSHR_UINT8 nfSigFats; // New field for r2.0
|
|
TSHR_UINT8 nfSigThins; // New field for r2.0
|
|
TSHR_UINT16 nfSigSymbol; // New field for r2.0
|
|
TSHR_UINT16 nfCodePage; // New field for R2.0
|
|
TSHR_UINT16 nfMaxAscent; // New field for R2.0
|
|
}
|
|
NETWORKFONT;
|
|
typedef NETWORKFONT * LPNETWORKFONT;
|
|
|
|
|
|
typedef struct tagFHPACKET
|
|
{
|
|
S20DATAPACKET header;
|
|
|
|
TSHR_UINT16 cFonts;
|
|
TSHR_UINT16 cbFontSize;
|
|
NETWORKFONT aFonts[1];
|
|
}
|
|
FHPACKET;
|
|
typedef FHPACKET * PFHPACKET;
|
|
|
|
|
|
|
|
|
|
//
|
|
// DT_HET
|
|
// Hosting state (nothing, apps, desktop)
|
|
//
|
|
|
|
typedef struct tagHETPACKET
|
|
{
|
|
S20DATAPACKET header;
|
|
|
|
TSHR_UINT16 msg;
|
|
TSHR_UINT16 hostState; // ONLY ONE VALUE FOR MSG; IF MORE MAKE MORE STRUCTS
|
|
}
|
|
HETPACKET;
|
|
typedef HETPACKET * PHETPACKET;
|
|
|
|
|
|
|
|
//
|
|
// HETPACKET msg values
|
|
//
|
|
#define HET_MSG_NUMHOSTED 1
|
|
|
|
|
|
//
|
|
// HETPACKET hostState values
|
|
//
|
|
#define HET_NOTHOSTING 0
|
|
#define HET_APPSSHARED 0x0001 // Packet only
|
|
#define HET_DESKTOPSHARED 0xFFFF // Packet and per-person data
|
|
|
|
|
|
|
|
//
|
|
// DT_IM
|
|
// Input events
|
|
//
|
|
|
|
//
|
|
// This is the base keyboard event (IM_TYPE_ASCII, IM_TYPE_VK1,
|
|
// IM_TYPE_VK2). Future keyboard events may append extra fields. The
|
|
// flags defined in the base keyboard event must be set to reasonable
|
|
// values in all future keyboard events.
|
|
//
|
|
// flags:
|
|
//
|
|
// bit 0-6: unused (available for future keyboard events)
|
|
// bit 7: Secondary key (unused).
|
|
// bit 8: SET - extended key, RESET - normal key
|
|
// bit 9-11: unused (available for future keyboard events)
|
|
// bit 12: SET - when replayed this key stroke should NOT cause
|
|
// anything to happen
|
|
// bit 13: reserved - this flag is not part of the protocol and is
|
|
// never sent. It is used internally by IEM when processing received
|
|
// packets.
|
|
// bit 14: SET - previously down, RESET previously up
|
|
// bit 15: SET - key release, RESET key press
|
|
//
|
|
//
|
|
typedef struct tagIMKEYBOARD
|
|
{
|
|
TSHR_UINT16 flags;
|
|
TSHR_UINT16 keyCode;
|
|
}
|
|
IMKEYBOARD;
|
|
typedef IMKEYBOARD * PIMKEYBOARD;
|
|
|
|
|
|
//
|
|
// IMKEYBOARD flags values
|
|
//
|
|
#define IM_FLAG_KEYBOARD_RIGHT 0x0001
|
|
#define IM_FLAG_KEYBOARD_UPDATESTATE 0x0002 // not sent; just internal
|
|
#define IM_FLAG_KEYBOARD_SECONDARY 0x0080
|
|
#define IM_FLAG_KEYBOARD_EXTENDED 0x0100
|
|
#define IM_FLAG_KEYBOARD_QUIET 0x1000
|
|
#define IM_FLAG_KEYBOARD_ALT_DOWN 0x2000
|
|
#define IM_FLAG_KEYBOARD_DOWN 0x4000
|
|
#define IM_FLAG_KEYBOARD_RELEASE 0x8000
|
|
|
|
//
|
|
// This is the base mouse event (IM_TYPE_3BUTTON). Future mouse events
|
|
// may append extra fields but they must include all the fields in the
|
|
// base mouse event and these must be set to reasonable values.
|
|
//
|
|
// flags:
|
|
//
|
|
// bit 0-8: ignored by old systems
|
|
// new systems: signed wheel rotation amount if bit 9 set
|
|
// bit 9: ignored by old systems
|
|
// new systems: SET - wheel rotate, RESET - other event
|
|
// (takes precedent over bit 11 - mouse move)
|
|
//
|
|
// bit 10: SET - double click, RESET - single click
|
|
// bit 11: SET - mouse move (ignore bits 9,10, 12-15), RESET - mouse
|
|
// action
|
|
// bit 12: SET - button 1 (left button)
|
|
// bit 13: SET - button 2 (right button)
|
|
// bit 14: SET - button 3 (middle button)
|
|
// bit 15: SET - button press, RESET - button release
|
|
//
|
|
//
|
|
typedef struct tagIMMOUSE
|
|
{
|
|
TSHR_UINT16 flags;
|
|
TSHR_INT16 x;
|
|
TSHR_INT16 y;
|
|
}
|
|
IMMOUSE;
|
|
typedef IMMOUSE * PIMMOUSE;
|
|
|
|
|
|
//
|
|
// IMMOUSE flags values
|
|
//
|
|
#define IM_FLAG_MOUSE_WHEEL 0x0200
|
|
#define IM_FLAG_MOUSE_DIRECTION 0x0100
|
|
#define IM_FLAG_MOUSE_ROTATION_MASK 0x01FF
|
|
#define IM_FLAG_MOUSE_DOUBLE 0x0400
|
|
#define IM_FLAG_MOUSE_MOVE 0x0800
|
|
#define IM_FLAG_MOUSE_BUTTON1 0x1000
|
|
#define IM_FLAG_MOUSE_BUTTON2 0x2000
|
|
#define IM_FLAG_MOUSE_BUTTON3 0x4000
|
|
#define IM_FLAG_MOUSE_DOWN 0x8000
|
|
|
|
|
|
typedef struct tagIMEVENT
|
|
{
|
|
TSHR_UINT32 timeMS;
|
|
TSHR_UINT16 type;
|
|
union
|
|
{
|
|
IMKEYBOARD keyboard;
|
|
IMMOUSE mouse;
|
|
}
|
|
data;
|
|
}
|
|
IMEVENT;
|
|
typedef IMEVENT * PIMEVENT;
|
|
typedef IMEVENT FAR * LPIMEVENT;
|
|
|
|
|
|
//
|
|
// IMEVENT type values
|
|
//
|
|
#define IM_TYPE_SYNC 0x0000 // OBSOLETE 2.X
|
|
#define IM_TYPE_ASCII 0x0001
|
|
#define IM_TYPE_VK1 0x0002
|
|
#define IM_TYPE_VK2 0x0003
|
|
#define IM_TYPE_3BUTTON 0x8001
|
|
|
|
|
|
typedef struct tagIMPACKET
|
|
{
|
|
S20DATAPACKET header;
|
|
|
|
TSHR_UINT16 numEvents;
|
|
TSHR_UINT16 padding;
|
|
IMEVENT aEvents[1];
|
|
}
|
|
IMPACKET;
|
|
typedef IMPACKET * PIMPACKET;
|
|
typedef IMPACKET FAR * LPIMPACKET;
|
|
|
|
|
|
|
|
|
|
//
|
|
// DT_UP
|
|
// Update packet (orders, screen data, palettes)
|
|
//
|
|
|
|
|
|
typedef struct tagUPPACKETHEADER
|
|
{
|
|
S20DATAPACKET header;
|
|
|
|
TSHR_UINT16 updateType;
|
|
TSHR_UINT16 padding;
|
|
}
|
|
UPPACKETHEADER;
|
|
typedef UPPACKETHEADER * PUPPACKETHEADER;
|
|
|
|
|
|
|
|
|
|
//
|
|
// UPPACKETHEADER updateType values
|
|
//
|
|
#define UPD_ORDERS 0
|
|
#define UPD_SCREEN_DATA 1
|
|
#define UPD_PALETTE 2
|
|
#define UPD_SYNC 3
|
|
|
|
|
|
//
|
|
// UPD_ORDERS
|
|
//
|
|
typedef struct tagORDPACKET
|
|
{
|
|
UPPACKETHEADER header;
|
|
|
|
TSHR_UINT16 cOrders;
|
|
TSHR_UINT16 sendBPP;
|
|
BYTE data[1];
|
|
}
|
|
ORDPACKET;
|
|
typedef ORDPACKET * PORDPACKET;
|
|
|
|
|
|
|
|
|
|
//
|
|
// UPD_SCREEN_DATA
|
|
//
|
|
// Bitmap packet contains bitmap image of window changes made by a shared
|
|
// application. These packets are sent when a screen update occurs that
|
|
// can not be sent as an order. The structure contains the following
|
|
// fields:
|
|
//
|
|
// winID - window handle of the shared window from which the update came
|
|
// position - virtual desktop position of the update
|
|
// realWidth - width of update bitmap
|
|
// realHeight - height of update bitmap
|
|
// format - bits per pel of update bitmap
|
|
// dataSize - size in bytes of following bitmap data
|
|
// firstData - first byte in array of bytes that contains the bitmap
|
|
//
|
|
// Note that the realWidth is not always the same as the width of the
|
|
// update as given by the position field rectangle. This is because a
|
|
// number of fixed size cached bitmaps are used for speed when generating
|
|
// the update packets. The bitmap data (firstData onwards) should be
|
|
// set into a bitmap of realWidth, realHeight dimensions by the receiver
|
|
// and then the appropriate portion blted to the desired destination
|
|
// determined by the position rectangle. The valid portion of the bitmap
|
|
// always starts 0,0 within the bitmap.
|
|
//
|
|
typedef struct tagSDPACKET
|
|
{
|
|
UPPACKETHEADER header;
|
|
|
|
TSHR_RECT16 position;
|
|
TSHR_UINT16 realWidth;
|
|
TSHR_UINT16 realHeight;
|
|
TSHR_UINT16 format;
|
|
TSHR_UINT16 compressed;
|
|
TSHR_UINT16 dataSize;
|
|
BYTE data[1];
|
|
}
|
|
SDPACKET;
|
|
typedef SDPACKET * PSDPACKET;
|
|
|
|
|
|
|
|
|
|
//
|
|
// UPD_PALETTE
|
|
//
|
|
// Palette packet. This is sent before any SDPACKETS to define the
|
|
// colors in the bitmap data. The fields are as follows:
|
|
//
|
|
// numColors - the number of colors in the palette
|
|
// firstColor - the first entry in an array of TSHR_COLORs
|
|
//
|
|
// The TSHR_COLOR structures are 3 bytes long (r,g,b) and are NOT padded.
|
|
//
|
|
//
|
|
typedef struct tagPMPACKET
|
|
{
|
|
UPPACKETHEADER header;
|
|
|
|
TSHR_UINT32 numColors;
|
|
TSHR_COLOR aColors[1];
|
|
}
|
|
PMPACKET;
|
|
typedef PMPACKET * PPMPACKET;
|
|
|
|
|
|
|
|
//
|
|
// UPD_SYNC
|
|
//
|
|
typedef struct tagUPSPACKET
|
|
{
|
|
UPPACKETHEADER header;
|
|
}
|
|
UPSPACKET;
|
|
typedef UPSPACKET * PUPSPACKET;
|
|
|
|
|
|
|
|
|
|
//
|
|
// DT_SNI
|
|
// Share controller packet
|
|
//
|
|
|
|
typedef struct tagSNIPACKET
|
|
{
|
|
S20DATAPACKET header;
|
|
|
|
TSHR_UINT16 message;
|
|
TSHR_UINT16 destination;
|
|
}
|
|
SNIPACKET;
|
|
typedef SNIPACKET * PSNIPACKET;
|
|
|
|
|
|
|
|
//
|
|
// SNIPACKET message values
|
|
//
|
|
#define SNI_MSG_SYNC 1
|
|
|
|
//
|
|
// For a SNI_MSG_SYNC,
|
|
// The network ID of the destination (all syncs are broadcast
|
|
// and discarded at the destination if they are not for the
|
|
// destination).
|
|
//
|
|
|
|
|
|
|
|
|
|
//
|
|
// DT_SWL
|
|
// Shared window list packet
|
|
//
|
|
|
|
#define SWL_MAX_WINDOW_TITLE_SEND 50
|
|
#define SWL_MAX_NONRECT_SIZE 10240
|
|
|
|
//
|
|
// Structures used to define the window structure (Z-order and
|
|
// position).
|
|
//
|
|
typedef struct tagSWLWINATTRIBUTES
|
|
{
|
|
UINT_PTR winID;
|
|
//
|
|
// The window ID for shared windows - otherwise 0. Note that
|
|
// this is the window ID on the machine hosting the application
|
|
// even for view frames.
|
|
//
|
|
TSHR_UINT32 extra;
|
|
//
|
|
// Extra information for the window. The contents depend on
|
|
// the flags.
|
|
//
|
|
// For SWL_FLAG_WINDOW_HOSTED this contains the appID of the
|
|
// application which owns the window.
|
|
//
|
|
// For SWL_FLAG_WINDOW_SHADOW this contains the person ID of
|
|
// the party which is hosting the app
|
|
//
|
|
// For SWL_FLAG_WINDOW_LOCAL this entry is 0.
|
|
//
|
|
TSHR_UINT32 ownerWinID;
|
|
//
|
|
// The window ID of the owner of this window. Only valid for
|
|
// shared, hosted windows. NULL is a valid owner ID.
|
|
//
|
|
TSHR_UINT32 flags;
|
|
//
|
|
// Flags describing window
|
|
//
|
|
// SWL_FLAG_WINDOW_MINIMIZED
|
|
// SWL_FLAG_WINDOW_TAGGABLE
|
|
// SWL_FLAG_WINDOW_HOSTED
|
|
// SWL_FLAG_WINDOW_SHADOW
|
|
// SWL_FLAG_WINDOW_LOCAL
|
|
// SWL_FLAG_WINDOW_TOPMOST
|
|
//
|
|
// SWL_FLAG_WINDOW_TASKBAR - window appears on Win95 task bar
|
|
// SWL_FLAG_WINDOW_NOTASKBAR - window not on Win95 task bar
|
|
//
|
|
// (SWL_FLAG_WINDOW_TRANSPARENT - this is not sent but is used
|
|
// during the creation of the packet)
|
|
//
|
|
#define SWL_FLAG_WINDOW_MINIMIZED 0x00000001
|
|
#define SWL_FLAG_WINDOW_TAGGABLE 0x00000002
|
|
#define SWL_FLAG_WINDOW_HOSTED 0x00000004
|
|
#define SWL_FLAG_WINDOW_LOCAL 0x00000010
|
|
#define SWL_FLAG_WINDOW_TOPMOST 0x00000020
|
|
|
|
//
|
|
// New for NM 1.0, non-R11
|
|
//
|
|
#define SWL_FLAG_WINDOW_TASKBAR 0x00010000
|
|
#define SWL_FLAG_WINDOW_NOTASKBAR 0x00020000
|
|
#define SWL_FLAG_WINDOW_TRANSPARENT 0x40000000
|
|
|
|
//
|
|
// New for NM 2.0
|
|
//
|
|
#define SWL_FLAG_WINDOW_NONRECTANGLE 0x00040000
|
|
|
|
//
|
|
// Obsolete in NM 3.0
|
|
// These were used at some point in backlevel versions.
|
|
// If you reuse these bits, DO A LOT OF INTEROP TESTING.
|
|
//
|
|
#define SWL_FLAG_WINDOW_SHADOW 0x00000008
|
|
#define SWL_FLAG_WINDOW_DESKTOP 0x00080000
|
|
#define SWL_FLAG_WINDOW_REQD 0x80000000
|
|
|
|
//
|
|
// NM 3.0 INTERNAL only; not transmitted
|
|
//
|
|
#define SWL_FLAG_INTERNAL_SEEN 0x000001000
|
|
|
|
//
|
|
// These are valid to SEND in a packet or PROCESS when RECEIVED
|
|
//
|
|
#define SWL_FLAGS_VALIDPACKET \
|
|
(SWL_FLAG_WINDOW_MINIMIZED | \
|
|
SWL_FLAG_WINDOW_TAGGABLE | \
|
|
SWL_FLAG_WINDOW_HOSTED | \
|
|
SWL_FLAG_WINDOW_TOPMOST | \
|
|
SWL_FLAG_WINDOW_TASKBAR | \
|
|
SWL_FLAG_WINDOW_NONRECTANGLE | \
|
|
SWL_FLAG_WINDOW_SHADOW)
|
|
|
|
TSHR_RECT16 position;
|
|
//
|
|
// The bounding rectangle of the window in inclusive virtual
|
|
// desktop coordinates.
|
|
//
|
|
}
|
|
SWLWINATTRIBUTES;
|
|
typedef SWLWINATTRIBUTES *PSWLWINATTRIBUTES;
|
|
|
|
|
|
//
|
|
// The SWL packet consists of an array of SWLWINATTRIBUTES structures,
|
|
// followed by some variable length string data (the window titles)
|
|
// followed by zero or more, word aligned, additional chunks of data.
|
|
//
|
|
// The only currently defined chunk is for the non-rectangular window
|
|
// data.
|
|
//
|
|
typedef struct
|
|
{
|
|
TSHR_UINT16 size;
|
|
//
|
|
// Total size in bytes of this chunk
|
|
//
|
|
TSHR_UINT16 idChunk;
|
|
//
|
|
// An identifier for the contents of this chunk.
|
|
//
|
|
#define SWL_PACKET_ID_NONRECT 0x524e // "NR"
|
|
}
|
|
SWLPACKETCHUNK;
|
|
typedef SWLPACKETCHUNK * PSWLPACKETCHUNK;
|
|
|
|
|
|
|
|
typedef struct tagSWLPACKET
|
|
{
|
|
S20DATAPACKET header;
|
|
|
|
TSHR_UINT16 msg; // ONLY ONE VALUE FOR MSG; MAKE MORE STRUCTS IF ADDED
|
|
TSHR_UINT16 flags;
|
|
TSHR_UINT16 numWindows;
|
|
TSHR_UINT16 tick;
|
|
TSHR_UINT16 token;
|
|
TSHR_UINT16 reserved;
|
|
SWLWINATTRIBUTES aWindows[1];
|
|
|
|
//
|
|
// The last SWLWINATTRIBUTES structure is followed by the
|
|
// window title data. This is made up as follows.
|
|
//
|
|
// For each window which is a window from a shared, hosted
|
|
// application (ie winID and appID are non-zero) #either -
|
|
//
|
|
// (char)0xFF - not a `task window' - give it a NULL title
|
|
// or -
|
|
// a null terminated string up to MAX_WINDOW_TITLE_SEND
|
|
// characters
|
|
//
|
|
// The titles appear in the same order as the corresponding
|
|
// windows in the SWLWINSTRUCTURE.
|
|
//
|
|
|
|
//
|
|
// The last TITLE is followed by the regional data,
|
|
// SWLPACKETCHUNK, if there is any. One for each NONRECT window in
|
|
// the list.
|
|
//
|
|
}
|
|
SWLPACKET;
|
|
typedef SWLPACKET *PSWLPACKET;
|
|
|
|
|
|
|
|
|
|
//
|
|
// SWLPACKET msg values
|
|
//
|
|
#define SWL_MSG_WINSTRUCT 1
|
|
|
|
|
|
//
|
|
// SWLPACKET flags values
|
|
//
|
|
#define SWL_FLAG_STATE_SYNCING 0x0001
|
|
|
|
|
|
#endif // _H_T_SHARE
|
|
|