/******************************Module*Header*******************************\ * Module Name: driver.h * * Contains prototypes for the display driver. * * Copyright (c) 1992-1995 Microsoft Corporation \**************************************************************************/ ////////////////////////////////////////////////////////////////////// // Put all the conditional-compile constants here. There had better // not be many! // Set this bit when GDI's HOOK_SYNCHRONIZEACCESS works so that we don't // have to worry about synchronizing device-bitmap access. Note that // this wasn't an option in the first release of NT: #define SYNCHRONIZEACCESS_WORKS 1 // When running on an x86, we can make banked call-backs to GDI where // GDI can write directly on the frame buffer. The Alpha has a weird // bus scheme, and can't do that: #if !defined(_ALPHA_) #define GDI_BANKING 1 #else #define GDI_BANKING 0 #endif // Multi-board support can be enabled by setting this to 1: #define MULTI_BOARDS 0 // This is the maximum number of boards we'll support in a single // virtual driver: #if MULTI_BOARDS #define MAX_BOARDS 16 #define IBOARD(ppdev) ((ppdev)->iBoard) #else #define MAX_BOARDS 1 #define IBOARD(ppdev) 0 #endif // Useful for visualizing the 2-d heap: #define DEBUG_HEAP 0 ////////////////////////////////////////////////////////////////////// // Miscellaneous shared stuff #define DLL_NAME L"QV" // Name of the DLL in UNICODE #define STANDARD_DEBUG_PREFIX "Qv: " // All debug output is prefixed // by this string #define ALLOC_TAG ' vqD' // Dqv // Four byte tag (characters in // reverse order) used for memory // allocations #define CLIP_LIMIT 50 // We'll be taking 800 bytes of stack space #define DRIVER_EXTRA_SIZE 0 // Size of the DriverExtra information in the // DEVMODE structure #define TMP_BUFFER_SIZE 8192 // Size in bytes of 'pvTmpBuffer'. Has to // be at least enough to store an entire // scan line (i.e., 6400 for 1600x1200x32). #if defined(ALPHA) #define XFER_BUFFERS 16 // Defines the maximum number of write buffers // possible on any Alpha. Must be a power #else // of two. #define XFER_BUFFERS 1 // On non-alpha systems, we don't have to // worry about the chip caching our bus #endif // writes. #define XFER_MASK (XFER_BUFFERS - 1) typedef struct _CLIPENUM { LONG c; RECTL arcl[CLIP_LIMIT]; // Space for enumerating complex clipping } CLIPENUM; /* ce, pce */ typedef struct _PDEV PDEV; // Handy forward declaration VOID vSetClipping(PDEV*, RECTL*); VOID vResetClipping(PDEV*); ////////////////////////////////////////////////////////////////////// // Text stuff #define GLYPH_CACHE_HEIGHT 32 // Number of scans to allocate for glyph cache #define GLYPH_GRANULARITY 31 // Horizontal granularity for packing glyphs, // expressed in pixels as width minus one #define GLYPH_CACHE_CX 32 // Maximal width of glyphs that we'll consider // caching #define GLYPH_CACHE_CY 32 // Maximum height of glyphs that we'll consider // caching #define MAX_GLYPH_SIZE ((((GLYPH_CACHE_CX + GLYPH_GRANULARITY) & ~GLYPH_GRANULARITY) \ * GLYPH_CACHE_CY + 7) / 8) // Maximum amount of off-screen memory required // to cache a glyph, in bytes #define GLYPH_ALLOC_SIZE 8100 // Do all cached glyph memory allocations // in 8k chunks #define HGLYPH_SENTINEL ((ULONG) -1) // GDI will never give us a glyph with a // handle value of 0xffffffff, so we can // use this as a sentinel for the end of // our linked lists #define GLYPH_HASH_SIZE 256 #define GLYPH_HASH_FUNC(x) ((x) & (GLYPH_HASH_SIZE - 1)) typedef struct _CACHEDGLYPH CACHEDGLYPH; typedef struct _CACHEDGLYPH { CACHEDGLYPH* pcgNext; // Points to next glyph that was assigned // to the same hash table bucket HGLYPH hg; // Handles in the bucket-list are kept in // increasing order POINTL ptlOrigin; // Origin of glyph bits LONG yxHeightWidth; // Packed height and width of glyph ULONG ulSrcLin; // QVision style linear address for glyph in // off-screen memory } CACHEDGLYPH; /* cg, pcg */ typedef struct _GLYPHALLOC GLYPHALLOC; typedef struct _GLYPHALLOC { GLYPHALLOC* pgaNext; // Points to next glyph structure that // was allocated for this font CACHEDGLYPH acg[1]; // This array is a bit misleading, because // the CACHEDGLYPH structures are actually // variable sized } GLYPHAALLOC; /* ga, pga */ typedef struct _CACHEDFONT CACHEDFONT; typedef struct _CACHEDFONT { CACHEDFONT* pcfNext; // Points to next entry in CACHEDFONT list CACHEDFONT* pcfPrev; // Points to previous entry in CACHEDFONT list GLYPHALLOC* pgaChain; // Points to start of allocated memory list CACHEDGLYPH* pcgNew; // Points to where in the current glyph // allocation structure a new glyph should // be placed LONG cjAlloc; // Bytes remaining in current glyph allocation // structure CACHEDGLYPH cgSentinel; // Sentinel entry of the end of our bucket // lists, with a handle of HGLYPH_SENTINEL CACHEDGLYPH* apcg[GLYPH_HASH_SIZE]; // Hash table for glyphs } CACHEDFONT; /* cf, pcf */ BOOL bEnableText(PDEV*); VOID vDisableText(PDEV*); VOID vAssertModeText(PDEV*, BOOL); ////////////////////////////////////////////////////////////////////// // Dither stuff // Describes a single colour tetrahedron vertex for dithering: typedef struct _VERTEX_DATA { ULONG ulCount; // Number of pixels in this vertex ULONG ulVertex; // Vertex number } VERTEX_DATA; /* vd, pv */ VERTEX_DATA* vComputeSubspaces(ULONG, VERTEX_DATA*); VOID vDitherColor(ULONG*, VERTEX_DATA*, VERTEX_DATA*, ULONG); ////////////////////////////////////////////////////////////////////// // Brush stuff #define RBRUSH_2COLOR 1 // For RBRUSH flags #define TOTAL_BRUSH_SIZE 64 // We'll only ever handle 8x8 patterns, // and this is the number of pels typedef struct _BRUSHENTRY BRUSHENTRY; // NOTE: Changes to the RBRUSH or BRUSHENTRY structures must be reflected // in strucs.inc! typedef struct _RBRUSH { FLONG fl; // Type flags ULONG ulForeColor; // Foreground colour if 1bpp ULONG ulBackColor; // Background colour if 1bpp LONG cy; // Unique height of pattern ULONG cyLog2; // Unique height expressed as power of 2 LONG xBlockAlign; // 'x' alignment of block-write pattern ULONG aulBlockPattern[TOTAL_BRUSH_SIZE / 4]; // Contains screen-aligned version of // 'aulPattern', used for block-write // patterns; -1 indicates it's not yet // aligned ULONG aulPattern[1]; // Open-ended array for keeping copy of the // Don't put anything // actual pattern bits in case the brush // after here, or // origin changes, or someone else steals // you'll be sorry! // our brush entry (declared as a ULONG // for proper dword alignment) } RBRUSH; /* rb, prb */ typedef union _RBRUSH_COLOR { RBRUSH* prb; ULONG iSolidColor; } RBRUSH_COLOR; /* rbc, prbc */ BOOL bEnableBrushCache(PDEV*); VOID vDisableBrushCache(PDEV*); VOID vAssertModeBrushCache(PDEV*, BOOL); ///////////////////////////////////////////////////////////////////////// // Heap stuff typedef enum { OFL_INUSE = 1, // The device bitmap is no longer located in // off-screen memory; it's been converted to // a DIB OFL_AVAILABLE = 2, // Space is in-use OFL_PERMANENT = 4 // Space is available } OHFLAGS; // Space is permanently allocated; never free it typedef struct _DSURF DSURF; typedef struct _OH OH; typedef struct _OH { OHFLAGS ofl; // OH_ flags LONG x; // x-coordinate of left edge of allocation LONG y; // y-coordinate of top edge of allocation LONG cx; // Width in pixels of allocation LONG cy; // Height in pixels of allocation OH* pohNext; // When OFL_AVAILABLE, points to the next free node, // in ascending cxcy value. This is kept as a // circular doubly-linked list with a sentinel // at the end. // When OFL_INUSE, points to the next most recently // blitted allocation. This is kept as a circular // doubly-linked list so that the list can be // quickly be updated on every blt. OH* pohPrev; // Opposite of 'pohNext' ULONG cxcy; // Width and height in a dword for searching OH* pohLeft; // Adjacent allocation when in-use or available OH* pohUp; OH* pohRight; OH* pohDown; DSURF* pdsurf; // Points to our DSURF structure }; /* oh, poh */ // This is the smallest structure used for memory allocations: typedef struct _OHALLOC OHALLOC; typedef struct _OHALLOC { OHALLOC* pohaNext; OH aoh[1]; } OHALLOC; /* oha, poha */ typedef struct _HEAP { LONG cxMax; // Largest possible free space by area LONG cyMax; OH ohAvailable; // Head of available list (pohNext points to // smallest available rectangle, pohPrev // points to largest available rectangle, // sorted by cxcy) OH ohDfb; // Head of the list of all DFBs currently in // offscreen memory that are eligible to be // tossed out of the heap (pohNext points to // the most recently blitted; pohPrev points // to least recently blitted) OH* pohFreeList; // List of OH node data structures available OHALLOC* pohaChain; // Chain of allocations } HEAP; /* heap, pheap */ typedef enum { DT_SCREEN, // Surface is kept in screen memory DT_DIB // Surface is kept as a DIB } DSURFTYPE; /* dt, pdt */ typedef struct _DSURF { DSURFTYPE dt; // DSURF status (whether off-screen or in a DIB) SIZEL sizl; // Size of the original bitmap (could be smaller // than poh->sizl) PDEV* ppdev; // Need this for deleting the bitmap union { OH* poh; // If DT_SCREEN, points to off-screen heap node SURFOBJ* pso; // If DT_DIB, points to locked GDI surface }; // The following are used for DT_DIB only... ULONG cBlt; // Counts down the number of blts necessary at // the current uniqueness before we'll consider // putting the DIB back into off-screen memory ULONG iUniq; // Tells us whether there have been any heap // 'free's since the last time we looked at // this DIB } DSURF; /* dsurf, pdsurf */ // GDI expects dword alignment for any bitmaps on which it is expected // to draw. Since we occasionally ask GDI to draw directly on our off- // screen bitmaps, this means that any off-screen bitmaps must be dword // aligned in the frame buffer. We enforce this merely by ensuring that // all off-screen bitmaps are four-pel aligned (we may waste a couple of // pixels at the higher colour depths): #define HEAP_X_ALIGNMENT 4 // Number of blts necessary before we'll consider putting a DIB DFB back // into off-screen memory: #define HEAP_COUNT_DOWN 6 // Flags for 'pohAllocate': typedef enum { FLOH_ONLY_IF_ROOM = 0x00000001, // Don't kick stuff out of off- // screen memory to make room } FLOH; BOOL bEnableOffscreenHeap(PDEV*); VOID vDisableOffscreenHeap(PDEV*); BOOL bAssertModeOffscreenHeap(PDEV*, BOOL); OH* pohMoveOffscreenDfbToDib(PDEV*, OH*); BOOL bMoveDibToOffscreenDfbIfRoom(PDEV*, DSURF*); OH* pohAllocatePermanent(PDEV*, LONG, LONG); BOOL bMoveAllDfbsFromOffscreenToDibs(PDEV* ppdev); ///////////////////////////////////////////////////////////////////////// // Bank manager stuff #define BANK_DATA_SIZE 80 // Number of bytes to allocate for the // miniport down-loaded bank code working // space typedef struct _BANK { // Private data: RECTL rclDraw; // Rectangle describing the remaining undrawn // portion of the drawing operation RECTL rclSaveBounds; // Saved from original CLIPOBJ for restoration BYTE iSaveDComplexity; // Saved from original CLIPOBJ for restoration BYTE fjSaveOptions; // Saved from original CLIPOBJ for restoration LONG iBank; // Current bank PDEV* ppdev; // Saved copy // Public data: SURFOBJ* pso; // Surface wrapped around the bank. Has to be // passed as the surface in any banked call- // back. CLIPOBJ* pco; // Clip object that is the intersection of the // original clip object with the bounds of the // current bank. Has to be passed as the clip // object in any banked call-back. } BANK; /* bnk, pbnk */ typedef enum { BANK_OFF = 0, // We've finished using the memory aperture BANK_ON, // We're about to use the memory aperture BANK_DISABLE, // We're about to enter full-screen; shut down banking BANK_ENABLE, // We've exited full-screen; re-enable banking } BANK_MODE; /* bankm, pbankm */ typedef BOOL (FNBANKCOMPUTE)(PDEV*, RECTL*, RECTL*, LONG*, LONG*); VOID vBankStart(PDEV*, RECTL*, CLIPOBJ*, BANK*); BOOL bBankEnum(BANK*); FNBANKCOMPUTE bBankComputeNonPower2; FNBANKCOMPUTE bBankComputePower2; BOOL bEnableBanking(PDEV*); VOID vDisableBanking(PDEV*); VOID vAssertModeBanking(PDEV*, BOOL); ///////////////////////////////////////////////////////////////////////// // Pointer stuff BOOL bEnablePointer(PDEV*); VOID vDisablePointer(PDEV*); VOID vAssertModePointer(PDEV*, BOOL); BOOL bInitializePointer(PDEV*); VOID vUninitializePointer(PDEV*); ///////////////////////////////////////////////////////////////////////// // Palette stuff BOOL bEnablePalette(PDEV*); VOID vDisablePalette(PDEV*); VOID vAssertModePalette(PDEV*, BOOL); BOOL bInitializePalette(PDEV*, DEVINFO*); VOID vUninitializePalette(PDEV*); #define MAX_CLUT_SIZE (sizeof(VIDEO_CLUT) + (sizeof(ULONG) * 256)) ///////////////////////////////////////////////////////////////////////// // 3D DDI Rendering Extension stuff BOOL bEnableRx(PDEV*); VOID vDisableRx(PDEV*); VOID vAssertModeRx(PDEV*, BOOL); ////////////////////////////////////////////////////////////////////// // Low-level blt function prototypes typedef VOID (FNFILL)(PDEV*, LONG, RECTL*, ULONG, RBRUSH_COLOR, POINTL*); typedef VOID (FNXFER)(PDEV*, LONG, RECTL*, ULONG, SURFOBJ*, POINTL*, RECTL*, XLATEOBJ*); typedef VOID (FNCOPY)(PDEV*, LONG, RECTL*, ULONG, POINTL*, RECTL*); typedef VOID (FNTEXTOUT)(PDEV*, STROBJ*, FONTOBJ*, CLIPOBJ*, RECTL*, BRUSHOBJ*, BRUSHOBJ*); FNFILL vIoFillPat; FNFILL vIoFillSolid; FNXFER vIoXfer1bpp; FNCOPY vIoCopyBlt; FNTEXTOUT vIoTextOut; FNFILL vMmFillPat; FNFILL vMmFillSolid; FNXFER vMmXfer1bpp; FNCOPY vMmCopyBlt; FNTEXTOUT vMmTextOut; VOID vPutBits(PDEV*, SURFOBJ*, RECTL*, POINTL*); VOID vGetBits(PDEV*, SURFOBJ*, RECTL*, POINTL*); BOOL bFastFill(PDEV*, LONG, POINTFIX*, ULONG, ULONG, RBRUSH*, POINTL*); //////////////////////////////////////////////////////////////////////// // Capabilities flags // // These are private flags passed to us from the S3 miniport. They // come from the high word of the 'AttributeFlags' field of the // 'VIDEO_MODE_INFORMATION' structure (found in 'ntddvdeo.h') passed // to us via an 'VIDEO_QUERY_AVAIL_MODES' or 'VIDEO_QUERY_CURRENT_MODE' // IOCTL. // // NOTE: These definitions must match those in the S3 miniport's 's3.h'! typedef enum { } CAPS; //////////////////////////////////////////////////////////////////////// // Status flags typedef enum { STAT_UNACCELERATED = 0x0001, // Unaccelerated 16bpp or 32bpp mode STAT_GLYPH_CACHE = 0x0002, // Off-screen glyph cache allocated } STATUS; //////////////////////////////////////////////////////////////////////// // The Physical Device data structure typedef struct _PDEV { LONG xOffset; // Pixel offset from (0, 0) to current LONG yOffset; // DFB located in off-screen memory BYTE* pjMmBase; // Start of memory mapped I/O BYTE* pjScreen; // Points to base screen address LONG lDelta; // Distance from one scan to the next. LONG cPelSize; // 0 if 8bpp, 1 if 16bpp, 2 if 32bpp ULONG iBitmapFormat; // BMF_8BPP or BMF_16BPP or BMF_32BPP // (our current colour depth) LONG iBoard; // Logical multi-board identifier // (zero by default) // Rendering extensions colour information. UCHAR rDepth; // Number of red bits UCHAR gDepth; // Number of green bits UCHAR bDepth; // Number of blue bits UCHAR aDepth; // Number of alpha bits UCHAR rBitShift; // Left bit-shift for red component UCHAR gBitShift; // Left bit-shift for green component UCHAR bBitShift; // Left bit-shift for blue component UCHAR aBitShift; // Left bit-shift for alpha component BYTE* pjIoBase; // !!! LONG cjPel; // !!! CAPS flCaps; // Capabilities flags STATUS flStat; // Status flags BOOL bEnabled; // In graphics mode (not full-screen) HANDLE hDriver; // Handle to \Device\Screen HDEV hdevEng; // Engine's handle to PDEV HSURF hsurfScreen; // Engine's handle to screen surface DSURF* pdsurfScreen; // Our private DSURF for the screen LONG cxScreen; // Visible screen width LONG cyScreen; // Visible screen height LONG cxMemory; // Width of Video RAM LONG cyMemory; // Height of Video RAM ULONG ulMode; // Mode the mini-port driver is in. FLONG flHooks; // What we're hooking from GDI ULONG ulWhite; // 0xff if 8bpp, 0xffff if 16bpp, // 0xffffffff if 32bpp VOID* pvTmpBuffer; // General purpose temporary buffer, // TMP_BUFFER_SIZE bytes in size // (Remember to synchronize if you // use this for device bitmaps or // async pointers) ////////// Low-level blt function pointers: FNFILL* pfnFillSolid; FNFILL* pfnFillPat; FNXFER* pfnXfer1bpp; FNCOPY* pfnCopyBlt; FNTEXTOUT* pfnTextOut; ////////// Palette stuff: PALETTEENTRY* pPal; // The palette if palette managed HPALETTE hpalDefault; // GDI handle to the default palette. FLONG flRed; // Red mask for 16/32bpp bitfields FLONG flGreen; // Green mask for 16/32bpp bitfields FLONG flBlue; // Blue mask for 16/32bpp bitfields ULONG cPaletteShift; // number of bits the 8-8-8 palette must // be shifted by to fit in the hardware // palette. ////////// Heap stuff: HEAP heap; // All our off-screen heap data ULONG iHeapUniq; // Incremented every time room is freed // in the off-screen heap ////////// Banking stuff: LONG cjBank; // Size of a bank, in bytes LONG cPower2ScansPerBank; // Used by 'bBankComputePower2' LONG cPower2BankSizeInBytes; // Used by 'bBankComputePower2' CLIPOBJ* pcoBank; // Clip object for banked call backs SURFOBJ* psoBank; // Surface object for banked call backs PFN pfnBankSwitchCode; // Pointer to bank switch code VIDEO_BANK_SELECT* pBankInfo; // Bank info for current mode returned // by miniport FNBANKCOMPUTE* pfnBankCompute; ////////// Pointer stuff: VIDEO_POINTER_CAPABILITIES PointerCapabilities; // Capabilities of the hardware // pointer, as reported back by // the miniport VIDEO_POINTER_ATTRIBUTES* pPointerAttributes; // Points to attributes buffer for // current pointer shape LONG cjPointerAttributes; // Length of allocated pointer // attributes buffer LONG cjXorMaskStartOffset; // Offset from start of AND buffer to // start of XOR buffer, in bytes POINTL ptlHotSpot; // Current pointer hot-spot BOOL bPointerEnabled; // True if pointer is current visible ////////// Brush stuff: LONG iBrushCache; // Index for next brush to be allocated LONG cBrushCache; // Total number of brushes cached POINTL ptlReRealize; // Work area for 864/964 pattern // hardware bug work-around ////////// Text stuff: LONG xGlyphCurrent; // x-position of next glyph to be // cached in off-screen memory LONG yGlyphCurrent; // y-position of next glyph LONG yGlyphStart; // y-coordinate of start of glyph cache LONG yGlyphEnd; // y-coordinate of one-past end of // cache CACHEDFONT cfSentinel; // Sentinel for the doubly-linked list // we use to keep track of all // cached font allocations ////////// 3D DDI Rendering Extension stuff: VOID* pvOut; // Points to current output buffer VOID* pvOutMax; // Points to end of current output buffer VOID* pvInMax; // Points to end of current input buffer OH* pohFrontBuffer; // Allocation structure for the screen OH* pohBackBuffer; // Allocation structure for optional // off-screen back buffer LONG cDoubleBufferRef; // Reference count for current number // of RC's that have active double- // buffers POINTL ptlDoubleBuffer[2]; // (x, y) positions of front and back // buffers in video memory // 0 -- RX_BACK_LEFT // 1 -- RX_FRONT_LEFT // Note: Make sure that the index // is in the range [0, 1]! } PDEV; ///////////////////////////////////////////////////////////////////////// // Miscellaneous prototypes: BOOL bIntersect(RECTL*, RECTL*, RECTL*); LONG cIntersect(RECTL*, RECTL*, LONG); DWORD getAvailableModes(HANDLE, PVIDEO_MODE_INFORMATION*, DWORD*); BOOL bInitializeModeFields(PDEV*, GDIINFO*, DEVINFO*, DEVMODEW*); BOOL bEnableHardware(PDEV*); VOID vDisableHardware(PDEV*); BOOL bAssertModeHardware(PDEV*, BOOL); extern BYTE gaRop3FromMix[]; extern BYTE gabMixNeedsPattern[]; extern BYTE gabRopNeedsPattern[]; ///////////////////////////////////////////////////////////////////////// // The x86 C compiler insists on making a divide and modulus operation // into two DIVs, when it can in fact be done in one. So we use this // macro. // // Note: QUOTIENT_REMAINDER implicitly takes unsigned arguments. #if defined(i386) #define QUOTIENT_REMAINDER(ulNumerator, ulDenominator, ulQuotient, ulRemainder) \ { \ __asm mov eax, ulNumerator \ __asm sub edx, edx \ __asm div ulDenominator \ __asm mov ulQuotient, eax \ __asm mov ulRemainder, edx \ } #else #define QUOTIENT_REMAINDER(ulNumerator, ulDenominator, ulQuotient, ulRemainder) \ { \ ulQuotient = (ULONG) ulNumerator / (ULONG) ulDenominator; \ ulRemainder = (ULONG) ulNumerator % (ULONG) ulDenominator; \ } #endif ///////////////////////////////////////////////////////////////////////// // OVERLAP - Returns TRUE if the same-size lower-right exclusive // rectangles defined by 'pptl' and 'prcl' overlap: #define OVERLAP(prcl, pptl) \ (((prcl)->right > (pptl)->x) && \ ((prcl)->bottom > (pptl)->y) && \ ((prcl)->left < ((pptl)->x + (prcl)->right - (prcl)->left)) && \ ((prcl)->top < ((pptl)->y + (prcl)->bottom - (prcl)->top))) ///////////////////////////////////////////////////////////////////////// // SWAP - Swaps the value of two variables, using a temporary variable #define SWAP(a, b, tmp) { (tmp) = (a); (a) = (b); (b) = (tmp); } ////////////////////////////////////////////////////////////////////// // These Mul prototypes are thunks for multi-board support: ULONG MulGetModes(HANDLE, ULONG, DEVMODEW*); DHPDEV MulEnablePDEV(DEVMODEW*, PWSTR, ULONG, HSURF*, ULONG, ULONG*, ULONG, DEVINFO*, HDEV, PWSTR, HANDLE); VOID MulCompletePDEV(DHPDEV, HDEV); HSURF MulEnableSurface(DHPDEV); BOOL MulStrokePath(SURFOBJ*, PATHOBJ*, CLIPOBJ*, XFORMOBJ*, BRUSHOBJ*, POINTL*, LINEATTRS*, MIX); BOOL MulFillPath(SURFOBJ*, PATHOBJ*, CLIPOBJ*, BRUSHOBJ*, POINTL*, MIX, FLONG); BOOL MulBitBlt(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, POINTL*, POINTL*, BRUSHOBJ*, POINTL*, ROP4); VOID MulDisablePDEV(DHPDEV); VOID MulDisableSurface(DHPDEV); BOOL MulAssertMode(DHPDEV, BOOL); VOID MulMovePointer(SURFOBJ*, LONG, LONG, RECTL*); ULONG MulSetPointerShape(SURFOBJ*, SURFOBJ*, SURFOBJ*, XLATEOBJ*, LONG, LONG, LONG, LONG, RECTL*, FLONG); ULONG MulDitherColor(DHPDEV, ULONG, ULONG, ULONG*); BOOL MulSetPalette(DHPDEV, PALOBJ*, FLONG, ULONG, ULONG); BOOL MulCopyBits(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, POINTL*); BOOL MulTextOut(SURFOBJ*, STROBJ*, FONTOBJ*, CLIPOBJ*, RECTL*, RECTL*, BRUSHOBJ*, BRUSHOBJ*, POINTL*, MIX); VOID MulDestroyFont(FONTOBJ*); BOOL MulPaint(SURFOBJ*, CLIPOBJ*, BRUSHOBJ*, POINTL*, MIX); BOOL MulRealizeBrush(BRUSHOBJ*, SURFOBJ*, SURFOBJ*, SURFOBJ*, XLATEOBJ*, ULONG); HBITMAP MulCreateDeviceBitmap(DHPDEV, SIZEL, ULONG); VOID MulDeleteDeviceBitmap(DHSURF); BOOL MulStretchBlt(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, COLORADJUSTMENT*, POINTL*, RECTL*, RECTL*, POINTL*, ULONG); // These Dbg prototypes are thunks for debugging: ULONG DbgGetModes(HANDLE, ULONG, DEVMODEW*); DHPDEV DbgEnablePDEV(DEVMODEW*, PWSTR, ULONG, HSURF*, ULONG, ULONG*, ULONG, DEVINFO*, HDEV, PWSTR, HANDLE); VOID DbgCompletePDEV(DHPDEV, HDEV); HSURF DbgEnableSurface(DHPDEV); BOOL DbgStrokePath(SURFOBJ*, PATHOBJ*, CLIPOBJ*, XFORMOBJ*, BRUSHOBJ*, POINTL*, LINEATTRS*, MIX); BOOL DbgFillPath(SURFOBJ*, PATHOBJ*, CLIPOBJ*, BRUSHOBJ*, POINTL*, MIX, FLONG); BOOL DbgBitBlt(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, POINTL*, POINTL*, BRUSHOBJ*, POINTL*, ROP4); VOID DbgDisablePDEV(DHPDEV); VOID DbgDisableSurface(DHPDEV); BOOL DbgAssertMode(DHPDEV, BOOL); VOID DbgMovePointer(SURFOBJ*, LONG, LONG, RECTL*); ULONG DbgSetPointerShape(SURFOBJ*, SURFOBJ*, SURFOBJ*, XLATEOBJ*, LONG, LONG, LONG, LONG, RECTL*, FLONG); ULONG DbgDitherColor(DHPDEV, ULONG, ULONG, ULONG*); BOOL DbgSetPalette(DHPDEV, PALOBJ*, FLONG, ULONG, ULONG); BOOL DbgCopyBits(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, POINTL*); BOOL DbgTextOut(SURFOBJ*, STROBJ*, FONTOBJ*, CLIPOBJ*, RECTL*, RECTL*, BRUSHOBJ*, BRUSHOBJ*, POINTL*, MIX); VOID DbgDestroyFont(FONTOBJ*); BOOL DbgPaint(SURFOBJ*, CLIPOBJ*, BRUSHOBJ*, POINTL*, MIX); BOOL DbgRealizeBrush(BRUSHOBJ*, SURFOBJ*, SURFOBJ*, SURFOBJ*, XLATEOBJ*, ULONG); HBITMAP DbgCreateDeviceBitmap(DHPDEV, SIZEL, ULONG); VOID DbgDeleteDeviceBitmap(DHSURF); BOOL DbgStretchBlt(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, COLORADJUSTMENT*, POINTL*, RECTL*, RECTL*, POINTL*, ULONG); BOOL DbgEscape(SURFOBJ*, ULONG, ULONG, VOID*, ULONG, VOID*);