windows-server-2003/windows/core/ntgdi/gre/dcobj.hxx

/******************************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