1162 lines
36 KiB
C
1162 lines
36 KiB
C
|
|
|
|
/****************************************************************************
|
|
Unit Cache; Implementation
|
|
*****************************************************************************
|
|
|
|
Module Prefix: Ca
|
|
|
|
****************************************************************************/
|
|
|
|
#include "headers.c"
|
|
#pragma hdrstop
|
|
|
|
#include "cache.h" /* own interface */
|
|
|
|
/*********************** Exported Data **************************************/
|
|
|
|
|
|
/*********************** Private Data ***************************************/
|
|
|
|
/*--- Gdi cache ---*/
|
|
|
|
typedef struct
|
|
{
|
|
HPEN handle;
|
|
LOGPEN logPen;
|
|
Boolean stockObject;
|
|
|
|
} Pen, far * PenLPtr;
|
|
|
|
|
|
typedef struct
|
|
{
|
|
HBRUSH handle;
|
|
LOGBRUSH logBrush;
|
|
Boolean stockObject;
|
|
|
|
} Brush, far * BrushLPtr;
|
|
|
|
|
|
typedef struct
|
|
{
|
|
Handle metafile; // metafile handle
|
|
|
|
Rect prevClipRect; // last cliprect before SaveDC()
|
|
Rect curClipRect; // last clipping rectangle
|
|
Boolean forceNewClipRect; // always emit new clipping rectangle?
|
|
|
|
HPEN nulPen; // frequently used pens
|
|
HPEN whitePen;
|
|
HPEN blackPen;
|
|
|
|
HBRUSH nulBrush; // frequently used brushes
|
|
HBRUSH whiteBrush;
|
|
HBRUSH blackBrush;
|
|
|
|
Boolean stockFont; // current font selection
|
|
HFONT curFont;
|
|
LOGFONT curLogFont;
|
|
|
|
Brush curBrush; // current pen and brush selections
|
|
Pen curPen;
|
|
Pen nextPen; // cached frame(pen)
|
|
|
|
CaPrimitive nextPrim; // cached primitive
|
|
Boolean samePrim;
|
|
Handle polyHandle;
|
|
Integer numPoints;
|
|
Integer maxPoints;
|
|
Point far * pointList;
|
|
|
|
Word iniROP2; // initial value for ROP2 mode
|
|
Word iniTextAlign; // initial value for text alignment
|
|
Word iniBkMode;
|
|
RGBColor iniTxColor;
|
|
RGBColor iniBkColor;
|
|
|
|
Word curROP2; // current ROP codes setting
|
|
Word curBkMode; // current background mode
|
|
RGBColor curBkColor; // current background color
|
|
Word curStretchMode; // current stretchblt mode
|
|
|
|
RGBColor curTextColor; // last text color
|
|
Word curTextAlign; // last text alignment value
|
|
short curCharExtra; // last char extra value
|
|
Fixed spExtra; // last space extra value
|
|
Point txNumer; // last text scaling
|
|
Point txDenom; // factors
|
|
|
|
Boolean restorePen; // do any attribs need to be re-issued
|
|
Boolean restoreBrush; // after RestoreDC() call?
|
|
Boolean restoreFont;
|
|
Boolean restoreCharExtra;
|
|
Boolean restoreStretchMode;
|
|
|
|
} GdiCache;
|
|
|
|
private GdiCache gdiCache;
|
|
|
|
/*********************** Private Function Definitions ***********************/
|
|
|
|
#define /* void */ NewPolygon( /* void */ ) \
|
|
/* start a new polygon definition */ \
|
|
gdiCache.numPoints = 0
|
|
|
|
|
|
private void AddPolyPt( Point pt );
|
|
/* Add a point to the polygon buffer */
|
|
|
|
|
|
private void SelectCachedPen( void );
|
|
/* select the currently cached Pen into the metafile */
|
|
|
|
|
|
/*********************** Function Implementation ****************************/
|
|
|
|
|
|
void CaInit( Handle metafile )
|
|
/*=========*/
|
|
/* initialize the gdi cache module */
|
|
{
|
|
/* save off the metafile handle into global structure */
|
|
gdiCache.metafile = metafile;
|
|
|
|
/* make sure that text and background colors will be set */
|
|
gdiCache.curTextColor =
|
|
gdiCache.curBkColor = RGB( 12, 34, 56 );
|
|
|
|
/* get handles to some stock pen objects */
|
|
gdiCache.nulPen = GetStockObject( NULL_PEN );
|
|
gdiCache.whitePen = CreatePen( PS_INSIDEFRAME, 1, RGB( 255, 255, 255 ) );
|
|
gdiCache.blackPen = CreatePen( PS_INSIDEFRAME, 1, RGB( 0, 0, 0 ) );
|
|
|
|
/* get handles to some stock brush objects */
|
|
gdiCache.nulBrush = GetStockObject( NULL_BRUSH );
|
|
gdiCache.whiteBrush = GetStockObject( WHITE_BRUSH );
|
|
gdiCache.blackBrush = GetStockObject( BLACK_BRUSH );
|
|
|
|
/* allocate space for the polygon buffer */
|
|
gdiCache.numPoints = 0;
|
|
gdiCache.maxPoints = 16;
|
|
gdiCache.polyHandle = GlobalAlloc( GHND, gdiCache.maxPoints * sizeof( Point ) );
|
|
if (gdiCache.polyHandle == NULL)
|
|
{
|
|
ErSetGlobalError( ErMemoryFull);
|
|
}
|
|
else
|
|
{
|
|
/* get a pointer address for the memory block */
|
|
gdiCache.pointList = (Point far *)GlobalLock( gdiCache.polyHandle );
|
|
}
|
|
|
|
/* mark the primitive cache as empty */
|
|
gdiCache.nextPrim.type = CaEmpty;
|
|
|
|
/* the current primitive isn't being repeated */
|
|
gdiCache.samePrim = FALSE;
|
|
|
|
/* turn off forcing of a new clipping rectangle */
|
|
gdiCache.forceNewClipRect = FALSE;
|
|
|
|
} /* CaInit */
|
|
|
|
|
|
|
|
void CaFini( void )
|
|
/*=========*/
|
|
/* close down the cache module */
|
|
{
|
|
/* delete the current font selection if non-NULL and non-stock */
|
|
if ((gdiCache.curFont != NULL) && !gdiCache.stockFont)
|
|
{
|
|
/* free the font object */
|
|
DeleteObject( gdiCache.curFont );
|
|
}
|
|
|
|
/* remove the current brush selection if non-NULL and not a stock brush */
|
|
if ((gdiCache.curBrush.handle != NULL) && !gdiCache.curBrush.stockObject)
|
|
{
|
|
/* see if the current brush has a DIB - if so, delete it */
|
|
if (gdiCache.curBrush.logBrush.lbStyle == BS_DIBPATTERN)
|
|
{
|
|
/* free the DIB memory used for brush */
|
|
GlobalFree( (HANDLE) gdiCache.curBrush.logBrush.lbHatch );
|
|
}
|
|
|
|
/* delte the brush object */
|
|
DeleteObject( gdiCache.curBrush.handle );
|
|
}
|
|
|
|
/* remove the current pen selection if non-NULL and not a stock pen */
|
|
if ((gdiCache.curPen.handle != NULL) && !gdiCache.curPen.stockObject)
|
|
{
|
|
DeleteObject( gdiCache.curPen.handle );
|
|
}
|
|
|
|
/* Remove other pens created at initialization time */
|
|
DeleteObject( gdiCache.whitePen );
|
|
DeleteObject( gdiCache.blackPen );
|
|
|
|
/* deallocate the polygon buffer */
|
|
GlobalUnlock( gdiCache.polyHandle );
|
|
GlobalFree( gdiCache.polyHandle );
|
|
|
|
} /* CaFini */
|
|
|
|
|
|
|
|
void CaSetMetafileDefaults( void )
|
|
/*========================*/
|
|
/* Set up any defaults that will be used throughout the metafile context */
|
|
{
|
|
/* set up some metafile defaults */
|
|
gdiCache.iniTextAlign = TA_LEFT | TA_BASELINE | TA_NOUPDATECP;
|
|
gdiCache.iniROP2 = R2_COPYPEN;
|
|
gdiCache.iniBkMode = TRANSPARENT;
|
|
gdiCache.iniTxColor = RGB( 0, 0, 0 );
|
|
gdiCache.iniBkColor = RGB( 255, 255, 255 );
|
|
|
|
/* Put the records into the metafile */
|
|
CaSetROP2( gdiCache.iniROP2 );
|
|
CaSetTextAlign( gdiCache.iniTextAlign );
|
|
CaSetBkMode( gdiCache.iniBkMode );
|
|
CaSetTextColor( gdiCache.iniTxColor );
|
|
CaSetBkColor( gdiCache.iniBkColor );
|
|
|
|
} /* CaSetMetafileDefaults */
|
|
|
|
|
|
|
|
void CaSamePrimitive( Boolean same )
|
|
/*==================*/
|
|
/* indicate whether next primitive is the same or new */
|
|
{
|
|
gdiCache.samePrim = same;
|
|
|
|
} /* CaSamePrimitive */
|
|
|
|
|
|
|
|
void CaMergePen( Word verb )
|
|
/*=============*/
|
|
/* indicate that next pen should be merged with previous logical pen */
|
|
{
|
|
if (gdiCache.nextPen.handle != NULL)
|
|
{
|
|
/* check to see if this is a NULL pen - the merge can happen */
|
|
if (gdiCache.samePrim && verb == GdiFrame &&
|
|
gdiCache.nextPen.handle == gdiCache.nulPen)
|
|
{
|
|
/* remove the cached pen - don't delte the pen object */
|
|
gdiCache.nextPen.handle = NULL;
|
|
}
|
|
else
|
|
{
|
|
/* if not removing a null pen, then flush the cache. This will most
|
|
often result in a line segment being flushed. */
|
|
CaFlushCache();
|
|
}
|
|
}
|
|
|
|
} /* CaMergePen */
|
|
|
|
|
|
|
|
Word CaGetCachedPrimitive( void )
|
|
/*=======================*/
|
|
/* return the current cached primitive type */
|
|
{
|
|
return gdiCache.nextPrim.type;
|
|
|
|
} /* CaGetCachedPrimitive */
|
|
|
|
|
|
|
|
void CaCachePrimitive( CaPrimitiveLPtr primLPtr )
|
|
/*===================*/
|
|
/* Cache the primitive passed down. This includes the current pen and brush. */
|
|
{
|
|
/* not another line segment and/or not continuous - flush cache */
|
|
CaFlushCache();
|
|
|
|
/* save off the new primitive */
|
|
gdiCache.nextPrim = *primLPtr;
|
|
|
|
/* check if we need to copy over the polygon list, also */
|
|
if ((gdiCache.nextPrim.type == CaPolygon) ||
|
|
(gdiCache.nextPrim.type == CaPolyLine))
|
|
{
|
|
/* create new polygon */
|
|
NewPolygon();
|
|
|
|
/* add the polygon to the polygon buffer */
|
|
while (gdiCache.nextPrim.a.poly.numPoints--)
|
|
{
|
|
AddPolyPt( *gdiCache.nextPrim.a.poly.pointList++);
|
|
}
|
|
}
|
|
|
|
} /* CaCachePrimitive */
|
|
|
|
|
|
|
|
void CaFlushCache( void )
|
|
/*===============*/
|
|
/* Flush the current primitive stored in the cache */
|
|
{
|
|
/* if the cache is empty, then just return - nothing to do */
|
|
if (gdiCache.nextPrim.type == CaEmpty)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/* select all cached attributes */
|
|
CaFlushAttributes();
|
|
|
|
/* emit any cached primitive, if necessary */
|
|
switch (gdiCache.nextPrim.type)
|
|
{
|
|
case CaLine:
|
|
{
|
|
Rect clip;
|
|
Point delta;
|
|
Point offset;
|
|
|
|
/* determine the length in both directions */
|
|
delta.x = gdiCache.nextPrim.a.line.end.x - gdiCache.nextPrim.a.line.start.x;
|
|
delta.y = gdiCache.nextPrim.a.line.end.y - gdiCache.nextPrim.a.line.start.y;
|
|
|
|
/* set clipRect extents based upon current point position */
|
|
clip.left = min( gdiCache.nextPrim.a.line.start.x, gdiCache.nextPrim.a.line.end.x );
|
|
clip.top = min( gdiCache.nextPrim.a.line.start.y, gdiCache.nextPrim.a.line.end.y );
|
|
clip.right = max( gdiCache.nextPrim.a.line.start.x, gdiCache.nextPrim.a.line.end.x );
|
|
clip.bottom = max( gdiCache.nextPrim.a.line.start.y, gdiCache.nextPrim.a.line.end.y );
|
|
|
|
/* extend clip rectangle for down-right pen stylus hang */
|
|
clip.right += gdiCache.nextPrim.a.line.pnSize.x;
|
|
clip.bottom += gdiCache.nextPrim.a.line.pnSize.y;
|
|
|
|
/* determine the new starting and ending points */
|
|
gdiCache.nextPrim.a.line.start.x -= delta.x;
|
|
gdiCache.nextPrim.a.line.start.y -= delta.y;
|
|
gdiCache.nextPrim.a.line.end.x += delta.x;
|
|
gdiCache.nextPrim.a.line.end.y += delta.y;
|
|
|
|
/* ajust the clipping rect for vertical line penSize roundoff? */
|
|
if (delta.x == 0)
|
|
{
|
|
/* vertical line - expand clip in x dimension */
|
|
clip.left--;
|
|
}
|
|
/* are we are adjusting pen by 1/2 metafile unit - roundoff error? */
|
|
else if (gdiCache.nextPrim.a.line.pnSize.x & 0x01)
|
|
{
|
|
/* adjust clipping rectangle to clip the rounding error */
|
|
clip.right--;
|
|
}
|
|
|
|
/* ajust the clipping rect for horizontal line penSize roundoff? */
|
|
if (delta.y == 0)
|
|
{
|
|
/* horizontal line - extend clip in y dimension */
|
|
clip.top--;
|
|
}
|
|
/* are we are adjusting pen by 1/2 metafile unit - roundoff error? */
|
|
else if (gdiCache.nextPrim.a.line.pnSize.y & 0x01)
|
|
{
|
|
/* adjust clipping rectangle to clip the rounding error */
|
|
clip.bottom--;
|
|
}
|
|
|
|
/* cut the size of the pen dimensions in half for offsets */
|
|
offset.x = gdiCache.nextPrim.a.line.pnSize.x / 2;
|
|
offset.y = gdiCache.nextPrim.a.line.pnSize.y / 2;
|
|
|
|
/* set the new clipping rectangle */
|
|
SaveDC( gdiCache.metafile );
|
|
IntersectClipRect( gdiCache.metafile,
|
|
clip.left, clip.top, clip.right, clip.bottom );
|
|
|
|
/* move to the first point and draw to second (with padding) */
|
|
|
|
// MoveTo is replaced by MoveToEx in win32
|
|
#ifdef WIN32
|
|
MoveToEx( gdiCache.metafile,
|
|
gdiCache.nextPrim.a.line.start.x + offset.x,
|
|
gdiCache.nextPrim.a.line.start.y + offset.y, NULL );
|
|
#else
|
|
MoveTo( gdiCache.metafile,
|
|
gdiCache.nextPrim.a.line.start.x + offset.x,
|
|
gdiCache.nextPrim.a.line.start.y + offset.y );
|
|
#endif
|
|
|
|
LineTo( gdiCache.metafile,
|
|
gdiCache.nextPrim.a.line.end.x + offset.x,
|
|
gdiCache.nextPrim.a.line.end.y + offset.y );
|
|
|
|
/* restore the previous clipping rectangle */
|
|
RestoreDC( gdiCache.metafile, -1 );
|
|
break;
|
|
}
|
|
|
|
case CaRectangle:
|
|
{
|
|
if (gdiCache.curPen.handle == gdiCache.nulPen)
|
|
{
|
|
Point poly[5];
|
|
|
|
/* set up the bounding coodinates */
|
|
poly[0].x = poly[3].x = gdiCache.nextPrim.a.rect.bbox.left;
|
|
poly[0].y = poly[1].y = gdiCache.nextPrim.a.rect.bbox.top;
|
|
poly[1].x = poly[2].x = gdiCache.nextPrim.a.rect.bbox.right;
|
|
poly[2].y = poly[3].y = gdiCache.nextPrim.a.rect.bbox.bottom;
|
|
poly[4] = poly[0];
|
|
|
|
/* perform call to render rectangle */
|
|
Polygon( gdiCache.metafile, poly, 5 );
|
|
}
|
|
else
|
|
{
|
|
Rectangle( gdiCache.metafile,
|
|
gdiCache.nextPrim.a.rect.bbox.left, gdiCache.nextPrim.a.rect.bbox.top,
|
|
gdiCache.nextPrim.a.rect.bbox.right, gdiCache.nextPrim.a.rect.bbox.bottom );
|
|
}
|
|
break;
|
|
}
|
|
|
|
case CaRoundRect:
|
|
{
|
|
RoundRect( gdiCache.metafile,
|
|
gdiCache.nextPrim.a.rect.bbox.left, gdiCache.nextPrim.a.rect.bbox.top,
|
|
gdiCache.nextPrim.a.rect.bbox.right, gdiCache.nextPrim.a.rect.bbox.bottom,
|
|
gdiCache.nextPrim.a.rect.oval.x, gdiCache.nextPrim.a.rect.oval.y );
|
|
break;
|
|
}
|
|
|
|
case CaEllipse:
|
|
{
|
|
Ellipse( gdiCache.metafile,
|
|
gdiCache.nextPrim.a.rect.bbox.left, gdiCache.nextPrim.a.rect.bbox.top,
|
|
gdiCache.nextPrim.a.rect.bbox.right, gdiCache.nextPrim.a.rect.bbox.bottom );
|
|
break;
|
|
}
|
|
|
|
case CaArc:
|
|
{
|
|
Arc( gdiCache.metafile,
|
|
gdiCache.nextPrim.a.arc.bbox.left, gdiCache.nextPrim.a.arc.bbox.top,
|
|
gdiCache.nextPrim.a.arc.bbox.right, gdiCache.nextPrim.a.arc.bbox.bottom,
|
|
gdiCache.nextPrim.a.arc.start.x, gdiCache.nextPrim.a.arc.start.y,
|
|
gdiCache.nextPrim.a.arc.end.x, gdiCache.nextPrim.a.arc.end.y );
|
|
break;
|
|
}
|
|
|
|
case CaPie:
|
|
{
|
|
Pie( gdiCache.metafile,
|
|
gdiCache.nextPrim.a.arc.bbox.left, gdiCache.nextPrim.a.arc.bbox.top,
|
|
gdiCache.nextPrim.a.arc.bbox.right, gdiCache.nextPrim.a.arc.bbox.bottom,
|
|
gdiCache.nextPrim.a.arc.start.x, gdiCache.nextPrim.a.arc.start.y,
|
|
gdiCache.nextPrim.a.arc.end.x, gdiCache.nextPrim.a.arc.end.y );
|
|
break;
|
|
}
|
|
|
|
case CaPolygon:
|
|
case CaPolyLine:
|
|
{
|
|
Point offset;
|
|
Integer i;
|
|
|
|
/* see if centering of the pen is required */
|
|
if (gdiCache.curPen.handle == gdiCache.nulPen)
|
|
{
|
|
/* no - just filling the object without frame */
|
|
offset.x = offset.y = 0;
|
|
}
|
|
else
|
|
{
|
|
/* transform all points to correct for down-right pen
|
|
rendering in QuickDraw and make for a GDI centered pen */
|
|
offset.x = gdiCache.nextPrim.a.poly.pnSize.x / 2;
|
|
offset.y = gdiCache.nextPrim.a.poly.pnSize.y / 2;
|
|
}
|
|
|
|
/* transform end point for all points in the polygon */
|
|
for (i = 0; i < gdiCache.numPoints; i++)
|
|
{
|
|
/* increment each coordinate pair off half of the pen size */
|
|
gdiCache.pointList[i].x += offset.x;
|
|
gdiCache.pointList[i].y += offset.y;
|
|
}
|
|
|
|
/* call the appropriate GDI routine based upon the type */
|
|
if (gdiCache.nextPrim.type == CaPolygon)
|
|
{
|
|
Polygon( gdiCache.metafile,
|
|
gdiCache.pointList,
|
|
gdiCache.numPoints );
|
|
}
|
|
else
|
|
{
|
|
Polyline( gdiCache.metafile,
|
|
gdiCache.pointList,
|
|
gdiCache.numPoints );
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* mark the primitive cache as empty */
|
|
gdiCache.nextPrim.type = CaEmpty;
|
|
|
|
} /* CaFlushCache */
|
|
|
|
|
|
|
|
void CaFlushAttributes( void )
|
|
/*====================*/
|
|
/* flush any pending attribute elements */
|
|
{
|
|
/* select the cached pen - the routine will determine if one exits */
|
|
SelectCachedPen();
|
|
|
|
} /* CaFlushAttributes */
|
|
|
|
|
|
|
|
void CaCreatePenIndirect( LOGPEN far * newLogPen )
|
|
/*======================*/
|
|
/* create a new pen */
|
|
{
|
|
PenLPtr compare;
|
|
Boolean different;
|
|
|
|
/* determine which pen to compare against */
|
|
compare = (gdiCache.nextPen.handle != NULL) ? &gdiCache.nextPen :
|
|
&gdiCache.curPen;
|
|
|
|
/* compare the two pens */
|
|
different = ((newLogPen->lopnStyle != compare->logPen.lopnStyle) ||
|
|
(newLogPen->lopnColor != compare->logPen.lopnColor) ||
|
|
(newLogPen->lopnWidth.x != compare->logPen.lopnWidth.x));
|
|
|
|
/* if the pens are different ... */
|
|
if (different)
|
|
{
|
|
/* if there is a cached pen ... */
|
|
if (gdiCache.nextPen.handle != NULL)
|
|
{
|
|
/* flush the cached primitive - there is a change of pens */
|
|
CaFlushCache();
|
|
|
|
/* check to see if the new pen is changed by next selection */
|
|
different = ((newLogPen->lopnStyle != gdiCache.curPen.logPen.lopnStyle) ||
|
|
(newLogPen->lopnColor != gdiCache.curPen.logPen.lopnColor) ||
|
|
(newLogPen->lopnWidth.x != gdiCache.curPen.logPen.lopnWidth.x));
|
|
}
|
|
}
|
|
|
|
/* if the pen has changed from the current setting, cache the next pen */
|
|
if (different || gdiCache.curPen.handle == NULL)
|
|
{
|
|
/* if there is a pending line or polyline, the flush the cache */
|
|
if (gdiCache.nextPrim.type == CaLine || gdiCache.nextPrim.type == CaPolyLine)
|
|
{
|
|
CaFlushCache();
|
|
}
|
|
|
|
/* assign the new pen attributes */
|
|
gdiCache.nextPen.logPen = *newLogPen;
|
|
|
|
/* currently not using a stock pen object */
|
|
gdiCache.nextPen.stockObject = FALSE;
|
|
|
|
/* check for any pre-defined pen objects */
|
|
if (gdiCache.nextPen.logPen.lopnStyle == PS_NULL)
|
|
{
|
|
/* and use them if possible */
|
|
gdiCache.nextPen.handle = gdiCache.nulPen;
|
|
gdiCache.nextPen.stockObject = TRUE;
|
|
}
|
|
else if (gdiCache.nextPen.logPen.lopnWidth.x == 1)
|
|
{
|
|
if (newLogPen->lopnColor == RGB( 0, 0, 0 ))
|
|
{
|
|
gdiCache.nextPen.handle = gdiCache.blackPen;
|
|
gdiCache.nextPen.stockObject = TRUE;
|
|
}
|
|
else if (gdiCache.nextPen.logPen.lopnColor == RGB( 255, 255, 255 ))
|
|
{
|
|
gdiCache.nextPen.handle = gdiCache.whitePen;
|
|
gdiCache.nextPen.stockObject = TRUE;
|
|
}
|
|
}
|
|
|
|
if (!gdiCache.nextPen.stockObject)
|
|
{
|
|
/* otherwise, create a new pen */
|
|
gdiCache.nextPen.handle = CreatePenIndirect( &gdiCache.nextPen.logPen );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* copy the current setting back into the next pen setting */
|
|
gdiCache.nextPen = gdiCache.curPen;
|
|
}
|
|
|
|
/* check if cache was invalidated */
|
|
if (gdiCache.restorePen && (gdiCache.curPen.handle != NULL))
|
|
{
|
|
/* if pen was invalidated by RestoreDC(), reselect it */
|
|
SelectObject( gdiCache.metafile, gdiCache.curPen.handle );
|
|
}
|
|
|
|
/* all is ok with cache now */
|
|
gdiCache.restorePen = FALSE;
|
|
|
|
} /* CaCreatePenIndirect */
|
|
|
|
|
|
|
|
void CaCreateBrushIndirect( LOGBRUSH far * newLogBrush )
|
|
/*========================*/
|
|
/* Create a new logical brush using structure passed in */
|
|
{
|
|
/* assume that the DIB patterns are different */
|
|
Boolean differentDIB = TRUE;
|
|
|
|
/* check if we are comparing two DIB patterned brushes */
|
|
if ((newLogBrush->lbStyle == BS_DIBPATTERN) &&
|
|
(gdiCache.curBrush.logBrush.lbStyle == BS_DIBPATTERN))
|
|
{
|
|
Word nextSize = (Word)GlobalSize( (HANDLE) newLogBrush->lbHatch ) / 2;
|
|
Word currSize = (Word)GlobalSize( (HANDLE) gdiCache.curBrush.logBrush.lbHatch ) / 2;
|
|
|
|
/* make sure that the sizes are the same */
|
|
if (nextSize == currSize)
|
|
{
|
|
Word far * nextDIBPattern = (Word far *)GlobalLock( (HANDLE) newLogBrush->lbHatch );
|
|
Word far * currDIBPattern = (Word far *)GlobalLock( (HANDLE) gdiCache.curBrush.logBrush.lbHatch );
|
|
|
|
/* assume that the DIBs are the same so far */
|
|
differentDIB = FALSE;
|
|
|
|
/* compare all the bytes in the two brush patterns */
|
|
while (currSize--)
|
|
{
|
|
/* are they the same ? */
|
|
if (*nextDIBPattern++ != *currDIBPattern++)
|
|
{
|
|
/* if not, flag the difference and break from the loop */
|
|
differentDIB = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Unlock the data blocks */
|
|
GlobalUnlock( (HANDLE) newLogBrush->lbHatch );
|
|
GlobalUnlock( (HANDLE) gdiCache.curBrush.logBrush.lbHatch );
|
|
|
|
/* see if these did compare exactly */
|
|
if (!differentDIB)
|
|
{
|
|
/* if so, free the new DIB brush - it's no longer needed */
|
|
GlobalFree( (HANDLE) newLogBrush->lbHatch );
|
|
}
|
|
}
|
|
}
|
|
|
|
/* see if we are requesting a new brush */
|
|
if (differentDIB &&
|
|
(newLogBrush->lbStyle != gdiCache.curBrush.logBrush.lbStyle ||
|
|
newLogBrush->lbColor != gdiCache.curBrush.logBrush.lbColor ||
|
|
newLogBrush->lbHatch != gdiCache.curBrush.logBrush.lbHatch ||
|
|
gdiCache.curBrush.handle == NULL))
|
|
{
|
|
HBRUSH brushHandle;
|
|
Boolean stockBrush;
|
|
|
|
/* flush the primitive cache if changing brush selection */
|
|
CaFlushCache();
|
|
|
|
/* if current brush has a DIB, make sure to free memory */
|
|
if (gdiCache.curBrush.logBrush.lbStyle == BS_DIBPATTERN)
|
|
{
|
|
/* free the memory */
|
|
GlobalFree( (HANDLE) gdiCache.curBrush.logBrush.lbHatch );
|
|
}
|
|
|
|
/* copy over the new structure */
|
|
gdiCache.curBrush.logBrush = *newLogBrush;
|
|
|
|
/* We currently aren't using a stock brush */
|
|
stockBrush = FALSE;
|
|
|
|
/* use stock objects if possible */
|
|
if (gdiCache.curBrush.logBrush.lbStyle == BS_HOLLOW)
|
|
{
|
|
/* use null (hollow) brush */
|
|
brushHandle = gdiCache.nulBrush;
|
|
stockBrush = TRUE;
|
|
}
|
|
/* check for some standard solid colored brushes */
|
|
else if (gdiCache.curBrush.logBrush.lbStyle == BS_SOLID)
|
|
{
|
|
if (gdiCache.curBrush.logBrush.lbColor == RGB( 0, 0, 0) )
|
|
{
|
|
/* use solid black brush */
|
|
brushHandle = gdiCache.blackBrush;
|
|
stockBrush = TRUE;
|
|
}
|
|
else if (gdiCache.curBrush.logBrush.lbColor == RGB( 255, 255, 255 ))
|
|
{
|
|
/* use solid white brush */
|
|
brushHandle = gdiCache.whiteBrush;
|
|
stockBrush = TRUE;
|
|
}
|
|
}
|
|
|
|
/* if unable to find a stock brush, then create a new one */
|
|
if (!stockBrush)
|
|
{
|
|
/* otherwise, create new brush using logbrush structure */
|
|
brushHandle = CreateBrushIndirect( &gdiCache.curBrush.logBrush );
|
|
}
|
|
|
|
/* select the new brush */
|
|
SelectObject( gdiCache.metafile, brushHandle );
|
|
|
|
/* if this isn't the first brush selection and not a stock brush */
|
|
if (gdiCache.curBrush.handle != NULL && !gdiCache.curBrush.stockObject)
|
|
{
|
|
/* delete the previous brush object */
|
|
DeleteObject( gdiCache.curBrush.handle );
|
|
}
|
|
|
|
/* save brush handle in current cache variable */
|
|
gdiCache.curBrush.handle = brushHandle;
|
|
gdiCache.curBrush.stockObject = stockBrush;
|
|
}
|
|
else if (gdiCache.restoreBrush)
|
|
{
|
|
/* if brush was invalidated by RestoreDC(), reselect it */
|
|
SelectObject( gdiCache.metafile, gdiCache.curBrush.handle );
|
|
}
|
|
|
|
/* all is ok with cache now */
|
|
gdiCache.restoreBrush = FALSE;
|
|
|
|
} /* CaCreateBrushIndirect */
|
|
|
|
|
|
|
|
void CaCreateFontIndirect( LOGFONT far * newLogFont )
|
|
/*=======================*/
|
|
/* create the logical font passed as paramter */
|
|
{
|
|
/* make sure we are requesting a new font */
|
|
if (newLogFont->lfHeight != gdiCache.curLogFont.lfHeight ||
|
|
newLogFont->lfWeight != gdiCache.curLogFont.lfWeight ||
|
|
newLogFont->lfEscapement != gdiCache.curLogFont.lfEscapement ||
|
|
newLogFont->lfOrientation != gdiCache.curLogFont.lfOrientation ||
|
|
newLogFont->lfItalic != gdiCache.curLogFont.lfItalic ||
|
|
newLogFont->lfUnderline != gdiCache.curLogFont.lfUnderline ||
|
|
newLogFont->lfPitchAndFamily != gdiCache.curLogFont.lfPitchAndFamily ||
|
|
lstrcmp( newLogFont->lfFaceName, gdiCache.curLogFont.lfFaceName ) != 0 ||
|
|
gdiCache.curFont == NULL)
|
|
{
|
|
HFONT fontHandle;
|
|
Boolean stockFont;
|
|
|
|
/* flush the primitive cache if changing font attributes */
|
|
CaFlushCache();
|
|
|
|
/* assign the new pen attributes */
|
|
gdiCache.curLogFont = *newLogFont;
|
|
|
|
/* currently not using a stock font object */
|
|
stockFont = FALSE;
|
|
|
|
/* check for any pre-defined pen objects */
|
|
if (newLogFont->lfFaceName == NULL)
|
|
{
|
|
fontHandle = GetStockObject( SYSTEM_FONT );
|
|
stockFont = TRUE;
|
|
}
|
|
else
|
|
{
|
|
/* otherwise, create a new pen */
|
|
fontHandle = CreateFontIndirect( &gdiCache.curLogFont );
|
|
}
|
|
|
|
/* select the new font */
|
|
SelectObject( gdiCache.metafile, fontHandle );
|
|
|
|
/* if this isn't the first font selection and not a stock font */
|
|
if (gdiCache.curFont != NULL && !gdiCache.stockFont)
|
|
{
|
|
/* delete the previous font object */
|
|
DeleteObject( gdiCache.curFont );
|
|
}
|
|
|
|
/* save font handle in current cache variable */
|
|
gdiCache.curFont = fontHandle;
|
|
gdiCache.stockFont = stockFont;
|
|
}
|
|
else if (gdiCache.restoreFont)
|
|
{
|
|
/* if pen was invalidated by RestoreDC(), reselect it */
|
|
SelectObject( gdiCache.metafile, gdiCache.curFont );
|
|
}
|
|
|
|
/* all is ok with cache now */
|
|
gdiCache.restoreFont = FALSE;
|
|
|
|
} /* CaCreateFontIndirect */
|
|
|
|
|
|
|
|
void CaSetBkMode( Word mode )
|
|
/*==============*/
|
|
/* set the backgound transfer mode */
|
|
{
|
|
if (gdiCache.curBkMode != mode)
|
|
{
|
|
/* flush the primitive cache if changing mode */
|
|
CaFlushCache();
|
|
|
|
/* set the background mode and save in global cache */
|
|
SetBkMode( gdiCache.metafile, mode );
|
|
gdiCache.curBkMode = mode;
|
|
}
|
|
|
|
/* no need to worry about restoring BkMode, since this is set
|
|
before the initial SaveDC() is issued and is restored after each
|
|
RestoreDC() call back to the metafile default. */
|
|
|
|
} /* CaSetBkMode */
|
|
|
|
|
|
|
|
void CaSetROP2( Word ROP2Code )
|
|
/*============*/
|
|
/* set the transfer ROP mode according to ROP2Code */
|
|
{
|
|
/* check for change in ROP code */
|
|
if (gdiCache.curROP2 != ROP2Code)
|
|
{
|
|
/* flush the primitive cache if changing ROP mode */
|
|
CaFlushCache();
|
|
|
|
/* set the ROP code and save in global cache variable */
|
|
SetROP2( gdiCache.metafile, ROP2Code );
|
|
gdiCache.curROP2 = ROP2Code;
|
|
}
|
|
|
|
/* no need to worry about restoring ROP code, since this is set
|
|
before the initial SaveDC() is issued and is restored after each
|
|
RestoreDC() call back to the metafile default. */
|
|
|
|
} /* CaSetROP2 */
|
|
|
|
|
|
|
|
void CaSetStretchBltMode( Word mode )
|
|
/*======================*/
|
|
/* stretch blt mode - how to preserve scanlines using StretchDIBits() */
|
|
{
|
|
if (gdiCache.curStretchMode != mode)
|
|
{
|
|
/* flush the primitive cache if changing mode */
|
|
CaFlushCache();
|
|
|
|
/* set the stretch blt mode and save in global cache variable */
|
|
SetStretchBltMode( gdiCache.metafile, mode );
|
|
gdiCache.curStretchMode = mode;
|
|
}
|
|
else if (gdiCache.restoreStretchMode)
|
|
{
|
|
/* if stretch blt mode was invalidated by RestoreDC(), re-issue */
|
|
SetStretchBltMode( gdiCache.metafile, gdiCache.curStretchMode );
|
|
}
|
|
|
|
/* all is ok with cache now */
|
|
gdiCache.restoreStretchMode = FALSE;
|
|
|
|
} /* CaSetStretchBltMode */
|
|
|
|
|
|
|
|
void CaSetTextAlign( Word txtAlign )
|
|
/*=================*/
|
|
/* set text alignment according to parameter */
|
|
{
|
|
if (gdiCache.curTextAlign != txtAlign)
|
|
{
|
|
/* flush the primitive cache if changing text alignment */
|
|
CaFlushCache();
|
|
|
|
/* Set the text color and save in cache */
|
|
SetTextAlign( gdiCache.metafile, txtAlign );
|
|
gdiCache.curTextAlign = txtAlign;
|
|
}
|
|
|
|
/* no need to worry about restoring text align, since this is set
|
|
before the initial SaveDC() is issued and is restored after each
|
|
RestoreDC() call back to the metafile default. */
|
|
|
|
} /* CaSetTextAlign */
|
|
|
|
|
|
void CaSetTextColor( RGBColor txtColor )
|
|
/*=================*/
|
|
/* set the text color if different from current setting */
|
|
{
|
|
if (gdiCache.curTextColor != txtColor)
|
|
{
|
|
/* flush the primitive cache if changing text color */
|
|
CaFlushCache();
|
|
|
|
/* Set the text color and save in cache */
|
|
SetTextColor( gdiCache.metafile, txtColor );
|
|
gdiCache.curTextColor = txtColor;
|
|
}
|
|
|
|
/* no need to worry about restoring text color, since this is set
|
|
before the initial SaveDC() is issued and is restored after each
|
|
RestoreDC() call back to the metafile default. */
|
|
|
|
} /* CaSetTextColor */
|
|
|
|
|
|
void CaSetTextCharacterExtra( Integer chExtra )
|
|
/*==========================*/
|
|
/* set the character extra spacing */
|
|
{
|
|
if (gdiCache.curCharExtra != chExtra)
|
|
{
|
|
/* flush the primitive cache if changing text char extra */
|
|
CaFlushCache();
|
|
|
|
/* set the char extra and same state in the cache */
|
|
SetTextCharacterExtra( gdiCache.metafile, chExtra );
|
|
gdiCache.curCharExtra = (WORD) chExtra;
|
|
|
|
}
|
|
else if (gdiCache.restoreCharExtra)
|
|
{
|
|
/* if text char extra was invalidated by RestoreDC(), re-issue */
|
|
SetTextCharacterExtra( gdiCache.metafile, gdiCache.curCharExtra );
|
|
}
|
|
|
|
/* all is ok with cache now */
|
|
gdiCache.restoreCharExtra = FALSE;
|
|
|
|
} /* CaSetTextCharacterExtra */
|
|
|
|
|
|
void CaSetBkColor( RGBColor bkColor )
|
|
/*===============*/
|
|
/* set background color if different from current setting */
|
|
{
|
|
if (gdiCache.curBkColor != bkColor)
|
|
{
|
|
/* flush the primitive cache if changing background color */
|
|
CaFlushCache();
|
|
|
|
/* Set the background color and save in cache */
|
|
SetBkColor( gdiCache.metafile, bkColor );
|
|
gdiCache.curBkColor = bkColor;
|
|
}
|
|
|
|
/* no need to worry about restoring background color, since this is set
|
|
before the initial SaveDC() is issued and is restored after each
|
|
RestoreDC() call back to the metafile default. */
|
|
|
|
} /* CaSetBkColor */
|
|
|
|
|
|
Boolean CaIntersectClipRect( Rect rect )
|
|
/*=========================*/
|
|
/* Create new clipping rectangle - return FALSE if drawing is disabled */
|
|
{
|
|
Rect combinedRect;
|
|
|
|
/* See if the clipping rectangle is empty, indicating that no drawing
|
|
should occur into the metafile */
|
|
if (Height( rect ) == 0 || Width( rect ) == 0)
|
|
{
|
|
/* indicate that drawing is disabled */
|
|
return FALSE;
|
|
}
|
|
|
|
/* don't do anything if rectangle hasn't changed */
|
|
if (!EqualRect( &rect, &gdiCache.curClipRect ) || gdiCache.forceNewClipRect)
|
|
{
|
|
/* flush the primitive cache if changing clip region */
|
|
CaFlushCache();
|
|
|
|
/* is new clip rect is completely enclosed by current cliprect? */
|
|
IntersectRect( &combinedRect, &rect, &gdiCache.curClipRect );
|
|
|
|
/* check for equality of intersection and new cliprect */
|
|
if (!EqualRect( &combinedRect, &rect ) || gdiCache.forceNewClipRect)
|
|
{
|
|
/* must be called just to be able to change clipping rectangle */
|
|
CaRestoreDC();
|
|
CaSaveDC();
|
|
}
|
|
|
|
/* set the new clipping rectangle */
|
|
IntersectClipRect( gdiCache.metafile,
|
|
rect.left, rect.top, rect.right, rect.bottom );
|
|
|
|
/* save the current clip rectangle, since it has changed */
|
|
gdiCache.curClipRect = rect;
|
|
|
|
/* turn off forcing of the clipping rectangle */
|
|
gdiCache.forceNewClipRect = FALSE;
|
|
}
|
|
|
|
/* return TRUE - drawing is enabled */
|
|
return TRUE;
|
|
|
|
} /* GdiIntersectClipRect */
|
|
|
|
|
|
void CaSetClipRect( Rect rect )
|
|
/*================*/
|
|
/* set the current cliprectangle to be equal to rect */
|
|
{
|
|
gdiCache.curClipRect = rect;
|
|
|
|
} /* CaSetClipRect */
|
|
|
|
|
|
Rect far * CaGetClipRect( void )
|
|
/*=====================*/
|
|
/* get the current cliprectangle */
|
|
{
|
|
return &gdiCache.curClipRect;
|
|
|
|
} /* CaGetClipRect */
|
|
|
|
|
|
void CaNonRectangularClip( void )
|
|
/*=======================*/
|
|
/* notify cache that a non-rectangular clipping region was set */
|
|
{
|
|
gdiCache.forceNewClipRect = TRUE;
|
|
|
|
} /* CaNonRectangularClip */
|
|
|
|
|
|
void CaSaveDC( void )
|
|
/*===========*/
|
|
/* save the current device context - used to set up clipping rects */
|
|
{
|
|
/* the previous clipping rectangle is saved off */
|
|
gdiCache.prevClipRect = gdiCache.curClipRect;
|
|
|
|
/* issue call to GDI */
|
|
SaveDC( gdiCache.metafile );
|
|
}
|
|
|
|
|
|
void CaRestoreDC( void )
|
|
/*==============*/
|
|
/* restore the device context and invalidate cached attributes */
|
|
{
|
|
/* restore previous clipping rectangle */
|
|
gdiCache.curClipRect = gdiCache.prevClipRect;
|
|
|
|
/* invalidate all of the cached attributes and objects */
|
|
gdiCache.restorePen =
|
|
gdiCache.restoreBrush =
|
|
gdiCache.restoreFont =
|
|
gdiCache.restoreCharExtra = TRUE;
|
|
|
|
/* reset metafile defaults */
|
|
gdiCache.curROP2 = gdiCache.iniROP2;
|
|
gdiCache.curTextAlign = gdiCache.iniTextAlign;
|
|
gdiCache.curBkMode = gdiCache.iniBkMode;
|
|
gdiCache.curTextColor = gdiCache.iniTxColor;
|
|
gdiCache.curBkColor = gdiCache.iniBkColor;
|
|
|
|
/* issue call to GDI */
|
|
RestoreDC( gdiCache.metafile, -1 );
|
|
}
|
|
|
|
/******************************* Private Routines ***************************/
|
|
|
|
|
|
private void AddPolyPt( Point pt )
|
|
/*--------------------*/
|
|
/* Add a point to the polygon buffer */
|
|
{
|
|
/* make sure that we haven't reached maximum size */
|
|
if ((gdiCache.numPoints + 1) >= gdiCache.maxPoints)
|
|
{
|
|
/* expand the number of points that can be cached by 10 */
|
|
gdiCache.maxPoints += 16;
|
|
|
|
/* unlock to prepare for re-allocation */
|
|
GlobalUnlock( gdiCache.polyHandle);
|
|
|
|
/* re-allocate the memory handle by the given amount */
|
|
gdiCache.polyHandle = GlobalReAlloc(
|
|
gdiCache.polyHandle,
|
|
gdiCache.maxPoints * sizeof( Point ),
|
|
GMEM_MOVEABLE);
|
|
|
|
/* make sure that the re-allocation succeeded */
|
|
if (gdiCache.polyHandle == NULL)
|
|
{
|
|
/* if not, flag global error and exit from here */
|
|
ErSetGlobalError( ErMemoryFull );
|
|
return;
|
|
}
|
|
|
|
/* lock the memory handle to get a pointer address */
|
|
gdiCache.pointList = (Point far *)GlobalLock( gdiCache.polyHandle );
|
|
}
|
|
|
|
/* insert the new point and increment the number of points in the buffer */
|
|
gdiCache.pointList[gdiCache.numPoints++] = pt;
|
|
|
|
} /* AddPolyPt */
|
|
|
|
|
|
|
|
private void SelectCachedPen( void )
|
|
/*--------------------------*/
|
|
/* select the currently cached Pen into the metafile */
|
|
{
|
|
/* make sure that there is some new pen to select */
|
|
if (gdiCache.nextPen.handle != NULL)
|
|
{
|
|
/* make sure that the pens are different */
|
|
if (gdiCache.nextPen.handle != gdiCache.curPen.handle)
|
|
{
|
|
/* select the new pen */
|
|
SelectObject( gdiCache.metafile, gdiCache.nextPen.handle);
|
|
|
|
/* if this isn't the first pen selection and not a stock pen */
|
|
if (gdiCache.curPen.handle != NULL && !gdiCache.curPen.stockObject)
|
|
{
|
|
/* delete the previous pen selection */
|
|
DeleteObject( gdiCache.curPen.handle );
|
|
}
|
|
|
|
/* save pen handle in current cache variable */
|
|
gdiCache.curPen = gdiCache.nextPen;
|
|
}
|
|
|
|
/* reset the cache pen to indicate no pre-existing cached pen */
|
|
gdiCache.nextPen.handle = NULL;
|
|
}
|
|
|
|
} /* SelectCachedPen */
|
|
|