able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/enduser/netmeeting/as/h/t_share.h

3636 lines
99 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//
// 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
Reference in a new issue Copy permalink