1855 lines
48 KiB
C++
1855 lines
48 KiB
C++
/**************************************************************************\
|
|
*
|
|
* Copyright (c) 1998-1999 Microsoft Corporation
|
|
*
|
|
* Module Name:
|
|
*
|
|
* Graphics.hpp
|
|
*
|
|
* Abstract:
|
|
*
|
|
* Declarations for Graphics class
|
|
*
|
|
* Revision History:
|
|
*
|
|
* 12/04/1998 davidx
|
|
* Created it.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
#ifndef _GRAPHICS_HPP
|
|
#define _GRAPHICS_HPP
|
|
|
|
#include "printer.hpp"
|
|
|
|
#define GDIP_NOOP_ROP3 0x00AA0029 // do-nothing ROP
|
|
|
|
// definitions copied from winddi.h :
|
|
|
|
#ifndef _WINDDI_
|
|
|
|
DECLARE_HANDLE(HSURF);
|
|
DECLARE_HANDLE(DHSURF);
|
|
DECLARE_HANDLE(DHPDEV);
|
|
|
|
typedef struct _SURFOBJ
|
|
{
|
|
DHSURF dhsurf;
|
|
HSURF hsurf;
|
|
DHPDEV dhpdev;
|
|
HDEV hdev;
|
|
SIZEL sizlBitmap;
|
|
ULONG cjBits;
|
|
PVOID pvBits;
|
|
PVOID pvScan0;
|
|
LONG lDelta;
|
|
ULONG iUniq;
|
|
ULONG iBitmapFormat;
|
|
USHORT iType;
|
|
USHORT fjBitmap;
|
|
} SURFOBJ;
|
|
|
|
#endif
|
|
|
|
// Forward declaration of the GpCachedBitmap class.
|
|
class GpCachedBitmap;
|
|
class CopyOnWriteBitmap;
|
|
|
|
/**
|
|
* Represent a graphics context
|
|
*/
|
|
class GpGraphics
|
|
{
|
|
friend class GpBitmap;
|
|
friend class CopyOnWriteBitmap;
|
|
friend class GpMetafile;
|
|
friend class MetafilePlayer;
|
|
friend class HdcLock;
|
|
friend class DriverUni;
|
|
friend class MetafileRecorder;
|
|
friend class DriverStringImager;
|
|
friend class FullTextImager;
|
|
friend class FastTextImager;
|
|
friend class GpCachedBitmap;
|
|
|
|
private:
|
|
// We now use an ObjectTag to determine if the object is valid
|
|
// instead of using a BOOL. This is much more robust and helps
|
|
// with debugging. It also enables us to version our objects
|
|
// more easily with a version number in the ObjectTag.
|
|
ObjectTag Tag; // Keep this as the 1st value in the object!
|
|
|
|
protected:
|
|
VOID SetValid(BOOL valid)
|
|
{
|
|
Tag = valid ? ObjectTagGraphics : ObjectTagInvalid;
|
|
}
|
|
|
|
// This method is here so that we have a virtual function table so
|
|
// that we can add virtual methods in V2 without shifting the position
|
|
// of the Tag value within the data structure.
|
|
virtual VOID DontCallThis()
|
|
{
|
|
DontCallThis();
|
|
}
|
|
|
|
public:
|
|
LONG LockedByGetDC; // Used by GdipGetDC and GdipReleaseDC
|
|
|
|
protected:
|
|
static GpGraphics*
|
|
GetForMetafile(
|
|
IMetafileRecord * metafile,
|
|
EmfType type,
|
|
HDC hdc
|
|
);
|
|
|
|
// used by the MetafileRecorder in the EndRecording method
|
|
VOID NoOpPatBlt(
|
|
INT left,
|
|
INT top,
|
|
INT width,
|
|
INT height
|
|
)
|
|
{
|
|
// Get the devlock because the surface will be flushed when we get the
|
|
// HDC
|
|
Devlock devlock(Device);
|
|
|
|
// Get the HDC in the correct state
|
|
HDC hdc = Context->GetHdc(Surface);
|
|
if (hdc != NULL)
|
|
{
|
|
::PatBlt(hdc, left, top, width, height, GDIP_NOOP_ROP3);
|
|
Context->ReleaseHdc(hdc);
|
|
}
|
|
|
|
// Now Reset the HDC so that this happens before the
|
|
// EndOfFile record (which has to be the last record before the
|
|
// EMF's EOF record).
|
|
Context->ResetHdc();
|
|
}
|
|
|
|
// If we should send rects to the driver instead of a path
|
|
BOOL UseDriverRects() const
|
|
{
|
|
return (Context->WorldToDevice.IsTranslateScale() &&
|
|
((!Context->AntiAliasMode) || DownLevel));
|
|
}
|
|
|
|
|
|
public:
|
|
|
|
// Get a graphics context from an existing Win32 HDC or HWND
|
|
|
|
static GpGraphics* GetFromHdc(HDC hdc, HANDLE hDevice = NULL);
|
|
|
|
// Default behaviour is to ignore ICM mode.
|
|
|
|
static GpGraphics* GetFromHwnd(
|
|
HWND hwnd,
|
|
HdcIcmMode icmMode = IcmModeOff
|
|
);
|
|
|
|
~GpGraphics();
|
|
|
|
// Internal use only
|
|
|
|
static GpGraphics* GetFromHdcSurf(HDC hdc,
|
|
SURFOBJ* surfObj,
|
|
RECTL* bandClip);
|
|
|
|
static GpGraphics* GetFromGdiScreenDC(HDC hdc);
|
|
|
|
// Get the lock object
|
|
|
|
GpLockable *GetObjectLock() const
|
|
{
|
|
return &Lockable;
|
|
}
|
|
|
|
// Check to see if the object is valid
|
|
|
|
BOOL IsValid() const
|
|
{
|
|
#ifdef _X86_
|
|
// We have to guarantee that the Tag field doesn't move for
|
|
// versioning to work between releases of GDI+.
|
|
ASSERT(offsetof(GpGraphics, Tag) == 4);
|
|
#endif
|
|
|
|
ASSERT((Tag == ObjectTagGraphics) || (Tag == ObjectTagInvalid));
|
|
#if DBG
|
|
if (Tag == ObjectTagInvalid)
|
|
{
|
|
WARNING1("Invalid Graphics");
|
|
}
|
|
#endif
|
|
|
|
return (Tag == ObjectTagGraphics);
|
|
}
|
|
|
|
// Derive a win32 HDC from the graphics context
|
|
|
|
HDC GetHdc();
|
|
VOID ReleaseHdc(HDC hdc);
|
|
|
|
// Flush any pending rendering
|
|
|
|
VOID Flush(GpFlushIntention intention)
|
|
{
|
|
Devlock devlock(Device);
|
|
|
|
DrvFlush(intention);
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
// Manipulate the current world transform
|
|
//------------------------------------------------------------------------
|
|
|
|
GpStatus SetWorldTransform(const GpMatrix& matrix);
|
|
|
|
GpStatus ResetWorldTransform();
|
|
|
|
GpStatus MultiplyWorldTransform(const GpMatrix& matrix,
|
|
GpMatrixOrder order = MatrixOrderPrepend);
|
|
|
|
GpStatus TranslateWorldTransform(REAL dx, REAL dy,
|
|
GpMatrixOrder order = MatrixOrderPrepend);
|
|
|
|
GpStatus ScaleWorldTransform(REAL sx, REAL sy,
|
|
GpMatrixOrder order = MatrixOrderPrepend);
|
|
|
|
GpStatus RotateWorldTransform(REAL angle,
|
|
GpMatrixOrder order = MatrixOrderPrepend);
|
|
|
|
VOID GetWorldTransform(GpMatrix & matrix) const
|
|
{
|
|
matrix = Context->WorldToPage;
|
|
}
|
|
|
|
GpStatus GetDeviceToWorldTransform(GpMatrix * matrix) const;
|
|
|
|
VOID GetWorldToDeviceTransform(GpMatrix * matrix) const
|
|
{
|
|
*matrix = Context->WorldToDevice;
|
|
}
|
|
VOID GetWorldToDeviceTransform(REAL * m) const
|
|
{
|
|
Context->WorldToDevice.GetMatrix(m);
|
|
}
|
|
|
|
VOID GetWorldPixelSize(REAL & xSize, REAL & ySize);
|
|
|
|
// Manipulate the current page transform
|
|
|
|
// !! *PageTransform's to be phased out...
|
|
GpStatus SetPageTransform(GpPageUnit unit, REAL scale = 1);
|
|
|
|
GpStatus ResetPageTransform()
|
|
{
|
|
return SetPageTransform(UnitDisplay);
|
|
}
|
|
|
|
GpPageUnit GetPageUnit() const { return Context->PageUnit; }
|
|
REAL GetPageScale() const { return Context->PageScale; }
|
|
|
|
GpStatus SetPageUnit(GpPageUnit unit)
|
|
{
|
|
return SetPageTransform(unit, GetPageScale());
|
|
}
|
|
|
|
GpStatus SetPageScale(REAL scale)
|
|
{
|
|
return SetPageTransform(GetPageUnit(), scale);
|
|
}
|
|
|
|
GpStatus TransformPoints(
|
|
GpPointF * points,
|
|
INT count,
|
|
GpCoordinateSpace source = CoordinateSpaceWorld,
|
|
GpCoordinateSpace dest = CoordinateSpaceDevice
|
|
);
|
|
|
|
|
|
/// GetScaleForAlternatePageUnit
|
|
//
|
|
// Return world unit scale factor corresponding to the difference
|
|
// between the page units selected in the graphics and a unit specified
|
|
// to an API such as pen thickness or font height.
|
|
//
|
|
// The returned vector provides the amount by which to multiply world
|
|
// x and y coordinates so that they will behave according to the
|
|
// alternate unit when passed through Context.WorldToDevice.
|
|
|
|
REAL GetScaleForAlternatePageUnit(Unit unit) const
|
|
{
|
|
// pen width and font height must not use UnitDisplay because
|
|
// it is a device dependent unit.
|
|
ASSERT(unit != UnitDisplay);
|
|
|
|
// The x:Y aspect ratio of the device resolution doesn't matter here,
|
|
// we get exactly the same values whether we use DpiX/PageMultiplierX
|
|
// or DpiY/PageMiltiplierY.
|
|
|
|
switch (unit)
|
|
{
|
|
case UnitDocument:
|
|
return ((GetDpiX()/300.0f) / Context->PageMultiplierX);
|
|
case UnitPoint:
|
|
return ((GetDpiX()/72.0f) / Context->PageMultiplierX);
|
|
case UnitMillimeter:
|
|
return ((GetDpiX()/25.4f) / Context->PageMultiplierX);
|
|
case UnitInch:
|
|
return (GetDpiX() / Context->PageMultiplierX);
|
|
case UnitWorld:
|
|
case UnitPixel:
|
|
default:
|
|
return 1.0f;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// Clipping related methods
|
|
|
|
GpStatus SetClip(GpGraphics* g, CombineMode combineMode);
|
|
|
|
GpStatus SetClip(const GpRectF& rect, CombineMode combineMode);
|
|
|
|
GpStatus SetClip(GpPath* path, CombineMode combineMode,
|
|
BOOL isDevicePath = FALSE);
|
|
|
|
GpStatus SetClip(GpRegion* region, CombineMode combineMode);
|
|
|
|
GpStatus SetClip(HRGN hRgn, CombineMode combineMode);
|
|
|
|
GpStatus ResetClip();
|
|
|
|
GpStatus OffsetClip(REAL dx, REAL dy);
|
|
|
|
GpRegion* GetClip() const;
|
|
|
|
GpStatus GetClip(GpRegion* region) const;
|
|
|
|
// save and restore graphics state
|
|
|
|
INT Save();
|
|
VOID Restore(INT gstate);
|
|
|
|
// start and end container drawing
|
|
|
|
INT
|
|
BeginContainer(
|
|
const GpRectF & destRect,
|
|
const GpRectF & srcRect,
|
|
GpPageUnit srcUnit,
|
|
REAL srcDpiX = 0.0f, // for metafile playback only
|
|
REAL srcDpiY = 0.0f,
|
|
BOOL srcIsDisplay = TRUE // for metafile playback only
|
|
);
|
|
|
|
INT BeginContainer(
|
|
// all these params are only applicable for metafile playback
|
|
BOOL forceIdentityTransform = FALSE,
|
|
REAL srcDpiX = 0.0f,
|
|
REAL srcDpiY = 0.0f,
|
|
BOOL srcIsDisplay = TRUE
|
|
);
|
|
|
|
VOID EndContainer(INT containerState);
|
|
|
|
// Hit testing operations
|
|
|
|
VOID GetClipBounds(GpRectF& rect) const;
|
|
|
|
BOOL IsClipEmpty() const;
|
|
|
|
VOID GetVisibleClipBounds(GpRectF& rect) const;
|
|
|
|
BOOL IsVisibleClipEmpty() const;
|
|
|
|
GpRegion* GetVisibleClip() const;
|
|
|
|
HRGN GetVisibleClipHRgn() const
|
|
{
|
|
return Context->VisibleClip.GetHRgn();
|
|
}
|
|
|
|
BOOL IsVisible(const GpPointF& point) const;
|
|
|
|
BOOL IsVisible(const GpRectF& rect) const;
|
|
|
|
GpStatus GetPixelColor(REAL x, REAL y, ARGB* argb) const;
|
|
|
|
// Set antialiasing mode
|
|
|
|
VOID SetAntiAliasMode( BOOL newMode )
|
|
{
|
|
ASSERT(Context);
|
|
|
|
// for Printer DC never set AA
|
|
if (IsPrinter())
|
|
{
|
|
Context->AntiAliasMode = FALSE;
|
|
return;
|
|
}
|
|
|
|
if (IsRecording() && (newMode != Context->AntiAliasMode))
|
|
{
|
|
Metafile->RecordSetAntiAliasMode(newMode);
|
|
}
|
|
Context->AntiAliasMode = newMode;
|
|
}
|
|
|
|
BOOL GetAntiAliasMode() const
|
|
{
|
|
ASSERT(Context);
|
|
return(Context->AntiAliasMode);
|
|
}
|
|
|
|
// Set antialiasing text
|
|
|
|
VOID SetTextRenderingHint( TextRenderingHint newMode)
|
|
{
|
|
ASSERT(Context);
|
|
|
|
// for Printer DC never set AA or Clear Type text
|
|
if (IsPrinter())
|
|
{
|
|
Context->TextRenderHint = TextRenderingHintSingleBitPerPixelGridFit;
|
|
return;
|
|
}
|
|
|
|
if (IsRecording() && (newMode != Context->TextRenderHint))
|
|
{
|
|
Metafile->RecordSetTextRenderingHint(newMode);
|
|
}
|
|
|
|
Context->TextRenderHint = newMode;
|
|
}
|
|
|
|
TextRenderingHint GetTextRenderingHint() const
|
|
{
|
|
ASSERT(Context);
|
|
return(Context->TextRenderHint);
|
|
}
|
|
|
|
// this procedure is meant to be used by internal text routines
|
|
// and will return real text rendering hint (not TextRenderingHintSystemDefault)
|
|
// we should always call CalculateTextRenderingHintInternal() before
|
|
// calling GetTextRenderingHintInternal()
|
|
TextRenderingHint GetTextRenderingHintInternal() const
|
|
{
|
|
return TextRenderingHintInternal;
|
|
}
|
|
|
|
Status SetTextContrast(UINT contrast)
|
|
{
|
|
ASSERT(Context);
|
|
|
|
if (contrast > MAX_TEXT_CONTRAST_VALUE)
|
|
return InvalidParameter;
|
|
|
|
// for Printer DC never set AA or Clear Type text
|
|
if (IsPrinter())
|
|
{
|
|
Context->TextContrast = 0;
|
|
return Ok;
|
|
}
|
|
|
|
if (IsRecording() && (contrast != Context->TextContrast))
|
|
{
|
|
Metafile->RecordSetTextContrast(contrast);
|
|
}
|
|
|
|
Context->TextContrast = contrast;
|
|
return Ok;
|
|
}
|
|
|
|
UINT GetTextContrast() const
|
|
{
|
|
ASSERT(Context);
|
|
|
|
return Context->TextContrast;
|
|
}
|
|
|
|
// Rendering Origin
|
|
// This is the origin used for Dither and Halftone matrix origins
|
|
// and should be used for any raster operations that need an origin.
|
|
|
|
VOID SetRenderingOrigin(INT x, INT y)
|
|
{
|
|
ASSERT(Context);
|
|
|
|
if (IsRecording() &&
|
|
(x != Context->RenderingOriginX ||
|
|
y != Context->RenderingOriginY)
|
|
)
|
|
{
|
|
Metafile->RecordSetRenderingOrigin(x, y);
|
|
}
|
|
Context->RenderingOriginX = x;
|
|
Context->RenderingOriginY = y;
|
|
}
|
|
|
|
|
|
// Rendering Origin
|
|
// Returns the origin used for the Dither and Halftone matrix origin.
|
|
|
|
VOID GetRenderingOrigin(INT *x, INT *y) const
|
|
{
|
|
ASSERT(Context);
|
|
ASSERT(x);
|
|
ASSERT(y);
|
|
|
|
*x = Context->RenderingOriginX;
|
|
*y = Context->RenderingOriginY;
|
|
}
|
|
|
|
|
|
// Compositing mode
|
|
|
|
VOID SetCompositingMode( GpCompositingMode newMode )
|
|
{
|
|
ASSERT(Context);
|
|
|
|
if (IsRecording() && (newMode != Context->CompositingMode))
|
|
{
|
|
Metafile->RecordSetCompositingMode(newMode);
|
|
}
|
|
Context->CompositingMode = newMode;
|
|
}
|
|
|
|
GpCompositingMode GetCompositingMode() const
|
|
{
|
|
ASSERT(Context);
|
|
return(Context->CompositingMode);
|
|
}
|
|
|
|
// Compositing quality
|
|
|
|
VOID SetCompositingQuality( GpCompositingQuality newQuality )
|
|
{
|
|
ASSERT(Context);
|
|
|
|
if (IsRecording() && (newQuality != Context->CompositingQuality))
|
|
{
|
|
Metafile->RecordSetCompositingQuality(newQuality);
|
|
}
|
|
Context->CompositingQuality = newQuality;
|
|
}
|
|
|
|
GpCompositingQuality GetCompositingQuality() const
|
|
{
|
|
ASSERT(Context);
|
|
return(Context->CompositingQuality);
|
|
}
|
|
|
|
VOID SetInterpolationMode(InterpolationMode newMode)
|
|
{
|
|
ASSERT(Context);
|
|
|
|
if (IsRecording() && (newMode != Context->FilterType))
|
|
{
|
|
Metafile->RecordSetInterpolationMode(newMode);
|
|
}
|
|
|
|
Context->FilterType = newMode;
|
|
}
|
|
InterpolationMode GetInterpolationMode() const
|
|
{
|
|
ASSERT(Context);
|
|
return Context->FilterType;
|
|
}
|
|
|
|
VOID SetPixelOffsetMode(PixelOffsetMode newMode)
|
|
{
|
|
ASSERT(Context);
|
|
|
|
if (newMode != Context->PixelOffset)
|
|
{
|
|
if (IsRecording())
|
|
{
|
|
Metafile->RecordSetPixelOffsetMode(newMode);
|
|
}
|
|
Context->PixelOffset = newMode;
|
|
Context->InverseOk = FALSE;
|
|
Context->UpdateWorldToDeviceMatrix();
|
|
}
|
|
}
|
|
|
|
PixelOffsetMode GetPixelOffsetMode() const
|
|
{
|
|
ASSERT(Context);
|
|
return Context->PixelOffset;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
// GetNearestColor (for <= 8bpp surfaces)
|
|
//------------------------------------------------------------------------
|
|
|
|
ARGB
|
|
GetNearestColor(
|
|
ARGB argb
|
|
);
|
|
|
|
//------------------------------------------------------------------------
|
|
// Stroke vector shapes
|
|
//------------------------------------------------------------------------
|
|
|
|
GpStatus
|
|
DrawLine(
|
|
GpPen* pen,
|
|
const GpPointF& pt1,
|
|
const GpPointF& pt2
|
|
)
|
|
{
|
|
GpPointF points[2];
|
|
|
|
points[0] = pt1;
|
|
points[1] = pt2;
|
|
|
|
return(DrawLines(pen, &points[0], 2));
|
|
}
|
|
|
|
GpStatus
|
|
DrawLine(
|
|
GpPen* pen,
|
|
REAL x1,
|
|
REAL y1,
|
|
REAL x2,
|
|
REAL y2
|
|
)
|
|
{
|
|
GpPointF points[2];
|
|
|
|
points[0].X = x1;
|
|
points[0].Y = y1;
|
|
points[1].X = x2;
|
|
points[1].Y = y2;
|
|
|
|
return(DrawLines(pen, &points[0], 2));
|
|
}
|
|
|
|
GpStatus
|
|
DrawLines(
|
|
GpPen* pen,
|
|
const GpPointF* points,
|
|
INT count,
|
|
BOOL closed = FALSE
|
|
);
|
|
|
|
GpStatus
|
|
DrawArc(
|
|
GpPen* pen,
|
|
const GpRectF& rect,
|
|
REAL startAngle,
|
|
REAL sweepAngle
|
|
);
|
|
|
|
GpStatus
|
|
DrawArc(
|
|
GpPen* pen,
|
|
REAL x,
|
|
REAL y,
|
|
REAL width,
|
|
REAL height,
|
|
REAL startAngle,
|
|
REAL sweepAngle
|
|
)
|
|
{
|
|
GpRectF rect(x, y, width, height);
|
|
|
|
return DrawArc(pen, rect, startAngle, sweepAngle);
|
|
}
|
|
|
|
GpStatus
|
|
DrawBezier(
|
|
GpPen* pen,
|
|
const GpPointF& pt1,
|
|
const GpPointF& pt2,
|
|
const GpPointF& pt3,
|
|
const GpPointF& pt4
|
|
)
|
|
{
|
|
GpPointF points[4];
|
|
|
|
points[0] = pt1;
|
|
points[1] = pt2;
|
|
points[2] = pt3;
|
|
points[3] = pt4;
|
|
|
|
return DrawBeziers(pen, points, 4);
|
|
}
|
|
|
|
GpStatus
|
|
DrawBezier(
|
|
GpPen* pen,
|
|
REAL x1, REAL y1,
|
|
REAL x2, REAL y2,
|
|
REAL x3, REAL y3,
|
|
REAL x4, REAL y4
|
|
)
|
|
{
|
|
GpPointF points[4];
|
|
|
|
points[0].X = x1;
|
|
points[0].Y = y1;
|
|
points[1].X = x2;
|
|
points[1].Y = y2;
|
|
points[2].X = x3;
|
|
points[2].Y = y3;
|
|
points[3].X = x4;
|
|
points[3].Y = y4;
|
|
|
|
return DrawBeziers(pen, points, 4);
|
|
}
|
|
|
|
GpStatus
|
|
DrawBeziers(
|
|
GpPen* pen,
|
|
const GpPointF* points,
|
|
INT count
|
|
);
|
|
|
|
GpStatus
|
|
DrawRect(
|
|
GpPen* pen,
|
|
const GpRectF& rect
|
|
)
|
|
{
|
|
return(DrawRects(pen, &rect, 1));
|
|
}
|
|
|
|
GpStatus
|
|
DrawRect(
|
|
GpPen* pen,
|
|
REAL x,
|
|
REAL y,
|
|
REAL width,
|
|
REAL height
|
|
)
|
|
{
|
|
GpRectF rect(x, y, width, height);
|
|
return(DrawRects(pen, &rect, 1));
|
|
}
|
|
|
|
GpStatus
|
|
DrawRects(
|
|
GpPen* pen,
|
|
const GpRectF* rects,
|
|
INT count
|
|
);
|
|
|
|
GpStatus
|
|
DrawEllipse(
|
|
GpPen* pen,
|
|
const GpRectF& rect
|
|
);
|
|
|
|
GpStatus
|
|
DrawEllipse(
|
|
GpPen* pen,
|
|
REAL x,
|
|
REAL y,
|
|
REAL width,
|
|
REAL height
|
|
)
|
|
{
|
|
GpRectF rect(x, y, width, height);
|
|
return DrawEllipse(pen, rect);
|
|
}
|
|
|
|
GpStatus
|
|
DrawPie(
|
|
GpPen* pen,
|
|
const GpRectF& rect,
|
|
REAL startAngle,
|
|
REAL sweepAngle
|
|
);
|
|
|
|
GpStatus
|
|
DrawPie(
|
|
GpPen* pen,
|
|
REAL x,
|
|
REAL y,
|
|
REAL width,
|
|
REAL height,
|
|
REAL startAngle,
|
|
REAL sweepAngle
|
|
)
|
|
{
|
|
GpRectF rect(x, y, width, height);
|
|
return DrawPie(pen, rect, startAngle, sweepAngle);
|
|
}
|
|
|
|
GpStatus
|
|
DrawPolygon(
|
|
GpPen* pen,
|
|
const GpPointF* points,
|
|
INT count
|
|
)
|
|
{
|
|
return(DrawLines(pen, points, count, TRUE));
|
|
}
|
|
|
|
GpStatus
|
|
DrawPath(
|
|
GpPen* pen,
|
|
GpPath* path
|
|
);
|
|
|
|
GpStatus
|
|
DrawPathData(
|
|
GpPen* pen,
|
|
const GpPointF* points,
|
|
const BYTE *types,
|
|
INT count,
|
|
GpFillMode fillMode
|
|
)
|
|
{
|
|
GpStatus status = GenericError;
|
|
|
|
GpPath path(points, types, count, fillMode);
|
|
if(path.IsValid())
|
|
status = DrawPath(pen, &path);
|
|
|
|
return status;
|
|
}
|
|
|
|
GpStatus
|
|
DrawCurve(
|
|
GpPen* pen,
|
|
const GpPointF* points,
|
|
INT count
|
|
);
|
|
|
|
GpStatus
|
|
DrawCurve(
|
|
GpPen* pen,
|
|
const GpPointF* points,
|
|
INT count,
|
|
REAL tension,
|
|
INT offset,
|
|
INT numberOfSegments
|
|
);
|
|
|
|
GpStatus
|
|
DrawClosedCurve(
|
|
GpPen* pen,
|
|
const GpPointF* points,
|
|
INT count
|
|
);
|
|
|
|
GpStatus
|
|
DrawClosedCurve(
|
|
GpPen* pen,
|
|
const GpPointF* points,
|
|
INT count,
|
|
REAL tension
|
|
);
|
|
|
|
|
|
//------------------------------------------------------------------------
|
|
// Fill shapes
|
|
//------------------------------------------------------------------------
|
|
|
|
GpStatus
|
|
Clear(
|
|
const GpColor &color
|
|
);
|
|
|
|
GpStatus
|
|
FillRect(
|
|
GpBrush* brush,
|
|
const GpRectF& rect
|
|
)
|
|
{
|
|
return(FillRects(brush, &rect, 1));
|
|
}
|
|
|
|
GpStatus
|
|
FillRect(
|
|
GpBrush* brush,
|
|
REAL x,
|
|
REAL y,
|
|
REAL width,
|
|
REAL height
|
|
)
|
|
{
|
|
GpRectF rect(x, y, width, height);
|
|
return(FillRects(brush, &rect, 1));
|
|
}
|
|
|
|
GpStatus
|
|
FillRects(
|
|
GpBrush* brush,
|
|
const GpRectF* rects,
|
|
INT count
|
|
);
|
|
|
|
GpStatus
|
|
FillPolygon(
|
|
GpBrush* brush,
|
|
const GpPointF* points,
|
|
INT count
|
|
)
|
|
{
|
|
return FillPolygon(brush, points, count, FillModeAlternate);
|
|
}
|
|
|
|
GpStatus
|
|
FillPolygon(
|
|
GpBrush* brush,
|
|
const GpPointF* points,
|
|
INT count,
|
|
GpFillMode fillMode
|
|
);
|
|
|
|
GpStatus
|
|
FillEllipse(
|
|
GpBrush* brush,
|
|
const GpRectF& rect
|
|
);
|
|
|
|
GpStatus
|
|
FillEllipse(
|
|
GpBrush* brush,
|
|
REAL x,
|
|
REAL y,
|
|
REAL width,
|
|
REAL height
|
|
)
|
|
{
|
|
GpRectF rect(x, y, width, height);
|
|
return FillEllipse(brush, rect);
|
|
}
|
|
|
|
GpStatus
|
|
FillPie(
|
|
GpBrush* brush,
|
|
const GpRectF& rect,
|
|
REAL startAngle,
|
|
REAL sweepAngle
|
|
);
|
|
|
|
GpStatus
|
|
FillPie(
|
|
GpBrush* brush,
|
|
REAL x,
|
|
REAL y,
|
|
REAL width,
|
|
REAL height,
|
|
REAL startAngle,
|
|
REAL sweepAngle
|
|
)
|
|
{
|
|
GpRectF rect(x, y, width, height);
|
|
return FillPie(brush, rect, startAngle, sweepAngle);
|
|
}
|
|
|
|
GpStatus
|
|
FillPath(
|
|
const GpBrush* brush,
|
|
GpPath* path
|
|
);
|
|
|
|
GpStatus
|
|
FillPathData(
|
|
GpBrush* brush,
|
|
const GpPointF* points,
|
|
const BYTE *types,
|
|
INT count,
|
|
GpFillMode fillMode
|
|
)
|
|
{
|
|
GpStatus status = GenericError;
|
|
|
|
GpPath path(points, types, count, fillMode);
|
|
if(path.IsValid())
|
|
status = FillPath(brush, &path);
|
|
|
|
return status;
|
|
}
|
|
|
|
GpStatus
|
|
FillClosedCurve(
|
|
GpBrush* brush,
|
|
const GpPointF* points,
|
|
INT count,
|
|
REAL tension = 0.5,
|
|
GpFillMode fillMode = FillModeAlternate
|
|
);
|
|
|
|
GpStatus
|
|
FillRegion(
|
|
GpBrush* brush,
|
|
GpRegion* region
|
|
);
|
|
|
|
|
|
//------------------------------------------------------------------------
|
|
// Draw text strings
|
|
//------------------------------------------------------------------------
|
|
|
|
|
|
#define DG_NOGDI 4 // Disable optimisation through GDI
|
|
#define DG_SIDEWAY 0x80000000 // flag used by the drivers (Meta Driver) for sideway runs.
|
|
|
|
|
|
// To be removed, replaced by DrawRealizedGlyphs and GdiDrawGlyphs
|
|
|
|
GpStatus
|
|
DrawGlyphs(
|
|
const UINT16 *glyphIndices,
|
|
INT count,
|
|
const GpFontFace *face,
|
|
INT style,
|
|
REAL emSize,
|
|
Unit unit,
|
|
const GpBrush *brush,
|
|
const UINT32 *px,
|
|
const UINT32 *py,
|
|
INT flags,
|
|
const GpMatrix *pmx = NULL
|
|
);
|
|
|
|
|
|
// Internal text drawing APIs
|
|
|
|
protected:
|
|
// should be called once per DrawString/DrawDriverString call
|
|
// checks for invalid text rendering hint combinations
|
|
GpStatus CheckTextMode();
|
|
|
|
// this method is meant to calculate TextRenderingHintInternal
|
|
// we call this method once and only once before using GetTextRenderingHintInternal()
|
|
void CalculateTextRenderingHintInternal();
|
|
|
|
public:
|
|
|
|
GpStatus DrawPlacedGlyphs(
|
|
const GpFaceRealization *faceRealization,
|
|
const GpBrush *brush,
|
|
INT flags,
|
|
const WCHAR *string,
|
|
UINT stringLength,
|
|
BOOL rightToLeft,
|
|
const UINT16 *glyphs,
|
|
const UINT16 *glyphMap,
|
|
const PointF *glyphOrigins,
|
|
INT glyphCount,
|
|
ItemScript Script,
|
|
BOOL sideways // e.g. FE characters in vertical text
|
|
);
|
|
|
|
|
|
GpStatus DrawDriverGlyphs(
|
|
const UINT16 *glyphs,
|
|
INT glyphCount,
|
|
const GpFont *font,
|
|
const GpFontFace *face,
|
|
const GpBrush *brush,
|
|
const WCHAR *string,
|
|
const PointF *positions,
|
|
INT flags,
|
|
const GpMatrix *matrix
|
|
);
|
|
|
|
|
|
// External text drawing APIs
|
|
GpStatus
|
|
DrawString(
|
|
const WCHAR *string,
|
|
INT length,
|
|
const GpFont *font,
|
|
const RectF *layoutRect,
|
|
const GpStringFormat *format,
|
|
const GpBrush *brush
|
|
);
|
|
|
|
GpStatus
|
|
MeasureString(
|
|
const WCHAR *string,
|
|
INT length,
|
|
const GpFont *font,
|
|
const RectF *layoutRect,
|
|
const GpStringFormat *format,
|
|
RectF *boundingBox,
|
|
INT *codepointsFitted,
|
|
INT *linesFilled
|
|
);
|
|
|
|
|
|
GpStatus
|
|
MeasureCharacterRanges(
|
|
const WCHAR *string,
|
|
INT length,
|
|
const GpFont *font,
|
|
const RectF &layoutRect,
|
|
const GpStringFormat *format,
|
|
INT regionCount,
|
|
GpRegion **regions
|
|
);
|
|
|
|
/// Start API for graphicstext.cpp
|
|
|
|
GpStatus
|
|
RecordEmfPlusDrawDriverString(
|
|
const UINT16 *text,
|
|
INT glyphCount,
|
|
const GpFont *font,
|
|
const GpFontFace *face,
|
|
const GpBrush *brush,
|
|
const PointF *positions,
|
|
INT flags,
|
|
const GpMatrix *matrix // optional
|
|
);
|
|
|
|
GpStatus
|
|
DrawDriverString(
|
|
const UINT16 *text,
|
|
INT length,
|
|
const GpFont *font,
|
|
const GpBrush *brush,
|
|
const PointF *positions,
|
|
INT flags,
|
|
const GpMatrix *matrix
|
|
);
|
|
|
|
GpStatus
|
|
MeasureDriverString(
|
|
const UINT16 *text,
|
|
INT glyphCount,
|
|
const GpFont *font,
|
|
const PointF *positions,
|
|
INT flags,
|
|
const GpMatrix *matrix, // In - Optional glyph transform
|
|
RectF *boundingBox // Out - Overall bounding box of cells
|
|
);
|
|
|
|
GpStatus
|
|
DrawFontStyleLine(
|
|
const PointF *baselineOrigin, // baseline origin
|
|
REAL baselineLength, // baseline length
|
|
const GpFontFace *face, // font face
|
|
const GpBrush *brush, // brush
|
|
BOOL vertical, // vertical text?
|
|
REAL emSize, // font EM size in world unit
|
|
INT style, // kind of lines to be drawn
|
|
const GpMatrix *matrix = NULL // additional transform
|
|
);
|
|
|
|
REAL GetDevicePenWidth(
|
|
REAL widthInWorldUnits,
|
|
const GpMatrix *matrix = NULL
|
|
);
|
|
|
|
/// End API for graphicstext.cpp
|
|
|
|
|
|
GpStatus
|
|
DrawCachedBitmap(
|
|
GpCachedBitmap *cb,
|
|
INT x,
|
|
INT y
|
|
)
|
|
{
|
|
return DrvDrawCachedBitmap(cb, x, y);
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
// Draw images (both bitmap and metafile)
|
|
//------------------------------------------------------------------------
|
|
|
|
GpStatus
|
|
DrawImage(
|
|
GpImage* image,
|
|
const GpPointF& point
|
|
);
|
|
|
|
GpStatus
|
|
DrawImage(
|
|
GpImage* image,
|
|
REAL x,
|
|
REAL y
|
|
)
|
|
{
|
|
GpPointF point(x, y);
|
|
return DrawImage(image, point);
|
|
}
|
|
|
|
GpStatus
|
|
DrawImage(
|
|
GpImage* image,
|
|
const GpRectF& destRect
|
|
);
|
|
|
|
GpStatus
|
|
DrawImage(
|
|
GpImage* image,
|
|
REAL x,
|
|
REAL y,
|
|
REAL width,
|
|
REAL height
|
|
)
|
|
{
|
|
GpRectF destRect(x, y, width, height);
|
|
return DrawImage(image, destRect);
|
|
}
|
|
|
|
GpStatus
|
|
DrawImage(
|
|
GpImage* image,
|
|
const GpPointF* destPoints,
|
|
INT count
|
|
);
|
|
|
|
GpStatus
|
|
DrawImage(
|
|
GpImage* image,
|
|
REAL x,
|
|
REAL y,
|
|
const GpRectF & srcRect,
|
|
GpPageUnit srcUnit
|
|
);
|
|
|
|
GpStatus
|
|
DrawImage(
|
|
GpImage* image,
|
|
const GpRectF& destRect,
|
|
const GpRectF& srcRect,
|
|
GpPageUnit srcUnit,
|
|
const GpImageAttributes* imageAttributes = NULL,
|
|
DrawImageAbort callback = NULL,
|
|
VOID* callbackData = NULL
|
|
);
|
|
|
|
GpStatus
|
|
DrawImage(
|
|
GpImage* image,
|
|
const GpPointF* destPoints,
|
|
INT count,
|
|
const GpRectF& srcRect,
|
|
GpPageUnit srcUnit,
|
|
const GpImageAttributes* imageAttributes = NULL,
|
|
DrawImageAbort callback = NULL,
|
|
VOID* callbackData = NULL
|
|
);
|
|
|
|
GpStatus
|
|
EnumerateMetafile(
|
|
const GpMetafile * metafile,
|
|
const PointF & destPoint,
|
|
EnumerateMetafileProc callback,
|
|
VOID * callbackData,
|
|
const GpImageAttributes * imageAttributes
|
|
);
|
|
|
|
GpStatus
|
|
EnumerateMetafile(
|
|
const GpMetafile * metafile,
|
|
const RectF & destRect,
|
|
EnumerateMetafileProc callback,
|
|
VOID * callbackData,
|
|
const GpImageAttributes * imageAttributes
|
|
);
|
|
|
|
GpStatus
|
|
EnumerateMetafile(
|
|
const GpMetafile * metafile,
|
|
const PointF * destPoints,
|
|
INT count,
|
|
EnumerateMetafileProc callback,
|
|
VOID * callbackData,
|
|
const GpImageAttributes * imageAttributes
|
|
);
|
|
|
|
GpStatus
|
|
EnumerateMetafile(
|
|
const GpMetafile * metafile,
|
|
const PointF & destPoint,
|
|
const RectF & srcRect,
|
|
Unit srcUnit,
|
|
EnumerateMetafileProc callback,
|
|
VOID * callbackData,
|
|
const GpImageAttributes * imageAttributes
|
|
);
|
|
|
|
GpStatus
|
|
EnumerateMetafile(
|
|
const GpMetafile * metafile,
|
|
const RectF & destRect,
|
|
const RectF & srcRect,
|
|
Unit srcUnit,
|
|
EnumerateMetafileProc callback,
|
|
VOID * callbackData,
|
|
const GpImageAttributes * imageAttributes
|
|
);
|
|
|
|
GpStatus
|
|
EnumerateMetafile(
|
|
const GpMetafile * metafile,
|
|
const PointF * destPoints,
|
|
INT count,
|
|
const RectF & srcRect,
|
|
Unit srcUnit,
|
|
EnumerateMetafileProc callback,
|
|
VOID * callbackData,
|
|
const GpImageAttributes * imageAttributes
|
|
);
|
|
|
|
GpStatus
|
|
Comment(
|
|
UINT sizeData,
|
|
const BYTE * data
|
|
)
|
|
{
|
|
GpStatus status = InvalidParameter;
|
|
|
|
if (IsRecording())
|
|
{
|
|
status = Metafile->RecordComment(sizeData, data);
|
|
if (status != Ok)
|
|
{
|
|
SetValid(FALSE); // Prevent any more recording
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
// Called only by metafile player
|
|
GpStatus
|
|
EnumEmf(
|
|
MetafilePlayer * player,
|
|
HENHMETAFILE hEmf,
|
|
const GpRectF & destRect,
|
|
const GpRectF & srcRect,
|
|
const GpRectF & deviceDestRect,
|
|
MetafileType type,
|
|
BOOL isTranslateScale,
|
|
BOOL renderToBitmap,
|
|
const GpMatrix & flipAndCropTransform
|
|
);
|
|
|
|
// Called only by metafile player
|
|
GpStatus
|
|
EnumEmfPlusDual(
|
|
MetafilePlayer * player,
|
|
HENHMETAFILE hEmf,
|
|
const GpRectF& destRect, // inclusive, exclusive
|
|
const GpRectF& deviceDestRect, // inclusive, exclusive
|
|
BOOL isTranslateScale,
|
|
BOOL renderToBitmap
|
|
);
|
|
|
|
protected:
|
|
|
|
// if an HWND is passed in, the default ICM mode is off.
|
|
// if an HDC is passed in, the icmMode flag is ignored.
|
|
|
|
GpGraphics(
|
|
HWND hwnd,
|
|
HDC hdc,
|
|
INT clientWidth,
|
|
INT clientHeight,
|
|
HdcIcmMode icmMode = IcmModeOff,
|
|
BOOL gdiLayered = FALSE
|
|
);
|
|
|
|
GpGraphics(DpBitmap * surface);
|
|
|
|
GpStatus GetDCDrawBounds(HDC hdc, RECT *rect);
|
|
|
|
public:
|
|
|
|
// The Context dpi and the Surface dpi are always the same,
|
|
// except possibly during metafile playback when the Context
|
|
// may be using the metafile dpi (which is what rendering
|
|
// should use).
|
|
|
|
REAL GetDpiX() const { return Context->GetDpiX(); }
|
|
REAL GetDpiY() const { return Context->GetDpiY(); }
|
|
|
|
BOOL IsPrinter() const { return Printer; }
|
|
|
|
protected:
|
|
|
|
enum HalftoneType
|
|
{
|
|
HalftoneTypeNone,
|
|
HalftoneType16Color,
|
|
HalftoneType216Color,
|
|
HalftoneType15Bpp,
|
|
HalftoneType16Bpp,
|
|
};
|
|
|
|
HalftoneType GetHalftoneType() const
|
|
{
|
|
EpPaletteMap* paletteMap = BottomContext.PaletteMap;
|
|
|
|
// !! TODO: Verify this works on when switching modes
|
|
if (paletteMap != NULL)
|
|
{
|
|
// we are doing 8bpp palette map
|
|
if (paletteMap->IsVGAOnly())
|
|
{
|
|
return HalftoneType16Color;
|
|
}
|
|
else
|
|
{
|
|
return HalftoneType216Color;
|
|
}
|
|
}
|
|
else if (Surface->PixelFormat == PixelFormat16bppRGB555)
|
|
{
|
|
return HalftoneType15Bpp;
|
|
}
|
|
else if (Surface->PixelFormat == PixelFormat16bppRGB565)
|
|
{
|
|
return HalftoneType16Bpp;
|
|
}
|
|
else
|
|
{
|
|
return HalftoneTypeNone;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Internal fill and draw routines that do not record
|
|
// path, rect, or region in a metafile.
|
|
//--------------------------------------------------------------
|
|
|
|
GpStatus
|
|
RenderFillRects(
|
|
GpRectF* bounds,
|
|
INT count,
|
|
const GpRectF* rects,
|
|
GpBrush* brush
|
|
)
|
|
{
|
|
GpRect deviceBounds;
|
|
GpStatus status = BoundsFToRect(bounds, &deviceBounds);
|
|
|
|
if (status == Ok && !IsTotallyClipped(&deviceBounds))
|
|
{
|
|
// Now that we've done a bunch of work in accumulating the bounds,
|
|
// acquire the device lock before calling the driver:
|
|
|
|
Devlock devlock(Device);
|
|
|
|
return DrvFillRects(&deviceBounds, count, rects, brush->GetDeviceBrush());
|
|
}
|
|
return status;
|
|
}
|
|
|
|
GpStatus
|
|
RenderFillRegion(
|
|
GpRectF* bounds,
|
|
GpRegion* region,
|
|
GpBrush* brush,
|
|
GpRect* metafileBounds
|
|
)
|
|
{
|
|
GpRect deviceBounds;
|
|
GpStatus status = BoundsFToRect(bounds, &deviceBounds);
|
|
BOOL isInfinite = FALSE;
|
|
GpMatrix identity;
|
|
|
|
if (status == Ok && !IsTotallyClipped(&deviceBounds))
|
|
{
|
|
// Now that we've done a bunch of work in accumulating the bounds,
|
|
// acquire the device lock before calling the driver:
|
|
|
|
status = region->UpdateDeviceRegion(&(Context->WorldToDevice));
|
|
|
|
if (status == Ok)
|
|
{
|
|
DpRegion * deviceRegion = &(region->DeviceRegion);
|
|
DpRegion metafileRegion;
|
|
|
|
if (metafileBounds != NULL)
|
|
{
|
|
metafileRegion.Set(metafileBounds);
|
|
metafileRegion.And(deviceRegion);
|
|
if (!metafileRegion.IsValid())
|
|
{
|
|
return GenericError;
|
|
}
|
|
deviceRegion = &metafileRegion;
|
|
}
|
|
|
|
// Get the actual bounds now to give to the driver
|
|
deviceRegion->GetBounds(&deviceBounds);
|
|
|
|
// Make sure there is still something to fill so we
|
|
// don't ASSERT later on.
|
|
if ((deviceBounds.Width > 0) && (deviceBounds.Height > 0))
|
|
{
|
|
Devlock devlock(Device);
|
|
|
|
return DrvFillRegion(&deviceBounds, deviceRegion, brush->GetDeviceBrush());
|
|
}
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
GpStatus RenderDrawPath(
|
|
GpRectF *bounds,
|
|
GpPath *path,
|
|
GpPen *pen
|
|
);
|
|
|
|
GpStatus RenderFillPath(
|
|
GpRectF *bounds,
|
|
GpPath *path,
|
|
const GpBrush *brush
|
|
);
|
|
|
|
VOID
|
|
GetImageDestPageSize(
|
|
const GpImage * image,
|
|
REAL srcWidth,
|
|
REAL srcHeight,
|
|
GpPageUnit srcUnit,
|
|
REAL & destWidth,
|
|
REAL & destHeight
|
|
);
|
|
|
|
VOID
|
|
DeviceToWorldTransformRect(
|
|
const GpRect & deviceRect,
|
|
GpRectF & rect
|
|
) const;
|
|
|
|
static GpGraphics *GetFromGdiBitmap(HDC hdc);
|
|
static GpGraphics *GetFromGdipBitmap(
|
|
GpBitmap* bitmap,
|
|
ImageInfo * imageInfo,
|
|
EpScanBitmap * scanBitmap,
|
|
BOOL isDisplay
|
|
);
|
|
static GpGraphics *GetFromGdiPrinterDC(HDC hdc);
|
|
static GpGraphics *GetFromGdiEmfDC(HDC hdc);
|
|
static GpGraphics *GetFromDirectDrawSurface(IDirectDrawSurface7 * surface);
|
|
static GpGraphics *GetFromGdiPrinterDC(HDC hdc, HANDLE hPrinter);
|
|
|
|
static INT GetPostscriptLevel(HDC hdc, HANDLE hPrinter);
|
|
|
|
GpStatus StartPrinterEMF();
|
|
|
|
GpStatus EndPrinterEMF();
|
|
|
|
BOOL IsTotallyClipped(GpRect *rect) const;
|
|
|
|
BOOL IsRecording() const { return Metafile != NULL; }
|
|
|
|
BOOL IsDisplay() const { return Context->IsDisplay; }
|
|
|
|
VOID DoResetClip()
|
|
{
|
|
Context->AppClip.SetInfinite();
|
|
|
|
// ContainerClip always contains the clipping for the container,
|
|
// intersected with the WindowClip.
|
|
Context->VisibleClip.Set(&(Context->ContainerClip));
|
|
}
|
|
|
|
// The AppClip has been set into VisibleClip; now intersect it with
|
|
// the container clip and the window clip.
|
|
GpStatus AndVisibleClip()
|
|
{
|
|
// ContainerClip always contains the clipping for the container,
|
|
// intersected with the WindowClip.
|
|
return Context->VisibleClip.And(&(Context->ContainerClip));
|
|
}
|
|
|
|
GpStatus
|
|
CombineClip(
|
|
const GpRectF & rect,
|
|
CombineMode combineMode
|
|
);
|
|
|
|
GpStatus
|
|
CombineClip(
|
|
const GpPath * path,
|
|
CombineMode combineMode,
|
|
BOOL isDevicePath = FALSE
|
|
);
|
|
|
|
GpStatus
|
|
CombineClip(
|
|
GpRegion * region,
|
|
CombineMode combineMode
|
|
);
|
|
|
|
GpStatus
|
|
InheritAppClippingAndTransform(
|
|
HDC hdc
|
|
);
|
|
|
|
VOID
|
|
ResetState(
|
|
INT x,
|
|
INT y,
|
|
INT width,
|
|
INT height
|
|
);
|
|
|
|
VOID
|
|
UpdateDrawBounds(
|
|
INT x,
|
|
INT y,
|
|
INT width,
|
|
INT height
|
|
);
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Routines for calling the driver
|
|
//--------------------------------------------------------------------------
|
|
|
|
VOID
|
|
DrvFlush(
|
|
GpFlushIntention intention
|
|
)
|
|
{
|
|
ASSERTMSG(Device->DeviceLock.IsLockedByCurrentThread(),
|
|
("DeviceLock must be held by current thread"));
|
|
|
|
Driver->Flush(Device, Surface, intention);
|
|
|
|
}
|
|
|
|
GpStatus
|
|
DrvStrokePath(
|
|
const GpRect *drawBounds,
|
|
const DpPath *path,
|
|
const DpPen *pen
|
|
)
|
|
{
|
|
ASSERTMSG(GetObjectLock()->IsLocked(),
|
|
("Graphics object must be locked"));
|
|
|
|
ASSERTMSG(Device->DeviceLock.IsLockedByCurrentThread(),
|
|
("DeviceLock must be held by current thread"));
|
|
|
|
FPUStateSaver::AssertMode();
|
|
|
|
Surface->Uniqueness = (DWORD)GpObject::GenerateUniqueness();
|
|
return(Driver->StrokePath(Context, Surface, drawBounds, path, pen));
|
|
}
|
|
|
|
GpStatus
|
|
DrvFillRects(
|
|
const GpRect *drawBounds,
|
|
INT numRects,
|
|
const GpRectF *rects,
|
|
const DpBrush *brush
|
|
)
|
|
{
|
|
ASSERTMSG(GetObjectLock()->IsLocked(),
|
|
("Graphics object must be locked"));
|
|
|
|
ASSERTMSG(Device->DeviceLock.IsLockedByCurrentThread(),
|
|
("DeviceLock must be held by current thread"));
|
|
|
|
FPUStateSaver::AssertMode();
|
|
|
|
Surface->Uniqueness = (DWORD)GpObject::GenerateUniqueness();
|
|
return(Driver->FillRects(Context, Surface, drawBounds,
|
|
numRects, rects, brush));
|
|
}
|
|
|
|
GpStatus
|
|
DrvFillPath(
|
|
const GpRect *drawBounds,
|
|
const DpPath *path,
|
|
const DpBrush *brush
|
|
)
|
|
{
|
|
ASSERTMSG(GetObjectLock()->IsLocked(),
|
|
("Graphics object must be locked"));
|
|
|
|
ASSERTMSG(Device->DeviceLock.IsLockedByCurrentThread(),
|
|
("DeviceLock must be held by current thread"));
|
|
|
|
FPUStateSaver::AssertMode();
|
|
|
|
Surface->Uniqueness = (DWORD)GpObject::GenerateUniqueness();
|
|
return(Driver->FillPath(Context, Surface, drawBounds, path, brush));
|
|
}
|
|
|
|
GpStatus
|
|
DrvFillRegion(
|
|
const GpRect *drawBounds,
|
|
const DpRegion *region,
|
|
const DpBrush *brush
|
|
)
|
|
{
|
|
ASSERTMSG(GetObjectLock()->IsLocked(),
|
|
("Graphics object must be locked"));
|
|
|
|
ASSERTMSG(Device->DeviceLock.IsLockedByCurrentThread(),
|
|
("DeviceLock must be held by current thread"));
|
|
|
|
FPUStateSaver::AssertMode();
|
|
|
|
Surface->Uniqueness = (DWORD)GpObject::GenerateUniqueness();
|
|
return(Driver->FillRegion(Context, Surface, drawBounds, region, brush));
|
|
}
|
|
|
|
GpStatus
|
|
DrvDrawGlyphs(
|
|
const GpRect *drawBounds,
|
|
const GpGlyphPos *glyphPos,
|
|
const GpGlyphPos *glyphPathPos,
|
|
INT count,
|
|
const DpBrush *brush,
|
|
const GpFaceRealization *faceRealization,
|
|
const UINT16 *glyphs,
|
|
const UINT16 *glyphMap,
|
|
const PointF *glyphOrigins,
|
|
INT glyphCount,
|
|
const WCHAR *string,
|
|
UINT stringLength,
|
|
ItemScript script,
|
|
INT edgeGlyphAdvance,
|
|
BOOL rightToLeft,
|
|
INT flags
|
|
)
|
|
{
|
|
// check the input parameter!!
|
|
|
|
GpStatus status;
|
|
DrawGlyphData drawGlyphData;
|
|
|
|
drawGlyphData.context = Context;
|
|
drawGlyphData.surface = Surface;
|
|
drawGlyphData.drawBounds = drawBounds;
|
|
drawGlyphData.glyphPos = glyphPos;
|
|
drawGlyphData.glyphPathPos = glyphPathPos;
|
|
drawGlyphData.count = count;
|
|
drawGlyphData.brush = brush;
|
|
drawGlyphData.faceRealization = faceRealization;
|
|
drawGlyphData.glyphs = glyphs;
|
|
drawGlyphData.glyphMap = glyphMap;
|
|
drawGlyphData.glyphOrigins = glyphOrigins;
|
|
drawGlyphData.glyphCount = glyphCount;
|
|
drawGlyphData.string = string;
|
|
drawGlyphData.stringLength = stringLength;
|
|
drawGlyphData.script = script;
|
|
drawGlyphData.edgeGlyphAdvance = edgeGlyphAdvance;
|
|
drawGlyphData.rightToLeft = rightToLeft;
|
|
drawGlyphData.flags = flags;
|
|
|
|
status = Driver->DrawGlyphs(&drawGlyphData);
|
|
|
|
return status;
|
|
}
|
|
|
|
// Draw the CachedBitmap on this graphics.
|
|
// This routine sets up the rendering origin and the locks
|
|
// and calls the appropriate driver.
|
|
|
|
GpStatus
|
|
DrvDrawCachedBitmap(
|
|
GpCachedBitmap *inputCachedBitmap,
|
|
INT x,
|
|
INT y
|
|
);
|
|
|
|
GpStatus
|
|
DrvDrawImage(
|
|
const GpRect *drawBounds,
|
|
GpBitmap *intputBitmap,
|
|
INT numPoints,
|
|
const GpPointF *dstPoints,
|
|
const GpRectF *srcRect,
|
|
const GpImageAttributes *imageAttributes,
|
|
DrawImageAbort callback,
|
|
VOID *callbackData,
|
|
DriverDrawImageFlags flags
|
|
);
|
|
|
|
GpStatus
|
|
DrvMoveBits(
|
|
const GpRect *drawBounds,
|
|
const GpRect *dstRect,
|
|
const GpPoint *srcPoint
|
|
)
|
|
{
|
|
GpStatus status;
|
|
|
|
ASSERTMSG(GetObjectLock()->IsLocked(),
|
|
("Graphics object must be locked"));
|
|
|
|
ASSERTMSG(Device->DeviceLock.IsLockedByCurrentThread(),
|
|
("DeviceLock must be held by current thread"));
|
|
|
|
FPUStateSaver::AssertMode();
|
|
|
|
Surface->Uniqueness = (DWORD)GpObject::GenerateUniqueness();
|
|
status = Driver->MoveBits(Context, Surface, drawBounds, dstRect,
|
|
srcPoint);
|
|
|
|
return status;
|
|
}
|
|
|
|
public:
|
|
// Simple inline function to return the selected surface.
|
|
|
|
DpBitmap *GetSurface() {
|
|
return Surface;
|
|
}
|
|
|
|
// Simple inline function to return the driver.
|
|
|
|
DpDriver *GetDriver() {
|
|
return Driver;
|
|
}
|
|
|
|
protected:
|
|
|
|
enum GraphicsType
|
|
{
|
|
GraphicsBitmap = 1,
|
|
GraphicsScreen = 2,
|
|
GraphicsMetafile = 3,
|
|
};
|
|
|
|
mutable GpLockable Lockable;
|
|
GpRect SurfaceBounds; // Bounds of surface in device units.
|
|
DpBitmap *Surface; // Selected surface
|
|
|
|
GpBitmap *GdipBitmap; // point to GpBitmap if the graphics is created from one
|
|
|
|
IMetafileRecord * Metafile; // For recording metafiles
|
|
|
|
BOOL Printer; // Whether this object is a printer
|
|
PGDIPPRINTINIT PrintInit; // Initialization data for printer types
|
|
HGLOBAL PrinterEMF;
|
|
GpMetafile *PrinterMetafile;
|
|
GpGraphics *PrinterGraphics;
|
|
|
|
BOOL DownLevel; // Whether or not to do down-level metafile
|
|
GraphicsType Type; // Type of GpGraphics created
|
|
|
|
BOOL CreatedDevice; // Whether 'Device' was created at GpGraphics
|
|
// construction time, and so needs to be
|
|
// freed in the GpGraphics destructor
|
|
GpDevice *Device; // Associated device
|
|
DpDriver *Driver; // Associate driver interface
|
|
DpContext *Context; // Contains all the driver-viewable state:
|
|
// Transforms, clipping, alpha/antialias/etc.
|
|
// modes
|
|
DpContext BottomContext; // Always the bottom of the Context Stack
|
|
DpRegion WindowClip; // The clip region of the window
|
|
|
|
TextRenderingHint TextRenderingHintInternal; // cached internal value of TextRenderingHint
|
|
// valid during one call to Draw(Driver)String
|
|
};
|
|
|
|
#endif // !_GRAPHICS_HPP
|