|
|
/****************************************************************************
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 = NULL; 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 */{ HANDLE tmpHandle; /* 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 */ /* save current ptr so it can be freed if GlobalReAlloc fails */ tmpHandle = GlobalReAlloc( gdiCache.polyHandle, gdiCache.maxPoints * sizeof( Point ), GMEM_MOVEABLE);
/* make sure that the re-allocation succeeded */ if (tmpHandle == NULL) { /* if not, free the old memory, flag global error and exit from here */ GlobalFree(gdiCache.polyHandle); gdiCache.polyHandle = NULL; ErSetGlobalError( ErMemoryFull ); return; } gdiCache.polyHandle = tmpHandle;
/* 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 */
|
