GraphicsContext.cpp [plain text]
#include "config.h"
#include "GraphicsContext.h"
#include "DeprecatedString.h"
#include "Font.h"
using namespace std;
namespace WebCore {
struct GraphicsContextState {
GraphicsContextState() : fillColor(Color::black), paintingDisabled(false) { }
Font font;
Pen pen;
Color fillColor;
bool paintingDisabled;
};
class GraphicsContextPrivate {
public:
GraphicsContextPrivate();
GraphicsContextState state;
Vector<GraphicsContextState> stack;
Vector<IntRect> m_focusRingRects;
int m_focusRingWidth;
int m_focusRingOffset;
bool m_updatingControlTints;
};
GraphicsContextPrivate::GraphicsContextPrivate()
: m_focusRingWidth(0)
, m_focusRingOffset(0)
, m_updatingControlTints(false)
{
}
GraphicsContextPrivate* GraphicsContext::createGraphicsContextPrivate()
{
return new GraphicsContextPrivate;
}
void GraphicsContext::destroyGraphicsContextPrivate(GraphicsContextPrivate* deleteMe)
{
delete deleteMe;
}
void GraphicsContext::save()
{
if (paintingDisabled())
return;
m_common->stack.append(m_common->state);
savePlatformState();
}
void GraphicsContext::restore()
{
if (paintingDisabled())
return;
if (m_common->stack.isEmpty()) {
LOG_ERROR("ERROR void GraphicsContext::restore() stack is empty");
return;
}
m_common->state = m_common->stack.last();
m_common->stack.removeLast();
restorePlatformState();
}
void GraphicsContext::drawRaisedEllipse(const FloatRect& rect, Color ellipseColor, Color shadowColor)
{
if (paintingDisabled())
return;
save();
setPen(shadowColor);
setFillColor(shadowColor);
drawEllipse(FloatRect(rect.x(), rect.y() + 1.0, rect.width(), rect.height()));
setPen(ellipseColor);
setFillColor(ellipseColor);
drawEllipse(rect);
restore();
}
const Font& GraphicsContext::font() const
{
return m_common->state.font;
}
void GraphicsContext::setFont(const Font& aFont)
{
m_common->state.font = aFont;
}
const Pen& GraphicsContext::pen() const
{
return m_common->state.pen;
}
void GraphicsContext::setPen(const Pen& pen)
{
m_common->state.pen = pen;
}
void GraphicsContext::setPen(Pen::PenStyle style)
{
m_common->state.pen.setStyle(style);
m_common->state.pen.setColor(Color::black);
m_common->state.pen.setWidth(0);
}
void GraphicsContext::setPen(RGBA32 rgb)
{
m_common->state.pen.setStyle(Pen::SolidLine);
m_common->state.pen.setColor(rgb);
m_common->state.pen.setWidth(0);
}
void GraphicsContext::setFillColor(const Color& color)
{
m_common->state.fillColor = color;
}
Color GraphicsContext::fillColor() const
{
return m_common->state.fillColor;
}
bool GraphicsContext::updatingControlTints() const
{
return m_common->m_updatingControlTints;
}
void GraphicsContext::setUpdatingControlTints(bool b)
{
setPaintingDisabled(b);
m_common->m_updatingControlTints = b;
}
void GraphicsContext::setPaintingDisabled(bool f)
{
m_common->state.paintingDisabled = f;
}
bool GraphicsContext::paintingDisabled() const
{
return m_common->state.paintingDisabled;
}
void GraphicsContext::drawImage(Image* image, const IntPoint& p, CompositeOperator op)
{
drawImage(image, p, IntRect(0, 0, -1, -1), op);
}
void GraphicsContext::drawImage(Image* image, const IntRect& r, CompositeOperator op)
{
drawImage(image, r, IntRect(0, 0, -1, -1), op);
}
void GraphicsContext::drawImage(Image* image, const IntPoint& dest, const IntRect& srcRect, CompositeOperator op)
{
drawImage(image, IntRect(dest, srcRect.size()), srcRect, op);
}
void GraphicsContext::drawImage(Image* image, const IntRect& dest, const IntRect& srcRect, CompositeOperator op)
{
drawImage(image, FloatRect(dest), srcRect, op);
}
void GraphicsContext::drawText(const TextRun& run, const IntPoint& point, const TextStyle& style)
{
if (paintingDisabled())
return;
font().drawText(this, run, style, point);
}
void GraphicsContext::drawHighlightForText(const TextRun& run, const IntPoint& point, int h, const TextStyle& style, const Color& backgroundColor)
{
if (paintingDisabled())
return;
fillRect(font().selectionRectForText(run, style, point, h), backgroundColor);
}
void GraphicsContext::initFocusRing(int width, int offset)
{
if (paintingDisabled())
return;
clearFocusRing();
m_common->m_focusRingWidth = width;
m_common->m_focusRingOffset = offset;
}
void GraphicsContext::clearFocusRing()
{
m_common->m_focusRingRects.clear();
}
void GraphicsContext::addFocusRingRect(const IntRect& rect)
{
if (paintingDisabled() || rect.isEmpty())
return;
m_common->m_focusRingRects.append(rect);
}
int GraphicsContext::focusRingWidth() const
{
return m_common->m_focusRingWidth;
}
int GraphicsContext::focusRingOffset() const
{
return m_common->m_focusRingOffset;
}
const Vector<IntRect>& GraphicsContext::focusRingRects() const
{
return m_common->m_focusRingRects;
}
void GraphicsContext::drawImage(Image* image, const FloatRect& dest, const FloatRect& src, CompositeOperator op)
{
if (paintingDisabled())
return;
float tsw = src.width();
float tsh = src.height();
float tw = dest.width();
float th = dest.height();
if (tsw == -1)
tsw = image->width();
if (tsh == -1)
tsh = image->height();
if (tw == -1)
tw = image->width();
if (th == -1)
th = image->height();
image->draw(this, FloatRect(dest.location(), FloatSize(tw, th)), FloatRect(src.location(), FloatSize(tsw, tsh)), op);
}
void GraphicsContext::drawTiledImage(Image* image, const IntRect& rect, const IntPoint& srcPoint, const IntSize& tileSize, CompositeOperator op)
{
if (paintingDisabled())
return;
image->drawTiled(this, rect, srcPoint, tileSize, op);
}
void GraphicsContext::drawTiledImage(Image* image, const IntRect& dest, const IntRect& srcRect, Image::TileRule hRule, Image::TileRule vRule, CompositeOperator op)
{
if (paintingDisabled())
return;
if (hRule == Image::StretchTile && vRule == Image::StretchTile)
return drawImage(image, dest, srcRect);
image->drawTiled(this, dest, srcRect, hRule, vRule, op);
}
}