/******************************Module*Header*******************************\ * Module Name: dcobj.hxx * * Definition the the base DC user object * * Created: 23-Jul-1989 17:06:20 * Author: Donald Sidoroff [donalds] * * Copyright (c) 1990-1999 Microsoft Corporation \**************************************************************************/ #ifndef _DCOBJHXX_ #define _DCOBJHXX_ #ifndef GDIFLAGS_ONLY // used for gdikdx // // STOCKOBJECTS // extern HANDLE gahStockObjects[PRIV_STOCK_LAST+1]; #define STOCKOBJ_PAL (HPAL) gahStockObjects[DEFAULT_PALETTE] #define STOCKFONT(iFont) (HLFONT) gahStockObjects[iFont] #define STOCKOBJ_SYSFONT (HLFONT) gahStockObjects[SYSTEM_FONT] #define STOCKOBJ_SYSFIXEDFONT (HLFONT) gahStockObjects[SYSTEM_FIXED_FONT] #define STOCKOBJ_OEMFIXEDFONT (HLFONT) gahStockObjects[OEM_FIXED_FONT] #define STOCKOBJ_ANSIFIXEDFONT (HLFONT) gahStockObjects[ANSI_FIXED_FONT] #define STOCKOBJ_ANSIVARFONT (HLFONT) gahStockObjects[ANSI_VAR_FONT] #define STOCKOBJ_DEFAULTDEVFONT (HLFONT) gahStockObjects[DEVICE_DEFAULT_FONT] #define STOCKOBJ_NULLBRUSH (HBRUSH) gahStockObjects[NULL_BRUSH] #define STOCKOBJ_WHITEPEN (HPEN) gahStockObjects[WHITE_PEN] #define STOCKOBJ_BLACKPEN (HPEN) gahStockObjects[BLACK_PEN] #define STOCKOBJ_NULLPEN (HPEN) gahStockObjects[NULL_PEN] #if(WINVER >= 0x0400) #define STOCKOBJ_DEFAULTGUIFONT (HLFONT) gahStockObjects[DEFAULT_GUI_FONT] #endif #define STOCKOBJ_BITMAP (HBITMAP) gahStockObjects[PRIV_STOCK_BITMAP] #define STOCKOBJ_COLORSPACE (HCOLORSPACE) gahStockObjects[PRIV_STOCK_COLORSPACE] BOOL bSetStockObject(HANDLE h,int iObj); #define MIRRORED_DC(pdc) (pdc->dwLayout() & LAYOUT_RTL) #define MIRRORED_DC_NO_BITMAP_FLIP(pdc) ((pdc->dwLayout() & (LAYOUT_RTL | LAYOUT_BITMAPORIENTATIONPRESERVED)) == \ (LAYOUT_RTL | LAYOUT_BITMAPORIENTATIONPRESERVED)) #endif // GDIFLAGS_ONLY used for gdikdx // Flags for dc.fs #define DC_DISPLAY 0x0001 #define DC_DIRECT 0x0002 #define DC_CANCELED 0x0004 #define DC_PERMANANT 0x0008 #define DC_DIRTY_RAO 0x0010 #define DC_ACCUM_WMGR 0x0020 #define DC_ACCUM_APP 0x0040 #define DC_RESET 0x0080 #define DC_SYNCHRONIZEACCESS 0x0100 #define DC_EPSPRINTINGESCAPE 0x0200 #define DC_TEMPINFODC 0x0400 #define DC_FULLSCREEN 0x0800 #define DC_IN_CLONEPDEV 0x1000 #define DC_REDIRECTION 0x2000 #define DC_SHAREACCESS 0x4000 #define DC_STOCKBITMAP 0x8000 // Flags for flPath in DC #define DCPATH_ACTIVE 0x0001L // Set if DC in path bracket #define DCPATH_SAVE 0x0002L // Set if lazy save for path pending #define DCPATH_CLOCKWISE 0x0004L // Set if arcs to be drawn clockwise // misc flags #define CA_DEFAULT 0x8000 #ifndef GDIFLAGS_ONLY // used for gdikdx // // Forward Class declarations needed in this file // class EWNDOBJ; class SURFACE; extern DC_ATTR DcAttrDefault; #define QUICK_UFI_LINKS 4 /*********************************Class************************************\ * class DC * * History: * 3-Nov-1994 -by- Lingyun Wang [lingyunw] * Moved some client side attrs over * * Thu 09-Aug-1990 20:41:55 -by- Charles Whitmer [chuckwh] * Separated out the DCLEVEL part. Ripped out lots of fields. * * Thu 01-Jun-1989 08:43:17 by Kirk Olynyk [kirko] * Wrote it. \**************************************************************************/ // The DCLEVEL is the part of the DC that must be preserved for each saved // DC level. The rest of the DC belongs to the Window Manager and the DC // Manager. class DCLEVEL { public: // *** ASSOCIATED OBJECTS *** HPAL hpal; PPALETTE ppal; // *** COLOR SPACE *** PVOID pColorSpace; // *** ICM modes *** ULONG lIcmMode; // *** SaveDC INFORMATION *** LONG lSaveDepth; LONG lSaveDepthStartDoc; HDC hdcSave; // *** BRUSH INFORMATION *** POINTL ptlKmBrushOrigin; // KM component of ptlBrushOrg // Brush origin matches dcattr in kmode PBRUSH pbrFill; // Brush used for filling PBRUSH pbrLine; // Brush used for lines PLFONT plfntNew_; // Currently selected font // *** PATHS DATA *** HPATH hpath; // DC's active or inactive path FLONG flPath; LINEATTRS laPath; // Realized line attributes // *** REGIONS DATA *** PREGION prgnClip; // May be NULL PREGION prgnMeta; // May be NULL // *** HALFTONE COLOR ADJUSTMENT DATA *** COLORADJUSTMENT ca; // *** FONT STATE FLAGS *** FLONG flFontState; // *** Forced mapping UNIVERSAL_FONT_ID ufi; // UFI to which mapping must be forced // *** Remote font links UNIVERSAL_FONT_ID aQuickLinks[QUICK_UFI_LINKS]; PUNIVERSAL_FONT_ID pufi; // UFIs which must be linked to font in DC UINT uNumLinkedFonts; // number of UFIs currently linked BOOL bTurnOffLinking; // linking must be turned off to match state // on client machine // *** General Flags *** FLONG fl; // *** brush Flags *** FLONG flbrush; // *** TRANSFORMS COMPONENT DATA *** MATRIX mxWorldToDevice; MATRIX mxDeviceToWorld; MATRIX mxWorldToPage; EFLOAT efM11PtoD; // efM11 of the Page transform EFLOAT efM22PtoD; // efM22 of the Page transform EFLOAT efDxPtoD; // efDx of the Page transform EFLOAT efDyPtoD; // efDy of the Page transform EFLOAT efM11_TWIPS; // cache the TWIPS values EFLOAT efM22_TWIPS; // // *** Set by metafile component. *** EFLOAT efPr11; // (Page to Device)11 of the metafile recording device EFLOAT efPr22; // (Page to Device)22 of the metafile recording device // *** OBJECTS AFFECTED BY DYNAMIC MODE CHANGING *** // // These must come at the end of the DCLEVEL structure so that they're not // overwritten when the DCLEVEL is reset. Look at bCleanDC() to see how // the DCLEVEL only up to offsetof(DCLEVEL, pSurface) is copied. SURFACE *pSurface; // Level dependent for DCTYPE_MEMORY. SIZEL sizl; // Size of the surface or bitmap. }; #endif // GDIFLAGS_ONLY used for gdikdx // These are the general flags for fl in the DCLEVEL #define DC_FL_PAL_BACK 0x00000001 // These flags are used to specify the state of the font selected into the // DC. When the transform changes such that it may impact the font context, // the DC_DIRTYFONT_XFORM flag must be set. When the logical font is changed, // the DC_DIRTYFONT_LFONT flag must be set. // #define DC_DIRTYFONT_XFORM 0x00000001 #define DC_DIRTYFONT_LFONT 0x00000002 #define DC_UFI_MAPPING 0x00000004 // // These flags are used to indicate which realizations may have been dirtied // since the objects (fonts, brushes, etc) were realized. The flags are set // where the action takes place, and are gathered here so that we can quickly // determine which objects need to be re-realized at API time. #define DC_DIRTYBRUSHES 0x00000001 #ifndef GDIFLAGS_ONLY // used for gdikdx // used to keep track of remote fonts installed on this DC. typedef struct tagPFFLIST { PFF *pPFF; struct tagPFFLIST *pNext; } PFFLIST; // used to keep track of linked font setting from remote machine // used to keep track of color transform created on this DC. typedef struct tagCXFLIST { HANDLE hCXform; struct tagCXFLIST *pNext; } CXFLIST, *PCXFLIST; class PDEV; // Forward reference. /*********************************Class************************************\ * class DC * * History: * 29-Dec-1994 -by- Eric Kutter [erick] * Added comment header, rearanged to have methods directly off of DC \**************************************************************************/ class DC : public OBJECT { public: // // These fields can be changed asynchronously by dynamic mode changing. // DHPDEV dhpdev_; // Driver's dhpdev value DCTYPE dctp_; FSHORT fs_; // // DC Manager info. // PDEV *ppdev_; HSEMAPHORE hsemDcDevLock_; // Semaphore from the PDEV, not necessarily a Display. FLONG flGraphicsCaps_; // cached here from pdev FLONG flGraphicsCaps2_; // cached here from pdev // // Level dependent attributes // PDC_ATTR pDCAttr; DCLEVEL dclevel; DC_ATTR dcattr; // // Linked list of DC's off of palette // HDC hdcNext_; // linked list of DC's HDC hdcPrev_; // // Window Manager info. // ERECTL erclClip_; // This contains the first rectangle of // the Rao-Region. To quickly check for // no clip case we compare to this guy. EPOINTL eptlOrigin_; // DC origin ERECTL erclWindow_; // Extents of window ERECTL erclBounds_; // USER/Metafile accumulation ERECTL erclBoundsApp_; // Application accumulation REGION *prgnAPI_; REGION *prgnVis_; // Cached pointer to VisRgn REGION *prgnRao_; // Cached pointer to RaoRgn // // Accelerators for the brush // POINTL ptlFillOrigin_; // Alignment origin for brushes EBRUSHOBJ eboFill_; // Brush used for filling EBRUSHOBJ eboLine_; // Brush used for lines EBRUSHOBJ eboText_; // Brush used for text EBRUSHOBJ eboBackground_; // Brush used for opaque text // // Accelerators for Fonts // HLFONT hlfntCur_; // handle of the selected LFONT FLONG flSimulationFlags_; // cached from LFONT LONG lEscapement_; // cached from LFONT RFONT *prfnt_; // accelerator for font selection XCLIPOBJ co_; // cached clip object // // Remote font stuff. // PFFLIST *pPFFList; // list of remote fonts installed // on this DC. // // Color transform stuff // CXFLIST *pCXFList; // list of color transform created // on this DC. // // OpenGL info. // SHORT ipfdDevMax_; // Max device pixel formats, init to -1 // // for printing, remember the copy count // ULONG ulCopyCount_; // copy count for printing SURFACE *psurfInfo_; POINTL ptlBandPosition_; // current band position in current page. #if DBG || defined(PRERELEASE) BOOL bValidateVisrgn_; #endif /**************************************************************************\ * * Attribute methods * \**************************************************************************/ public: DWORD iCS_CP() { return(pDCAttr->iCS_CP); } DWORD iCS_CP(DWORD dw) { return(pDCAttr->iCS_CP = dw); } BYTE jROP2() { return(pDCAttr->jROP2); } BYTE jROP2(BYTE j) { return(pDCAttr->jROP2 = j); } BYTE jBkMode() { return(pDCAttr->jBkMode); } BYTE jBkMode(BYTE j) { return(pDCAttr->jBkMode = j); } LONG lBkMode() { return(pDCAttr->lBkMode); } LONG lBkMode(LONG l) { return(pDCAttr->lBkMode = l); } BYTE jFillMode() { return(pDCAttr->jFillMode); } BYTE jFillMode(BYTE j) { return(pDCAttr->jFillMode = j); } LONG lFillMode() { return(pDCAttr->lFillMode); } LONG lFillMode(LONG l) { return(pDCAttr->lFillMode = l); } BYTE jStretchBltMode() { return(pDCAttr->jStretchBltMode); } BYTE jStretchBltMode(BYTE j) { return(pDCAttr->jStretchBltMode = j); } LONG lStretchBltMode() { return(pDCAttr->lStretchBltMode); } LONG lStretchBltMode(LONG l) { return(pDCAttr->lStretchBltMode = l); } int iGraphicsMode() { return(pDCAttr->iGraphicsMode); } int iGraphicsMode(int i) { return(pDCAttr->iGraphicsMode = i); } COLORREF crBackClr() { return(pDCAttr->crBackgroundClr); } COLORREF crBackClr(COLORREF cr) { return(pDCAttr->crBackgroundClr = cr); } ULONG ulBackClr() { return(pDCAttr->ulBackgroundClr); } ULONG ulBackClr(ULONG ul) { return(pDCAttr->ulBackgroundClr = ul); } COLORREF crTextClr() { return(pDCAttr->crForegroundClr); } COLORREF crTextClr(COLORREF cr) { return(pDCAttr->crForegroundClr = cr); } ULONG ulTextClr() { return(pDCAttr->ulForegroundClr); } ULONG ulTextClr(COLORREF ul) { return(pDCAttr->ulForegroundClr = ul); } COLORREF crDCBrushClr() { return(pDCAttr->crDCBrushClr); } COLORREF crDCBrushClr(COLORREF cr) { return(pDCAttr->crDCBrushClr = cr); } COLORREF ulDCBrushClr() { return(pDCAttr->ulDCBrushClr); } COLORREF ulDCBrushClr(ULONG ul) { return(pDCAttr->ulDCBrushClr = ul); } COLORREF crDCPenClr() { return(pDCAttr->crDCPenClr); } COLORREF crDCPenClr(COLORREF cr) { return(pDCAttr->crDCPenClr = cr); } COLORREF ulDCPenClr() { return(pDCAttr->ulDCPenClr); } COLORREF ulDCPenClr(ULONG ul) { return(pDCAttr->ulDCPenClr = ul); } FLONG flTextAlign() { return(pDCAttr->flTextAlign); } FLONG flTextAlign(FLONG fl) { return(pDCAttr->flTextAlign = fl);} LONG lTextAlign() { return(pDCAttr->lTextAlign); } LONG lTextAlign(LONG l) { return(pDCAttr->lTextAlign = l); } LONG lTextExtra() { return(pDCAttr->lTextExtra); } LONG lTextExtra(LONG l) { return(pDCAttr->lTextExtra = l); } LONG lBreakExtra() { return(pDCAttr->lBreakExtra); } LONG cBreak() { return(pDCAttr->cBreak); } LONG lBreakExtra(LONG l) { return(pDCAttr->lBreakExtra = l);} LONG cBreak(LONG l) { return(pDCAttr->cBreak = l); } DWORD dwLayout() { return(pDCAttr->dwLayout); } void dwLayout(DWORD dwLayout_) { pDCAttr->dwLayout = dwLayout_; } LONG lRelAbs() { return(pDCAttr->lRelAbs); } LONG lRelAbs(LONG l) { return(pDCAttr->lRelAbs = l); } /**************************************************************************\ * * BRUSH methods * \**************************************************************************/ public: // Return the current logical brush handle. PBRUSH pbrushFill() { return(dclevel.pbrFill); } PBRUSH pbrushLine() { return(dclevel.pbrLine); } PBRUSH pbrushFill(PBRUSH p) { return(dclevel.pbrFill=p); } PBRUSH pbrushLine(PBRUSH p) { return(dclevel.pbrLine=p); } FLONG flbrush() { return(dclevel.flbrush);} FLONG flbrush(FLONG fl) { return(dclevel.flbrush=fl); } // move brush flags here so that a different process can access this field (when it cannot // access the one in dc_attr) FLONG flbrushAdd(LONG lflag) { return(dclevel.flbrush |= lflag);} FLONG flbrushSub(LONG lflag) { return(dclevel.flbrush &= ~lflag);} EBRUSHOBJ *peboFill() { return(&eboFill_); } EBRUSHOBJ *peboLine() { return(&eboLine_); } EBRUSHOBJ *peboText() { return(&eboText_); } EBRUSHOBJ *peboBackground() { return(&eboBackground_); } // ptlFillOrigin -- Return a reference to the filling origin. (window) POINTL& ptlFillOrigin() { return(ptlFillOrigin_); } VOID ptlFillOrigin(PPOINTL pptl){ ptlFillOrigin_ = *pptl; } VOID ptlFillOrigin(LONG x, LONG y) { ptlFillOrigin_.x = x; ptlFillOrigin_.y = y; } // Update fill origin. Note: this routine uses the ptlBrushOrigin // from the dclevel, not pdcattr. This is because the value must // be visible to all process. This is kept in sync with // pdcattr->ptlBrushOrigin by a batched command VOID vCalcFillOrigin() { ptlFillOrigin_.x = dclevel.ptlKmBrushOrigin.x + eptlOrigin_.x; ptlFillOrigin_.y = dclevel.ptlKmBrushOrigin.y + eptlOrigin_.y; } // ptlKmBrushOrigin -- Set/return brush origin as set by application POINTL& ptlBrushOrigin() { return(dclevel.ptlKmBrushOrigin); } POINTL& ptlBrushOrigin(LONG x, LONG y) { dclevel.ptlKmBrushOrigin.x = x; dclevel.ptlKmBrushOrigin.y = y; vCalcFillOrigin(); return(dclevel.ptlKmBrushOrigin); } HLFONT hlfntNew () { return((HLFONT)pDCAttr->hlfntNew);} HLFONT hlfntNew (HLFONT _hlfnt) { return((HLFONT)(pDCAttr->hlfntNew = (HANDLE) _hlfnt)); } HBRUSH hbrush() { return((HBRUSH)pDCAttr->hbrush); }; HBRUSH hbrush(HBRUSH h) { return((HBRUSH)(pDCAttr->hbrush = (HANDLE)h));}; HPEN hpen() { return((HPEN)pDCAttr->hpen); }; HPEN hpen(HPEN h) { return((HPEN)(pDCAttr->hpen = (HANDLE)h)); }; ULONG ulDirty() { return(pDCAttr->ulDirty_); }; ULONG ulDirty(ULONG fl) { return(pDCAttr->ulDirty_ = fl); }; ULONG ulDirtyAdd(ULONG fl) { return(pDCAttr->ulDirty_ |= fl); }; ULONG ulDirtySub(ULONG fl) { return(pDCAttr->ulDirty_ &= ~fl); }; /**************************************************************************\ * * Font methods * \**************************************************************************/ public: RFONT *prfnt() { return(prfnt_); } RFONT *prfnt(RFONT *prfnt) { return(prfnt_ = prfnt); } HLFONT hlfntCur() { return(hlfntCur_); } HLFONT hlfntCur(HLFONT hlfnt) { return(hlfntCur_ = hlfnt); } FLONG flSimulationFlags() { return(flSimulationFlags_); } FLONG flSimulationFlags(FLONG fl) { return(flSimulationFlags_ = fl); } LONG lEscapement() { return(lEscapement_); } LONG lEscapement(LONG l) { return(lEscapement_ = l); } BOOL bXFormChange() { return(dclevel.flFontState & DC_DIRTYFONT_XFORM); } BOOL bForcedMapping( PUNIVERSAL_FONT_ID pufi ) { if( dclevel.flFontState & DC_UFI_MAPPING ) { *pufi = *(&dclevel.ufi); return(TRUE); } else { return(FALSE); } } VOID vForceMapping( PUNIVERSAL_FONT_ID pufi ) { *(&dclevel.ufi) = *pufi; dclevel.flFontState |= DC_UFI_MAPPING; } VOID vXformChange(BOOL bDirty) { if (bDirty) dclevel.flFontState |= DC_DIRTYFONT_XFORM; else dclevel.flFontState &= ~DC_DIRTYFONT_XFORM; } FLONG flFontMapper() { return(pDCAttr->flFontMapper); } FLONG flFontMapper(FLONG fl) { return(pDCAttr->flFontMapper = fl); } // pointer to a currently selected logfont object, // this is somewhat analogous to pbrFill in how it is ref counted. PLFONT plfntNew() { return (dclevel.plfntNew_); } PLFONT plfntNew(PLFONT p) { return (dclevel.plfntNew_ = p); } VOID vPFFListSet(PFFLIST *pPFFList_) { pPFFList = pPFFList_; } /**************************************************************************\ * * Palette methods * \**************************************************************************/ public: VOID hpal(HPAL hpal) { dclevel.hpal = hpal; } HPAL hpal() { return(dclevel.hpal); } VOID ppal(PPALETTE ppalNew) { dclevel.ppal = ppalNew; } PPALETTE ppal() { return(dclevel.ppal); } HDC hdcPrev() { return(hdcPrev_); } HDC hdcNext() { return(hdcNext_); } HDC hdcPrev(HDC hdcTemp) { return(hdcPrev_ = hdcTemp); } HDC hdcNext(HDC hdcTemp) { return(hdcNext_ = hdcTemp); } /**************************************************************************\ * * Path methods * \**************************************************************************/ public: // Current position functions. We keep values for both the logical space // current position (ptlCurrent) and device space current position // (ptfxCurrent). // // We must keep a logical space CP for Win3.x compatibility, and we keep a // device space CP for speed in functions like TextOut, which updates the // CP in device space. // // At any one time, either ptlCurrent or ptfxCurrent or both are valid; // the bValidPtlCurrent() or bValidPtfxCurrent() flags must be checked // before using the value; if it's not valid, apply the appropriate // transform to the other value. BOOL bValidPtlCurrent() { return(!(pDCAttr->ulDirty_ & DIRTY_PTLCURRENT)); } BOOL bValidPtfxCurrent() { return(!(pDCAttr->ulDirty_ & DIRTY_PTFXCURRENT)); } POINTFIX& ptfxCurrent(POINTFIX& ptfx) { return(pDCAttr->ptfxCurrent.x = ptfx.x, pDCAttr->ptfxCurrent.y = ptfx.y, *((POINTFIX*) &pDCAttr->ptfxCurrent)); } POINTL& ptlCurrent(POINTL& ptl) { return(pDCAttr->ptlCurrent.x = ptl.x, pDCAttr->ptlCurrent.y = ptl.y, pDCAttr->ptlCurrent); } VOID vInvalidatePtlCurrent() { pDCAttr->ulDirty_ |= DIRTY_PTLCURRENT; } VOID vInvalidatePtfxCurrent() { pDCAttr->ulDirty_ |= DIRTY_PTFXCURRENT; } VOID vValidatePtlCurrent() { pDCAttr->ulDirty_ &= ~DIRTY_PTLCURRENT; } VOID vValidatePtfxCurrent() { pDCAttr->ulDirty_ &= ~DIRTY_PTFXCURRENT; } VOID vCurrentPosition(const POINTL& ptl, const POINTFIX& ptfx) { pDCAttr->ulDirty_ &= ~(DIRTY_PTFXCURRENT | DIRTY_PTLCURRENT); pDCAttr->ptlCurrent.x = ptl.x; pDCAttr->ptlCurrent.y = ptl.y; pDCAttr->ptfxCurrent.x = ptfx.x; pDCAttr->ptfxCurrent.y = ptfx.y; } VOID vCurrentPosition(LONG x, LONG y, FIX fxX, FIX fxY) { pDCAttr->ulDirty_ &= ~(DIRTY_PTFXCURRENT | DIRTY_PTLCURRENT); pDCAttr->ptlCurrent.x = x; pDCAttr->ptlCurrent.y = y; pDCAttr->ptfxCurrent.x = fxX; pDCAttr->ptfxCurrent.y = fxY; } VOID vPtfxCurrentPosition(FIX fxX, FIX fxY) { pDCAttr->ulDirty_ &= ~DIRTY_PTFXCURRENT; pDCAttr->ulDirty_ |= DIRTY_PTLCURRENT; pDCAttr->ptfxCurrent.x = fxX; pDCAttr->ptfxCurrent.y = fxY; } // hpath - return or set path handle HPATH hpath(HPATH hpath) { // Private debug code to catch invalid hpath handle in DC // 6/24/98 - davidx ASSERTGDI(hpath == HPATH_INVALID || HmgObjtype(hpath) == PATH_TYPE, "Private debug breakpoint. Please contact ntgdi."); return(dclevel.hpath = hpath); } // Decide if there is no path, or if in path bracket, or if done bracket BOOL bNone() { return(dclevel.hpath == HPATH_INVALID);} BOOL bActive() { return(dclevel.flPath & DCPATH_ACTIVE);} BOOL bInactive() { return(!bNone() && !bActive()); } VOID vSetActive() { dclevel.flPath |= DCPATH_ACTIVE; } VOID vClearActive() { dclevel.flPath &= ~DCPATH_ACTIVE; } VOID vDestroy() { vClearActive(); hpath(HPATH_INVALID);} // Set direction in which arcs are drawn BOOL bClockwise() { return(dclevel.flPath & DCPATH_CLOCKWISE);} VOID vSetClockwise() { dclevel.flPath |= DCPATH_CLOCKWISE; } VOID vClearClockwise() { dclevel.flPath &= ~DCPATH_CLOCKWISE; } // Lazy save flag for SaveDC BOOL bLazySave() { return(dclevel.flPath & DCPATH_SAVE);} VOID vSetLazySave() { dclevel.flPath |= DCPATH_SAVE; } VOID vClearLazySave() { dclevel.flPath &= ~DCPATH_SAVE; } FLOATL l_eMiterLimit(FLOATL& e) { return(dclevel.laPath.eMiterLimit = e);} FLOATL l_eMiterLimit() { return(dclevel.laPath.eMiterLimit); } // Line-state type is LONG if pen selected into DC is a styled cosmetic // pen, and FLOAT if pen selected is a geometric styled pen (undefined // otherwise): FLOAT_LONG elStyleState() { return(dclevel.laPath.elStyleState); } FLOAT_LONG elStyleState(FLOAT_LONG el){ return(dclevel.laPath.elStyleState = el);} LONG lStyleState() { return(dclevel.laPath.elStyleState.l); } LONG lStyleState(LONG l) { return(dclevel.laPath.elStyleState.l = l); } FLOATL l_eStyleState() { return(dclevel.laPath.elStyleState.e); } FLOATL l_eStyleState(FLOATL e) { return(dclevel.laPath.elStyleState.e = e); } // LINEATTRS support: VOID vRealizeLineAttrs(EXFORMOBJ& exo); BOOL bOldPenNominal(EXFORMOBJ& exo, LONG lPenWidth); /**************************************************************************\ * * Region methods * \**************************************************************************/ public: #if DBG || defined(PRERELEASE) BOOL bValidateVisrgn() { return(bValidateVisrgn_); } VOID vValidateVisrgn(BOOL b) { bValidateVisrgn_ = b; } #endif REGION *prgnVis() { return(prgnVis_); } REGION *prgnVis(REGION *prgn) { return(prgnVis_ = prgn); } REGION *prgnRao() { return(prgnRao_); } REGION *prgnRao(REGION *prgn) { return(prgnRao_ = prgn); } VOID vReleaseVis(); VOID vReleaseRao(); BOOL bDirtyRao() { return(fs_ & DC_DIRTY_RAO); } PREGION prgnAPI() { return(prgnAPI_); } PREGION prgnAPI(PREGION prgn) { vReleaseRao(); return(prgnAPI_ = prgn); } PREGION prgnMeta() { return(dclevel.prgnMeta); } PREGION prgnMeta(PREGION prgn) { return(dclevel.prgnMeta = prgn); } PREGION prgnClip() { return(dclevel.prgnClip); } PREGION prgnClip(PREGION prgn) { return(dclevel.prgnClip = prgn); } INT iSelect(HRGN hrgn,int iMode); // Select in a new clip region INT iSelect(PREGION prgn,int iMode); // Select in a new clip region INT iSetMetaRgn(); // Combine the clip and meta rgn's BOOL bCompute(); LONG iCombine(RECTL *, LONG); LONG iCombine(EXFORMOBJ *, RECTL *, LONG); VOID vUpdate_VisRect(REGION *prgn); BOOL bSetDefaultRegion(); BOOL bReset(); PRECTL prclClip() { return(&erclClip_); } ERECTL& erclClip() { return(erclClip_); } VOID erclClip(PRECTL prcl) { erclClip_ = *prcl; } PRECTL prclWindow() { return(&erclWindow_); } ERECTL& erclWindow() { return(erclWindow_); } VOID erclWindow(PRECTL prcl) { erclWindow_ = *prcl; } EPOINTL& eptlOrigin() { return(eptlOrigin_); } VOID eptlOrigin(PPOINTL pptl) { eptlOrigin_ = *pptl; } ERECTL& erclBounds() { return(erclBounds_); } ERECTL& erclBoundsApp() { return(erclBoundsApp_); } /**************************************************************************\ * * Saved level methods * \**************************************************************************/ public: DCTYPE dctp() { return(dctp_); } DCTYPE dctp(DCTYPE dctp) { return(dctp_ = dctp); } HDC hdcSave(HDC hdc) { return(dclevel.hdcSave = hdc); } LONG lIncSaveDepth() { return(++(dclevel.lSaveDepth)); } PDEV *ppdev(PDEV *ppdev) { return(ppdev_ = ppdev); } PDEV *ppdev() { return(ppdev_); } HDEV hdev() { return((HDEV)ppdev_); } FLONG flGraphicsCaps() { return(flGraphicsCaps_); } VOID flGraphicsCaps(FLONG fl) { flGraphicsCaps_ = fl; } FLONG flGraphicsCaps2() { return(flGraphicsCaps2_); } VOID flGraphicsCaps2(FLONG fl) { flGraphicsCaps2_ = fl; } // // The following fields may be changed asynchronously by the dynamic // mode changing code even if an exclusive DC lock is held -- unless // an appropriate lock is held. // // Note that no lock need be held to determine bHasSurface() since // the dyanmic mode change code will always ensure that pSurface() will // be non-NULL if it was already non-NULL, and vice versa. // // For checked builds, this does a function call to dcobj.cxx. For // free builds, it compiles to nothing. // #if DBG VOID vAssertDynaLock(BOOL bDcLevelField); #else VOID vAssertDynaLock(BOOL bDcLevelField) {} #endif BOOL bHasSurface() { return(dclevel.pSurface != NULL); } SURFACE *pSurface() { vAssertDynaLock(TRUE); return(dclevel.pSurface);} VOID pSurface(SURFACE *pSurf) { dclevel.pSurface = pSurf; } DHPDEV dhpdev() { vAssertDynaLock(FALSE); return(dhpdev_); } VOID dhpdev(DHPDEV dhpdev) { dhpdev_ = dhpdev; } SIZEL sizl() { vAssertDynaLock(TRUE); return(dclevel.sizl); } VOID vGet_sizl(PSIZEL psizl) { vAssertDynaLock(TRUE); *psizl = dclevel.sizl; } VOID sizl(SIZEL sizl) { dclevel.sizl = sizl; } // // WARNING: You don't have to hold a lock to access vGet_sizlWindow, // but unless you do you won't be guaranteed that you have // read a consitent value because a mode change could happen // in the middle of copying both dwords. // VOID vGet_sizlWindow(SIZEL *psizl) { *psizl = dclevel.sizl; } // // bDisplay -- Set the DC_DISPLAY bit. hsemDcDevLock will be set for all // DC's that are display related whether they are memory or info. // VOID vDisplay(BOOL b) { if (b) fs_ |= DC_DISPLAY; else fs_ &= ~DC_DISPLAY; } BOOL bDisplay() { return(fs() & DC_DISPLAY); } // // bInFullScreen -- Set the DC_FULLSCREEN bit. // VOID bInFullScreen(BOOL b) { if (b) fs_ |= DC_FULLSCREEN; else fs_ &= ~DC_FULLSCREEN; } BOOL bInFullScreen() { return(fs() & DC_FULLSCREEN); } // // bRedirection -- Set the DC_REDIRECTION bit. // VOID bRedirection(BOOL b) { if (b) fs_ |= DC_REDIRECTION; else fs_ &= ~DC_REDIRECTION; } BOOL bRedirection() { return(fs() & DC_REDIRECTION); } // // bStockBitmap -- Set the DC_STOCKBITMAP bit. // VOID bStockBitmap(BOOL b) { if (b) fs_ |= DC_STOCKBITMAP; else fs_ &= ~DC_STOCKBITMAP; } BOOL bStockBitmap() { return(fs() & DC_STOCKBITMAP); } // // bDIBSection true only if DC surface is a DIBSection // VOID vDIBSection(BOOL b) { if (b) pDCAttr->ulDirty_ |= DC_DIBSECTION; else pDCAttr->ulDirty_ &= ~DC_DIBSECTION; } BOOL bDIBSection() { return(pDCAttr->ulDirty_ & DC_DIBSECTION);} // // vCopyTo -- Xeroxes the contents to somewhere else. This is designed for // use only by SaveDC and RestoreDC. Only the level dependent // stuff is copied. Window Manager stuff is preserved. // VOID vCopyTo(XDCOBJ& dco); /**************************************************************************\ * * Transform methods * \**************************************************************************/ public: SIZEL szlWindowExt() { return(pDCAttr->szlWindowExt); } LONG lWindowExtCx() { return(pDCAttr->szlWindowExt.cx); } LONG lWindowExtCy() { return(pDCAttr->szlWindowExt.cy); } LONG lWindowExtCx(LONG l) { return(pDCAttr->szlWindowExt.cx=l); } LONG lWindowExtCy(LONG l) { return(pDCAttr->szlWindowExt.cy=l); } SIZEL szlViewportExt() { return(pDCAttr->szlViewportExt); } LONG lViewportExtCx() { return(pDCAttr->szlViewportExt.cx); } LONG lViewportExtCy() { return(pDCAttr->szlViewportExt.cy); } LONG lViewportExtCx(LONG l) { return(pDCAttr->szlViewportExt.cx=l); } LONG lViewportExtCy(LONG l) { return(pDCAttr->szlViewportExt.cy=l); } POINTL ptlWindowOrg() { return(pDCAttr->ptlWindowOrg); } LONG lWindowOrgX() { return(pDCAttr->ptlWindowOrg.x); } LONG lWindowOrgY() { return(pDCAttr->ptlWindowOrg.y); } LONG lWindowOrgX(LONG l) { return(pDCAttr->ptlWindowOrg.x=l); } LONG lWindowOrgY(LONG l) { return(pDCAttr->ptlWindowOrg.y=l); } POINTL ptlViewportOrg() { return(pDCAttr->ptlViewportOrg); } LONG lViewportOrgX() { return(pDCAttr->ptlViewportOrg.x); } LONG lViewportOrgY() { return(pDCAttr->ptlViewportOrg.y); } LONG lViewportOrgX(LONG l) { return(pDCAttr->ptlViewportOrg.x=l); } LONG lViewportOrgY(LONG l) { return(pDCAttr->ptlViewportOrg.y=l); } SIZEL szlVirtualDevicePixel() { return(pDCAttr->szlVirtualDevicePixel); } LONG lVirtualDevicePixelCx() { return(pDCAttr->szlVirtualDevicePixel.cx); } LONG lVirtualDevicePixelCy() { return(pDCAttr->szlVirtualDevicePixel.cy); } SIZEL szlVirtualDeviceMm() { return(pDCAttr->szlVirtualDeviceMm); } LONG lVirtualDeviceMmCx() { return(pDCAttr->szlVirtualDeviceMm.cx); } LONG lVirtualDeviceMmCy() { return(pDCAttr->szlVirtualDeviceMm.cy); } LONG lVirtualDeviceCx() { return(pDCAttr->szlVirtualDevice.cx); } LONG lVirtualDeviceCy() { return(pDCAttr->szlVirtualDevice.cy); } LONG lVirtualDevicePixelCx(LONG l){ return(pDCAttr->szlVirtualDevicePixel.cx=l); } LONG lVirtualDevicePixelCy(LONG l){ return(pDCAttr->szlVirtualDevicePixel.cy=l); } LONG lVirtualDeviceMmCx(LONG l) { return(pDCAttr->szlVirtualDeviceMm.cx=l); } LONG lVirtualDeviceMmCy(LONG l) { return(pDCAttr->szlVirtualDeviceMm.cy=l); } LONG lVirtualDeviceCx(LONG l) { return(pDCAttr->szlVirtualDevice.cx=l); } LONG lVirtualDeviceCy(LONG l) { return(pDCAttr->szlVirtualDevice.cy=l); } ULONG ulMapMode(ULONG ul) { return(pDCAttr->iMapMode = ul); } MATRIX& mxWorldToDevice() { return(dclevel.mxWorldToDevice); } MATRIX& mxDeviceToWorld() { return(dclevel.mxDeviceToWorld); } MATRIX& mxWorldToPage() { return(dclevel.mxWorldToPage); } MATRIX& mxUserWorldToDevice() { return((MATRIX &)pDCAttr->mxWtoD); } MATRIX& mxUserDeviceToWorld() { return((MATRIX &)pDCAttr->mxDtoW); } MATRIX& mxUserWorldToPage() { return((MATRIX &)pDCAttr->mxWtoP); } EFLOAT efM11() { return(dclevel.mxWorldToDevice.efM11);} EFLOAT efM12() { return(dclevel.mxWorldToDevice.efM12);} EFLOAT efM21() { return(dclevel.mxWorldToDevice.efM21);} EFLOAT efM22() { return(dclevel.mxWorldToDevice.efM22);} FIX fxDx() { return(dclevel.mxWorldToDevice.fxDx);} FIX fxDy() { return(dclevel.mxWorldToDevice.fxDy);} EFLOAT efM11PtoD() { return(dclevel.efM11PtoD); } EFLOAT efM22PtoD() { return(dclevel.efM22PtoD); } EFLOAT efDxPtoD() { return(dclevel.efDxPtoD); } EFLOAT efDyPtoD() { return(dclevel.efDyPtoD); } EFLOAT efM11_TWIPS() { return(dclevel.efM11_TWIPS); } EFLOAT efM22_TWIPS() { return(dclevel.efM22_TWIPS); } EFLOAT& efrM11PtoD() { return(dclevel.efM11PtoD); } EFLOAT& efrM22PtoD() { return(dclevel.efM22PtoD); } EFLOAT& efrDxPtoD() { return(dclevel.efDxPtoD); } EFLOAT& efrDyPtoD() { return(dclevel.efDyPtoD); } EFLOAT efM11PtoD(EFLOAT ef) { pDCAttr->efM11PtoD = ef.Base(); return(dclevel.efM11PtoD = ef); } EFLOAT efM22PtoD(EFLOAT ef) { pDCAttr->efM22PtoD = ef.Base(); return(dclevel.efM22PtoD = ef); } EFLOAT efDxPtoD(EFLOAT ef) { pDCAttr->efDxPtoD = ef.Base(); return(dclevel.efDxPtoD = ef); } EFLOAT efDyPtoD(EFLOAT ef) { pDCAttr->efDyPtoD = ef.Base(); return(dclevel.efDyPtoD = ef); } EFLOAT efM11_TWIPS(EFLOAT ef) { return(dclevel.efM11_TWIPS = ef); } EFLOAT efM22_TWIPS(EFLOAT ef) { return(dclevel.efM22_TWIPS = ef); } EFLOAT efM11PtoD(LONG l) { EFLOATEXT ef(l); pDCAttr->efM11PtoD = ef.Base(); return(dclevel.efM11PtoD = ef); } EFLOAT efM22PtoD(LONG l) { EFLOATEXT ef(l); pDCAttr->efM22PtoD = ef.Base(); return(dclevel.efM22PtoD = ef); } EFLOAT efDxPtoD(LONG l) { EFLOATEXT ef(l); pDCAttr->efDxPtoD = ef.Base(); return(dclevel.efDxPtoD =ef); } EFLOAT efDyPtoD(LONG l) { EFLOATEXT ef(l); pDCAttr->efDyPtoD = ef.Base(); return(dclevel.efDyPtoD = ef); } EFLOAT efM11_TWIPS(LONG l) { EFLOATEXT ef(l);return(dclevel.efM11_TWIPS = ef); } EFLOAT efM22_TWIPS(LONG l) { EFLOATEXT ef(l);return(dclevel.efM22_TWIPS = ef); } EFLOAT efMetaPtoD11() { return(dclevel.efPr11); } EFLOAT efMetaPtoD22() { return(dclevel.efPr22); } ULONG ulMapMode() { return(pDCAttr->iMapMode); } VOID vUpdateWtoDXform(); FLONG flSet_flXform(FLONG fl) { return(pDCAttr->flXform |= fl); } FLONG flClr_flXform(FLONG fl) { return(pDCAttr->flXform &= ~fl); } FLONG flXform() { return(pDCAttr->flXform); } BOOL bAnisoOrIsoMapMode() { return(pDCAttr->flXform & ISO_OR_ANISO_MAP_MODE);} FLONG flResetflXform(FLONG fl) { return(pDCAttr->flXform = fl); } BOOL befM11IsNegative() { return(pDCAttr->flXform & PTOD_EFM11_NEGATIVE);} BOOL befM22IsNegative() { return(pDCAttr->flXform & PTOD_EFM22_NEGATIVE);} BOOL bYisUp() { return(pDCAttr->flXform & POSITIVE_Y_IS_UP);} BOOL bPageExtentsChanged() { return(pDCAttr->flXform & PAGE_EXTENTS_CHANGED);} BOOL bPageXlateChanged() { return(pDCAttr->flXform & PAGE_XLATE_CHANGED);} BOOL bWorldToPageIdentity() { return(flXform() & WORLD_TO_PAGE_IDENTITY); } BOOL bPageToDeviceIdentity() { return(flXform() & PAGE_TO_DEVICE_IDENTITY); } BOOL bPageToDeviceScaleIdentity(){ return(flXform() & PAGE_TO_DEVICE_SCALE_IDENTITY);} BOOL bUseMetaPtoD() { return(!dclevel.efPr11.bIsZero() && !dclevel.efPr22.bIsZero()); } VOID vSet_MetaPtoD(FLOATL l_eX, FLOATL l_eY) { dclevel.efPr11 = l_eX; dclevel.efPr22 = l_eY; } BOOL bWorldToDeviceIdentity() { return( (flXform() & (WORLD_TO_PAGE_IDENTITY|PAGE_TO_DEVICE_IDENTITY)) == (WORLD_TO_PAGE_IDENTITY|PAGE_TO_DEVICE_IDENTITY)); } BOOL bYisUp(BOOL b) { if (b) pDCAttr->flXform |= POSITIVE_Y_IS_UP; else pDCAttr->flXform &= ~POSITIVE_Y_IS_UP; return(b); } BOOL bDirtyXform() { return(pDCAttr->flXform & (PAGE_XLATE_CHANGED | PAGE_EXTENTS_CHANGED | WORLD_XFORM_CHANGED)); } BOOL bDirtyXlateOrExt() { return(pDCAttr->flXform & (PAGE_XLATE_CHANGED | PAGE_EXTENTS_CHANGED | WORLD_XFORM_CHANGED)); } VOID vSetWorldXformIdentity() { flSet_flXform(WORLD_XFORM_CHANGED | DEVICE_TO_WORLD_INVALID | INVALIDATE_ATTRIBUTES | WORLD_TO_PAGE_IDENTITY | WORLD_TRANSFORM_SET); } VOID vClrWorldXformIdentity() { flSet_flXform(WORLD_XFORM_CHANGED | DEVICE_TO_WORLD_INVALID | INVALIDATE_ATTRIBUTES | WORLD_TRANSFORM_SET); flClr_flXform(WORLD_TO_PAGE_IDENTITY); } VOID vPageExtentsChanged() { pDCAttr->flXform |= (INVALIDATE_ATTRIBUTES | PAGE_EXTENTS_CHANGED | DEVICE_TO_WORLD_INVALID); } VOID vPageXlateChanged() { pDCAttr->flXform |= (PAGE_XLATE_CHANGED | DEVICE_TO_WORLD_INVALID); } VOID vSetFlagsMM_TEXT() { pDCAttr->flXform |= (INVALIDATE_ATTRIBUTES | PAGE_TO_DEVICE_SCALE_IDENTITY | PAGE_XLATE_CHANGED | DEVICE_TO_WORLD_INVALID); pDCAttr->flXform &= ~(PTOD_EFM11_NEGATIVE | PTOD_EFM22_NEGATIVE | POSITIVE_Y_IS_UP | ISO_OR_ANISO_MAP_MODE); } VOID vSetFlagsMM_FIXED_CACHED() { pDCAttr->flXform |= (INVALIDATE_ATTRIBUTES | POSITIVE_Y_IS_UP | PTOD_EFM22_NEGATIVE | PAGE_XLATE_CHANGED | DEVICE_TO_WORLD_INVALID); pDCAttr->flXform &= ~(ISO_OR_ANISO_MAP_MODE | PAGE_TO_DEVICE_SCALE_IDENTITY | PAGE_TO_DEVICE_IDENTITY | PTOD_EFM11_NEGATIVE); } VOID vSetFlagsMM_FIXED() { pDCAttr->flXform |= POSITIVE_Y_IS_UP; pDCAttr->flXform &= ~(ISO_OR_ANISO_MAP_MODE|PAGE_TO_DEVICE_IDENTITY); } VOID vSetFlagsMM_ISO_OR_ANISO() { pDCAttr->flXform &= ~(POSITIVE_Y_IS_UP|PAGE_TO_DEVICE_IDENTITY); pDCAttr->flXform |= ISO_OR_ANISO_MAP_MODE; } VOID vGet_szlWindowExt(PSIZEL pSizl) { *pSizl = pDCAttr->szlWindowExt; } VOID vGet_ptlWindowOrg(PPOINTL pPtl) { *pPtl = pDCAttr->ptlWindowOrg; } VOID vGet_szlViewportExt(PSIZEL pSizl){ *pSizl = pDCAttr->szlViewportExt;} VOID vGet_ptlViewportOrg(PPOINTL pPtl){ *pPtl = pDCAttr->ptlViewportOrg;} VOID vSet_szlWindowExt(PSIZEL pSizl) { pDCAttr->szlWindowExt = *pSizl;} VOID vSet_ptlWindowOrg(PPOINTL pPtl) { pDCAttr->ptlWindowOrg = *pPtl; } VOID vSet_szlViewportExt(PSIZEL pSizl){ pDCAttr->szlViewportExt = *pSizl;} VOID vSet_ptlViewportOrg(PPOINTL pPtl){ pDCAttr->ptlViewportOrg = *pPtl; } VOID vOffset_ptlWindowOrg(PPOINTL pPtl) { pDCAttr->ptlWindowOrg.x += pPtl->x; pDCAttr->ptlWindowOrg.y += pPtl->y; } VOID vOffset_ptlViewportOrg(PPOINTL pPtl) { pDCAttr->ptlViewportOrg.x += pPtl->x; pDCAttr->ptlViewportOrg.y += pPtl->y; } VOID vSet_szlWindowExt(LONG x, LONG y) { ASSERTGDI((sizeof(LONG) <= sizeof(int)), "LONG assigned to int"); pDCAttr->szlWindowExt.cx = (int)x; pDCAttr->szlWindowExt.cy = (int)y; } VOID vSet_szlViewportExt(LONG x, LONG y) { ASSERTGDI((sizeof(LONG) <= sizeof(int)), "LONG assigned to int"); pDCAttr->szlViewportExt.cx = (int)x; pDCAttr->szlViewportExt.cy = (int)y; } VOID vSet_szlVirtualDevicePixel(LONG x, LONG y) { pDCAttr->szlVirtualDevicePixel.cx = x; pDCAttr->szlVirtualDevicePixel.cy = y; } VOID vSet_szlVirtualDeviceMm(LONG x, LONG y) { pDCAttr->szlVirtualDeviceMm.cx = x; pDCAttr->szlVirtualDeviceMm.cy = y; } BOOL bUseVirtualResolution() { return(pDCAttr->szlVirtualDevicePixel.cx != 0); } VOID vMakeIso(); VOID vComputePageXform(); int iSetMapMode(int iMode); DWORD dwSetLayout(LONG wox, DWORD dwLayout); //get the device surface width. LONG GetDeviceWidth() { return (erclWindow_.right - erclWindow_.left); } // If the DC is mirrored the mirror the Window X Org. using the logical one. // Else set it equal the logical WindowOrg. VOID MirrorWindowOrg() { if (pDCAttr->dwLayout & LAYOUT_RTL) { LONG lViewportExtCx = pDCAttr->szlViewportExt.cx; if (lViewportExtCx) { pDCAttr->ptlWindowOrg.x = ((-(erclWindow_.right - erclWindow_.left - 1) * pDCAttr->szlWindowExt.cx) / \ lViewportExtCx) + pDCAttr->lWindowOrgx; } } else { pDCAttr->ptlWindowOrg.x = pDCAttr->lWindowOrgx; } } // Set the logical WindowOrg. and the mirror the WindowOrg. VOID SetWindowOrgAndMirror(LONG x) { pDCAttr->lWindowOrgx = x; MirrorWindowOrg(); } /**************************************************************************\ * * ICM methods * \**************************************************************************/ HANDLE hcmXform() { return(pDCAttr->hcmXform); } HANDLE hcmXform(HANDLE hcmNew) { pDCAttr->hcmXform = hcmNew;return (hcmNew); } BOOL bValidIcmBrushColor() { return(pDCAttr->ulDirty_ & ICM_BRUSH_TRANSLATED); } BOOL bValidIcmPenColor() { return(pDCAttr->ulDirty_ & ICM_PEN_TRANSLATED); } COLORREF crIcmBrushColor() { return(pDCAttr->IcmBrushColor); } COLORREF crIcmPenColor() { return(pDCAttr->IcmPenColor); } COLORREF crIcmBrushColor(COLORREF _crColor) {pDCAttr->IcmBrushColor = _crColor;return (_crColor); } COLORREF crIcmPenColor(COLORREF _crColor) {pDCAttr->IcmPenColor = _crColor;return (_crColor); } VOID vCXFListSet(CXFLIST *pCXFList_) {pCXFList = pCXFList_;} HCOLORSPACE hColorSpace(HCOLORSPACE hColorSpace) { pDCAttr->hColorSpace = hColorSpace;return (hColorSpace); } HCOLORSPACE hColorSpace() { return(pDCAttr->hColorSpace); } ULONG_PTR dwDIBColorSpace(ULONG_PTR dwColorSpace) { pDCAttr->dwDIBColorSpace = dwColorSpace;return (dwColorSpace); } ULONG_PTR dwDIBColorSpace() { return(pDCAttr->dwDIBColorSpace); } PVOID pColorSpace(PVOID pColorSpace) { dclevel.pColorSpace = pColorSpace; return(pColorSpace); } PVOID pColorSpace() { return(dclevel.pColorSpace); } LONG lIcmModeClient(LONG Mode) { pDCAttr->lIcmMode = Mode;return (Mode); } LONG lIcmModeClient() { return(pDCAttr->lIcmMode); } LONG lIcmMode(LONG Mode) { dclevel.lIcmMode = Mode;return (Mode); } LONG lIcmMode() { return(dclevel.lIcmMode); } LONG GetICMMode() { return(dclevel.lIcmMode); } // SHOULD BE DELETED. AND SHOULD USE lIcmMode() BOOL bIsAppsICM() { return(IS_ICM_OUTSIDEDC(dclevel.lIcmMode)); } BOOL bIsHostICM() { return(IS_ICM_HOST(dclevel.lIcmMode)); } BOOL bIsDeviceICM() { return(IS_ICM_DEVICE(dclevel.lIcmMode)); } BOOL bIsSoftwareICM() { return(bIsAppsICM() || bIsHostICM()); } BOOL bIsCMYKColor() { return(bIsHostICM() && (pDCAttr->hcmXform != NULL) && IS_CMYK_COLOR(dclevel.lIcmMode)); } /**************************************************************************\ * * Miscellaneous methods * \**************************************************************************/ FSHORT fs() { return(fs_); } FSHORT fs(FSHORT fs) { return(fs_ = fs); } VOID fsSet(FSHORT fs) { fs_ |= fs; } VOID fsClr(FSHORT fs) { fs_ &= ~fs; } SURFACE *psurfInfo() { return(psurfInfo_); } VOID vSavePsurfInfo() { psurfInfo_ = pSurface(); pSurface(NULL); } VOID vRestorePsurfInfo() { pSurface(psurfInfo_); psurfInfo_ = NULL; } BOOL bMakeInfoDC(BOOL bSet); BOOL bTempInfoDC() { return(fs() & DC_TEMPINFODC); } VOID vSetTempInfoDC() { fsSet(DC_TEMPINFODC); } VOID vClearTempInfoDC() { fsClr(DC_TEMPINFODC); } BOOL bAddRemoteFont( PFF *ppff, BOOL bMergeFont ); BOOL bRemoveMergeFont(UNIVERSAL_FONT_ID ufi); }; typedef DC *PDC; /******************************MACRO***************************************\ * SYNC_DRAWING_ATTRS * * - sync attributes that can be set in DC_ATTR from user mode * * Arguments: * * pdc * * Return Value: * * none * * History: * * 25-Jan-1996 -by- Mark Enstrom [marke] * \**************************************************************************/ #define SYNC_DRAWING_ATTRS(pdc) \ { \ ULONG ulDirty = pdc->ulDirty(); \ \ if ( ulDirty & DC_BRUSH_DIRTY) \ { \ GreDCSelectBrush(pdc,pdc->hbrush()); \ } \ \ if ( ulDirty & DC_PEN_DIRTY) \ { \ GreDCSelectPen(pdc,pdc->hpen()); \ } \ } /*********************************Class************************************\ * class XDCOBJ * * User object for DC class. * * History: * Tue 28-Dec-1993 -by- Patrick Haluptzok [patrickh] * Make it have do nothing const/destr and derive off it the other classes. * * Tue 25-Jun-1991 -by- Patrick Haluptzok [patrickh] * add all types of locking methods, out of line for now. * * Sun 09-Jun-1991 -by- Patrick Haluptzok [patrickh] * Optimizatize all constructors, destructors via inline. * * Fri 12-Apr-1991 10:42:06 -by- Donald Sidoroff [donalds] * The BIG rewrite * * Thu 09-Aug-1990 16:05:20 -by- Charles Whitmer [chuckwh] * Wrote it. \**************************************************************************/ class XDCOBJ /* dco */ { public: PDC pdc; public: XDCOBJ() {pdc = NULL;} ~XDCOBJ() {} XDCOBJ(HDC hdc) { pdc = (PDC) HmgLock((HOBJ)hdc, DC_TYPE); } VOID vLock(HDC hdc) { pdc = (PDC) HmgLock((HOBJ)hdc, DC_TYPE); } // Bug #223129: In GreRestoreDC, we need to get a lock on the saved DC even when // the process has reached its handle quota (this is OK because the saved DC is // about to be deleted anyway). This can be achieved via a call to HmgLockAllOwners. // However, in order to prevent other people from calling vLockAllOwners in the future // and making a big mess, we designate this a protected function and only allow // GreRestoreDC to call it. Do not call this routine outside of the above scenario // unless there's a really good reason! protected: friend BOOL GreRestoreDC(HDC hdc,int lDC); VOID vLockAllOwners(HDC hdc) { pdc = (PDC) HmgLockAllOwners((HOBJ)hdc, DC_TYPE); } public: VOID vAltLock(HDC hdc) { pdc = (PDC) HmgShareLock((HOBJ)hdc, DC_TYPE); } VOID vAltCheckLock(HDC hdc) { pdc = (PDC) HmgShareCheckLock((HOBJ)hdc, DC_TYPE); } VOID vDontUnlockDC() { pdc = (PDC) NULL; } // There are 3 different AltUnlock. vAltUnlock checks for NULL before // unlocking and then sets it to NULL after it's done unlocking so // a destructor doesn't try and unlock it. This is done when you need // to unlock a DC early and don't want the destructor to get called again // later. VOID vAltUnlock() { if (pdc != (PDC) NULL) { DEC_SHARE_REF_CNT(pdc); pdc = (PDC) NULL; } } // This is used by all the destructors because when you go out of scope // of the DCOBJ you don't need to set the pdc to NULL because it can't // be referenced again. VOID vAltUnlockNoNullSet() { if (pdc != (PDC) NULL) { DEC_SHARE_REF_CNT(pdc); } } // vAltUnlockFast is used when you have a DCOBJ class with no destructor // to worry about firing off and you know you have it locked down and // you want to unlock it because your done using it. VOID vAltUnlockFast() { DEC_SHARE_REF_CNT(pdc); } // The Unlocks have all the same variations as the AltUnlocks for the // same reasons and uses. VOID vUnlock() { if (pdc != (PDC) NULL) { DEC_EXCLUSIVE_REF_CNT(pdc); pdc = (PDC) NULL; } } VOID vUnlockNoNullSet() { if (pdc != (PDC) NULL) { DEC_EXCLUSIVE_REF_CNT(pdc); } } VOID vUnlockFast() { DEC_EXCLUSIVE_REF_CNT(pdc); } HDC hdc() { return((HDC) pdc->hGet()); } // bDelete -- Deletes DC memory. Assumes the DC was allocated through // DCMEMOBJ. BOOL bDeleteDC(BOOL bProcessCleanup = FALSE); // Validity testing for DC's is markedly different then most objects. DC's // can be valid in different senses. The handle can be valid, the physical // device can be valid, the surface can be valid and finally, the surface may // not be readable/writable (printers/scanners). This creates the need for // several validity checks. Most drawing API's can use bValidSurf, most other // API's will use bValid. Only a very few API's (DC management) can use // bLocked. Some API's only check bValid upfront and then check bFullScreen // later, this is to allow bounds accumulation or current position code to // execute that would be too difficult to do up front. BOOL bLocked() { return(pdc != (DC *) NULL); } BOOL bValid() { return((pdc != (DC *) NULL)); } VOID bInFullScreen(BOOL b) { pdc->bInFullScreen(b); } BOOL bInFullScreen() { return(pdc->bInFullScreen()); } BOOL bFullScreen() { return(!pdc->bHasSurface() || pdc->bInFullScreen()); } BOOL bValidSurf() { return((pdc != (DC *) NULL) && (pdc->bHasSurface()) && !(pdc->bInFullScreen())); } BOOL bPrinter() { return(pdc->ppdev()->fl & PDEV_PRINTER); } BOOL bUMPD() { return(pdc->ppdev()->fl & PDEV_UMPD); } BOOL bStockBitmap() { return(pdc->bStockBitmap()); } // PFFListGet and PFFListSet are used to transfer remote font list across ResetDC // calls PFFLIST *PFFListGet() { return(pdc->pPFFList); } VOID PFFListSet(PFFLIST *pPFFList_) { pdc->pPFFList = pPFFList_; } CXFLIST *CXFListGet() { return(pdc->pCXFList); } VOID CXFListSet(CXFLIST *pCXFList_) { pdc->pCXFList = pCXFList_; } FSHORT fs() { return(pdc->fs()); } FSHORT fs(FSHORT fs) { return(pdc->fs(fs)); } VOID fsSet(FSHORT fs) { pdc->fsSet(fs); } VOID fsClr(FSHORT fs) { pdc->fsClr(fs); } // Bounds accumulation. VOID vAccumulate(ERECTL& ercl); // Returns some commonly used info from the DC ECLIPOBJ *pco() { return((ECLIPOBJ *) &(pdc->co_));} HDEV hdev() { return(pdc->hdev());} FLONG flGraphicsCaps() { return(pdc->flGraphicsCaps());} FLONG flGraphicsCaps2() { return(pdc->flGraphicsCaps2());} HSEMAPHORE hsemDcDevLock() { return(pdc->hsemDcDevLock_);} HSEMAPHORE hsemDcDevLock(HSEMAPHORE hsem) { return(pdc->hsemDcDevLock_ = hsem);} DCTYPE dctp() { return(pdc->dctp());} // The following fields can change asynchronously by the dynamic-mode-change // code. Make sure you're holding the proper locks to access them. DHPDEV dhpdev() { return(pdc->dhpdev());} BOOL bHasSurface() { return(pdc->bHasSurface());} SURFACE *pSurface() { return(pdc->pSurface());} SURFACE *pSurfaceEff() { if (!pdc->bHasSurface()) return(SURFACE::pdibDefault); else return(pdc->pSurface()); } // bDisplay is only true for display PDEVS that are direct DC's. BOOL bDisplay() { return(pdc->bDisplay());} BOOL bRedirection() { return(pdc->bRedirection());} // bNeedsSomeExcluding is obsolete since the advent of sprites. BOOL bNeedsSomeExcluding() { return(FALSE);} BOOL bSynchronizeAccess() { return(fs() & DC_SYNCHRONIZEACCESS);} BOOL bShareAccess() { return(fs() & DC_SHAREACCESS);} BOOL bKillReset() { return(fs() & DC_RESET);} BOOL bAccum() { return(fs() & DC_ACCUM_WMGR);} BOOL bAccumApp() { return(fs() & DC_ACCUM_APP);} FCHAR fjAccum() { return(fs() & (DC_ACCUM_WMGR | DC_ACCUM_APP)); } HPAL hpal() { return(pdc->hpal());} PPALETTE ppal() { return(pdc->ppal());} HPATH hpath() { return(pdc->dclevel.hpath);} HDC hdcSave() { return(pdc->dclevel.hdcSave);} LONG lSaveDepth() { return(pdc->dclevel.lSaveDepth);} LONG lSaveDepthStartDoc() { return(pdc->dclevel.lSaveDepthStartDoc);} VOID vSetSaveDepthStartDoc() { pdc->dclevel.lSaveDepthStartDoc = pdc->dclevel.lSaveDepth;} COLORADJUSTMENT *pColorAdjustment() { return(&pdc->dclevel.ca);} // ulMapMode -- Get the current mapping mode. ULONG ulMapMode() { return(pdc->pDCAttr->iMapMode);} // Get current position in device or logical coords (note that you must // make sure the values are valid by calling pdc->bValidPtfxCurrent() // or pdc->bValidPtlCurrent()!) POINTFIX& ptfxCurrent() { return(*((POINTFIX*) &pdc->pDCAttr->ptfxCurrent));} POINTL& ptlCurrent() { return(pdc->pDCAttr->ptlCurrent);} // erclBounds -- Gets a reference to the bounding rectangle. ERECTL& erclBounds() { return(pdc->erclBounds());} ERECTL& erclBoundsApp() { return(pdc->erclBoundsApp());} // eptlOrigin -- Gets a reference to the DC origin. EPOINTL& eptlOrigin() { return(pdc->eptlOrigin());} // erclWindow -- Gets a reference to the Window RECTL. ERECTL& erclWindow() { return(pdc->erclWindow());} // erclClip -- Get/Set window rectangle PRECTL prclClip() { return(pdc->prclClip());} ERECTL& erclClip() { return(pdc->erclClip());} VOID erclClip(PRECTL prcl) { pdc->erclClip(prcl);} // prgnRao -- Get the pointer to the Rao region REGION *prgnEffRao() { if (pdc->prgnRao() != (REGION *) NULL) return(pdc->prgnRao()); else return(pdc->prgnVis()); } // plaRealized -- Return the currently realized LINEATTRS. LINEATTRS *plaRealized() { return(&pdc->dclevel.laPath);} // plaRealize -- Returns the currently realized LINEATTRS. This function // duplicates plaRealized() merely for historical reasons. LINEATTRS *plaRealize(EXFORMOBJ& exo) {return(plaRealized());} // bCleanDC -- Forces the default DCLEVEL into the DC, effectively // returning it to a "clean" state (i.e., like one from // CreateDC). BOOL bIsDeleteable() { return(!(fs() & DC_PERMANANT)); } VOID vMakeDeletable() { fsClr(DC_PERMANANT); } VOID vMakeUndeletable() { fsSet(DC_PERMANANT); } BOOL bCleanDC(); // In SelectPalette a bool is passed. We save that flag here and use it // in RealizePalette. BOOL bForceBackground() { return(pdc->dclevel.fl & DC_FL_PAL_BACK); } VOID vSetBackground() { pdc->dclevel.fl |= DC_FL_PAL_BACK; } VOID vClearBackground() { pdc->dclevel.fl &= ~DC_FL_PAL_BACK; } // Methods to get and update dirty flags. // // Note that these may be called only from the owning process. ULONG ulDirty() { return(pdc->ulDirty()); }; ULONG ulDirty(ULONG fl) { return(pdc->ulDirty(fl)); }; ULONG ulDirtyAdd(ULONG fl) { return(pdc->ulDirtyAdd(fl)); }; ULONG ulDirtySub(ULONG fl) { return(pdc->ulDirtySub(fl)); }; // The following methods act on both the brush flags stored in the // user-mode DC_ATTR and the brush flags stored in the DC. // // In general, drawing APIs should use these methods and not the // discrete ulDirty() and flBrush() methods. Both must be used because // brushes may be invalidate either in user-mode via API operations, or // while in kernel-mode via dynamic mode changes. // // Note that these may be called only from the owning process. BOOL bDirtyBrush(ULONG fl) { // Note that success is not necessarily a value of '1': return((pdc->ulDirty() | pdc->flbrush()) & fl); } VOID vCleanBrush(ULONG fl) { pdc->ulDirtySub(fl); pdc->flbrushSub(fl); } // Brushes EBRUSHOBJ *peboFill() { return(pdc->peboFill() );} EBRUSHOBJ *peboLine() { return(pdc->peboLine() );} EBRUSHOBJ *peboText() { return(pdc->peboText() );} EBRUSHOBJ *peboBackground() { return(pdc->peboBackground());} // OpenGL LONG ipfdDevMaxGet(); int ipfdDevMax(int i) { return((int) (pdc->ipfdDevMax_=(SHORT)i));} int ipfdDevMax() { return((pdc->ipfdDevMax_ >= 0 ? (int) pdc->ipfdDevMax_ : (int) ipfdDevMaxGet()));} // printing ULONG ulCopyCount() { return(pdc->ulCopyCount_);} ULONG ulCopyCount(ULONG ul) { return(pdc->ulCopyCount_ = ul);} VOID vSetPrintBandPos(POINTL *pt) { pdc->ptlBandPosition_ = *pt; } VOID vResetPrintBandPos() { pdc->ptlBandPosition_.x = 0; pdc->ptlBandPosition_.y = 0; } POINTL& ptlPrintBandPos() { return(pdc->ptlBandPosition_); } BOOL bEpsPrintingEscape() { return(fs() & DC_EPSPRINTINGESCAPE);} VOID vSetEpsPrintingEscape() { fsSet(DC_EPSPRINTINGESCAPE);} VOID vClearEpsPrintingEscape() { fsClr(DC_EPSPRINTINGESCAPE);} // bSynchronizeAccess -- Set the DC_SYNCHRONIZEACCESS bit when all surface // access is to be synchronized by the DEVLOCK. BOOL bSynchronizeAccess(BOOL b) { if (b) fsSet(DC_SYNCHRONIZEACCESS); else fsClr(DC_SYNCHRONIZEACCESS); return(b); } BOOL bShareAccess(BOOL b) { if(b) fsSet(DC_SHAREACCESS); else fsClr(DC_SHAREACCESS); return(b); } BOOL bAddRemoteFont( PFF *ppff ); BOOL bRemoveMergeFont(UNIVERSAL_FONT_ID ufi); // miscellaneous BOOL bModifyWorldTransform(CONST XFORML *pxf,ULONG iMode); // bSupportsJPEG -- Only TRUE for direct DCs that have the GCAPS2_JPEGSRC // flag set. BOOL bSupportsJPEG() { return ((flGraphicsCaps2() & GCAPS2_JPEGSRC) && (dctp() != DCTYPE_MEMORY)); } // bSupportsPNG -- Only TRUE for direct DCs that have the GCAPS2_PNGSRC // flag set. BOOL bSupportsPNG() { return ((flGraphicsCaps2() & GCAPS2_PNGSRC) && (dctp() != DCTYPE_MEMORY)); } // bSupportsPassthroughImage -- TRUE for direct DCs that support the // specified passthrough compression // format. BOOL bSupportsPassthroughImage(ULONG ulCompression) { ASSERTGDI((ulCompression == BI_JPEG) || (ulCompression == BI_PNG), "XDCOBJ::bSupportsPassthroughImage: invalid format\n"); if (ulCompression == BI_JPEG) return bSupportsJPEG(); else if (ulCompression == BI_PNG) return bSupportsPNG(); return FALSE; } // The WNDOBJ pointer for printer and memory bitmap is currently kept in pso. // We currently do not keep WNDOBJ pointers for display DCs in GDI. They // are stored in hwnd in User. // XXX In future, we may want to keep pwo in all DC including the display // XXX DC. It allows us fast access to pwo but we will need to fix // XXX bitmap selection, GetDC, ReleaseDC, DeleteDC, SaveDC, RestoreDC // XXX and others to update this field correctly. EWNDOBJ *pwo() { ASSERTGDI(!bDisplay() || (dctp() != DCTYPE_DIRECT) , "XDCOBJ::pwo(): display DC not allowed\n"); if (bHasSurface()) return(pSurface()->pwo()); else return((EWNDOBJ *)NULL); } VOID pwo(EWNDOBJ *pwo) { ASSERTGDI(!bDisplay(), "XDCOBJ::pwo(pwo): display DC not allowed\n"); ASSERTGDI(bHasSurface(), "XDCOBJ::pwo(pwo): no pSurface in DC"); pSurface()->pwo(pwo); } BOOL bSetLinkedUFIs(PUNIVERSAL_FONT_ID pufis, UINT uNumUFIs); UINT uNumberOfLinkedUFIs() { return(pdc->dclevel.uNumLinkedFonts); } BOOL bLinkingTurnedOff() { return(pdc->dclevel.bTurnOffLinking); } PUNIVERSAL_FONT_ID pufiLinkedFonts() { return(pdc->dclevel.pufi); } VOID vSetDefaultFont(BOOL bDisplay); // ICM (Image Color Matching) BOOL bAddColorTransform(HANDLE hCXform); // in icmobj.cxx BOOL bRemoveColorTransform(HANDLE hCXform); // in icmobj.cxx VOID vCleanupColorTransform(BOOL bProcessCleanup); // in icmobj.cxx }; typedef XDCOBJ *PXDCOBJ; /*********************************class************************************\ * class DCOBJ * * DC Multi-Lock object * * History: * Tue 28-Dec-1993 -by- Patrick Haluptzok [patrickh] * Wrote it. \**************************************************************************/ class DCOBJ : public XDCOBJ /* mdo */ { public: DCOBJ() { pdc = (PDC) NULL; } DCOBJ(HDC hdc) { vLock(hdc); } ~DCOBJ() { vUnlockNoNullSet(); } }; typedef DCOBJ *PDCOBJ; /*********************************class************************************\ * class MDCOBJ * * DC Multi-Lock object * * History: * Tue 25-Jun-1991 -by- Patrick Haluptzok [patrickh] * Wrote it. \**************************************************************************/ class MDCOBJ : public XDCOBJ /* mdo */ { public: MDCOBJ() { pdc = (PDC) NULL; } MDCOBJ(HDC hdc) { vLock(hdc); } ~MDCOBJ() { vUnlockNoNullSet(); } }; /*********************************class************************************\ * class DCOBJA * * DC AltLock object * * History: * Tue 25-Jun-1991 -by- Patrick Haluptzok [patrickh] * Wrote it. \**************************************************************************/ class DCOBJA : public XDCOBJ /* doa */ { public: DCOBJA() { pdc = (PDC) NULL; } DCOBJA(HDC hdc) { vAltLock(hdc); } ~DCOBJA() { vAltUnlockNoNullSet(); } }; /*********************************class************************************\ * class MDCOBJA * * DC Multi-lock AltLock object * * History: * Tue 25-Jun-1991 -by- Patrick Haluptzok [patrickh] * Wrote it. \**************************************************************************/ class MDCOBJA : public XDCOBJ /* doa */ { public: MDCOBJA() { pdc = (PDC) NULL; } MDCOBJA(HDC hdc) { vAltLock(hdc); } ~MDCOBJA() { vAltUnlockNoNullSet(); } }; /*********************************Class************************************\ * class DCMEMOBJ * * DC memory object * * Public Interface: * * DCMEMOBJ(DCOBJ&) -- Allocate a DC, fill by copying the given one. * vKeepIt() -- Don't free the object in the destructor. * * History: * Thu 09-Aug-1990 17:15:27 -by- Charles Whitmer [chuckwh] * Replaced the flags with the usual bKeep. * * Sun 06-Aug-1989 20:20:12 -by- Charles Whitmer [chuckwh] * Wrote it. \**************************************************************************/ class DCMEMOBJ : public XDCOBJ /* dcmo */ { private: BOOL bKeep; public: // This constructor is to be used by OpenDC. It allocates memory and // copies in default attributes. DCMEMOBJ(ULONG iType,BOOL bAltType); // DCOBJ.CXX // This constructor is to be used by SaveDC. It copies the contents of // the given DC into newly allocated memory. DCMEMOBJ(DCOBJ& dcobj); // DCOBJ.CXX ~DCMEMOBJ(); // DCOBJ.CXX VOID vKeepIt() {bKeep = TRUE;} }; extern DCLEVEL dclevelDefault; #if DBG VOID ASSERTDEVLOCK(PDC pdc); #else #define ASSERTDEVLOCK(pdc) #endif #define _DCOBJ_ #endif // GDIFLAGS_ONLY used for gdikdx #endif