2290 lines
89 KiB
C++
2290 lines
89 KiB
C++
/****************************************************************************/
|
|
// uh.h
|
|
//
|
|
// Update Handler Class
|
|
//
|
|
// Copyright (C) 1997-1999 Microsoft Corporation
|
|
/****************************************************************************/
|
|
|
|
#ifndef _H_UH_
|
|
#define _H_UH_
|
|
|
|
extern "C" {
|
|
#include <adcgdata.h>
|
|
}
|
|
|
|
#include "fs.h"
|
|
#include "op.h"
|
|
#include "or.h"
|
|
#include "gh.h"
|
|
#include "ih.h"
|
|
|
|
#include "objs.h"
|
|
#include "cd.h"
|
|
|
|
#ifdef OS_WINCE
|
|
#include <ceconfig.h>
|
|
#endif
|
|
|
|
#include "tscerrs.h"
|
|
|
|
//USE Mem mapped file for bitmap cache
|
|
//#define VM_BMPCACHE 1
|
|
|
|
class CSL;
|
|
class COD;
|
|
class CUI;
|
|
class CCC;
|
|
|
|
#define TRC_GROUP TRC_GROUP_CORE
|
|
#define TRC_FILE "uh"
|
|
#define TSC_HR_FILEID TSC_HR_UH_H
|
|
|
|
typedef struct tagUH_ORDER
|
|
{
|
|
RECT dstRect;
|
|
BYTE orderData[1];
|
|
} UH_ORDER, FAR *PUH_ORDER;
|
|
|
|
typedef UH_ORDER UNALIGNED FAR *PUH_ORDER_UA;
|
|
#define UH_ORDER_HEADER_SIZE (FIELDOFFSET(UH_ORDER, orderData))
|
|
|
|
extern const UINT16 uhWindowsROPs[256];
|
|
|
|
/****************************************************************************/
|
|
/* Number of glyph caches. */
|
|
/****************************************************************************/
|
|
#define UH_GLC_NUM_CACHES 10
|
|
|
|
/****************************************************************************/
|
|
/* Number of entries in the color table cache. */
|
|
/****************************************************************************/
|
|
#define UH_COLOR_TABLE_CACHE_ENTRIES 6
|
|
|
|
/****************************************************************************/
|
|
/* Save Bitmap constants */
|
|
/****************************************************************************/
|
|
#define UH_SAVE_BITMAP_WIDTH 480
|
|
#define UH_SAVE_BITMAP_HEIGHT 480
|
|
#define UH_SAVE_BITMAP_SIZE ((DCUINT32)UH_SAVE_BITMAP_WIDTH * \
|
|
(DCUINT32)UH_SAVE_BITMAP_HEIGHT)
|
|
#define UH_SAVE_BITMAP_X_GRANULARITY 1
|
|
#define UH_SAVE_BITMAP_Y_GRANULARITY 20
|
|
|
|
|
|
// Cache IDs have a protocol-implicit cell size, starting from 256 and
|
|
// increasing in factors of 4. Scale by the bit depth.
|
|
#ifdef DC_HICOLOR
|
|
#define UH_CellSizeFromCacheID(_id) \
|
|
((TS_BITMAPCACHE_0_CELL_SIZE << (2 * (_id))) * _UH.copyMultiplier)
|
|
|
|
#define UH_CellSizeFromCacheIDAndMult(_id,mult) \
|
|
((TS_BITMAPCACHE_0_CELL_SIZE << (2 * (_id))) * mult)
|
|
|
|
#define UH_PropVirtualCacheSizeFromMult(mult) \
|
|
(_UH.PropBitmapVirtualCacheSize[mult-1])
|
|
#else
|
|
#define UH_CellSizeFromCacheID(_id) \
|
|
(TS_BITMAPCACHE_0_CELL_SIZE << (2 * (_id)))
|
|
#endif
|
|
|
|
// Tile sizes are also protocol-implied and dependent on the cache ID,
|
|
// starting at 16 per side and increasing in powers of two in each dimension.
|
|
#define UH_CACHE_0_DIMENSION 16
|
|
|
|
|
|
|
|
//
|
|
// From wuhint.h
|
|
//
|
|
|
|
#define UH_NUM_8BPP_PAL_ENTRIES 256
|
|
#define UH_LOGPALETTE_VERSION 0x300
|
|
#define UH_LAST_PAL_ENTRY (UH_NUM_8BPP_PAL_ENTRIES-1)
|
|
#define UH_NUM_SYSTEM_COLORS 20
|
|
|
|
#define UH_COLOR_RGB 0
|
|
#define UH_COLOR_PALETTE 1
|
|
|
|
#define UH_RGB_BLACK RGB(0x00, 0x00, 0x00)
|
|
#define UH_RGB_RED RGB(0xFF, 0x00, 0x00)
|
|
#define UH_RGB_GREEN RGB(0x00, 0xFF, 0x00)
|
|
#define UH_RGB_BLUE RGB(0x00, 0x00, 0xFF)
|
|
#define UH_RGB_MAGENTA RGB(0xFF, 0x00, 0xFF)
|
|
#define UH_RGB_CYAN RGB(0x00, 0xFF, 0xFF)
|
|
#define UH_RGB_YELLOW RGB(0xFF, 0xFF, 0x00)
|
|
#define UH_RGB_WHITE RGB(0xFF, 0xFF, 0xFF)
|
|
|
|
#define UH_BRUSHTYPE_FDIAGONAL 1
|
|
#define UH_BRUSHTYPE_DIAGCROSS 2
|
|
#define UH_BRUSHTYPE_HORIZONTAL 3
|
|
#define UH_BRUSHTYPE_VERTICAL 4
|
|
|
|
#define WM_RECALC_CELL_SPACING (WM_APP + 100)
|
|
|
|
|
|
/****************************************************************************/
|
|
// Size of the decompression buffer used for decompressing screen data.
|
|
// This is the maximum decompressed size the server will send.
|
|
/****************************************************************************/
|
|
#define UH_DECOMPRESSION_BUFFER_LENGTH 32000
|
|
|
|
|
|
/****************************************************************************/
|
|
// Min value configurable for the bitmap cache total size.
|
|
/****************************************************************************/
|
|
#define UH_BMC_LOW_THRESHOLD 150
|
|
|
|
|
|
/****************************************************************************/
|
|
/* Max and min values configurable for the glyph cache total size */
|
|
/****************************************************************************/
|
|
#define UH_GLC_LOW_THRESHOLD 50
|
|
#define UH_GLC_HIGH_THRESHOLD 2000
|
|
|
|
|
|
/****************************************************************************/
|
|
/* Glyph cache constants. */
|
|
/****************************************************************************/
|
|
// Warning: data sizes must be a power of 2
|
|
#define UH_GLC_CACHE_MAXIMUMCELLSIZE 2048
|
|
|
|
#define UH_GLC_CACHE_MINIMUMCELLCOUNT 16
|
|
#define UH_GLC_CACHE_MAXIMUMCELLCOUNT 254
|
|
|
|
|
|
/****************************************************************************/
|
|
/* Frag cache constants. */
|
|
/****************************************************************************/
|
|
// Warning: data sizes must be a power of 2
|
|
#define UH_FGC_CACHE_MAXIMUMCELLSIZE 256
|
|
#define UH_FGC_CACHE_MAXIMUMCELLCOUNT 256
|
|
|
|
|
|
/****************************************************************************/
|
|
// Offscreen cache constants
|
|
/****************************************************************************/
|
|
#define UH_OBC_LOW_CACHESIZE 512 // half MB
|
|
#define UH_OBC_HIGH_CACHESIZE 7680 // 7.5 MB
|
|
|
|
#define UH_OBC_LOW_CACHEENTRIES 50
|
|
#define UH_OBC_HIGH_CACHEENTRIES 500
|
|
|
|
#ifdef DRAW_GDIPLUS
|
|
#define UH_GDIP_LOW_CACHEENTRIES 2
|
|
#define UH_GDIP_HIGH_CACHEENTRIES 20
|
|
#endif
|
|
|
|
|
|
#ifdef DC_DEBUG
|
|
/****************************************************************************/
|
|
/* Bitmap Cache Monitor Window Class name. */
|
|
/****************************************************************************/
|
|
#define UH_BITMAP_CACHE_MONITOR_CLASS_NAME _T("BitmapCacheMonitorClass")
|
|
|
|
#define UH_CACHE_WINDOW_BORDER_WIDTH 20
|
|
#define UH_CACHE_BLOB_WIDTH 6
|
|
#define UH_CACHE_BLOB_HEIGHT 6
|
|
#define UH_CACHE_BLOB_SPACING 1
|
|
#define UH_INTER_CACHE_SPACING 20
|
|
#define UH_CACHE_TEXT_SPACING 5
|
|
|
|
#define UH_CACHE_BLOB_TOTAL_WIDTH \
|
|
(UH_CACHE_BLOB_WIDTH + UH_CACHE_BLOB_SPACING)
|
|
|
|
#define UH_CACHE_BLOB_TOTAL_HEIGHT \
|
|
(UH_CACHE_BLOB_HEIGHT + UH_CACHE_BLOB_SPACING)
|
|
|
|
#define UH_CACHE_FLASH_PERIOD 1000
|
|
|
|
#define UH_CACHE_DISPLAY_FONT_NAME _T("Comic Sans MS")
|
|
#define UH_CACHE_DISPLAY_FONT_SIZE 16
|
|
#define UH_CACHE_DISPLAY_FONT_WEIGHT FW_NORMAL
|
|
|
|
#define UH_CACHE_MONITOR_UPDATE_PERIOD 200
|
|
|
|
|
|
// Cache monitor entry states. Describes where the cache entry is.
|
|
#define UH_CACHE_STATE_UNUSED 0
|
|
#define UH_CACHE_STATE_IN_MEMORY 1
|
|
#define UH_CACHE_STATE_ON_DISK 2
|
|
|
|
#define UH_CACHE_NUM_STATES 3
|
|
|
|
// Cache monitor flash transitions transitions. Describes the temporary state
|
|
// of a displayed entry after an event has occurred. Each entry has an
|
|
// associated timestamp that determines when the transition flash will end.
|
|
// These should be ordered in importance, most important having higher numbers
|
|
// -- the more important events supersede other events in use of the timer.
|
|
#define UH_CACHE_TRANSITION_NONE 0
|
|
#define UH_CACHE_TRANSITION_TOUCHED 1
|
|
#define UH_CACHE_TRANSITION_EVICTED 2
|
|
#define UH_CACHE_TRANSITION_LOADED_FROM_DISK 3
|
|
#define UH_CACHE_TRANSITION_KEY_LOAD_ON_SESSION_START 4
|
|
#define UH_CACHE_TRANSITION_SERVER_UPDATE 5
|
|
|
|
#define UH_CACHE_NUM_TRANSITIONS 6
|
|
|
|
#endif /* DC_DEBUG */
|
|
|
|
|
|
typedef struct tagUHBITMAPINFOPALINDEX
|
|
{
|
|
// Set where the palette contains palette indices of 0..255.
|
|
BOOL bIdentityPalette;
|
|
|
|
// The following entries are used directly as a bitmap info header with
|
|
// embedded palette when doing blts.
|
|
BITMAPINFOHEADER hdr;
|
|
UINT16 paletteIndexTable[256];
|
|
} UHBITMAPINFOPALINDEX, FAR *PUHBITMAPINFOPALINDEX;
|
|
|
|
|
|
typedef struct tagUHCACHEDCOLORTABLE
|
|
{
|
|
RGBTRIPLE rgb[256];
|
|
} UHCACHEDCOLORTABLE, FAR *PUHCACHEDCOLORTABLE;
|
|
|
|
|
|
/****************************************************************************/
|
|
// Bitmap Cache Definitions
|
|
/****************************************************************************/
|
|
#define CACHE_DIRECTORY_NAME _T("cache\\")
|
|
|
|
// This value should be 13 for 8.3 file name and \0, additional 2 is for legacy
|
|
// purpose. Old cache structure contains cacheId\ as subcache directory name.
|
|
// We can remove 2 if we don't need to support Win2000 Beta3.
|
|
#define CACHE_FILENAME_LENGTH 15
|
|
|
|
|
|
typedef struct tagUHBITMAPINFO
|
|
{
|
|
UINT32 Key1, Key2;
|
|
UINT16 bitmapWidth;
|
|
UINT16 bitmapHeight;
|
|
UINT32 bitmapLength;
|
|
} UHBITMAPINFO, FAR *PUHBITMAPINFO;
|
|
|
|
// File Header for bitmap file used in persistent bitmap caching
|
|
typedef struct tagUHBITMAPFILEHDR
|
|
{
|
|
UHBITMAPINFO bmpInfo;
|
|
|
|
UINT32 bmpVersion : 3;
|
|
UINT32 bCompressed : 1;
|
|
UINT32 bNoBCHeader : 1; // add new flag to indicate if the compressed
|
|
// bitmap data contains BC header or not
|
|
UINT32 pad : 27;
|
|
} UHBITMAPFILEHDR, FAR *PUHBITMAPFILEHDR;
|
|
|
|
// Information maintained for each bitmap cache
|
|
typedef struct tagUHBITMAPCACHEINFO
|
|
{
|
|
UINT32 NumVirtualEntries;
|
|
UINT32 NumEntries : 31;
|
|
UINT32 bSendBitmapKeys : 1;
|
|
#ifdef DC_HICOLOR
|
|
UINT32 OrigNumEntries;
|
|
UINT32 MemLen;
|
|
#endif
|
|
} UHBITMAPCACHEINFO, FAR *PUHBITMAPCACHEINFO;
|
|
|
|
#ifdef DC_DEBUG
|
|
// Used to hold bitmap cache monitor information in debug builds.
|
|
typedef struct {
|
|
BYTE ColorTable;
|
|
BYTE State : 2;
|
|
BYTE FlashTransition : 6;
|
|
unsigned UsageCount;
|
|
UINT32 EventTime;
|
|
} UH_CACHE_MONITOR_ENTRY_DATA;
|
|
#endif
|
|
|
|
// Bitmap cache entry definitions
|
|
// The fields in UHBITMAPCACHEENTRYHDR are of explicit length deliberately
|
|
// to ensure 16 and 32 bit client match and to help force the cache entry
|
|
// header sizes to be powers of two.
|
|
typedef struct tagUHBITMAPCACHEENTRYHDR
|
|
{
|
|
UINT16 bitmapWidth;
|
|
UINT16 bitmapHeight;
|
|
UINT32 bitmapLength : 31;
|
|
UINT32 hasData : 1;
|
|
} UHBITMAPCACHEENTRYHDR, FAR *PUHBITMAPCACHEENTRYHDR,
|
|
DCHPTR HPUHBITMAPCACHEENTRYHDR;
|
|
|
|
// bitmap cache file info
|
|
typedef struct tagUHCACHEFILEINFO
|
|
{
|
|
HANDLE hCacheFile;
|
|
#ifdef VM_BMPCACHE
|
|
LPBYTE pMappedView;
|
|
#endif
|
|
} UHCACHEFILEINFO, FAR *PUHCACHEFILEINFO;
|
|
|
|
// Doubly Linked List Node - Used to maintain MRU list
|
|
typedef struct tagUHCHAIN
|
|
{
|
|
UINT32 next;
|
|
UINT32 prev;
|
|
} UHCHAIN, FAR *PUHCHAIN;
|
|
|
|
typedef TS_BITMAPCACHE_PERSISTENT_LIST_ENTRY DCHPTR HPTS_BITMAPCACHE_PERSISTENT_LIST_ENTRY;
|
|
|
|
// Bitmap Virtual Cache Page Table Entry
|
|
// We need 3 pad here to make sure the struct size be power of two
|
|
// This is required for huge memory allocation in Win16
|
|
typedef struct tagUHBITMAPCACHEPTE
|
|
{
|
|
UHCHAIN mruList;
|
|
UINT32 iEntryToMem;
|
|
TS_BITMAPCACHE_PERSISTENT_LIST_ENTRY bmpInfo;
|
|
|
|
} UHBITMAPCACHEPTE, FAR *PUHBITMAPCACHEPTE, DCHPTR HPUHBITMAPCACHEPTE;
|
|
|
|
// Bitmap Virtual Cache Page Table
|
|
typedef struct tagUHBITMAPCACHEPAGETABLE
|
|
{
|
|
UINT32 MRUHead;
|
|
UINT32 MRUTail;
|
|
UINT32 FreeMemList;
|
|
UHCACHEFILEINFO CacheFileInfo;
|
|
HPUHBITMAPCACHEPTE PageEntries;
|
|
} UHBITMAPCACHEPAGETABLE, FAR *PUHBITMAPCACHEPAGETABLE;
|
|
|
|
// Bitmap physical memory caches
|
|
typedef struct tagUHBITMAPCACHE
|
|
{
|
|
UHBITMAPCACHEINFO BCInfo;
|
|
HPUHBITMAPCACHEENTRYHDR Header;
|
|
BYTE DCHPTR Entries;
|
|
UHBITMAPCACHEPAGETABLE PageTable;
|
|
} UHBITMAPCACHE;
|
|
|
|
|
|
/****************************************************************************/
|
|
/* Brush cache entry definitions */
|
|
/****************************************************************************/
|
|
typedef struct tagUHBRUSHCACHEHDR
|
|
{
|
|
BYTE iBitmapFormat;
|
|
BYTE cx;
|
|
BYTE cy;
|
|
BYTE iBytes;
|
|
} UHBRUSHCACHEHDR, FAR *PUHBRUSHCACHEHDR;
|
|
|
|
#define UH_MAX_MONO_BRUSHES 64
|
|
#define UH_MONO_BRUSH_SIZE 16
|
|
#define UH_COLOR_BRUSH_SIZE 64
|
|
|
|
#ifdef DC_HICOLOR
|
|
#define UH_COLOR_BRUSH_SIZE_16 128
|
|
#define UH_COLOR_BRUSH_SIZE_24 192
|
|
#endif
|
|
|
|
typedef struct tagUHMONOBRUSHCACHE
|
|
{
|
|
UHBRUSHCACHEHDR hdr;
|
|
BYTE data[UH_MONO_BRUSH_SIZE];
|
|
} UHMONOBRUSHCACHE, FAR *PUHMONOBRUSHCACHE;
|
|
|
|
typedef struct tagUHCOLORBRUSHINFO
|
|
{
|
|
BITMAPINFO bmi;
|
|
RGBQUAD rgbQuadTable[UH_NUM_8BPP_PAL_ENTRIES - 1];
|
|
BYTE bytes[UH_COLOR_BRUSH_SIZE];
|
|
HBRUSH hLastBrush;
|
|
} UHCOLORBRUSHINFO, *PUHCOLORBRUSHINFO;
|
|
|
|
#ifdef DC_HICOLOR
|
|
// We only need enough color table entries for the red, green blue bit masks
|
|
// used in 16bpp sessions.
|
|
// Note that we make this big enough to use for 15/16 and 24bpp brushes
|
|
typedef struct tagUHHICOLORBRUSHINFO
|
|
{
|
|
BITMAPINFOHEADER bmiHeader;
|
|
RGBQUAD bmiColors[3];
|
|
BYTE bytes[UH_COLOR_BRUSH_SIZE_24];
|
|
HBRUSH hLastBrush;
|
|
} UHHICOLORBRUSHINFO, FAR *PUHHICOLORBRUSHINFO;
|
|
#endif
|
|
|
|
|
|
#define UH_MAX_COLOR_BRUSHES 64
|
|
|
|
#ifdef DC_HICOLOR // Need enough space for a 24bpp brush
|
|
typedef struct tagUHCOLORBRUSHCACHE
|
|
{
|
|
UHBRUSHCACHEHDR hdr;
|
|
BYTE data[UH_COLOR_BRUSH_SIZE_24];
|
|
} UHCOLORBRUSHCACHE, FAR *PUHCOLORBRUSHCACHE;
|
|
#else
|
|
typedef struct tagUHCOLORBRUSHCACHE
|
|
{
|
|
UHBRUSHCACHEHDR hdr;
|
|
BYTE data[UH_COLOR_BRUSH_SIZE];
|
|
} UHCOLORBRUSHCACHE, FAR *PUHCOLORBRUSHCACHE;
|
|
#endif
|
|
|
|
|
|
/****************************************************************************/
|
|
/* Glyph cache entry definitions */
|
|
/****************************************************************************/
|
|
typedef struct tagUHGLYPHCACHEENTRYHDR
|
|
{
|
|
INT32 x;
|
|
INT32 y;
|
|
UINT32 cx;
|
|
UINT32 cy;
|
|
UINT32 unicode;
|
|
} UHGLYPHCACHEENTRYHDR, FAR *PUHGLYPHCACHEENTRYHDR,
|
|
DCHPTR HPUHGLYPHCACHEENTRYHDR;
|
|
|
|
typedef struct tagUHGLYPHCACHE
|
|
{
|
|
HPUHGLYPHCACHEENTRYHDR pHdr;
|
|
UINT32 cbEntrySize;
|
|
BYTE DCHPTR pData;
|
|
UINT32 cbUseCount;
|
|
} UHGLYPHCACHE, FAR *PUHGLYPHCACHE, DCHPTR HPUHGLYPHCACHE;
|
|
|
|
|
|
/****************************************************************************/
|
|
/* Frag cache entry definitions */
|
|
/****************************************************************************/
|
|
typedef struct tagUHFRAGCACHEENTRYHDR
|
|
{
|
|
UINT32 cbFrag;
|
|
INT32 cacheId;
|
|
} UHFRAGCACHEENTRYHDR, FAR *PUHFRAGCACHEENTRYHDR,
|
|
DCHPTR HPUHFRAGCACHEENTRYHDR;
|
|
|
|
typedef struct tagUHFRAGCACHE
|
|
{
|
|
HPUHFRAGCACHEENTRYHDR pHdr;
|
|
UINT32 cbEntrySize;
|
|
BYTE DCHPTR pData;
|
|
} UHFRAGCACHE, FAR *PUHFRAGCACHE, DCHPTR HPUHFRAGCACHE;
|
|
|
|
|
|
/****************************************************************************/
|
|
// Offscreen bitmap cache
|
|
/****************************************************************************/
|
|
typedef struct tagUHOFFSCRBITMAPCACHE
|
|
{
|
|
HBITMAP offscrBitmap;
|
|
UINT32 cx;
|
|
UINT32 cy;
|
|
} UHOFFSCRBITMAPCACHE, FAR *PUHOFFSCRBITMAPCACHE, DCHPTR HPUHOFFSCRBITMAPCACHE;
|
|
|
|
#ifdef DRAW_NINEGRID
|
|
/****************************************************************************/
|
|
// DrawNineGrid bitmap cache
|
|
/****************************************************************************/
|
|
typedef struct tagUHDRAWNINEGRIDBITMAPCACHE
|
|
{
|
|
HBITMAP drawNineGridBitmap;
|
|
UINT32 cx;
|
|
UINT32 cy;
|
|
UINT32 bitmapBpp;
|
|
TS_NINEGRID_BITMAP_INFO dngInfo;
|
|
} UHDRAWSTREAMBITMAPCACHE, FAR *PUHDRAWSTREAMBITMAPCACHE;
|
|
|
|
#ifdef DRAW_GDIPLUS
|
|
/****************************************************************************/
|
|
// Gdiplus object cache
|
|
/****************************************************************************/
|
|
typedef struct tagUHGDIPLUSOBJECTCACHE
|
|
{
|
|
UINT32 CacheSize;
|
|
BYTE * CacheData;
|
|
} UHGDIPLUSOBJECTCACHE, FAR *PUHGDIPLUSOBJECTCACHE;
|
|
|
|
typedef struct tagUHGDIPLUSIMAGECACHE
|
|
{
|
|
UINT32 CacheSize;
|
|
UINT16 ChunkNum;
|
|
INT16 *CacheDataIndex;
|
|
} UHGDIPLUSIMAGECACHE, FAR *PUHGDIPLUSIMAGECACHE;
|
|
#endif
|
|
|
|
|
|
typedef BOOL (FNGDI_DRAWSTREAM)(HDC, ULONG, VOID*);
|
|
|
|
#endif
|
|
|
|
#define UHROUNDUP(val, granularity) \
|
|
((((val)+((granularity) - 1)) / (granularity)) * (granularity))
|
|
|
|
#define UH_IS_SYSTEM_COLOR_INDEX(i) \
|
|
((i < (UH_NUM_SYSTEM_COLORS / 2)) || \
|
|
(i > (UH_LAST_PAL_ENTRY - (UH_NUM_SYSTEM_COLORS / 2))))
|
|
|
|
#define UH_TWEAK_COLOR_COMPONENT(colorComponent) \
|
|
if ((colorComponent) == 0) \
|
|
{ \
|
|
(colorComponent)++; \
|
|
} \
|
|
else \
|
|
{ \
|
|
(colorComponent)--; \
|
|
}
|
|
|
|
#define TSRECT16_TO_RECTL(dst, src) \
|
|
(dst).left = (src).left; \
|
|
(dst).top = (src).top; \
|
|
(dst).right = (src).right; \
|
|
(dst).bottom = (src).bottom;
|
|
|
|
#define TSPOINT16_TO_POINTL(dst, src) \
|
|
(dst).x = (src).x; \
|
|
(dst).y = (src).y;
|
|
|
|
/****************************************************************************/
|
|
// UH_DATA
|
|
/****************************************************************************/
|
|
typedef struct tagUH_DATA
|
|
{
|
|
#ifdef DC_LATENCY
|
|
unsigned fakeKeypressCount;
|
|
#endif /* DC_LATENCY */
|
|
HBITMAP hShadowBitmap;
|
|
HBITMAP hunusedBitmapForShadowDC;
|
|
HBITMAP hSaveScreenBitmap;
|
|
HBITMAP hunusedBitmapForSSBDC;
|
|
|
|
HDC hdcShadowBitmap;
|
|
HDC hdcOutputWindow;
|
|
HDC hdcDraw;
|
|
HDC hdcSaveScreenBitmap;
|
|
HDC hdcBrushBitmap;
|
|
|
|
BOOL usingDIBSection;
|
|
BOOL shadowBitmapRequested;
|
|
BOOL dedicatedTerminal;
|
|
unsigned drawThreshold;
|
|
|
|
UHBITMAPINFOPALINDEX bitmapInfo;
|
|
|
|
#ifdef DC_HICOLOR
|
|
unsigned DIBFormat;
|
|
unsigned copyMultiplier;
|
|
unsigned protocolBpp;
|
|
unsigned bitmapBpp;
|
|
unsigned shadowBitmapBpp;
|
|
#endif
|
|
BOOL shadowBitmapEnabled;
|
|
#ifdef DISABLE_SHADOW_IN_FULLSCREEN
|
|
BOOL DontUseShadowBitmap; // True: don't use shadow; False: use shadow
|
|
#endif
|
|
#ifdef OS_WINCE
|
|
BOOL paletteIsFixed;
|
|
#endif
|
|
HPALETTE hpalDefault;
|
|
HPALETTE hpalCurrent;
|
|
HWND hwndOutputWindow;
|
|
HRGN hrgnUpdate;
|
|
HRGN hrgnUpdateRect;
|
|
BOOL colorIndicesEnabled;
|
|
|
|
#ifdef DC_DEBUG
|
|
BOOL hatchBitmapPDUData;
|
|
BOOL hatchIndexPDUData;
|
|
BOOL hatchSSBOrderData;
|
|
BOOL hatchMemBltOrderData;
|
|
BOOL labelMemBltOrders;
|
|
#endif /* DC_DEBUG */
|
|
|
|
BYTE FAR *bitmapDecompressionBuffer;
|
|
unsigned bitmapDecompressionBufferSize;
|
|
|
|
/************************************************************************/
|
|
/* last used resource variables */
|
|
/************************************************************************/
|
|
COLORREF lastBkColor;
|
|
COLORREF lastTextColor;
|
|
int lastBkMode;
|
|
int lastROP2;
|
|
HDC lastHDC;
|
|
|
|
unsigned lastPenStyle;
|
|
unsigned lastPenWidth;
|
|
COLORREF lastPenColor;
|
|
COLORREF lastForeColor;
|
|
|
|
unsigned lastLogBrushStyle;
|
|
unsigned lastLogBrushHatch;
|
|
#if defined (OS_WINCE)
|
|
COLORREF lastLogBrushColorRef;
|
|
#else
|
|
DCCOLOR lastLogBrushColor;
|
|
#endif
|
|
BYTE lastLogBrushExtra[7];
|
|
|
|
#ifdef OS_WINCE
|
|
HDC hdcMemCached;
|
|
HBITMAP hBitmapCacheDIB;
|
|
PBYTE hBitmapCacheDIBits;
|
|
#endif
|
|
|
|
COLORREF lastBrushBkColor;
|
|
COLORREF lastBrushTextColor;
|
|
|
|
unsigned lastFillMode;
|
|
|
|
#ifdef DISABLE_SHADOW_IN_FULLSCREEN
|
|
BOOL fIsBBarVisible; // TRUE: visible, FALSE: invisible
|
|
RECT rectBBar;
|
|
|
|
#endif
|
|
|
|
/************************************************************************/
|
|
/* The following variables which describe the current clip rectangle */
|
|
/* are only valid if fRectReset is FALSE. If fRectReset is true then */
|
|
/* no clipping is in force. */
|
|
/************************************************************************/
|
|
BOOL rectReset;
|
|
int lastLeft;
|
|
int lastTop;
|
|
int lastRight;
|
|
int lastBottom;
|
|
|
|
#if defined (OS_WINCE)
|
|
HDC validClipDC;
|
|
HDC validBkColorDC;
|
|
HDC validBkModeDC;
|
|
HDC validROPDC;
|
|
HDC validTextColorDC;
|
|
HDC validPenDC;
|
|
HDC validBrushDC;
|
|
#endif
|
|
|
|
/************************************************************************/
|
|
/* Bitmaps */
|
|
/************************************************************************/
|
|
HBITMAP bmpPattern;
|
|
HBITMAP bmpMonoPattern;
|
|
HBITMAP bmpColorPattern;
|
|
|
|
/************************************************************************/
|
|
/* Memblt color table caches */
|
|
/************************************************************************/
|
|
PUHCACHEDCOLORTABLE pColorTableCache;
|
|
PUHBITMAPINFOPALINDEX pMappedColorTableCache;
|
|
int maxColorTableId;
|
|
|
|
/************************************************************************/
|
|
/* Glyph caches */
|
|
/************************************************************************/
|
|
UHGLYPHCACHE glyphCache[UH_GLC_NUM_CACHES];
|
|
UHFRAGCACHE fragCache;
|
|
|
|
unsigned cxGlyphBits;
|
|
unsigned cyGlyphBits;
|
|
HBITMAP hbmGlyph;
|
|
HDC hdcGlyph;
|
|
|
|
unsigned bmShadowWidth;
|
|
unsigned bmShadowHeight;
|
|
PBYTE bmShadowBits;
|
|
|
|
/************************************************************************/
|
|
// Bitmap cache entries.
|
|
/************************************************************************/
|
|
#if ((!defined(OS_WINCE)) || (defined(ENABLE_BMP_CACHING_FOR_WINCE)))
|
|
// Holds the persistent cache file name
|
|
TCHAR PersistCacheFileName[MAX_PATH];
|
|
UINT EndPersistCacheDir;
|
|
|
|
// For locking bitmap cache directory on disk
|
|
TCHAR PersistentLockName[MAX_PATH];
|
|
HANDLE hPersistentCacheLock;
|
|
|
|
// These entries are used in setting up bitmap key database and sending
|
|
// them to the server.
|
|
// bitmapKeyEnumTimerId: ID of timer used to schedule bitmap key enumeration.
|
|
// currentBitmapCacheId: currently enumerating keys at bitmap cache Id
|
|
// currentBitmapCacheIndex: currently enumerating keys at bitmap cache index
|
|
// sendBitmapCacheId: currently we are sending keys at bitmap cache id
|
|
// sendBitmapCacheIndex: currently we are sending keys at bitmap cache index
|
|
// sendNumBitmapKeys: how many keys we have sent so far
|
|
// numKeyEntries: number of keys at each bitmap cache
|
|
// totalNumKeyEntries: total number of keys in all caches
|
|
// BitmapCacheSizeInUse: total disk space in use for bitmaps
|
|
// pBitmapKeyDB: bitmap key database with all keys stored here
|
|
// totalNumErrorPDUs: maximum number of error pdus allowed to send to server
|
|
// lastTimeErrorPDU: last time sent error pdu for the cache
|
|
INT_PTR bitmapKeyEnumTimerId;
|
|
USHORT currentBitmapCacheId;
|
|
HANDLE currentFileHandle;
|
|
USHORT sendBitmapCacheId;
|
|
ULONG sendBitmapCacheIndex;
|
|
ULONG sendNumBitmapKeys;
|
|
ULONG numKeyEntries[TS_BITMAPCACHE_MAX_CELL_CACHES];
|
|
ULONG totalNumKeyEntries;
|
|
ULONG bitmapCacheSizeInUse;
|
|
ULONG totalNumErrorPDUs;
|
|
HPTS_BITMAPCACHE_PERSISTENT_LIST_ENTRY pBitmapKeyDB[TS_BITMAPCACHE_MAX_CELL_CACHES];
|
|
ULONG maxNumKeyEntries[TS_BITMAPCACHE_MAX_CELL_CACHES];
|
|
ULONG lastTimeErrorPDU[TS_BITMAPCACHE_MAX_CELL_CACHES];
|
|
|
|
ULONG BytesPerCluster;
|
|
ULONG NumberOfFreeClusters;
|
|
|
|
//
|
|
// Copy multiplier we are enumerating at
|
|
//
|
|
ULONG currentCopyMultiplier;
|
|
|
|
//
|
|
// Has the bmp cache memory been allocated
|
|
//
|
|
BOOL fBmpCacheMemoryAlloced;
|
|
#endif // ((!defined(OS_WINCE)) || (defined(ENABLE_BMP_CACHING_FOR_WINCE)))
|
|
|
|
// Property settings from which we determine how to allocate bitmap
|
|
// caches at connect time.
|
|
ULONG RegBitmapCacheSize;
|
|
//
|
|
// Virtual Cache size setting is indexed by copy multiplier
|
|
//
|
|
ULONG PropBitmapVirtualCacheSize[3];
|
|
ULONG RegScaleBitmapCachesByBPP;
|
|
USHORT RegNumBitmapCaches : 15;
|
|
USHORT RegPersistenceActive : 1;
|
|
UINT RegBCProportion[TS_BITMAPCACHE_MAX_CELL_CACHES];
|
|
ULONG RegBCMaxEntries[TS_BITMAPCACHE_MAX_CELL_CACHES];
|
|
UHBITMAPCACHEINFO RegBCInfo[TS_BITMAPCACHE_MAX_CELL_CACHES];
|
|
|
|
// Specifies the bitmap caching version the server has advertised.
|
|
// This is rev1 if no TS_BITMAPCACHE_CAPABILITYSET_HOSTSUPPORT
|
|
// capability was sent. Otherwise this version is the one advertised
|
|
// in HOSTSUPPORT.
|
|
unsigned BitmapCacheVersion;
|
|
|
|
// The number of cell caches in actual use in this session, and data
|
|
// for each cache. We need a copy of the cache attributes here
|
|
// because the capabilities could be rev1 or rev2 but we need a
|
|
// consistent format to work with.
|
|
unsigned NumBitmapCaches;
|
|
|
|
// Flags:
|
|
// bConnected: Used to reduce disconnect work done since it is
|
|
// possible to receive more than one call to UH_Disconnected()
|
|
// at session end.
|
|
// bEnabled : We can be disabled multiple times in a session. Make
|
|
// sure we don't do a bunch of extra work.
|
|
// bEnabledOnce: Indicates if we have already received a previous
|
|
// UH_Enable(). Used to keep from having to do work more than once
|
|
// on reconnect.
|
|
// bPersistentBitmapKeysSent: Set when we've sent the key PDUs to the
|
|
// server.
|
|
// bPersistenceActive: Session flag to determine if persistence is
|
|
// active.
|
|
// bPersistenceDisable: Property setting for persistent flag might
|
|
// change after UH_Init. But, if we have this flag on, we won't
|
|
// enable persistent caching even the property changed.
|
|
// bWarningDisplayed: We only need to display once per session for
|
|
// persistent caching failure
|
|
// bBitmapKeyEnumComplete: Set when we've done bitmap key enumeration
|
|
// on disk
|
|
unsigned bConnected : 1;
|
|
unsigned bEnabled : 1;
|
|
unsigned bEnabledOnce : 1;
|
|
unsigned bPersistenceActive : 1;
|
|
unsigned bPersistenceDisable : 1;
|
|
unsigned bPersistentBitmapKeysSent : 1;
|
|
unsigned bWarningDisplayed : 1;
|
|
unsigned bBitmapKeyEnumComplete : 1;
|
|
unsigned bBitmapKeyEnumerating : 1;
|
|
|
|
/************************************************************************/
|
|
/* Memblt bitmap caches */
|
|
/************************************************************************/
|
|
UHBITMAPCACHE bitmapCache[TS_BITMAPCACHE_MAX_CELL_CACHES];
|
|
|
|
/************************************************************************/
|
|
// Offscreen bitmap cache
|
|
/************************************************************************/
|
|
HDC hdcOffscreenBitmap;
|
|
HBITMAP hUnusedOffscrBitmap;
|
|
unsigned offscrCacheSize;
|
|
unsigned offscrCacheEntries;
|
|
HPUHOFFSCRBITMAPCACHE offscrBitmapCache;
|
|
unsigned sendOffscrCacheErrorPDU;
|
|
|
|
#ifdef DRAW_NINEGRID
|
|
/************************************************************************/
|
|
// DrawNineGrid bitmap cache
|
|
/************************************************************************/
|
|
BYTE *drawNineGridDecompressionBuffer;
|
|
unsigned drawNineGridDecompressionBufferSize;
|
|
BYTE *drawNineGridAssembleBuffer;
|
|
unsigned drawNineGridAssembleBufferOffset;
|
|
unsigned drawNineGridAssembleBufferBpp;
|
|
unsigned drawNineGridAssembleBufferWidth;
|
|
unsigned drawNineGridAssembleBufferHeight;
|
|
unsigned drawNineGridAssembleBufferSize;
|
|
BOOL drawNineGridAssembleCompressed;
|
|
HDC hdcDrawNineGridBitmap;
|
|
HBITMAP hUnusedDrawNineGridBitmap;
|
|
HRGN hDrawNineGridClipRegion;
|
|
unsigned drawNineGridCacheSize;
|
|
unsigned drawNineGridCacheEntries;
|
|
PUHDRAWSTREAMBITMAPCACHE drawNineGridBitmapCache;
|
|
unsigned sendDrawNineGridErrorPDU;
|
|
HMODULE hModuleGDI32;
|
|
HMODULE hModuleMSIMG32;
|
|
FNGDI_DRAWSTREAM *pfnGdiDrawStream;
|
|
FNGDI_ALPHABLEND *pfnGdiAlphaBlend;
|
|
FNGDI_TRANSPARENTBLT *pfnGdiTransparentBlt;
|
|
#endif
|
|
|
|
#ifdef DRAW_GDIPLUS
|
|
// Graw Gdiplus
|
|
TSUINT32 ServerGdiplusSupportLevel;
|
|
unsigned GdiplusCacheLevel;
|
|
BOOL fSendDrawGdiplusErrorPDU;
|
|
unsigned DrawGdiplusFailureCount;
|
|
#define DRAWGDIPLUSFAILURELIMIT 5
|
|
// Buffer to hold Gdiplus order
|
|
BYTE *drawGdipBuffer;
|
|
BYTE *drawGdipBufferOffset;
|
|
ULONG drawGdipBufferSize;
|
|
// Buffer to hold Gdiplus cache order
|
|
BYTE *drawGdipCacheBuffer;
|
|
BYTE *drawGdipCacheBufferOffset;
|
|
ULONG drawGdipCacheBufferSize;
|
|
// Buffer to hold assembled Gdiplus
|
|
BYTE *drawGdipEmfBuffer;
|
|
BYTE *drawGdipEmfBufferOffset;
|
|
// GdipCache Index data
|
|
PUHGDIPLUSOBJECTCACHE GdiplusGraphicsCache;
|
|
PUHGDIPLUSOBJECTCACHE GdiplusObjectPenCache;
|
|
PUHGDIPLUSOBJECTCACHE GdiplusObjectBrushCache;
|
|
PUHGDIPLUSIMAGECACHE GdiplusObjectImageCache;
|
|
PUHGDIPLUSOBJECTCACHE GdiplusObjectImageAttributesCache;
|
|
// Free list for the image cache chunks
|
|
INT16 *GdipImageCacheFreeList;
|
|
// Head index of the free list
|
|
INT16 GdipImageCacheFreeListHead;
|
|
#define GDIP_CACHE_INDEX_DEFAULT -1
|
|
INT16 *GdipImageCacheIndex;
|
|
// GdipCache actual data
|
|
BYTE *GdipGraphicsCacheData;
|
|
BYTE *GdipBrushCacheData;
|
|
BYTE *GdipPenCacheData;
|
|
BYTE *GdipImageAttributesCacheData;
|
|
BYTE *GdipImageCacheData;
|
|
// Gdiplus CacheEntries
|
|
unsigned GdiplusGraphicsCacheEntries;
|
|
unsigned GdiplusObjectPenCacheEntries;
|
|
unsigned GdiplusObjectBrushCacheEntries;
|
|
unsigned GdiplusObjectImageCacheEntries;
|
|
unsigned GdiplusObjectImageAttributesCacheEntries;
|
|
// Gdiplus CacheChunkSize
|
|
unsigned GdiplusGraphicsCacheChunkSize;
|
|
unsigned GdiplusObjectBrushCacheChunkSize;
|
|
unsigned GdiplusObjectPenCacheChunkSize;
|
|
unsigned GdiplusObjectImageAttributesCacheChunkSize;
|
|
unsigned GdiplusObjectImageCacheChunkSize;
|
|
// Total cache size allowed for Gdiplus image (number of chunks)
|
|
unsigned GdiplusObjectImageCacheTotalSize;
|
|
// Maximun size for a single Gdiplus image cache (number of chunks)
|
|
unsigned GdiplusObjectImageCacheMaxSize;
|
|
|
|
HMODULE hModuleGDIPlus;
|
|
FNGDIPPLAYTSCLIENTRECORD *pfnGdipPlayTSClientRecord;
|
|
FNGDIPLUSSTARTUP *pfnGdiplusStartup;
|
|
FNGDIPLUSSHUTDOWN *pfnGdiplusShutdown;
|
|
ULONG_PTR gpToken;
|
|
BOOL gpValid;
|
|
BOOL fGdipEnabled;
|
|
#endif // DRAW_GDIPLUS
|
|
|
|
/************************************************************************/
|
|
/* Brush caches */
|
|
/************************************************************************/
|
|
PUHMONOBRUSHCACHE pMonoBrush;
|
|
PUHCOLORBRUSHINFO pColorBrushInfo;
|
|
#ifdef DC_HICOLOR
|
|
PUHHICOLORBRUSHINFO pHiColorBrushInfo;
|
|
#endif
|
|
PUHCOLORBRUSHCACHE pColorBrush;
|
|
|
|
RGBQUAD rgbQuadTable[UH_NUM_8BPP_PAL_ENTRIES];
|
|
|
|
#ifdef DC_DEBUG
|
|
//
|
|
// Bitmap Cache Monitor data.
|
|
//
|
|
HWND hwndBitmapCacheMonitor;
|
|
UH_CACHE_MONITOR_ENTRY_DATA DCHPTR MonitorEntries[
|
|
TS_BITMAPCACHE_MAX_CELL_CACHES];
|
|
unsigned numCacheBlobsPerRow;
|
|
unsigned yCacheStart[TS_BITMAPCACHE_MAX_CELL_CACHES];
|
|
unsigned yDisplayedCacheBitmapStart;
|
|
unsigned displayedCacheId;
|
|
ULONG displayedCacheEntry;
|
|
BOOL showBitmapCacheMonitor;
|
|
INT_PTR timerBitmapCacheMonitor;
|
|
#endif /* DC_DEBUG */
|
|
|
|
//
|
|
// Disabled bitmap support
|
|
//
|
|
HBITMAP hbmpDisconnectedBitmap;
|
|
HBITMAP hbmpUnusedDisconnectedBitmap;
|
|
HDC hdcDisconnected;
|
|
#ifdef OS_WINCE
|
|
#define MAX_AOT_RECTS 10 //AOT = Always On Top
|
|
RECT rcaAOT[MAX_AOT_RECTS];
|
|
ULONG ulNumAOTRects;
|
|
#endif
|
|
} UH_DATA, FAR *PUH_DATA;
|
|
|
|
|
|
//
|
|
// Class definition
|
|
//
|
|
class CUH
|
|
{
|
|
public:
|
|
CUH(CObjs* objs);
|
|
~CUH();
|
|
|
|
public:
|
|
//
|
|
// Public data members
|
|
//
|
|
UH_DATA _UH;
|
|
|
|
public:
|
|
//
|
|
// API
|
|
//
|
|
|
|
/****************************************************************************/
|
|
/* FUNCTION PROTOTYPES */
|
|
/****************************************************************************/
|
|
void DCAPI UH_Init();
|
|
void DCAPI UH_Term();
|
|
DCBOOL DCAPI UH_SetServerFontCount(unsigned);
|
|
|
|
void DCAPI UH_Enable(ULONG_PTR);
|
|
EXPOSE_CD_SIMPLE_NOTIFICATION_FN(CUH, UH_Enable);
|
|
void DCAPI UH_Disable(ULONG_PTR);
|
|
EXPOSE_CD_SIMPLE_NOTIFICATION_FN(CUH, UH_Disable);
|
|
void DCAPI UH_Disconnect(ULONG_PTR);
|
|
EXPOSE_CD_SIMPLE_NOTIFICATION_FN(CUH, UH_Disconnect);
|
|
|
|
void DCAPI UH_SetConnectOptions(ULONG_PTR);
|
|
EXPOSE_CD_SIMPLE_NOTIFICATION_FN(CUH, UH_SetConnectOptions);
|
|
|
|
void DCAPI UH_ResetFontMap();
|
|
VOID DCAPI UH_BufferAvailable();
|
|
VOID DCAPI UH_SendPersistentKeysAndFontList();
|
|
VOID DCAPI UH_ClearOneBitmapDiskCache(UINT cacheId,UINT copyMultiplier);
|
|
HRESULT DCAPI UH_ProcessOrders(unsigned, BYTE FAR *, DCUINT);
|
|
HRESULT DCAPI UH_ProcessBitmapPDU(TS_UPDATE_BITMAP_PDU_DATA UNALIGNED FAR *,
|
|
DCUINT);
|
|
HRESULT DCAPI UH_ProcessPalettePDU(
|
|
TS_UPDATE_PALETTE_PDU_DATA UNALIGNED FAR *, DCUINT);
|
|
|
|
#ifdef DISABLE_SHADOW_IN_FULLSCREEN
|
|
void DCAPI UH_DisableShadowBitmap(ULONG_PTR);
|
|
EXPOSE_CD_SIMPLE_NOTIFICATION_FN(CUH, UH_DisableShadowBitmap);
|
|
void DCAPI UH_EnableShadowBitmap(ULONG_PTR);
|
|
EXPOSE_CD_SIMPLE_NOTIFICATION_FN(CUH, UH_EnableShadowBitmap);
|
|
void DCAPI UH_SetBBarRect(ULONG_PTR pData);
|
|
EXPOSE_CD_SIMPLE_NOTIFICATION_FN(CUH, UH_SetBBarRect);
|
|
void DCAPI UH_SetBBarVisible(ULONG_PTR pData);
|
|
EXPOSE_CD_SIMPLE_NOTIFICATION_FN(CUH, UH_SetBBarVisible);
|
|
#endif
|
|
|
|
// "Internal" functions required to handle inline functions below.
|
|
void DCINTERNAL UHUseSolidPaletteBrush(DCCOLOR);
|
|
|
|
#ifdef DC_DEBUG
|
|
void DCAPI UH_ChangeDebugSettings(ULONG_PTR);
|
|
EXPOSE_CD_SIMPLE_NOTIFICATION_FN(CUH, UH_ChangeDebugSettings);
|
|
#endif /* DC_DEBUG */
|
|
|
|
void DCAPI UH_SetClipRegion(int, int, int, int);
|
|
#ifdef DC_DEBUG
|
|
HWND UH_GetBitmapCacheMonHwnd() {return _UH.hwndBitmapCacheMonitor;}
|
|
#endif
|
|
|
|
#ifdef DRAW_NINEGRID
|
|
HRESULT DCAPI UH_DrawNineGrid(PUH_ORDER, unsigned, RECT*);
|
|
#endif
|
|
|
|
#ifdef DRAW_GDIPLUS
|
|
BOOL DCAPI UHDrawGdiplusStartup(ULONG_PTR);
|
|
void DCAPI UHDrawGdiplusShutdown(ULONG_PTR);
|
|
#endif
|
|
|
|
/****************************************************************************/
|
|
/* INLINE FUNCTIONS */
|
|
/* */
|
|
/****************************************************************************/
|
|
inline void DCINTERNAL UHAddUpdateRegion(PUH_ORDER, HRGN);
|
|
|
|
/****************************************************************************/
|
|
/* Name: UHResetClipRegion */
|
|
/* */
|
|
/* Purpose: Disables any clipping region in the current output DC. */
|
|
/****************************************************************************/
|
|
_inline void DCAPI UH_ResetClipRegion()
|
|
{
|
|
DC_BEGIN_FN("UHResetClipRegion");
|
|
|
|
#if defined (OS_WINCE)
|
|
if ((! _UH.rectReset) || (_UH.validClipDC != _UH.hdcDraw))
|
|
#endif
|
|
{
|
|
SelectClipRgn(_UH.hdcDraw, NULL);
|
|
|
|
/********************************************************************/
|
|
/* Indicate that the region is currently reset. */
|
|
/********************************************************************/
|
|
_UH.rectReset = TRUE;
|
|
#if defined (OS_WINCE)
|
|
_UH.validClipDC = _UH.hdcDraw;
|
|
#endif
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
#ifdef SMART_SIZING
|
|
/****************************************************************************/
|
|
/* Name: UHClearUpdateRegion */
|
|
/* */
|
|
/* Purpose: Clears the update region */
|
|
/****************************************************************************/
|
|
_inline void DCAPI UHClearUpdateRegion()
|
|
{
|
|
DC_BEGIN_FN("UHClearUpdateRegion");
|
|
SetRectRgn(_UH.hrgnUpdate, 0, 0, 0, 0);
|
|
_pOp->OP_ClearUpdateRegion();
|
|
DC_END_FN();
|
|
}
|
|
#endif // SMART_SIZING
|
|
|
|
#ifdef DC_HICOLOR
|
|
#define UHGetOffsetIntoCache(iEntry, cacheId) \
|
|
(iEntry) * UH_CellSizeFromCacheID((cacheId))
|
|
#endif
|
|
|
|
/****************************************************************************/
|
|
/* Name: UH_OnUpdatePDU */
|
|
/* */
|
|
/* Purpose: Process an Update PDU. */
|
|
/* */
|
|
/* Params: IN - pUpdatePDU: pointer to Update PDU */
|
|
/****************************************************************************/
|
|
inline HRESULT DCAPI UH_OnUpdatePDU(
|
|
TS_UPDATE_HDR_DATA UNALIGNED FAR *pUpdatePDU,
|
|
DCUINT dataLen)
|
|
{
|
|
DC_BEGIN_FN("UH_OnUpdatePDU");
|
|
HRESULT hr = S_OK;
|
|
PBYTE pDataEnd = (PBYTE)pUpdatePDU + dataLen;
|
|
|
|
switch (pUpdatePDU->updateType) {
|
|
case TS_UPDATETYPE_ORDERS: {
|
|
TS_UPDATE_ORDERS_PDU_DATA UNALIGNED FAR *pHdr;
|
|
|
|
// SECURITY: 552403
|
|
CHECK_READ_N_BYTES(pUpdatePDU, pDataEnd, sizeof(TS_UPDATE_ORDERS_PDU_DATA), hr,
|
|
(TB, _T("Bad TS_UPDATE_ORDERS_PDU_DATA; Size %u"), dataLen));
|
|
|
|
pHdr = (TS_UPDATE_ORDERS_PDU_DATA UNALIGNED FAR *)pUpdatePDU;
|
|
TRC_NRM((TB, _T("Order PDU")));
|
|
hr = UH_ProcessOrders(pHdr->numberOrders, pHdr->orderList,
|
|
dataLen - FIELDOFFSET(TS_UPDATE_ORDERS_PDU_DATA, orderList));
|
|
DC_QUIT_ON_FAIL(hr);
|
|
break;
|
|
}
|
|
|
|
case TS_UPDATETYPE_BITMAP:
|
|
TRC_NRM((TB, _T("Bitmap PDU")));
|
|
|
|
// SECURITY: 552403
|
|
CHECK_READ_N_BYTES(pUpdatePDU, pDataEnd, sizeof(TS_UPDATE_BITMAP_PDU_DATA), hr,
|
|
(TB, _T("Bad TS_UPDATE_BITMAP_PDU_DATA; Size %u"), dataLen));
|
|
|
|
hr = UH_ProcessBitmapPDU((PTS_UPDATE_BITMAP_PDU_DATA)pUpdatePDU,
|
|
dataLen);
|
|
DC_QUIT_ON_FAIL(hr);
|
|
break;
|
|
|
|
case TS_UPDATETYPE_PALETTE:
|
|
TRC_NRM((TB, _T("Palette PDU")));
|
|
|
|
// SECURITY: 552403
|
|
CHECK_READ_N_BYTES(pUpdatePDU, pDataEnd, sizeof(TS_UPDATE_PALETTE_PDU_DATA), hr,
|
|
(TB, _T("Bad TS_UPDATE_PALETTE_PDU_DATA; Size %u"), dataLen));
|
|
|
|
hr = UH_ProcessPalettePDU((PTS_UPDATE_PALETTE_PDU_DATA)pUpdatePDU,
|
|
dataLen);
|
|
DC_QUIT_ON_FAIL(hr);
|
|
break;
|
|
|
|
case TS_UPDATETYPE_SYNCHRONIZE:
|
|
TRC_NRM((TB, _T("Sync PDU")));
|
|
break;
|
|
|
|
default:
|
|
TRC_ERR((TB, _T("Unexpected Update PDU type: %u"),
|
|
pUpdatePDU->updateType));
|
|
DC_QUIT;
|
|
break;
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* If there are a large number of PDUs arriving, messages flood the */
|
|
/* Receive Thread's message queue and it is possible for WM_PAINT */
|
|
/* messages to not get processed within a reasonable amount of time */
|
|
/* (as they have the lowest priority). We therefore ensure that */
|
|
/* any outstanding WM_PAINTs are flushed if they have not been */
|
|
/* processed within UH_WORST_CASE_WM_PAINT_PERIOD. */
|
|
/* */
|
|
/* Note that the normal processing of updates does not involve */
|
|
/* WM_PAINT messages - we draw directly to the Output Window. */
|
|
/* WM_PAINTs are only generated by resizing or obscuring/revealing */
|
|
/* an area of the client window. */
|
|
/************************************************************************/
|
|
_pOp->OP_MaybeForcePaint();
|
|
|
|
DC_EXIT_POINT:
|
|
DC_END_FN();
|
|
return hr;
|
|
} /* UH_OnUpdatePDU */
|
|
|
|
|
|
/****************************************************************************/
|
|
/* Name: UH_GetShadowBitmapDC */
|
|
/* */
|
|
/* Purpose: Returns the Shadow Bitmap DC handle. */
|
|
/* */
|
|
/* Returns: Shadow Bitmap DC handle. */
|
|
/****************************************************************************/
|
|
inline HDC DCAPI UH_GetShadowBitmapDC()
|
|
{
|
|
DC_BEGIN_FN("UH_GetShadowBitmapDC");
|
|
DC_END_FN();
|
|
return _UH.hdcShadowBitmap;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* Name: UH_GetDisconnectBitmapDC */
|
|
/* */
|
|
/* Purpose: Returns the Disconnect Bitmap DC handle */
|
|
/* */
|
|
/* Returns: Disconnect DC handle. */
|
|
/****************************************************************************/
|
|
inline HDC DCAPI UH_GetDisconnectBitmapDC()
|
|
{
|
|
DC_BEGIN_FN("UH_GetShadowBitmapDC");
|
|
DC_END_FN();
|
|
return _UH.hdcDisconnected;
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************/
|
|
/* Name: UH_GetCurrentOutputDC */
|
|
/* */
|
|
/* Purpose: Returns the DC handle for the current output surface */
|
|
/* (either the Shadow Bitmap or the Output Window). */
|
|
/* */
|
|
/* Returns: Output DC handle. */
|
|
/****************************************************************************/
|
|
inline HDC DCAPI UH_GetCurrentOutputDC()
|
|
{
|
|
DC_BEGIN_FN("UH_GetCurrentOutputDC");
|
|
DC_END_FN();
|
|
return _UH.hdcDraw;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* Name: UH_ShadowBitmapIsEnabled */
|
|
/* */
|
|
/* Purpose: Returns whether the Shadow Bitmap is currently enabled */
|
|
/* */
|
|
/* Returns: TRUE if Shadow Bitmap is enabled, FALSE otherwise */
|
|
/****************************************************************************/
|
|
inline BOOL DCAPI UH_ShadowBitmapIsEnabled()
|
|
{
|
|
DC_BEGIN_FN("UH_ShadowBitmapIsEnabled");
|
|
DC_END_FN();
|
|
return _UH.shadowBitmapEnabled;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* Name: UH_GetCurrentPalette */
|
|
/* */
|
|
/* Purpose: Returns the handle of the current palette */
|
|
/* */
|
|
/* Returns: Palette handle */
|
|
/****************************************************************************/
|
|
inline HPALETTE DCAPI UH_GetCurrentPalette()
|
|
{
|
|
DC_BEGIN_FN("UH_GetCurrentPalette");
|
|
DC_END_FN();
|
|
return _UH.hpalCurrent;
|
|
}
|
|
|
|
#ifdef OS_WINCE
|
|
#define UHGetColorRef(_color,_type,_uhinst) (_uhinst)->UHGetColorRefCE(_color,_type)
|
|
#endif
|
|
|
|
/****************************************************************************/
|
|
// Convert the supplied DCCOLOR into a COLORREF.
|
|
// Macro to force inline.
|
|
/****************************************************************************/
|
|
#ifdef DC_HICOLOR
|
|
|
|
#ifndef OS_WINCE
|
|
#define UHGetColorRef(_color, _type, uhinst) \
|
|
(((uhinst)->_UH.protocolBpp == 24) \
|
|
? \
|
|
RGB(_color.u.rgb.red, _color.u.rgb.green, _color.u.rgb.blue) \
|
|
: \
|
|
(((uhinst)->_UH.protocolBpp == 16) \
|
|
? \
|
|
RGB((((*((PDCUINT16)&(_color))) >> 8) & 0x00f8) | \
|
|
(((*((PDCUINT16)&(_color))) >> 13) & 0x0007), \
|
|
(((*((PDCUINT16)&(_color))) >> 3) & 0x00fc) | \
|
|
(((*((PDCUINT16)&(_color))) >> 9) & 0x0003), \
|
|
(((*((PDCUINT16)&(_color))) << 3) & 0x00f8) | \
|
|
(((*((PDCUINT16)&(_color))) >> 2) & 0x0007)) \
|
|
: \
|
|
(((uhinst)->_UH.protocolBpp == 15) \
|
|
? \
|
|
RGB((((*((PDCUINT16)&(_color))) >> 7) & 0x00f8) | \
|
|
(((*((PDCUINT16)&(_color))) >> 12) & 0x0007), \
|
|
(((*((PDCUINT16)&(_color))) >> 2) & 0x00f8) | \
|
|
(((*((PDCUINT16)&(_color))) >> 7) & 0x0007), \
|
|
(((*((PDCUINT16)&(_color))) << 3) & 0x00f8) | \
|
|
(((*((PDCUINT16)&(_color))) >> 2) & 0x0007)) \
|
|
: \
|
|
((_type) != UH_COLOR_RGB \
|
|
? \
|
|
((uhinst)->_UH.colorIndicesEnabled \
|
|
? \
|
|
DC_PALINDEX((_color).u.index) \
|
|
: \
|
|
PALETTERGB((_color).u.rgb.red, \
|
|
(_color).u.rgb.green, \
|
|
(_color).u.rgb.blue)) \
|
|
: \
|
|
RGB((_color).u.rgb.red, \
|
|
(_color).u.rgb.green, \
|
|
(_color).u.rgb.blue)))) )
|
|
|
|
#else
|
|
inline COLORREF UHGetColorRefCE(DCCOLOR color, DCUINT type)
|
|
{
|
|
COLORREF outCol;
|
|
|
|
DC_BEGIN_FN("UHGetColorRef");
|
|
|
|
if (_UH.protocolBpp == 24)
|
|
{
|
|
outCol = RGB(color.u.rgb.red, color.u.rgb.green, color.u.rgb.blue);
|
|
}
|
|
else if (_UH.protocolBpp == 16)
|
|
{
|
|
outCol = RGB((((*((PDCUINT16)&(color))) & TS_RED_MASK_16BPP) >> 8),
|
|
(((*((PDCUINT16)&(color))) & TS_GREEN_MASK_16BPP)>> 3),
|
|
(((*((PDCUINT16)&(color))) & TS_BLUE_MASK_16BPP) << 3));
|
|
}
|
|
else if (_UH.protocolBpp == 15)
|
|
{
|
|
outCol = RGB((((*((PDCUINT16)&(color))) & TS_RED_MASK_15BPP) >> 7),
|
|
(((*((PDCUINT16)&(color))) & TS_GREEN_MASK_15BPP)>> 2),
|
|
(((*((PDCUINT16)&(color))) & TS_BLUE_MASK_15BPP) << 3));
|
|
}
|
|
else if (type == UH_COLOR_RGB)
|
|
{
|
|
outCol = RGB(color.u.rgb.red, color.u.rgb.green, color.u.rgb.blue);
|
|
}
|
|
else
|
|
{
|
|
if (_UH.colorIndicesEnabled)
|
|
{
|
|
if (g_CEConfig != CE_CONFIG_WBT)
|
|
{
|
|
if (_UH.paletteIsFixed)
|
|
{
|
|
PALETTEENTRY pe;
|
|
GetPaletteEntries(_UH.hpalCurrent, color.u.index, 1, &pe);
|
|
outCol = PALETTERGB(pe.peRed, pe.peGreen, pe.peBlue);
|
|
}
|
|
else
|
|
{
|
|
outCol = DC_PALINDEX(color.u.index);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
outCol = DC_PALINDEX(color.u.index);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
outCol = PALETTERGB(color.u.rgb.red,
|
|
color.u.rgb.green,
|
|
color.u.rgb.blue);
|
|
}
|
|
}
|
|
|
|
TRC_NRM((TB, "Returning rgb %08lx", outCol));
|
|
DC_END_FN();
|
|
return(outCol);
|
|
}
|
|
|
|
#endif // OS_WINCE
|
|
#else // not HICOLOR
|
|
|
|
|
|
#ifndef OS_WINCE
|
|
#define UHGetColorRef(_color, _type, uhinst) \
|
|
((_type) != UH_COLOR_RGB ? \
|
|
((uhinst)->_UH.colorIndicesEnabled ? DC_PALINDEX((_color).u.index) : \
|
|
PALETTERGB((_color).u.rgb.red, (_color).u.rgb.green, \
|
|
(_color).u.rgb.blue)) : \
|
|
RGB((_color).u.rgb.red, (_color).u.rgb.green, \
|
|
(_color).u.rgb.blue))
|
|
#else
|
|
|
|
_inline COLORREF DCINTERNAL UHGetColorRef(DCCOLOR color, DCUINT type)
|
|
{
|
|
COLORREF outCol;
|
|
|
|
DC_BEGIN_FN("UHGetColorRef");
|
|
|
|
if (type == UH_COLOR_RGB)
|
|
{
|
|
outCol = RGB(color.u.rgb.red, color.u.rgb.green, color.u.rgb.blue);
|
|
}
|
|
else
|
|
{
|
|
if (_UH.colorIndicesEnabled)
|
|
{
|
|
if (g_CEConfig != CE_CONFIG_WBT)
|
|
{
|
|
if (_UH.paletteIsFixed)
|
|
{
|
|
PALETTEENTRY pe;
|
|
GetPaletteEntries(_UH.hpalCurrent, color.u.index, 1, &pe);
|
|
outCol = PALETTERGB(pe.peRed, pe.peGreen, pe.peBlue);
|
|
}
|
|
else
|
|
{
|
|
outCol = DC_PALINDEX(color.u.index);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
outCol = DC_PALINDEX(color.u.index);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
outCol = PALETTERGB(color.u.rgb.red,
|
|
color.u.rgb.green,
|
|
color.u.rgb.blue);
|
|
}
|
|
}
|
|
|
|
TRC_NRM((TB, _T("Returning rgb %08lx"), outCol));
|
|
DC_END_FN();
|
|
return(outCol);
|
|
}
|
|
#endif // OS_WINCE
|
|
#endif // DC_HICOLOR
|
|
|
|
/****************************************************************************/
|
|
/* Name: UHUseBkColor */
|
|
/* */
|
|
/* Purpose: Selects a given background color into the output DC. */
|
|
/* */
|
|
/* Params: IN: color - background color */
|
|
/* IN: colorType - color type */
|
|
/****************************************************************************/
|
|
#if defined (OS_WINCE)
|
|
|
|
#define UHUseBkColor(_color, _colorType, uhinst) \
|
|
{ \
|
|
COLORREF rgb; \
|
|
\
|
|
rgb = UHGetColorRef((_color), (_colorType), (uhinst)); \
|
|
if ((rgb != (uhinst)->_UH.lastBkColor) || \
|
|
((uhinst)->_UH.hdcDraw != (uhinst)->_UH.validBkColorDC)) \
|
|
{ \
|
|
SetBkColor((uhinst)->_UH.hdcDraw, rgb); \
|
|
(uhinst)->_UH.lastBkColor = rgb; \
|
|
(uhinst)->_UH.validBkColorDC = (uhinst)->_UH.hdcDraw; \
|
|
} \
|
|
}
|
|
|
|
#else
|
|
|
|
#define UHUseBkColor(_color, _colorType, uhinst) \
|
|
{ \
|
|
COLORREF rgb; \
|
|
\
|
|
rgb = UHGetColorRef((_color), (_colorType), (uhinst)); \
|
|
{ \
|
|
SetBkColor((uhinst)->_UH.hdcDraw, rgb); \
|
|
(uhinst)->_UH.lastBkColor = rgb; \
|
|
} \
|
|
}
|
|
|
|
#endif
|
|
|
|
/****************************************************************************/
|
|
/* Name: UHUseTextColor */
|
|
/* */
|
|
/* Purpose: Selects a given text color into the output DC. */
|
|
/* */
|
|
/* Params: IN: color - text color */
|
|
/* IN: colorType - color type */
|
|
/****************************************************************************/
|
|
#if defined (OS_WINCE)
|
|
|
|
#define UHUseTextColor(_color, _colorType, uhinst) \
|
|
{ \
|
|
COLORREF rgb; \
|
|
\
|
|
rgb = UHGetColorRef((_color), (_colorType), uhinst); \
|
|
if ((rgb != (uhinst)->_UH.lastTextColor) || \
|
|
((uhinst)->_UH.hdcDraw != (uhinst)->_UH.validTextColorDC)) \
|
|
{ \
|
|
SetTextColor((uhinst)->_UH.hdcDraw, rgb); \
|
|
(uhinst)->_UH.lastTextColor = rgb; \
|
|
(uhinst)->_UH.validTextColorDC = (uhinst)->_UH.hdcDraw; \
|
|
} \
|
|
}
|
|
|
|
#else
|
|
|
|
#define UHUseTextColor(_color, _colorType, uhinst) \
|
|
{ \
|
|
COLORREF rgb; \
|
|
\
|
|
rgb = UHGetColorRef((_color), (_colorType), uhinst); \
|
|
{ \
|
|
SetTextColor((uhinst)->_UH.hdcDraw, rgb); \
|
|
(uhinst)->_UH.lastTextColor = rgb; \
|
|
} \
|
|
}
|
|
|
|
|
|
#endif
|
|
|
|
/****************************************************************************/
|
|
/* Name: UH_UseBrushEx */
|
|
/* */
|
|
/* Purpose: Creates and selects a given brush into the current output */
|
|
/* DC. */
|
|
/* */
|
|
/* Purpose: Sets given brush origin in the output DC. */
|
|
/* */
|
|
/* Params: IN: x, y - brush origin */
|
|
/* IN: style - brush style */
|
|
/* IN: hatch - brush hatch */
|
|
/* IN: color - brush color */
|
|
/* IN: colorType - type of color */
|
|
/* IN: extra - array of bitmap bits for custom brushes */
|
|
/****************************************************************************/
|
|
inline HRESULT DCAPI UH_UseBrushEx(
|
|
int x,
|
|
int y,
|
|
unsigned style,
|
|
unsigned hatch,
|
|
DCCOLOR color,
|
|
unsigned colorType,
|
|
PBYTE pextra)
|
|
{
|
|
DC_BEGIN_FN("UH_UseBrushEx");
|
|
HRESULT hr = S_OK;
|
|
|
|
UHUseBrushOrg(x, y);
|
|
hr = UHUseBrush(style, hatch, color, colorType, pextra);
|
|
|
|
DC_EXIT_POINT:
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* Name: UH_ProcessServerCaps */
|
|
/* */
|
|
/* Purpose: Processes the server's capabilities. Called on sender thread. */
|
|
/* +++NOTE: Called on sender thread. */
|
|
/* */
|
|
/* Returns: Nothing */
|
|
/* */
|
|
/* Params: IN: capsLength - number of bytes pointed to by pCaps */
|
|
/* IN: pCaps - pointer to the combined capabilities */
|
|
/****************************************************************************/
|
|
inline void DCAPI UH_ProcessServerCaps(PTS_ORDER_CAPABILITYSET pOrderCaps)
|
|
{
|
|
DC_BEGIN_FN("UH_ProcessServerCaps");
|
|
|
|
TRC_ASSERT(pOrderCaps, (TB,_T("pOrderCaps == NULL in call to UH_ProcessServerCaps")));
|
|
if (pOrderCaps)
|
|
{
|
|
// Look to see if the server will be sending us palette indices
|
|
// rather than RGB values.
|
|
if (_UH.colorIndicesEnabled)
|
|
{
|
|
if (pOrderCaps->orderFlags & TS_ORDERFLAGS_COLORINDEXSUPPORT)
|
|
{
|
|
TRC_NRM((TB, _T("color indices ARE supported")));
|
|
_UH.colorIndicesEnabled = TRUE;
|
|
}
|
|
else
|
|
{
|
|
TRC_NRM((TB, _T("color indices NOT supported")));
|
|
_UH.colorIndicesEnabled = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
DC_END_FN();
|
|
} /* UH_ProcessServerCaps */
|
|
|
|
|
|
/****************************************************************************/
|
|
// UH_ProcessBCHostSupportCaps
|
|
//
|
|
// Processes a TS_BITMAPCACHE_CAPABILITYSET_HOSTSUPPORT sent by the server.
|
|
// These caps are used to determine the bitmap caching protocol sequences
|
|
// to be used.
|
|
// +++NOTE: Called on sender thread.
|
|
/****************************************************************************/
|
|
inline void DCAPI UH_ProcessBCHostSupportCaps(
|
|
TS_BITMAPCACHE_CAPABILITYSET_HOSTSUPPORT *pHostSupport)
|
|
{
|
|
DC_BEGIN_FN("UH_ProcessBCHostSupportCaps");
|
|
|
|
if (pHostSupport != NULL &&
|
|
pHostSupport->CacheVersion == TS_BITMAPCACHE_REV2)
|
|
_UH.BitmapCacheVersion = TS_BITMAPCACHE_REV2;
|
|
else
|
|
_UH.BitmapCacheVersion = TS_BITMAPCACHE_REV1;
|
|
|
|
TRC_NRM((TB,_T("Received HOSTSUPPORT caps, cache version %u"),
|
|
_UH.BitmapCacheVersion));
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/* Name: UHIsValidGlyphCacheID */
|
|
/**************************************************************************/
|
|
inline HRESULT DCAPI UHIsValidGlyphCacheID(unsigned cacheId)
|
|
{
|
|
return (cacheId < UH_GLC_NUM_CACHES) ? S_OK : E_TSC_CORE_CACHEVALUE;
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/* Name: UHIsValidGlyphCacheIDIndex */
|
|
/**************************************************************************/
|
|
HRESULT DCAPI UHIsValidGlyphCacheIDIndex(unsigned cacheId, unsigned cacheIndex);
|
|
|
|
/**************************************************************************/
|
|
/* Name: UHIsValidMonoBrushCacheIndex */
|
|
/**************************************************************************/
|
|
inline HRESULT DCAPI UHIsValidMonoBrushCacheIndex(unsigned cacheIndex)
|
|
{
|
|
return cacheIndex < UH_MAX_MONO_BRUSHES ? S_OK : E_TSC_CORE_CACHEVALUE;
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/* Name: UHIsValidColorBrushCacheIndex */
|
|
/**************************************************************************/
|
|
inline HRESULT DCAPI UHIsValidColorBrushCacheIndex(unsigned cacheIndex)
|
|
{
|
|
return cacheIndex < UH_MAX_COLOR_BRUSHES ? S_OK : E_TSC_CORE_CACHEVALUE;
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/* Name: UHIsValidColorTableCacheIndex */
|
|
/**************************************************************************/
|
|
inline HRESULT DCAPI UHIsValidColorTableCacheIndex(unsigned cacheIndex)
|
|
{
|
|
return cacheIndex < UH_COLOR_TABLE_CACHE_ENTRIES ?
|
|
S_OK : E_TSC_CORE_CACHEVALUE;
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/* Name: UHIsValidOffsreenBitmapCacheIndex */
|
|
/**************************************************************************/
|
|
HRESULT DCAPI UHIsValidOffsreenBitmapCacheIndex(unsigned cacheIndex);
|
|
|
|
/**************************************************************************/
|
|
/* Name: UHIsValidBitmapCacheID */
|
|
/**************************************************************************/
|
|
inline HRESULT DCAPI UHIsValidBitmapCacheID(unsigned cacheId)
|
|
{
|
|
return cacheId < _UH.NumBitmapCaches ? S_OK : E_TSC_CORE_CACHEVALUE;
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/* Name: UHIsValidBitmapCacheIndex */
|
|
/**************************************************************************/
|
|
inline HRESULT DCAPI UHIsValidBitmapCacheIndex(unsigned cacheId,
|
|
unsigned cacheIndex)
|
|
{
|
|
HRESULT hr = UHIsValidBitmapCacheID(cacheId);
|
|
if (SUCCEEDED(hr)) {
|
|
if (BITMAPCACHE_WAITING_LIST_INDEX == cacheIndex) {
|
|
hr = S_OK;
|
|
}
|
|
else if (_UH.bitmapCache[cacheId].BCInfo.bSendBitmapKeys) {
|
|
hr = cacheIndex < _UH.bitmapCache[cacheId].BCInfo.NumVirtualEntries ?
|
|
S_OK : E_TSC_CORE_CACHEVALUE;
|
|
}
|
|
else {
|
|
hr = cacheIndex < _UH.bitmapCache[cacheId].BCInfo.NumEntries ?
|
|
S_OK : E_TSC_CORE_CACHEVALUE;
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/* Name: UHIsValidGdipCacheType */
|
|
/**************************************************************************/
|
|
inline HRESULT DCAPI UHIsValidGdipCacheType(TSUINT16 CacheType)
|
|
{
|
|
HRESULT hr;
|
|
switch (CacheType) {
|
|
case GDIP_CACHE_GRAPHICS_DATA:
|
|
case GDIP_CACHE_OBJECT_BRUSH:
|
|
case GDIP_CACHE_OBJECT_PEN:
|
|
case GDIP_CACHE_OBJECT_IMAGE:
|
|
case GDIP_CACHE_OBJECT_IMAGEATTRIBUTES:
|
|
hr = S_OK;
|
|
break;
|
|
default:
|
|
hr = E_TSC_CORE_CACHEVALUE;
|
|
break;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/* Name: UHIsValidGdipCacheTypeID */
|
|
/**************************************************************************/
|
|
inline HRESULT DCAPI UHIsValidGdipCacheTypeID(TSUINT16 CacheType,
|
|
TSUINT16 CacheID)
|
|
{
|
|
HRESULT hr;
|
|
switch (CacheType) {
|
|
case GDIP_CACHE_GRAPHICS_DATA:
|
|
hr = (CacheID < _UH.GdiplusGraphicsCacheEntries) ?
|
|
S_OK : E_TSC_CORE_CACHEVALUE;
|
|
break;
|
|
case GDIP_CACHE_OBJECT_BRUSH:
|
|
hr = (CacheID < _UH.GdiplusObjectBrushCacheEntries) ?
|
|
S_OK : E_TSC_CORE_CACHEVALUE;
|
|
break;
|
|
case GDIP_CACHE_OBJECT_PEN:
|
|
hr = (CacheID < _UH.GdiplusObjectPenCacheEntries) ?
|
|
S_OK : E_TSC_CORE_CACHEVALUE;
|
|
break;
|
|
case GDIP_CACHE_OBJECT_IMAGE:
|
|
hr = (CacheID < _UH.GdiplusObjectImageCacheEntries) ?
|
|
S_OK : E_TSC_CORE_CACHEVALUE;
|
|
break;
|
|
case GDIP_CACHE_OBJECT_IMAGEATTRIBUTES:
|
|
hr = (CacheID < _UH.GdiplusObjectImageAttributesCacheEntries) ?
|
|
S_OK : E_TSC_CORE_CACHEVALUE;
|
|
break;
|
|
default:
|
|
hr = E_TSC_CORE_CACHEVALUE;
|
|
break;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/* Name: UHGdipCacheChunkSize */
|
|
/**************************************************************************/
|
|
inline unsigned DCAPI UHGdipCacheChunkSize(TSUINT16 CacheType)
|
|
{
|
|
unsigned rc;
|
|
|
|
switch (CacheType) {
|
|
case GDIP_CACHE_GRAPHICS_DATA:
|
|
rc = _UH.GdiplusGraphicsCacheChunkSize;
|
|
break;
|
|
case GDIP_CACHE_OBJECT_BRUSH:
|
|
rc = _UH.GdiplusObjectBrushCacheChunkSize;
|
|
break;
|
|
case GDIP_CACHE_OBJECT_PEN:
|
|
rc = _UH.GdiplusObjectPenCacheChunkSize;
|
|
break;
|
|
case GDIP_CACHE_OBJECT_IMAGE:
|
|
rc = _UH.GdiplusObjectImageCacheChunkSize;
|
|
break;
|
|
case GDIP_CACHE_OBJECT_IMAGEATTRIBUTES:
|
|
rc = _UH.GdiplusObjectImageAttributesCacheChunkSize;
|
|
break;
|
|
default:
|
|
rc = 0;
|
|
break;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
inline void DCAPI UH_SetServerGdipSupportLevel(
|
|
UINT32 SupportLevel)
|
|
{
|
|
_UH.ServerGdiplusSupportLevel = SupportLevel;
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/* Name: UHIsValidNineGridCacheIndex */
|
|
/**************************************************************************/
|
|
inline HRESULT DCAPI UHIsValidNineGridCacheIndex(unsigned cacheIndex)
|
|
{
|
|
return cacheIndex < _UH.drawNineGridCacheEntries ?
|
|
S_OK : E_TSC_CORE_CACHEVALUE;
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/* Name: UHIsValidFragmentCacheIndex */
|
|
/**************************************************************************/
|
|
inline HRESULT DCAPI UHIsValidFragmentCacheIndex(unsigned cacheIndex)
|
|
{
|
|
return (cacheIndex < UH_FGC_CACHE_MAXIMUMCELLCOUNT) ?
|
|
S_OK : E_TSC_CORE_CACHEVALUE;
|
|
}
|
|
|
|
#ifdef DC_DEBUG
|
|
void DCAPI UH_HatchRect(int, int, int, int, COLORREF, unsigned);
|
|
DCVOID DCAPI UH_HatchOutputRect(DCINT left, DCINT top, DCINT right,
|
|
DCINT bottom, COLORREF color, DCUINT hatchStyle);
|
|
DCVOID DCAPI UH_HatchRectDC(HDC hdc, DCINT left, DCINT top, DCINT right,
|
|
DCINT bottom, COLORREF color, DCUINT hatchStyle);
|
|
#endif
|
|
|
|
HRESULT DCAPI UHDrawMemBltOrder(HDC, MEMBLT_COMMON FAR *);
|
|
|
|
#ifdef DC_DEBUG
|
|
void DCAPI UHLabelMemBltOrder(int, int, unsigned, unsigned);
|
|
#endif
|
|
|
|
void DCAPI UHUsePen(unsigned, unsigned, DCCOLOR, unsigned);
|
|
|
|
/****************************************************************************/
|
|
/* Name: UHConvertToWindowsROP */
|
|
/* */
|
|
/* Purpose: Converts a rop index (in the range 0-255) to a 32-bit Windows */
|
|
/* rop code. */
|
|
/* */
|
|
/* Returns: 32-bit rop value. */
|
|
/****************************************************************************/
|
|
inline UINT32 DCAPI UHConvertToWindowsROP(unsigned ropIndex)
|
|
{
|
|
UINT32 rc;
|
|
|
|
DC_BEGIN_FN("UHConvertToWindowsROP");
|
|
|
|
TRC_ASSERT((ropIndex <= 0xFF), (TB, _T("ropIndex (%u) invalid"), ropIndex));
|
|
|
|
/************************************************************************/
|
|
/* Simply take the ROP value from the uhWindowsROPs lookup table and */
|
|
/* place the ropIndex in the upper 16-bits. */
|
|
/************************************************************************/
|
|
rc = (((UINT32)ropIndex) << 16) | (UINT32)(uhWindowsROPs[ropIndex]);
|
|
|
|
DC_END_FN();
|
|
return rc;
|
|
}
|
|
|
|
|
|
HRESULT DCAPI UHUseBrush(unsigned, unsigned, DCCOLOR, unsigned, BYTE [7]);
|
|
|
|
void DCAPI UHUseBrushOrg(int, int);
|
|
|
|
|
|
/****************************************************************************/
|
|
/* Name: UHDrawGlyphOrder */
|
|
/* */
|
|
/* Purpose: Initiates the drawing of a glyph order */
|
|
/****************************************************************************/
|
|
inline HRESULT DCAPI UHDrawGlyphOrder(
|
|
LPINDEX_ORDER pOrder,
|
|
LPVARIABLE_INDEXBYTES pVariableBytes)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DC_BEGIN_FN("UHDrawGlyphOrder");
|
|
|
|
if (pOrder->cacheId >= UH_GLC_NUM_CACHES) {
|
|
TRC_ABORT((TB,_T("Invalid glyph cacheId=%d"), pOrder->cacheId));
|
|
hr = E_TSC_CORE_CACHEVALUE;
|
|
DC_QUIT;
|
|
}
|
|
|
|
// The structure is defined with 255 elements
|
|
if (0 >= pVariableBytes->len ||255 < pVariableBytes->len) {
|
|
TRC_ABORT((TB,_T("Invalid glyph order length")));
|
|
hr = E_TSC_CORE_LENGTH;
|
|
DC_QUIT;
|
|
}
|
|
|
|
hr = _pGh->GH_GlyphOut(pOrder, pVariableBytes);
|
|
|
|
DC_EXIT_POINT:
|
|
DC_END_FN();
|
|
return hr;
|
|
}
|
|
|
|
HRESULT DCAPI UHProcessCacheGlyphOrderRev2(BYTE, unsigned, BYTE FAR *,
|
|
unsigned);
|
|
|
|
VOID DCINTERNAL UHResetAndRestartEnumeration();
|
|
|
|
VOID DCINTERNAL UHSendPersistentBitmapKeyList(ULONG_PTR unusedParm);
|
|
EXPOSE_CD_SIMPLE_NOTIFICATION_FN(CUH, UHSendPersistentBitmapKeyList);
|
|
inline BOOL DCINTERNAL UHReadFromCacheFileForEnum(VOID);
|
|
VOID DCINTERNAL UHEnumerateBitmapKeyList(ULONG_PTR unusedParm);
|
|
EXPOSE_CD_SIMPLE_NOTIFICATION_FN(CUH, UHEnumerateBitmapKeyList);
|
|
BOOL DCINTERNAL UHSendBitmapCacheErrorPDU(ULONG_PTR cacheId);
|
|
EXPOSE_CD_SIMPLE_NOTIFICATION_FN(CUH, UHSendBitmapCacheErrorPDU);
|
|
BOOL DCINTERNAL UHSendOffscrCacheErrorPDU(DCUINT unused);
|
|
EXPOSE_CD_SIMPLE_NOTIFICATION_FN(CUH, UHSendOffscrCacheErrorPDU);
|
|
#ifdef DRAW_NINEGRID
|
|
BOOL DCINTERNAL UHSendDrawNineGridErrorPDU(DCUINT unused);
|
|
EXPOSE_CD_SIMPLE_NOTIFICATION_FN(CUH, UHSendDrawNineGridErrorPDU);
|
|
#endif
|
|
BOOL DCINTERNAL UHReadFromCacheIndexFile(VOID);
|
|
#ifdef DRAW_GDIPLUS
|
|
BOOL DCINTERNAL UHSendDrawGdiplusErrorPDU(DCUINT unused);
|
|
EXPOSE_CD_SIMPLE_NOTIFICATION_FN(CUH, UHSendDrawGdiplusErrorPDU);
|
|
#endif
|
|
|
|
private:
|
|
|
|
//
|
|
// Internal functions (from wuhint.h)
|
|
//
|
|
|
|
/****************************************************************************/
|
|
/* FUNCTIONS */
|
|
/****************************************************************************/
|
|
|
|
#ifndef OS_WINCE
|
|
inline HRESULT UHSetCurrentCacheFileName(UINT cacheId, UINT copyMultiplier);
|
|
#else
|
|
VOID UHSetCurrentCacheFileName(UINT cacheId, UINT copyMultiplier);
|
|
#endif
|
|
|
|
inline BOOL UHGrabPersistentCacheLock();
|
|
inline VOID UHReleasePersistentCacheLock();
|
|
inline HANDLE UHFindFirstFile(const TCHAR *, TCHAR *, long *);
|
|
inline BOOL UHFindNextFile(HANDLE, TCHAR *, long *);
|
|
inline void UHFindClose(HANDLE);
|
|
inline BOOL UHGetDiskFreeSpace(TCHAR *, ULONG *, ULONG *, ULONG *, ULONG *);
|
|
|
|
inline DCBOOL DCINTERNAL UHIsHighVGAColor(BYTE, BYTE, BYTE);
|
|
|
|
HRESULT DCINTERNAL UHCacheBitmap(UINT, UINT32,
|
|
TS_SECONDARY_ORDER_HEADER *, PUHBITMAPINFO, PBYTE);
|
|
|
|
inline VOID DCINTERNAL UHLoadBitmapBits(UINT, UINT32,
|
|
PUHBITMAPCACHEENTRYHDR *, PBYTE *);
|
|
|
|
inline VOID DCINTERNAL UHInitBitmapCachePageTable(UINT);
|
|
|
|
inline BOOL DCINTERNAL UHAllocBitmapCachePageTable(UINT32, UINT);
|
|
|
|
BOOL DCINTERNAL UHCreateCacheDirectory();
|
|
|
|
DCBOOL DCINTERNAL UHAllocOneGlyphCache(PUHGLYPHCACHE, DCUINT32);
|
|
|
|
DCBOOL DCINTERNAL UHAllocOneFragCache(PUHFRAGCACHE pCache,
|
|
DCUINT32 numEntries);
|
|
|
|
void DCINTERNAL GHSetShadowBitmapInfo();
|
|
|
|
unsigned DCINTERNAL UHGetANSICodePage();
|
|
|
|
void DCINTERNAL UHCommonDisable(BOOL fDisplayDisabledBitmap);
|
|
|
|
HRESULT DCINTERNAL UHProcessBitmapRect(TS_BITMAP_DATA UNALIGNED FAR *);
|
|
|
|
void DCINTERNAL UHResetDCState();
|
|
|
|
HRESULT DCINTERNAL UHProcessCacheBitmapOrder(void *, DCUINT);
|
|
HRESULT DCINTERNAL UHProcessCacheColorTableOrder(
|
|
PTS_CACHE_COLOR_TABLE_ORDER, DCUINT);
|
|
HRESULT DCINTERNAL UHProcessCacheGlyphOrder(PTS_CACHE_GLYPH_ORDER, DCUINT);
|
|
HRESULT DCINTERNAL UHProcessCacheBrushOrder(const TS_CACHE_BRUSH_ORDER *, DCUINT);
|
|
HRESULT DCINTERNAL UHCreateOffscrBitmap(PTS_CREATE_OFFSCR_BITMAP_ORDER,
|
|
DCUINT, unsigned *);
|
|
HRESULT DCINTERNAL UHSwitchBitmapSurface(PTS_SWITCH_SURFACE_ORDER, DCUINT);
|
|
|
|
HRESULT DCINTERNAL UHDrawOffscrBitmapBits(HDC hdc, MEMBLT_COMMON FAR *pMB);
|
|
|
|
#ifdef DRAW_GDIPLUS
|
|
HRESULT DCINTERNAL UHDrawGdiplusPDUComplete( ULONG, ULONG);
|
|
HRESULT DCINTERNAL UHDrawGdiplusPDUFirst(PTS_DRAW_GDIPLUS_ORDER_FIRST pOrder, DCUINT, unsigned *);
|
|
HRESULT DCINTERNAL UHDrawGdiplusPDUNext(PTS_DRAW_GDIPLUS_ORDER_NEXT pOrder, DCUINT, unsigned *);
|
|
HRESULT DCINTERNAL UHDrawGdiplusPDUEnd(PTS_DRAW_GDIPLUS_ORDER_END pOrder, DCUINT, unsigned *);
|
|
HRESULT DCINTERNAL UHDrawGdiplusCacheData(TSUINT16 CacheType, TSUINT16 CacheID, unsigned cbTotalSize);
|
|
HRESULT DCINTERNAL UHAssembleGdipEmfRecord(unsigned EmfSize, unsigned TotalSize);
|
|
|
|
HRESULT DCINTERNAL UHDrawGdiplusCachePDUFirst(PTS_DRAW_GDIPLUS_CACHE_ORDER_FIRST pOrder, DCUINT, unsigned *);
|
|
HRESULT DCINTERNAL UHDrawGdiplusCachePDUNext(PTS_DRAW_GDIPLUS_CACHE_ORDER_NEXT pOrder, DCUINT, unsigned *);
|
|
HRESULT DCINTERNAL UHDrawGdiplusCachePDUEnd(PTS_DRAW_GDIPLUS_CACHE_ORDER_END pOrder, DCUINT, unsigned *);
|
|
|
|
BOOL DCINTERNAL UHDrawGdipRemoveImageCacheEntry(TSUINT16 CacheID);
|
|
#endif
|
|
|
|
|
|
#ifdef DRAW_NINEGRID
|
|
#if 0
|
|
void DCINTERNAL UHCreateDrawStreamBitmap(PTS_CREATE_DRAW_STREAM_ORDER);
|
|
void DCINTERNAL UHDecodeDrawStream(PBYTE streamIn, unsigned streamSize, PBYTE streamOut,
|
|
unsigned *streamOutSize);
|
|
unsigned DCINTERNAL UHDrawStream(PTS_DRAW_STREAM_ORDER pOrder);
|
|
#endif
|
|
|
|
HRESULT DCINTERNAL UHCreateNineGridBitmap(PTS_CREATE_NINEGRID_BITMAP_ORDER, DCUINT, unsigned *);
|
|
HRESULT DCINTERNAL CUH::UHCacheStreamBitmapFirstPDU(
|
|
PTS_STREAM_BITMAP_FIRST_PDU pOrder, DCUINT, unsigned *);
|
|
HRESULT DCINTERNAL CUH::UHCacheStreamBitmapNextPDU(
|
|
PTS_STREAM_BITMAP_NEXT_PDU pOrder, DCUINT, unsigned *);
|
|
#endif
|
|
|
|
PBYTE DCINTERNAL UHGetMemBltBits(HDC, unsigned, unsigned, unsigned *,
|
|
PUHBITMAPCACHEENTRYHDR *);
|
|
|
|
BOOL DCINTERNAL UHDIBCopyBits(HDC, int, int, int, int, int, int, PBYTE,
|
|
UINT, PBITMAPINFO, BOOL);
|
|
|
|
void DCINTERNAL UHCalculateColorTableMapping(unsigned);
|
|
|
|
BOOL DCINTERNAL UHAllocColorTableCacheMemory();
|
|
|
|
DCBOOL DCINTERNAL UHAllocGlyphCacheMemory();
|
|
|
|
DCBOOL DCINTERNAL UHAllocBrushCacheMemory();
|
|
|
|
DCBOOL DCINTERNAL UHAllocOffscreenCacheMemory();
|
|
|
|
#ifdef DRAW_NINEGRID
|
|
DCBOOL DCINTERNAL UHAllocDrawNineGridCacheMemory();
|
|
#endif
|
|
|
|
#ifdef DRAW_GDIPLUS
|
|
DCBOOL DCINTERNAL UHAllocDrawGdiplusCacheMemory();
|
|
#endif
|
|
|
|
void DCINTERNAL UHReadBitmapCacheSettings();
|
|
|
|
void DCINTERNAL UHAllocBitmapCacheMemory();
|
|
|
|
void DCINTERNAL UHFreeCacheMemory();
|
|
|
|
#if ((!defined(OS_WINCE)) || (defined(ENABLE_BMP_CACHING_FOR_WINCE)))
|
|
|
|
UINT32 DCINTERNAL UHEvictLRUCacheEntry(UINT cacheId);
|
|
|
|
UINT32 DCINTERNAL UHFindFreeCacheEntry(UINT cacheId);
|
|
|
|
VOID DCINTERNAL UHTouchMRUCacheEntry(UINT cacheId, UINT32 iEntry);
|
|
|
|
#endif //((!defined(OS_WINCE)) || (defined(ENABLE_BMP_CACHING_FOR_WINCE)))
|
|
|
|
#ifdef DC_HICOLOR
|
|
DCUINT32 DCINTERNAL UHAllocOneBitmapCache(DCUINT32 maxMemToUse,
|
|
DCUINT entrySize,
|
|
HPDCVOID DCPTR ppCacheData,
|
|
HPDCVOID DCPTR ppCacheHdr);
|
|
#else
|
|
DCBOOL DCINTERNAL UHAllocOneBitmapCache(DCUINT32 maxMemToUse,
|
|
DCUINT entrySize,
|
|
HPDCVOID DCPTR ppCacheData,
|
|
HPDCVOID DCPTR ppCacheHdr);
|
|
#endif
|
|
DCBOOL DCINTERNAL UHCreateBitmap(HBITMAP* hBitmap,
|
|
HDC* hdcBitmap,
|
|
HBITMAP* hUnusedBitmap,
|
|
DCSIZE bitmapSize,
|
|
INT nForceBmpBpp=0);
|
|
|
|
void DCINTERNAL UHDeleteBitmap(HDC *, HBITMAP *, HBITMAP *);
|
|
|
|
#if ((!defined(OS_WINCE)) || (defined(ENABLE_BMP_CACHING_FOR_WINCE)))
|
|
|
|
BOOL DCINTERNAL UHSavePersistentBitmap(
|
|
#ifndef VM_BMPCACHE
|
|
HANDLE hFile,
|
|
#else
|
|
UINT cacheId,
|
|
#endif
|
|
UINT32 fileNum,
|
|
PDCUINT8 pCompressedBitmapBits,
|
|
UINT noBCHeader,
|
|
PUHBITMAPINFO pBitmapInfo);
|
|
|
|
HRESULT DCINTERNAL UHLoadPersistentBitmap(
|
|
HANDLE hFile,
|
|
UINT32 offset,
|
|
UINT cacheId,
|
|
UINT32 cacheIndex,
|
|
PUHBITMAPCACHEPTE pPTE);
|
|
|
|
#endif // ((!defined(OS_WINCE)) || (defined(ENABLE_BMP_CACHING_FOR_WINCE)))
|
|
|
|
|
|
void DCINTERNAL UHMaybeCreateShadowBitmap();
|
|
|
|
void DCINTERNAL UHMaybeCreateSaveScreenBitmap();
|
|
|
|
#ifdef OS_WINCE
|
|
void DCINTERNAL UHGetPaletteCaps();
|
|
#endif
|
|
|
|
#ifdef DC_DEBUG
|
|
|
|
|
|
void DCINTERNAL UHInitBitmapCacheMonitor();
|
|
|
|
void DCINTERNAL UHTermBitmapCacheMonitor();
|
|
|
|
LRESULT CALLBACK UHBitmapCacheWndProc( HWND hwnd,
|
|
UINT message,
|
|
WPARAM wParam,
|
|
LPARAM lParam );
|
|
|
|
static LRESULT CALLBACK UHStaticBitmapCacheWndProc( HWND hwnd,
|
|
UINT message,
|
|
WPARAM wParam,
|
|
LPARAM lParam );
|
|
|
|
|
|
void DCINTERNAL UHSetMonitorEntryState(unsigned, ULONG, BYTE, BYTE);
|
|
|
|
void DCINTERNAL UHCacheDataReceived(unsigned cacheId, ULONG cacheIndex);
|
|
|
|
void DCINTERNAL UHCacheEntryUsed(
|
|
unsigned cacheId,
|
|
ULONG cacheEntry,
|
|
unsigned colorTableCacheEntry);
|
|
|
|
#define UHCacheEntryEvictedFromMem(_id, _entry) \
|
|
UHSetMonitorEntryState(_id, _entry, UH_CACHE_STATE_ON_DISK, \
|
|
UH_CACHE_TRANSITION_EVICTED)
|
|
|
|
#define UHCacheEntryEvictedFromDisk(_id, _entry) \
|
|
UHSetMonitorEntryState(_id, _entry, UH_CACHE_STATE_UNUSED, \
|
|
UH_CACHE_TRANSITION_EVICTED)
|
|
|
|
#define UHCacheEntryKeyLoadOnSessionStart(_id, _entry) \
|
|
UHSetMonitorEntryState(_id, _entry, UH_CACHE_STATE_ON_DISK, \
|
|
UH_CACHE_TRANSITION_KEY_LOAD_ON_SESSION_START)
|
|
|
|
#define UHCacheEntryLoadedFromDisk(_id, _entry) \
|
|
UHSetMonitorEntryState(_id, _entry, UH_CACHE_STATE_IN_MEMORY, \
|
|
UH_CACHE_TRANSITION_LOADED_FROM_DISK)
|
|
|
|
|
|
void DCINTERNAL UHGetCacheBlobRect(unsigned, ULONG, LPRECT);
|
|
|
|
BOOL DCINTERNAL UHGetCacheBlobFromPoint(LPPOINT, unsigned *, ULONG *);
|
|
|
|
void DCINTERNAL UHDisplayCacheEntry(HDC, unsigned, ULONG);
|
|
|
|
void DCINTERNAL UHRefreshDisplayedCacheEntry();
|
|
|
|
void DCINTERNAL UHEnableBitmapCacheMonitor(void);
|
|
|
|
void DCINTERNAL UHDisconnectBitmapCacheMonitor(void);
|
|
#endif /* DC_DEBUG */
|
|
|
|
#if ((defined(OS_WINCE)) && (defined(ENABLE_BMP_CACHING_FOR_WINCE)))
|
|
|
|
#ifndef _tremove
|
|
#define _tremove DeleteFile
|
|
#endif
|
|
|
|
#define WINCE_STORAGE_CARD_DIRECTORY _T("\\Storage Card\\")
|
|
#define WINCE_FILE_SYSTEM_ROOT _T("\\")
|
|
|
|
#endif
|
|
|
|
|
|
/****************************************************************************/
|
|
/* Name: UHUseBkMode */
|
|
/* */
|
|
/* Purpose: Sets given background mode in output DC. */
|
|
/****************************************************************************/
|
|
|
|
#if defined (OS_WINCE)
|
|
|
|
#define UHUseBkMode(_mode, uhinst) \
|
|
if (((_mode) != (uhinst)->_UH.lastBkMode) || \
|
|
((uhinst)->_UH.hdcDraw != (uhinst)->_UH.validBkModeDC)) \
|
|
{ \
|
|
SetBkMode((uhinst)->_UH.hdcDraw, (_mode)); \
|
|
(uhinst)->_UH.lastBkMode = (_mode); \
|
|
(uhinst)->_UH.validBkModeDC = (uhinst)->_UH.hdcDraw; \
|
|
}
|
|
|
|
#else
|
|
|
|
#define UHUseBkMode(_mode, uhinst) \
|
|
{ \
|
|
SetBkMode((uhinst)->_UH.hdcDraw, (_mode)); \
|
|
(uhinst)->_UH.lastBkMode = (_mode); \
|
|
}
|
|
|
|
|
|
#endif
|
|
|
|
/****************************************************************************/
|
|
/* Name: UHUseROP2 */
|
|
/* */
|
|
/* Purpose: Sets given ROP2 in the output DC. */
|
|
/****************************************************************************/
|
|
#if defined (OS_WINCE)
|
|
|
|
#define UHUseROP2(_rop2, uhinst) \
|
|
if (((_rop2) != (uhinst)->_UH.lastROP2) || \
|
|
((uhinst)->_UH.hdcDraw != (uhinst)->_UH.validROPDC)) \
|
|
{ \
|
|
SetROP2((uhinst)->_UH.hdcDraw, (int)(_rop2)); \
|
|
(uhinst)->_UH.lastROP2 = (_rop2); \
|
|
(uhinst)->_UH.validROPDC = (uhinst)->_UH.hdcDraw; \
|
|
}
|
|
|
|
|
|
#else
|
|
|
|
#define UHUseROP2(_rop2, uhinst) \
|
|
{ \
|
|
SetROP2((uhinst)->_UH.hdcDraw, (int)(_rop2)); \
|
|
(uhinst)->_UH.lastROP2 = (_rop2); \
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
/****************************************************************************/
|
|
/* Name: UHUseBrushOrg */
|
|
/* */
|
|
/* Purpose: Sets given brush origin in the output DC. */
|
|
/****************************************************************************/
|
|
|
|
/************************************************************************/
|
|
/* JPB: There is a bug in WinNT as follows (as far as I can determine */
|
|
/* from observing the external behavior!)... */
|
|
/* */
|
|
/* When drawing to DIBSections, a particular (unknown) graphics */
|
|
/* operation occasionally modifies the brush origin in the DC state (in */
|
|
/* kernel mode). I don't know what this operation is, and think that */
|
|
/* it probably shouldn't be doing it. But it does. */
|
|
/* */
|
|
/* If this was the only problem, we could handle it by simply setting */
|
|
/* the origin to the desired value before every graphics call. */
|
|
/* However, this doesn't work! It appears that there is a "fastpath" */
|
|
/* check in the GDI that compares the supplied parameters with the */
|
|
/* previously set parameters, and takes an early exit if they are the */
|
|
/* same (i.e. does not update the DC). Therefore if we set the origin */
|
|
/* to (0,0), it gets mangled by the DIBSection code, then we try to */
|
|
/* set it to (0,0) again the actual DC value is NOT updated (i.e. stays */
|
|
/* in the mangled state). */
|
|
/* */
|
|
/* We therefore have to force the new origin to be set correctly in the */
|
|
/* DC by setting it twice: once to a value different from the one we */
|
|
/* want, then once to the actual value. Not pretty, but unfortunately */
|
|
/* seems to be the only way to ensure that the origin is set correctly! */
|
|
/* */
|
|
/* This problem has only been observed when drawing to 8bpp DIBSections */
|
|
/* on 16bpp and 24bpp machines. */
|
|
/************************************************************************/
|
|
|
|
/************************************************************************/
|
|
/* For Win9x we need to unrealise and re-select the brush before the */
|
|
/* new origin will take effect (BLAH!). On NT this does nothing. */
|
|
/************************************************************************/
|
|
|
|
#define UHUseBrushOrg(_x, _y, uhinst) \
|
|
SetBrushOrgEx((uhinst)->_UH.hdcDraw, (_x) + 1, (_y) + 1, NULL); \
|
|
SetBrushOrgEx((uhinst)->_UH.hdcDraw, (_x), (_y), NULL);
|
|
|
|
#ifdef DC_HICOLOR
|
|
/****************************************************************************/
|
|
/* Macro to calculate the number of cache entries that fit in a given space */
|
|
/****************************************************************************/
|
|
#define CALC_NUM_CACHE_ENTRIES(newNumEntries, origNumEntries, memLen, cacheId) \
|
|
{ \
|
|
DCUINT32 numEntries = (memLen) / UH_CellSizeFromCacheID((cacheId)); \
|
|
newNumEntries = DC_MIN(numEntries, origNumEntries); \
|
|
}
|
|
#endif
|
|
|
|
/****************************************************************************/
|
|
/* Name: UHUseFillMode */
|
|
/* */
|
|
/* Purpose: Sets given fill mode in the output DC. */
|
|
/****************************************************************************/
|
|
#if !defined(OS_WINCE) || defined(OS_WINCE_POLYFILLMODE)
|
|
#define UHUseFillMode(_mode, uhinst) \
|
|
{ \
|
|
SetPolyFillMode((uhinst)->_UH.hdcDraw, ((_mode) == ORD_FILLMODE_WINDING) ? \
|
|
WINDING : ALTERNATE); \
|
|
(uhinst)->_UH.lastFillMode = (unsigned)(_mode); \
|
|
}
|
|
|
|
#else
|
|
|
|
#define UHUseFillMode(_mode, uhinst) \
|
|
(uhinst)->_UH.lastFillMode = (_mode);
|
|
|
|
#endif
|
|
|
|
BOOL UHCreateDisconnectedBitmap();
|
|
|
|
private:
|
|
CGH* _pGh;
|
|
COP* _pOp;
|
|
CSL* _pSl;
|
|
CUT* _pUt;
|
|
CFS* _pFs;
|
|
COD* _pOd;
|
|
CIH* _pIh;
|
|
CCD* _pCd;
|
|
CUI* _pUi;
|
|
CCC* _pCc;
|
|
CCLX* _pClx;
|
|
COR* _pOr;
|
|
|
|
private:
|
|
CObjs* _pClientObjects;
|
|
|
|
};
|
|
|
|
#undef TRC_GROUP
|
|
#undef TRC_FILE
|
|
#undef TSC_HR_FILEID
|
|
|
|
#endif // _H_UH_
|
|
|