Sample Code
Windows Driver Samples/ MSPLOT Plotter Driver Sample/ C++/ plotter/ brush.c/
/*++
Copyright (c) 1990-2003 Microsoft Corporation
Module Name:
brush.c
Abstract:
This module implements the code to realize brushes. BRUSHOBJS, are
representations of logical objects. These objects are created in the
win32 world and eventually need to be converted (or realized) to
something that makes sense in the target device. This is done by realizing
a brush. We look at the logical representation of the brush, then based
on physical device characteristics, do the best job we can of simulating
it on the target device. This conversion is done once, and the result
is stored in the structure that represents the REALIZED brush. This
is optimal since brushes tend to get re-used, and REALIZING them
once, keeps us from having to execute the code every time a brush is used.
Author:
19:15 on Mon 15 Apr 1991
Created it
15-Nov-1993 Mon 19:29:07 updated
clean up / fixed
27-Jan-1994 Thu 23:39:34 updated
Add fill type cache. which we do not have to send FT if same one
already on the plotter
[Environment:]
GDI Device Driver - Plotter.
[Notes:]
Revision History:
--*/
#include "precomp.h"
#pragma hdrstop
#define DBG_PLOTFILENAME DbgBrush
#define DBG_RBRUSH 0x00000001
#define DBG_HATCHTYPE 0x00000002
#define DBG_SHOWSTDPAT 0x00000004
#define DBG_COPYUSERPATBGR 0x00000008
#define DBG_MINHTSIZE 0x00000010
#define DBG_FINDDBCACHE 0x00000020
DEFINE_DBGVAR(0);
//
// The pHSFillType's #d is the line spacing param
//
// for hatch brushes, we want the lines to be .01" thick and .0666666666667"
// this is 15 LPI according to DC. That is, .254mm thick and 2.54mm apart.
// for now, assume the pen is the correct thickness (.3 is right) to figure
// out the separation, in device coordinates, we do 2.54 mm * (device units /
// mm), or (254 * resolution / 100) where resolution is in device units /
// milimeter.
//
#define PATLINESPACE(pPDev) FXTODEVL(pPDev,LTOFX(pPDev->lCurResolution+7)/15)
static const BYTE CellSizePrims[10][4] = {
{ 2, 0, 0, 0 }, // 2x 2
{ 2, 2, 0, 0 }, // 4x 4
{ 2, 3, 0, 0 }, // 6x 6
{ 2, 2, 2, 0 }, // 8x 8
{ 2, 5, 0, 0 }, // 10x10
{ 2, 2, 3, 0 }, // 12x12
{ 2, 7, 0, 0 }, // 14x14
{ 2, 2, 2, 2 }, // 16x16
{ 91,0, 0, 0 }, // 91x91
{ 91,0, 0, 0 } // 91x91
};
VOID
ResetDBCache(
PPDEV pPDev
)
/*++
Routine Description:
This function clears the Device brush cach mechanism.
Arguments:
pPDev - Pointer to our PDEV
Return Value:
VOID
Author:
27-Jan-1994 Thu 20:30:35 created
Revision History:
--*/
{
PDBCACHE pDBCache;
UINT i;
pDBCache = (PDBCACHE)&pPDev->DBCache[0];
for (i = RF_MAX_IDX; i; i--, pDBCache++) {
pDBCache->RFIndex = (WORD)i;
pDBCache->DBUniq = 0;
}
}
LONG
FindDBCache(
PPDEV pPDev,
WORD DBUniq
)
/*++
Routine Description:
This function finds the RF Index number, if not there then it will add it
to the cache.
Arguments:
pPDev - Pointer to our PDEV
DBUniq - Uniq number to be search for
Return Value:
LONG value >0 found and RetVal is the RFIndex
<0 NOT Found and -RetVal is the new RFIndex
Author:
27-Jan-1994 Thu 20:32:12 created
Revision History:
--*/
{
PDBCACHE pDBCache;
DBCACHE DBCache;
LONG RetVal;
UINT i;
PLOTASSERT(1, "FindDevBrushCache: DBUniq is 0", DBUniq, 0);
pDBCache = (PDBCACHE)&pPDev->DBCache[0];
for (i = 0; i < RF_MAX_IDX; i++, pDBCache++) {
if (pDBCache->DBUniq == DBUniq) {
break;
}
}
if (i < RF_MAX_IDX) {
DBCache = *pDBCache;
RetVal = (LONG)DBCache.RFIndex;
PLOTDBG(DBG_FINDDBCACHE, ("FindDBCache: Found Uniq=%lu, RFIdx=%ld",
(DWORD)DBCache.DBUniq, (DWORD)DBCache.RFIndex));
} else {
//
// Since we did not find the pattern in the cache, we will add it
// to the beggining and move the rest of the entries down the list.
// We need to remember the last one.
//
pDBCache = (PDBCACHE)&pPDev->DBCache[i = (RF_MAX_IDX - 1)];
DBCache = *pDBCache;
DBCache.DBUniq = DBUniq;
RetVal = -(LONG)DBCache.RFIndex;
PLOTDBG(DBG_FINDDBCACHE, ("FindDBCache: NOT Found, NEW DBCache: Uniq=%lu, RFIdx=%ld",
(DWORD)DBCache.DBUniq, (DWORD)DBCache.RFIndex));
}
PLOTASSERT(1, "FindDBCache: Invalid RFIndex=%ld in the cache",
(DBCache.RFIndex > 0) && (DBCache.RFIndex <= RF_MAX_IDX),
(DWORD)DBCache.RFIndex);
//
// Move everything down by one slot, so the first one is the most
// recently used.
//
while (i--) {
*pDBCache = *(pDBCache - 1);
--pDBCache;
}
//
// Save the current cach back and return the RF index.
//
*pDBCache = DBCache;
return(RetVal);
}
BOOL
CopyUserPatBGR(
PPDEV pPDev,
SURFOBJ *psoPat,
XLATEOBJ *pxlo,
LPBYTE pBGRBmp
)
/*++
Routine Description:
This function take a pattern surface and converts it to a form suitable,
for downloading to the target device. The target device in this case,
expects a pattern made up of different pens that define the color of each
individual pixel. This conversion is done by first creating a
BitmapSurface (24 bpp) of the passed in size, then EngBitBliting, the
passed surface (that defines the pattern) into that 24 bpp surface, and
finally copying the color data into the passed buffer.
Arguments:
pPDev - Pointer to our PDEV
psoSrc - source surface object
pxlo - translate object
pBGRBmp - Pointer a 8x8 palette location for the bitmap
Return Value:
TRUE if sucessful, FALSE if failed
Author:
18-Jan-1994 Tue 03:20:10 created
Revision History:
--*/
{
SURFOBJ *pso24;
HBITMAP hBmp24;
if (pso24 = CreateBitmapSURFOBJ(pPDev,
&hBmp24,
psoPat->sizlBitmap.cx,
psoPat->sizlBitmap.cy,
BMF_24BPP,
NULL)) {
LPBYTE pbSrc;
RECTL rclDst;
DWORD SizeBGRPerScan;
BOOL Ok;
rclDst.left =
rclDst.top = 0;
rclDst.right = pso24->sizlBitmap.cx;
rclDst.bottom = pso24->sizlBitmap.cy;
if (!(Ok = EngBitBlt(pso24, // psoDst
psoPat, // psoSrc
NULL, // psoMask
NULL, // pco
pxlo, // pxlo
&rclDst, // prclDst
(PPOINTL)&rclDst, // pptlSrc
NULL, // pptlMask
NULL, // pbo
NULL, // pptlBrushOrg
0xCCCC))) {
PLOTERR(("CopyUserPatBGR: EngBitBlt() FALIED"));
return(FALSE);
}
SizeBGRPerScan = (DWORD)(pso24->sizlBitmap.cx * 3);
pbSrc = (LPBYTE)pso24->pvScan0;
PLOTDBG(DBG_COPYUSERPATBGR, ("CopyUserPatBGR: PerScan=%ld [%ld], cy=%ld",
SizeBGRPerScan, pso24->lDelta, rclDst.bottom));
while (rclDst.bottom--) {
CopyMemory(pBGRBmp, pbSrc, SizeBGRPerScan);
pBGRBmp += SizeBGRPerScan;
pbSrc += pso24->lDelta;
}
if (pso24) {
EngUnlockSurface(pso24);
}
if (hBmp24) {
EngDeleteSurface((HSURF)hBmp24);
}
return(Ok);
} else {
PLOTERR(("CopyUserPatBGR: CANNOT Create 24BPP for UserPat"));
return(FALSE);
}
}
VOID
GetMinHTSize(
PPDEV pPDev,
SIZEL *pszlPat
)
/*++
Routine Description:
This function computes and returns the minimum pattern size in pszlPat for
a halftone tile-able pattern size. This is required in order to tile a
repeating pattern correctly when filling an object. If the original
brush wasn't useable, we create a composite of that original bitmap, by
halftoning into a surface. In order for the result to be tile-able,
we must take into account the different Cell/Patter sizes for our
halftone data.
Arguments:
pPDev - Point to our PDEV
pszlPat - Points to a SIZEL structure for the original pattern size
Return Value:
VOID
Author:
26-Jan-1994 Wed 10:10:15 created
Revision History:
--*/
{
LPBYTE pCellPrims;
LPBYTE pPrims;
LONG Prim;
SIZEL szlPat;
LONG CellSize;
UINT i;
if (0 == pszlPat->cx || 0 == pszlPat->cy)
{
return;
}
szlPat = *pszlPat;
CellSize = (LONG)HTPATSIZE(pPDev);
pCellPrims = (LPBYTE)&CellSizePrims[(CellSize >> 1) - 1][0];
if (!(CellSize % szlPat.cx)) {
szlPat.cx = CellSize;
} else if (szlPat.cx % CellSize) {
//
// Since it's not an exact fit, calculate the correct number now.
//
i = 4;
pPrims = pCellPrims;
while ((i--) && (Prim = (LONG)*pPrims++)) {
if (!(szlPat.cx % Prim)) {
szlPat.cx /= Prim;
}
}
szlPat.cx *= CellSize;
}
if (!(CellSize % szlPat.cy)) {
szlPat.cy = CellSize;
} else if (szlPat.cy % CellSize) {
//
// Since it's not an exact fit, calculate the correct number now.
//
i = 4;
pPrims = pCellPrims;
while ((i--) && (Prim = (LONG)*pPrims++)) {
if (!(szlPat.cy % Prim)) {
szlPat.cy /= Prim;
}
}
szlPat.cy *= CellSize;
}
PLOTDBG(DBG_MINHTSIZE, ("GetMinHTSize: PatSize=%ld x %ld, HTSize=%ld x %ld, MinSize=%ld x %ld",
pszlPat->cx, pszlPat->cy, CellSize, CellSize,
szlPat.cx, szlPat.cy));
*pszlPat = szlPat;
}
_Use_decl_annotations_
BOOL
WINAPI
DrvRealizeBrush(
BRUSHOBJ *pbo,
SURFOBJ *psoDst,
SURFOBJ *psoPattern,
SURFOBJ *psoMask,
XLATEOBJ *pxlo,
ULONG iHatch
)
/*++
Routine Description:
DrvRealizeBrush requests the driver to realize a specified brush for a
specified surface. NT's GDI will usually realize a brush before using it.
Realing a brush allows our driver to take a logical representation of
a brush, and convert it to something that makes sense in the target device.
By having the NT GDI realize the brush, in essence allows us to cache the
physical representation of the brush, for future use.
Arguments:
pbo - Points to the BRUSHOBJ which is to be realized. All the other
parameters, except for psoDst, can be queried from this
object. Parameter specifications are provided as an
optimization. This parameter is best used only as a parameter
for BRUSHOBJ_pvAllocRBrush, which allocates the memory for
the realized brush.
psoDst - Points to the surface for which the brush is to be realized.
This surface could be the physical surface for the device,
a device format bitmap, or a standard format bitmap.
psoPattern - Points to the surface that describes the pattern for the
brush. For a raster device, this always represents a bitmap.
For a vector device, this is always one of the pattern
surfaces returned by DrvEnablePDEV.
psoMask - Points to a transparency mask for the brush. This is a one
bit per pixel bitmap that has the same extent as the pattern.
A mask of zero means the pixel is considered a background
pixel for the brush. (In transparent background mode, the
background pixels are unaffected in a fill.) Pen Plotters can
ignore this parameter because they never draw background
information.
pxlo - Points to an XLATEOBJ that tells how to interpret the colors
in the pattern. An XLATEOBJXxx service routine can be called
to translate the colors to device color indexes. Vector
devices should translate color zero through the XLATEOBJ to
get the foreground color for the brush.
iHatch - If this is less than HS_API_MAX, then it indicates that
psoPattern is one of the hatch brushes returned by
DrvEnablePDEV, such as HS_HORIZONTAL.
Return Value:
DrvRealizeBrush returns TRUE if the brush was successfully realized.
Otherwise, FALSE is returned and an error code is logged.
Author:
09-Feb-1994 Wed 10:04:17 updated
Put the CloneSURFOBJToHT() back for all psoPatterns, (this was to
prevent GDI go into GP), now we will raised a bug against it.
13-Jan-1994 Thu 23:12:40 updated
Totally re-write so that we will cached the psoPattern always
01-Dec-1993 Wed 17:27:19 updated
clean up, and re-write to generate the standard brush string.
Revision History:
--*/
{
PPDEV pPDev;
if (!(pPDev = SURFOBJ_GETPDEV(psoDst))) {
PLOTERR(("DrvRealizeBrush has invalid pPDev"));
return(FALSE);
}
//
// We don't check if iHatch is valid or not at this poin.
// We should always get a psoPattern that either points to the user
// defined pattern or to the standard monochrome pattern.
//
if ((psoPattern) &&
(psoPattern->iType == STYPE_BITMAP)) {
PDEVBRUSH pBrush;
SURFOBJ *psoHT;
HBITMAP hBmp;
SIZEL szlPat;
SIZEL szlHT;
RECTL rclHT;
LONG Size;
DWORD OffBGR;
BOOL RetOk;
//
// leave room for the color table. then allocate the new device brush
//
PLOTDBG(DBG_RBRUSH, ("DrvRealizeBrush: psoPat=%08lx [%ld], psoMask=%08lx, iHatch=%ld",
psoPattern, psoPattern->iBitmapFormat, psoMask, iHatch));
PLOTDBG(DBG_RBRUSH, ("psoPattern size = %ld x %ld",
(LONG)psoPattern->sizlBitmap.cx,
(LONG)psoPattern->sizlBitmap.cy));
#if DBG
if ((DBG_PLOTFILENAME & DBG_SHOWSTDPAT) &&
((psoPattern->iBitmapFormat == BMF_1BPP) ||
(iHatch < HS_DDI_MAX))) {
LPBYTE pbSrc;
LPBYTE pbCur;
LONG x;
LONG y;
BYTE bData = 0x0;
BYTE Mask;
BYTE Buf[128];
//
// Debug code that allows the pattern to be displayed with
// ASCII codes on the debug terminal. This was very helpful
// during development.
//
pbSrc = psoPattern->pvScan0;
for (y = 0; y < psoPattern->sizlBitmap.cy; y++) {
pbCur = pbSrc;
pbSrc += psoPattern->lDelta;
Mask = 0x0;
Size = 0;
for (x = 0;
x < psoPattern->sizlBitmap.cx && Size < sizeof(Buf);
x++)
{
if (!(Mask >>= 1)) {
Mask = 0x80;
bData = *pbCur++;
}
Buf[Size++] = (BYTE)((bData & Mask) ? 0xdb : 0xb0);
}
if (Size < sizeof(Buf))
{
Buf[Size] = '\0';
}
else
{
//
// Error case. Null-terminate anyway.
//
Buf[sizeof(Buf) - 1] = '\0';
}
DBGP((Buf));
}
}
#endif
//
// For pen plotter, we need to remember this one as well.
//
szlHT =
szlPat = psoPattern->sizlBitmap;
PLOTDBG(DBG_RBRUSH,
("DrvRealizeBrush: BG=%08lx, FG=%08lx",
(DWORD)XLATEOBJ_iXlate(pxlo, 1),
(DWORD)XLATEOBJ_iXlate(pxlo, 0)));
if (IS_RASTER(pPDev)) {
//
// For raster plotters, we will clone the surface and halftone
// the orignal pattern into a halftone bitmap which itself is
// tile-able. This allows us to use our color reduction code,
// to make the pattern look good.
//
if ((iHatch >= HS_DDI_MAX) &&
(!IsHTCompatibleSurfObj(pPDev,
psoPattern,
pxlo,
ISHTF_ALTFMT | ISHTF_DSTPRIM_OK))) {
GetMinHTSize(pPDev, &szlHT);
}
rclHT.left =
rclHT.top = 0;
rclHT.right = szlHT.cx;
rclHT.bottom = szlHT.cy;
PLOTDBG(DBG_RBRUSH,
("DrvRealizeBrush: PatSize=%ld x %ld, HT=%ld x %ld",
szlPat.cx, szlPat.cy, szlHT.cx, szlHT.cy));
//
// Go generate the bits for the pattern.
//
if (psoHT = CloneSURFOBJToHT(pPDev, // pPDev,
psoDst, // psoDst,
psoPattern, // psoSrc,
pxlo, // pxlo,
&hBmp, // hBmp,
&rclHT, // prclDst,
NULL)) { // prclSrc,
RetOk = TRUE;
} else {
PLOTDBG(DBG_RBRUSH, ("DrvRealizeBrush: Clone PATTERN FAILED"));
return(FALSE);
}
} else {
//
// For Pen type plotter we will never do a standard pattern in the
// memory (compatible DC). For user defined patterns we will
// only hatch '\' with background color and a '/' with foreground
// color with double standard line spacing. This is the best we
// can hope for on a pen plotter.
//
RetOk = TRUE;
psoHT = psoPattern;
hBmp = NULL;
}
if (RetOk) {
//
// Now Allocate device brush, remember we will only allocate the
// minimum size.
//
Size = (LONG)psoHT->cjBits - (LONG)sizeof(pBrush->BmpBits);
if (Size < 0) {
Size = sizeof(DEVBRUSH);
} else {
Size += sizeof(DEVBRUSH);
}
//
// Following are the user defined pattern sizes which can be handled
// internally by HPGL2. This is only for raster plotters. Pen
// plotters will have a cross hatch to show an emulation of the
// pattern.
//
if ((iHatch >= HS_DDI_MAX) &&
(IS_RASTER(pPDev)) &&
((szlPat.cx == 8) ||
(szlPat.cx == 16) ||
(szlPat.cx == 32) ||
(szlPat.cx == 64)) &&
((szlPat.cy == 8) ||
(szlPat.cy == 16) ||
(szlPat.cy == 32) ||
(szlPat.cy == 64))) {
ULONG ulMemAllocSize = 0;
//
// Adding the size which stored the BGR format of the pattern
//
OffBGR = Size;
if (
! SUCCEEDED(ULongMult(psoPattern->sizlBitmap.cx, 3, &ulMemAllocSize)) ||
! SUCCEEDED(ULongMult(ulMemAllocSize, psoPattern->sizlBitmap.cy, &ulMemAllocSize)) ||
! SUCCEEDED(ULongAdd(Size, ulMemAllocSize, &ulMemAllocSize)) ||
((Size = ulMemAllocSize) < 0)
)
{
PLOTERR(("DrvRealizeBrush: arithmetic overflow"));
RetOk = FALSE;
}
} else {
OffBGR = 0;
}
if (RetOk)
{
PLOTDBG(DBG_RBRUSH, ("DrvRealizeBrush: AllocDEVBRUSH(Bmp=%ld,BGR=%ld), TOT=%ld",
psoHT->cjBits, Size - OffBGR, Size));
//
// Now ask the NT graphics engine to allocate the device
// brush memory for us. This is done, so NT knows how to discard
// the memory when it is no longer needed (The brush getting
// destroyed).
//
if (pBrush = (PDEVBRUSH)BRUSHOBJ_pvAllocRbrush(pbo, Size)) {
//
// Set up either standard pattern or user defined pattern
// HPGL/2 FT command string pointer and parameters.
//
pBrush->psoMask = psoMask;
pBrush->PatIndex = (WORD)iHatch;
pBrush->Uniq = (WORD)(pPDev->DevBrushUniq += 1);
pBrush->LineSpacing = (LONG)PATLINESPACE(pPDev);
pBrush->ColorFG = (DWORD)XLATEOBJ_iXlate(pxlo, 1);
pBrush->ColorBG = (DWORD)XLATEOBJ_iXlate(pxlo, 0);
pBrush->sizlBitmap = psoHT->sizlBitmap;
pBrush->ScanLineDelta = psoHT->lDelta;
pBrush->BmpFormat = (WORD)psoHT->iBitmapFormat;
pBrush->BmpFlags = (WORD)psoHT->fjBitmap;
pBrush->pbgr24 = NULL;
pBrush->cxbgr24 =
pBrush->cybgr24 = 0;
PLOTDBG(DBG_RBRUSH, ("DrvRealizeBrush: DevBrush's Uniq = %ld",
pBrush->Uniq));
//
// Check to see if the cache is wrapping and handle it.
//
if (pBrush->Uniq == 0) {
ResetDBCache(pPDev);
pBrush->Uniq =
pPDev->DevBrushUniq = 1;
PLOTDBG(DBG_RBRUSH, ("DrvRealizeBrush: Reset DB Cache, (Uniq WRAP)"));
}
//
// Is it a user defined pattern.
//
if (iHatch >= HS_DDI_MAX) {
//
// Check to see if the brush could be downloaded to the
// target device as an HPGL2 brush. If this is the case
// save that information.
//
if (OffBGR) {
pBrush->pbgr24 = (LPBYTE)pBrush + OffBGR;
pBrush->cxbgr24 = (WORD)psoPattern->sizlBitmap.cx;
pBrush->cybgr24 = (WORD)psoPattern->sizlBitmap.cy;
ZeroMemory(pBrush->pbgr24, Size - OffBGR);
CopyUserPatBGR(pPDev, psoPattern, pxlo, pBrush->pbgr24);
} else if (!IS_RASTER(pPDev)) {
//
// If we are not talking to a RASTER plotter, not much
// we can do here. Trigger the simulation.
//
pBrush->pbgr24 = (LPBYTE)-1;
}
}
//
// Copy down the halftoned bits if any.
//
if (psoHT->cjBits) {
CopyMemory((LPBYTE)pBrush->BmpBits,
(LPBYTE)psoHT->pvBits,
psoHT->cjBits);
}
//
// Now record the realized brush pointer in the BRUSHOBJ.
//
pbo->pvRbrush = (LPVOID)pBrush;
}
} else {
PLOTERR(("DrvRealizeBrush: brush allocation failed"));
RetOk = FALSE;
}
} else {
PLOTERR(("DrvRealizeBrush: Cloning the psoPattern failed!"));
RetOk = FALSE;
}
if (psoHT != psoPattern) {
EngUnlockSurface(psoHT);
}
if (hBmp) {
EngDeleteSurface((HSURF)hBmp);
}
return(RetOk);
} else {
PLOTASSERT(0, "The psoPattern is not a bitmap (psoPattern= %08lx)",
(psoPattern) &&
(psoPattern->iType == STYPE_BITMAP), psoPattern);
return(FALSE);
}
}
Our Services
-
What our customers say about us?
Read our customer testimonials to find out why our clients keep returning for their projects.
View Testimonials
