windows-server-2003/termsrv/newclient/core/uh.h

/****************************************************************************/
// 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_