#ifndef GraphicsContext_h
#define GraphicsContext_h
#include "ColorSpace.h"
#include "DashArray.h"
#include "FloatRect.h"
#include "Gradient.h"
#include "Image.h"
#include "Path.h"
#include "Pattern.h"
#include <wtf/Noncopyable.h>
#include <wtf/PassOwnPtr.h>
#if USE(CG)
typedef struct CGContext PlatformGraphicsContext;
#elif USE(CAIRO)
namespace WebCore {
class ContextShadow;
class PlatformContextCairo;
}
typedef WebCore::PlatformContextCairo PlatformGraphicsContext;
#elif PLATFORM(OPENVG)
namespace WebCore {
class SurfaceOpenVG;
}
typedef class WebCore::SurfaceOpenVG PlatformGraphicsContext;
#elif PLATFORM(QT)
#include <QPainter>
namespace WebCore {
class ContextShadow;
}
typedef QPainter PlatformGraphicsContext;
#elif PLATFORM(WX)
class wxGCDC;
class wxWindowDC;
#if USE(WXGC)
#ifdef __APPLE__
class wxDC;
typedef wxDC PlatformGraphicsContext;
#else
typedef wxGCDC PlatformGraphicsContext;
#endif
#else
typedef wxWindowDC PlatformGraphicsContext;
#endif
#elif USE(SKIA)
namespace WebCore {
class PlatformContextSkia;
}
typedef WebCore::PlatformContextSkia PlatformGraphicsContext;
#elif PLATFORM(HAIKU)
class BView;
typedef BView PlatformGraphicsContext;
struct pattern;
#elif OS(WINCE)
typedef struct HDC__ PlatformGraphicsContext;
#else
typedef void PlatformGraphicsContext;
#endif
#if PLATFORM(WIN)
#include "DIBPixelData.h"
typedef struct HDC__* HDC;
#if !USE(CG)
typedef unsigned char UInt8;
#endif
#endif
#if PLATFORM(QT) && defined(Q_WS_WIN)
#include <windows.h>
#endif
namespace WebCore {
#if OS(WINCE) && !PLATFORM(QT)
class SharedBitmap;
class SimpleFontData;
class GlyphBuffer;
#endif
const int cMisspellingLineThickness = 3;
const int cMisspellingLinePatternWidth = 4;
const int cMisspellingLinePatternGapWidth = 1;
class AffineTransform;
class DrawingBuffer;
class Font;
class Generator;
class GraphicsContextPlatformPrivate;
class ImageBuffer;
class IntRect;
class RoundedIntRect;
class KURL;
class SharedGraphicsContext3D;
class TextRun;
struct BidiStatus;
enum TextDrawingMode {
TextModeInvisible = 0,
TextModeFill = 1 << 0,
TextModeStroke = 1 << 1,
TextModeClip = 1 << 2
};
typedef unsigned TextDrawingModeFlags;
enum StrokeStyle {
NoStroke,
SolidStroke,
DottedStroke,
DashedStroke
};
enum InterpolationQuality {
InterpolationDefault,
InterpolationNone,
InterpolationLow,
InterpolationMedium,
InterpolationHigh
};
struct GraphicsContextState {
GraphicsContextState()
: strokeThickness(0)
, shadowBlur(0)
#if USE(CAIRO)
, globalAlpha(1)
#endif
, textDrawingMode(TextModeFill)
, strokeColor(Color::black)
, fillColor(Color::black)
, strokeStyle(SolidStroke)
, fillRule(RULE_NONZERO)
, strokeColorSpace(ColorSpaceDeviceRGB)
, fillColorSpace(ColorSpaceDeviceRGB)
, shadowColorSpace(ColorSpaceDeviceRGB)
, compositeOperator(CompositeSourceOver)
, emojiDrawingEnabled(true)
, shouldUseContextColors(true)
, shouldAntialias(true)
, shouldSmoothFonts(true)
, paintingDisabled(false)
, shadowsIgnoreTransforms(false)
#if USE(CG)
, shadowsUseLegacyRadius(false)
#endif
{
}
RefPtr<Gradient> strokeGradient;
RefPtr<Pattern> strokePattern;
RefPtr<Gradient> fillGradient;
RefPtr<Pattern> fillPattern;
FloatSize shadowOffset;
float strokeThickness;
float shadowBlur;
#if USE(CAIRO)
float globalAlpha;
#endif
TextDrawingModeFlags textDrawingMode;
Color strokeColor;
Color fillColor;
Color shadowColor;
StrokeStyle strokeStyle;
WindRule fillRule;
ColorSpace strokeColorSpace;
ColorSpace fillColorSpace;
ColorSpace shadowColorSpace;
CompositeOperator compositeOperator;
bool emojiDrawingEnabled : 1;
bool shouldUseContextColors : 1;
bool shouldAntialias : 1;
bool shouldSmoothFonts : 1;
bool paintingDisabled : 1;
bool shadowsIgnoreTransforms : 1;
#if USE(CG)
bool shadowsUseLegacyRadius : 1;
#endif
};
void setStrokeAndFillColor(PlatformGraphicsContext* context, CGColorRef color);
class GraphicsContext {
WTF_MAKE_NONCOPYABLE(GraphicsContext); WTF_MAKE_FAST_ALLOCATED;
public:
GraphicsContext(PlatformGraphicsContext*, bool setContextColors = true);
~GraphicsContext();
#if !OS(WINCE) || PLATFORM(QT)
PlatformGraphicsContext* platformContext() const;
#endif
float strokeThickness() const;
void setStrokeThickness(float);
StrokeStyle strokeStyle() const;
void setStrokeStyle(StrokeStyle);
Color strokeColor() const;
ColorSpace strokeColorSpace() const;
void setStrokeColor(const Color&, ColorSpace);
void setStrokePattern(PassRefPtr<Pattern>);
Pattern* strokePattern() const;
void setStrokeGradient(PassRefPtr<Gradient>);
Gradient* strokeGradient() const;
WindRule fillRule() const;
void setFillRule(WindRule);
Color fillColor() const;
ColorSpace fillColorSpace() const;
void setFillColor(const Color&, ColorSpace);
void setFillPattern(PassRefPtr<Pattern>);
Pattern* fillPattern() const;
void setFillGradient(PassRefPtr<Gradient>);
Gradient* fillGradient() const;
void setShadowsIgnoreTransforms(bool);
bool shadowsIgnoreTransforms() const;
void setShouldAntialias(bool);
bool shouldAntialias() const;
void setShouldSmoothFonts(bool);
bool shouldSmoothFonts() const;
const GraphicsContextState& state() const;
#if USE(CG)
void applyStrokePattern();
void applyFillPattern();
void drawPath(const Path&);
void drawNativeImage(NativeImagePtr, const FloatSize& imageSize, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect,
#if ENABLE(RESPECT_EXIF_ORIENTATION)
int orientation,
#endif
float scale,
CompositeOperator = CompositeSourceOver);
void setAllowsFontSmoothing(bool);
void setIsCALayerContext(bool);
bool isCALayerContext() const;
void setIsAcceleratedContext(bool);
bool isAcceleratedContext() const;
#endif
void save();
void restore();
void drawRect(const IntRect&);
void drawLine(const IntPoint&, const IntPoint&, bool antialias = false);
void drawJoinedLines(CGPoint points [], unsigned count, bool antialias, CGLineCap lineCap = kCGLineCapButt);
void drawEllipse(const IntRect&);
void drawEllipse(const FloatRect&);
void drawRaisedEllipse(const FloatRect&, const Color& ellipseColor, ColorSpace ellipseColorSpace, const Color& shadowColor, ColorSpace shadowColorSpace);
void drawConvexPolygon(size_t numPoints, const FloatPoint*, bool shouldAntialias = false);
void fillPath(const Path&);
void strokePath(const Path&);
void strokeArc(const IntRect&, int startAngle, int angleSpan);
void fillRect(const FloatRect&);
void fillRect(const FloatRect&, const Color&, ColorSpace);
void fillRect(const FloatRect&, Generator&);
void fillRoundedRect(const IntRect&, const IntSize& topLeft, const IntSize& topRight, const IntSize& bottomLeft, const IntSize& bottomRight, const Color&, ColorSpace);
void fillRoundedRect(const RoundedIntRect&, const Color&, ColorSpace);
void fillRectWithRoundedHole(const IntRect&, const RoundedIntRect& roundedHoleRect, const Color&, ColorSpace);
void clearRect(const FloatRect&);
void strokeRect(const FloatRect&, float lineWidth);
void drawImage(Image*, ColorSpace styleColorSpace, const IntPoint&, CompositeOperator = CompositeSourceOver);
void drawImage(Image*, ColorSpace styleColorSpace, const IntRect&, CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);
void drawImage(Image*, ColorSpace styleColorSpace, const IntPoint& destPoint, const IntRect& srcRect, CompositeOperator = CompositeSourceOver);
void drawImage(Image*, ColorSpace styleColorSpace, const IntRect& destRect, const IntRect& srcRect, CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);
void drawImage(Image*, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect = FloatRect(0, 0, -1, -1),
CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);
void drawTiledImage(Image*, ColorSpace styleColorSpace, const IntRect& destRect, const IntPoint& srcPoint, const IntSize& tileSize,
CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);
void drawTiledImage(Image*, ColorSpace styleColorSpace, const IntRect& destRect, const IntRect& srcRect,
const FloatSize& tileScaleFactor, Image::TileRule hRule = Image::StretchTile, Image::TileRule vRule = Image::StretchTile,
CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);
void drawImageBuffer(ImageBuffer*, ColorSpace styleColorSpace, const IntPoint&, CompositeOperator = CompositeSourceOver);
void drawImageBuffer(ImageBuffer*, ColorSpace styleColorSpace, const IntRect&, CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);
void drawImageBuffer(ImageBuffer*, ColorSpace styleColorSpace, const IntPoint& destPoint, const IntRect& srcRect, CompositeOperator = CompositeSourceOver);
void drawImageBuffer(ImageBuffer*, ColorSpace styleColorSpace, const IntRect& destRect, const IntRect& srcRect, CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);
void drawImageBuffer(ImageBuffer*, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect = FloatRect(0, 0, -1, -1),
CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);
void setImageInterpolationQuality(InterpolationQuality);
InterpolationQuality imageInterpolationQuality() const;
void clip(const IntRect&);
void clip(const FloatRect&);
void addRoundedRectClip(const RoundedIntRect&);
void addRoundedRectClip(const FloatRect&, const FloatSize& topLeft, const FloatSize& topRight, const FloatSize& bottomLeft, const FloatSize& bottomRight);
void addInnerRoundedRectClip(const IntRect&, int thickness);
void clipOut(const IntRect&);
void clipOutRoundedRect(const RoundedIntRect&);
void clipPath(const Path&, WindRule);
void clipConvexPolygon(size_t numPoints, const FloatPoint*, bool antialias = true);
void clipToImageBuffer(ImageBuffer*, const FloatRect&);
IntRect clipBounds() const;
TextDrawingModeFlags textDrawingMode() const;
void setTextDrawingMode(TextDrawingModeFlags);
bool emojiDrawingEnabled();
void setEmojiDrawingEnabled(bool emojiDrawingEnabled);
float drawText(const Font&, const TextRun&, const FloatPoint&, int from = 0, int to = -1);
void drawEmphasisMarks(const Font&, const TextRun& , const AtomicString& mark, const FloatPoint&, int from = 0, int to = -1);
float drawBidiText(const Font&, const TextRun&, const FloatPoint&, BidiStatus* = 0, int length = -1);
void drawHighlightForText(const Font&, const TextRun&, const FloatPoint&, int h, const Color& backgroundColor, ColorSpace, int from = 0, int to = -1);
enum RoundingMode {
RoundAllSides,
RoundOriginAndDimensions
};
FloatRect roundToDevicePixels(const FloatRect&, RoundingMode = RoundAllSides);
void drawLineForText(const FloatPoint&, float width, bool printing);
enum TextCheckingLineStyle {
TextCheckingDictationPhraseWithAlternativesLineStyle,
TextCheckingSpellingLineStyle,
TextCheckingGrammarLineStyle,
TextCheckingReplacementLineStyle
};
void drawLineForTextChecking(const FloatPoint&, float width, TextCheckingLineStyle);
bool paintingDisabled() const;
void setPaintingDisabled(bool);
bool updatingControlTints() const;
void setUpdatingControlTints(bool);
void beginTransparencyLayer(float opacity);
void endTransparencyLayer();
bool hasShadow() const;
void setShadow(const FloatSize&, float blur, const Color&, ColorSpace);
void setLegacyShadow(const FloatSize&, float blur, const Color&, ColorSpace);
bool getShadow(FloatSize&, float&, Color&, ColorSpace&) const;
void clearShadow();
void drawFocusRing(const Vector<IntRect>&, int width, int offset, const Color&);
void drawFocusRing(const Path&, int width, int offset, const Color&);
void setLineCap(LineCap);
void setLineDash(const DashArray&, float dashOffset);
void setLineJoin(LineJoin);
void setMiterLimit(float);
void setAlpha(float);
#if USE(CAIRO)
float getAlpha();
#endif
void setCompositeOperation(CompositeOperator);
CompositeOperator compositeOperation() const;
void clip(const Path&);
void canvasClip(const Path&);
void clipOut(const Path&);
void scale(const FloatSize&);
void rotate(float angleInRadians);
void translate(const FloatSize& size) { translate(size.width(), size.height()); }
void translate(float x, float y);
void setURLForRect(const KURL&, const IntRect&);
void concatCTM(const AffineTransform&);
void setCTM(const AffineTransform&);
AffineTransform getCTM() const;
#if OS(WINCE) && !PLATFORM(QT)
void setBitmap(PassRefPtr<SharedBitmap>);
const AffineTransform& affineTransform() const;
AffineTransform& affineTransform();
void resetAffineTransform();
void fillRect(const FloatRect&, const Gradient*);
void drawText(const SimpleFontData* fontData, const GlyphBuffer& glyphBuffer, int from, int numGlyphs, const FloatPoint& point);
void drawFrameControl(const IntRect& rect, unsigned type, unsigned state);
void drawFocusRect(const IntRect& rect);
void paintTextField(const IntRect& rect, unsigned state);
void drawBitmap(SharedBitmap*, const IntRect& dstRect, const IntRect& srcRect, ColorSpace styleColorSpace, CompositeOperator compositeOp);
void drawBitmapPattern(SharedBitmap*, const FloatRect& tileRectIn, const AffineTransform& patternTransform, const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect, const IntSize& origSourceSize);
void drawIcon(HICON icon, const IntRect& dstRect, UINT flags);
HDC getWindowsContext(const IntRect&, bool supportAlphaBlend = false, bool mayCreateBitmap = true); void releaseWindowsContext(HDC, const IntRect&, bool supportAlphaBlend = false, bool mayCreateBitmap = true); void drawRoundCorner(bool newClip, RECT clipRect, RECT rectWin, HDC dc, int width, int height);
#elif PLATFORM(WIN)
GraphicsContext(HDC, bool hasAlpha = false); bool inTransparencyLayer() const;
HDC getWindowsContext(const IntRect&, bool supportAlphaBlend = true, bool mayCreateBitmap = true); void releaseWindowsContext(HDC, const IntRect&, bool supportAlphaBlend = true, bool mayCreateBitmap = true);
void setShouldIncludeChildWindows(bool);
bool shouldIncludeChildWindows() const;
class WindowsBitmap {
WTF_MAKE_NONCOPYABLE(WindowsBitmap);
public:
WindowsBitmap(HDC, const IntSize&);
~WindowsBitmap();
HDC hdc() const { return m_hdc; }
UInt8* buffer() const { return m_pixelData.buffer(); }
unsigned bufferLength() const { return m_pixelData.bufferLength(); }
const IntSize& size() const { return m_pixelData.size(); }
unsigned bytesPerRow() const { return m_pixelData.bytesPerRow(); }
unsigned short bitsPerPixel() const { return m_pixelData.bitsPerPixel(); }
const DIBPixelData& windowsDIB() const { return m_pixelData; }
private:
HDC m_hdc;
HBITMAP m_bitmap;
DIBPixelData m_pixelData;
};
PassOwnPtr<WindowsBitmap> createWindowsBitmap(const IntSize&);
void drawWindowsBitmap(WindowsBitmap*, const IntPoint&);
#endif
#if (PLATFORM(QT) && defined(Q_WS_WIN)) || (PLATFORM(WX) && OS(WINDOWS))
HDC getWindowsContext(const IntRect&, bool supportAlphaBlend = true, bool mayCreateBitmap = true);
void releaseWindowsContext(HDC, const IntRect&, bool supportAlphaBlend = true, bool mayCreateBitmap = true);
bool shouldIncludeChildWindows() const { return false; }
#endif
#if PLATFORM(WX)
bool inTransparencyLayer() const { return false; }
#endif
#if PLATFORM(QT)
bool inTransparencyLayer() const;
void pushTransparencyLayerInternal(const QRect &rect, qreal opacity, QPixmap& alphaMask);
void takeOwnershipOfPlatformContext();
#endif
#if PLATFORM(QT) || USE(CAIRO)
ContextShadow* contextShadow();
#endif
#if USE(CAIRO)
GraphicsContext(cairo_t*);
#endif
#if PLATFORM(GTK)
void setGdkExposeEvent(GdkEventExpose*);
GdkWindow* gdkWindow() const;
GdkEventExpose* gdkExposeEvent() const;
#endif
#if PLATFORM(HAIKU)
pattern getHaikuStrokeStyle();
#endif
void setSharedGraphicsContext3D(SharedGraphicsContext3D*, DrawingBuffer*, const IntSize&);
void syncSoftwareCanvas();
void markDirtyRect(const IntRect&);
static void adjustLineToPixelBoundaries(FloatPoint& p1, FloatPoint& p2, float strokeWidth, StrokeStyle);
private:
void platformInit(PlatformGraphicsContext*, bool setContextColors);
void platformDestroy();
#if PLATFORM(WIN) && !OS(WINCE)
void platformInit(HDC, bool hasAlpha = false);
#endif
void savePlatformState();
void restorePlatformState();
void setPlatformTextDrawingMode(TextDrawingModeFlags);
void setPlatformFont(const Font& font);
void setPlatformStrokeColor(const Color&, ColorSpace);
void setPlatformStrokeStyle(StrokeStyle);
void setPlatformStrokeThickness(float);
void setPlatformStrokeGradient(Gradient*);
void setPlatformStrokePattern(Pattern*);
void setPlatformFillColor(const Color&, ColorSpace);
void setPlatformFillGradient(Gradient*);
void setPlatformFillPattern(Pattern*);
void setPlatformShouldAntialias(bool);
void setPlatformShouldSmoothFonts(bool);
void setPlatformShadow(const FloatSize&, float blur, const Color&, ColorSpace);
void clearPlatformShadow();
void setPlatformCompositeOperation(CompositeOperator);
GraphicsContextPlatformPrivate* m_data;
GraphicsContextState m_state;
Vector<GraphicsContextState> m_stack;
bool m_updatingControlTints;
};
class GraphicsContextStateSaver {
public:
GraphicsContextStateSaver(GraphicsContext& context, bool saveAndRestore = true)
: m_context(context)
, m_saveAndRestore(saveAndRestore)
{
if (m_saveAndRestore)
m_context.save();
}
~GraphicsContextStateSaver()
{
if (m_saveAndRestore)
m_context.restore();
}
void save()
{
ASSERT(!m_saveAndRestore);
m_context.save();
m_saveAndRestore = true;
}
void restore()
{
ASSERT(m_saveAndRestore);
m_context.restore();
m_saveAndRestore = false;
}
private:
GraphicsContext& m_context;
bool m_saveAndRestore;
};
}
#endif // GraphicsContext_h