diff options
Diffstat (limited to 'Source/WebCore/platform/graphics/android/context/GraphicsOperation.h')
| -rw-r--r-- | Source/WebCore/platform/graphics/android/context/GraphicsOperation.h | 809 |
1 files changed, 809 insertions, 0 deletions
diff --git a/Source/WebCore/platform/graphics/android/context/GraphicsOperation.h b/Source/WebCore/platform/graphics/android/context/GraphicsOperation.h new file mode 100644 index 0000000..927ff0a --- /dev/null +++ b/Source/WebCore/platform/graphics/android/context/GraphicsOperation.h @@ -0,0 +1,809 @@ +/* + * Copyright 2012, The Android Open Source Project + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef GraphicsOperation_h +#define GraphicsOperation_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "Color.h" +#include "FloatRect.h" +#include "GlyphBuffer.h" +#include "Font.h" +#include "IntRect.h" +#include "PlatformGraphicsContext.h" +#include "PlatformGraphicsContextSkia.h" +#include "SkCanvas.h" +#include "SkShader.h" +#include "SkRefCnt.h" + +#include <utils/threads.h> +#include <wtf/text/CString.h> + +#define TYPE_CASE(type) case type: return #type; + +namespace WebCore { + +namespace GraphicsOperation { + +class Operation : public SkRefCnt { +public: + typedef enum { UndefinedOperation + // State management + , BeginTransparencyLayerOperation + , EndTransparencyLayerOperation + , SaveOperation + , RestoreOperation + // State setters + , SetAlphaOperation + , SetCompositeOpOperation + , SetFillColorOperation + , SetFillShaderOperation + , SetLineCapOperation + , SetLineDashOperation + , SetLineJoinOperation + , SetMiterLimitOperation + , SetShadowOperation + , SetShouldAntialiasOperation + , SetStrokeColorOperation + , SetStrokeShaderOperation + , SetStrokeStyleOperation + , SetStrokeThicknessOperation + // Paint setup + , SetupPaintFillOperation + , SetupPaintShadowOperation + , SetupPaintStrokeOperation + // Matrix operations + , ConcatCTMOperation + , ScaleOperation + , RotateOperation + , TranslateOperation + // Clipping + , InnerRoundedRectClipOperation + , ClipOperation + , ClipPathOperation + , ClipOutOperation + , ClearRectOperation + // Drawing + , DrawBitmapPatternOperation + , DrawBitmapRectOperation + , DrawEllipseOperation + , DrawLineOperation + , DrawLineForTextOperation + , DrawLineForTextCheckingOperation + , DrawRectOperation + , FillPathOperation + , FillRectOperation + , FillRoundedRectOperation + , StrokeArcOperation + , StrokePathOperation + , StrokeRectOperation + // Text + , DrawComplexTextOperation + , DrawTextOperation + } OperationType; + + virtual void apply(PlatformGraphicsContext* context) = 0; + virtual ~Operation() {} + virtual OperationType type() { return UndefinedOperation; } + virtual String parameters() { return ""; } + String name() + { + switch (type()) { + TYPE_CASE(UndefinedOperation) + // State management + TYPE_CASE(BeginTransparencyLayerOperation) + TYPE_CASE(EndTransparencyLayerOperation) + TYPE_CASE(SaveOperation) + TYPE_CASE(RestoreOperation) + // State setters + TYPE_CASE(SetAlphaOperation) + TYPE_CASE(SetCompositeOpOperation) + TYPE_CASE(SetFillColorOperation) + TYPE_CASE(SetFillShaderOperation) + TYPE_CASE(SetLineCapOperation) + TYPE_CASE(SetLineDashOperation) + TYPE_CASE(SetLineJoinOperation) + TYPE_CASE(SetMiterLimitOperation) + TYPE_CASE(SetShadowOperation) + TYPE_CASE(SetShouldAntialiasOperation) + TYPE_CASE(SetStrokeColorOperation) + TYPE_CASE(SetStrokeShaderOperation) + TYPE_CASE(SetStrokeStyleOperation) + TYPE_CASE(SetStrokeThicknessOperation) + // Paint setup + TYPE_CASE(SetupPaintFillOperation) + TYPE_CASE(SetupPaintShadowOperation) + TYPE_CASE(SetupPaintStrokeOperation) + // Matrix operations + TYPE_CASE(ConcatCTMOperation) + TYPE_CASE(ScaleOperation) + TYPE_CASE(RotateOperation) + TYPE_CASE(TranslateOperation) + // Clipping + TYPE_CASE(InnerRoundedRectClipOperation) + TYPE_CASE(ClipOperation) + TYPE_CASE(ClipPathOperation) + TYPE_CASE(ClipOutOperation) + TYPE_CASE(ClearRectOperation) + // Drawing + TYPE_CASE(DrawBitmapPatternOperation) + TYPE_CASE(DrawBitmapRectOperation) + TYPE_CASE(DrawEllipseOperation) + TYPE_CASE(DrawLineOperation) + TYPE_CASE(DrawLineForTextOperation) + TYPE_CASE(DrawLineForTextCheckingOperation) + TYPE_CASE(DrawRectOperation) + TYPE_CASE(FillPathOperation) + TYPE_CASE(FillRectOperation) + TYPE_CASE(FillRoundedRectOperation) + TYPE_CASE(StrokeArcOperation) + TYPE_CASE(StrokePathOperation) + TYPE_CASE(StrokeRectOperation) + // Text + TYPE_CASE(DrawComplexTextOperation) + TYPE_CASE(DrawTextOperation) + } + return "Undefined"; + } +}; + +//************************************** +// State management +//************************************** + +class BeginTransparencyLayer : public Operation { +public: + BeginTransparencyLayer(const float opacity) : m_opacity(opacity) {} + virtual void apply(PlatformGraphicsContext* context) { context->beginTransparencyLayer(m_opacity); } + virtual OperationType type() { return BeginTransparencyLayerOperation; } +private: + float m_opacity; +}; +class EndTransparencyLayer : public Operation { +public: + EndTransparencyLayer() {} + virtual void apply(PlatformGraphicsContext* context) { context->endTransparencyLayer(); } + virtual OperationType type() { return EndTransparencyLayerOperation; } +}; +class Save : public Operation { +public: + virtual void apply(PlatformGraphicsContext* context) { context->save(); } + virtual OperationType type() { return SaveOperation; } +}; +class Restore : public Operation { +public: + virtual void apply(PlatformGraphicsContext* context) { context->restore(); } + virtual OperationType type() { return RestoreOperation; } +}; + +//************************************** +// State setters +//************************************** + +class SetAlpha : public Operation { +public: + SetAlpha(const float alpha) : m_alpha(alpha) {} + virtual void apply(PlatformGraphicsContext* context) { context->setAlpha(m_alpha); } + virtual OperationType type() { return SetAlphaOperation; } +private: + float m_alpha; +}; + +class SetCompositeOperation : public Operation { +public: + SetCompositeOperation(CompositeOperator op) : m_operator(op) {} + virtual void apply(PlatformGraphicsContext* context) { + context->setCompositeOperation(m_operator); + } + virtual OperationType type() { return SetCompositeOpOperation; } +private: + CompositeOperator m_operator; +}; + +class SetFillColor : public Operation { +public: + SetFillColor(Color color) : m_color(color) {} + virtual void apply(PlatformGraphicsContext* context) { + context->setFillColor(m_color); + } + virtual OperationType type() { return SetFillColorOperation; } + virtual String parameters() { + return String::format("r: %d g: %d b: %d a: %d", + m_color.red(), + m_color.green(), + m_color.blue(), + m_color.alpha()); + } +private: + Color m_color; +}; + +class SetFillShader : public Operation { +public: + SetFillShader(SkShader* shader) : m_shader(shader) { + SkSafeRef(m_shader); + } + ~SetFillShader() { SkSafeUnref(m_shader); } + virtual void apply(PlatformGraphicsContext* context) { + context->setFillShader(m_shader); + } + virtual OperationType type() { return SetFillShaderOperation; } +private: + SkShader* m_shader; +}; + +class SetLineCap : public Operation { +public: + SetLineCap(LineCap cap) : m_cap(cap) {} + virtual void apply(PlatformGraphicsContext* context) { + context->setLineCap(m_cap); + } + virtual OperationType type() { return SetLineCapOperation; } +private: + LineCap m_cap; +}; + +class SetLineDash : public Operation { +public: + SetLineDash(const DashArray& dashes, float dashOffset) + : m_dashes(dashes), m_dashOffset(dashOffset) {} + virtual void apply(PlatformGraphicsContext* context) { + context->setLineDash(m_dashes, m_dashOffset); + } + virtual OperationType type() { return SetLineDashOperation; } +private: + DashArray m_dashes; + float m_dashOffset; +}; + +class SetLineJoin : public Operation { +public: + SetLineJoin(LineJoin join) : m_join(join) {} + virtual void apply(PlatformGraphicsContext* context) { + context->setLineJoin(m_join); + } + virtual OperationType type() { return SetLineJoinOperation; } +private: + LineJoin m_join; +}; + +class SetMiterLimit : public Operation { +public: + SetMiterLimit(float limit) : m_limit(limit) {} + virtual void apply(PlatformGraphicsContext* context) { + context->setMiterLimit(m_limit); + } + virtual OperationType type() { return SetMiterLimitOperation; } +private: + float m_limit; +}; + +class SetShadow : public Operation { +public: + SetShadow(int radius, int dx, int dy, SkColor c) + : m_radius(radius), m_dx(dx), m_dy(dy), m_color(c) {} + virtual void apply(PlatformGraphicsContext* context) { + context->setShadow(m_radius, m_dx, m_dy, m_color); + } + virtual OperationType type() { return SetShadowOperation; } +private: + int m_radius; + int m_dx; + int m_dy; + SkColor m_color; +}; + +class SetShouldAntialias : public Operation { +public: + SetShouldAntialias(bool useAA) : m_useAA(useAA) {} + virtual void apply(PlatformGraphicsContext* context) { + context->setShouldAntialias(m_useAA); + } + virtual OperationType type() { return SetShouldAntialiasOperation; } +private: + bool m_useAA; +}; + +class SetStrokeColor : public Operation { +public: + SetStrokeColor(const Color& c) : m_color(c) {} + virtual void apply(PlatformGraphicsContext* context) { + context->setStrokeColor(m_color); + } + virtual OperationType type() { return SetStrokeColorOperation; } +private: + Color m_color; +}; + +class SetStrokeShader : public Operation { +public: + SetStrokeShader(SkShader* strokeShader) : m_shader(strokeShader) { + SkSafeRef(m_shader); + } + ~SetStrokeShader() { SkSafeUnref(m_shader); } + virtual void apply(PlatformGraphicsContext* context) { + context->setStrokeShader(m_shader); + } + virtual OperationType type() { return SetStrokeShaderOperation; } +private: + SkShader* m_shader; +}; + +class SetStrokeStyle : public Operation { +public: + SetStrokeStyle(StrokeStyle style) : m_style(style) {} + virtual void apply(PlatformGraphicsContext* context) { + context->setStrokeStyle(m_style); + } + virtual OperationType type() { return SetStrokeStyleOperation; } +private: + StrokeStyle m_style; +}; + +class SetStrokeThickness : public Operation { +public: + SetStrokeThickness(float thickness) : m_thickness(thickness) {} + virtual void apply(PlatformGraphicsContext* context) { + context->setStrokeThickness(m_thickness); + } + virtual OperationType type() { return SetStrokeThicknessOperation; } +private: + float m_thickness; +}; + +//************************************** +// Paint setup +//************************************** + +class SetupPaintFill : public Operation { +public: + SetupPaintFill(SkPaint* paint) : m_paint(*paint) {} + virtual void apply(PlatformGraphicsContext* context) { + context->setupPaintFill(&m_paint); + } + virtual OperationType type() { return SetupPaintFillOperation; } +private: + SkPaint m_paint; +}; + +class SetupPaintShadow : public Operation { +public: + SetupPaintShadow(SkPaint* paint, SkPoint* offset) + : m_paint(*paint), m_offset(*offset) {} + virtual void apply(PlatformGraphicsContext* context) { + context->setupPaintShadow(&m_paint, &m_offset); + } + virtual OperationType type() { return SetupPaintShadowOperation; } +private: + SkPaint m_paint; + SkPoint m_offset; +}; + +class SetupPaintStroke : public Operation { +public: + SetupPaintStroke(SkPaint* paint, SkRect* rect, bool isHLine) + : m_paint(*paint), m_rect(*rect), m_isHLine(isHLine) {} + virtual void apply(PlatformGraphicsContext* context) { + context->setupPaintStroke(&m_paint, &m_rect, m_isHLine); + } + virtual OperationType type() { return SetupPaintStrokeOperation; } +private: + SkPaint m_paint; + SkRect m_rect; + bool m_isHLine; +}; + +//************************************** +// Matrix operations +//************************************** + +class ConcatCTM : public Operation { +public: + ConcatCTM(const AffineTransform& affine) : m_matrix(affine) {} + virtual void apply(PlatformGraphicsContext* context) { + context->concatCTM(m_matrix); + } + virtual OperationType type() { return ConcatCTMOperation; } +private: + AffineTransform m_matrix; +}; + +class Rotate : public Operation { +public: + Rotate(float angleInRadians) : m_angle(angleInRadians) {} + virtual void apply(PlatformGraphicsContext* context) { + context->rotate(m_angle); + } + virtual OperationType type() { return RotateOperation; } +private: + float m_angle; +}; + +class Scale : public Operation { +public: + Scale(const FloatSize& size) : m_scale(size) {} + virtual void apply(PlatformGraphicsContext* context) { + context->scale(m_scale); + } + virtual OperationType type() { return ScaleOperation; } +private: + FloatSize m_scale; +}; + +class Translate : public Operation { +public: + Translate(float x, float y) : m_x(x), m_y(y) {} + virtual void apply(PlatformGraphicsContext* context) { + context->translate(m_x, m_y); + } + virtual OperationType type() { return TranslateOperation; } +private: + float m_x; + float m_y; +}; + +//************************************** +// Clipping +//************************************** + +class InnerRoundedRectClip : public Operation { +public: + InnerRoundedRectClip(const IntRect& rect, int thickness) + : m_rect(rect), m_thickness(thickness) {} + virtual void apply(PlatformGraphicsContext* context) { + context->addInnerRoundedRectClip(m_rect, m_thickness); + } + virtual OperationType type() { return InnerRoundedRectClipOperation; } +private: + IntRect m_rect; + int m_thickness; +}; + +class Clip : public Operation { +public: + Clip(const FloatRect& rect) : m_rect(rect) {} + virtual void apply(PlatformGraphicsContext* context) { + context->clip(m_rect); + } + virtual OperationType type() { return ClipOperation; } +private: + const FloatRect m_rect; +}; + +class ClipPath : public Operation { +public: + ClipPath(const Path& path, bool clipout = false) + : m_path(path), m_clipOut(clipout), m_hasWindRule(false) {} + void setWindRule(WindRule rule) { m_windRule = rule; m_hasWindRule = true; } + virtual void apply(PlatformGraphicsContext* context) { + if (m_hasWindRule) { + context->clipPath(m_path, m_windRule); + return; + } + if (m_clipOut) + context->clipOut(m_path); + else + context->clip(m_path); + } + virtual OperationType type() { return ClipPathOperation; } +private: + const Path m_path; + bool m_clipOut; + WindRule m_windRule; + bool m_hasWindRule; +}; + +class ClipOut : public Operation { +public: + ClipOut(const IntRect& rect) : m_rect(rect) {} + virtual void apply(PlatformGraphicsContext* context) { + context->clipOut(m_rect); + } + virtual OperationType type() { return ClipOutOperation; } +private: + const IntRect m_rect; +}; + +class ClearRect : public Operation { +public: + ClearRect(const FloatRect& rect) : m_rect(rect) {} + virtual void apply(PlatformGraphicsContext* context) { + context->clearRect(m_rect); + } + virtual OperationType type() { return ClearRectOperation; } +private: + FloatRect m_rect; +}; + +//************************************** +// Drawing +//************************************** + +class DrawBitmapPattern : public Operation { +public: + DrawBitmapPattern(const SkBitmap& bitmap, const SkMatrix& matrix, + CompositeOperator op, const FloatRect& destRect) + : m_bitmap(bitmap), m_matrix(matrix), m_operator(op), m_destRect(destRect) {} + virtual void apply(PlatformGraphicsContext* context) { + context->drawBitmapPattern(m_bitmap, m_matrix, m_operator, m_destRect); + } + virtual OperationType type() { return DrawBitmapPatternOperation; } +private: + // TODO: use refcounted bitmap + const SkBitmap m_bitmap; + SkMatrix m_matrix; + CompositeOperator m_operator; + FloatRect m_destRect; +}; + +class DrawBitmapRect : public Operation { +public: + DrawBitmapRect(const SkBitmap& bitmap, const SkIRect& srcR, + const SkRect& dstR, CompositeOperator op) + : m_bitmap(bitmap), m_srcR(srcR), m_dstR(dstR), m_operator(op) {} + virtual void apply(PlatformGraphicsContext* context) { + context->drawBitmapRect(m_bitmap, &m_srcR, m_dstR, m_operator); + } + virtual OperationType type() { return DrawBitmapRectOperation; } + virtual String parameters() { + return String::format("%.2f, %.2f - %.2f x %.2f", + m_dstR.fLeft, m_dstR.fTop, + m_dstR.width(), m_dstR.height()); + } +private: + const SkBitmap& m_bitmap; + SkIRect m_srcR; + SkRect m_dstR; + CompositeOperator m_operator; +}; + +class DrawEllipse : public Operation { +public: + DrawEllipse(const IntRect& rect) : m_rect(rect) {} + virtual void apply(PlatformGraphicsContext* context) { + context->drawEllipse(m_rect); + } + virtual OperationType type() { return DrawEllipseOperation; } +private: + IntRect m_rect; +}; + +class DrawLine : public Operation { +public: + DrawLine(const IntPoint& point1, const IntPoint& point2) + : m_point1(point1), m_point2(point2) {} + virtual void apply(PlatformGraphicsContext* context) { + context->drawLine(m_point1, m_point2); + } + virtual OperationType type() { return DrawLineOperation; } +private: + IntPoint m_point1; + IntPoint m_point2; +}; + +class DrawLineForText : public Operation { +public: + DrawLineForText(const FloatPoint& pt, float width) + : m_point(pt), m_width(width) {} + virtual void apply(PlatformGraphicsContext* context) { + context->drawLineForText(m_point, m_width); + } + virtual OperationType type() { return DrawLineForTextOperation; } +private: + FloatPoint m_point; + float m_width; +}; + +class DrawLineForTextChecking : public Operation { +public: + DrawLineForTextChecking(const FloatPoint& pt, float width, + GraphicsContext::TextCheckingLineStyle lineStyle) + : m_point(pt), m_width(width), m_lineStyle(lineStyle) {} + virtual void apply(PlatformGraphicsContext* context) { + context->drawLineForTextChecking(m_point, m_width, m_lineStyle); + } + virtual OperationType type() { return DrawLineForTextCheckingOperation; } +private: + FloatPoint m_point; + float m_width; + GraphicsContext::TextCheckingLineStyle m_lineStyle; +}; + +class DrawRect : public Operation { +public: + DrawRect(const IntRect& rect) : m_rect(rect) {} + virtual void apply(PlatformGraphicsContext* context) { + context->drawRect(m_rect); + } + virtual OperationType type() { return DrawRectOperation; } +private: + IntRect m_rect; +}; + +class FillPath : public Operation { +public: + FillPath(const Path& pathToFill, WindRule fillRule) + : m_path(pathToFill), m_fillRule(fillRule) {} + virtual void apply(PlatformGraphicsContext* context) { + context->fillPath(m_path, m_fillRule); + } + virtual OperationType type() { return FillPathOperation; } +private: + Path m_path; + WindRule m_fillRule; +}; + +class FillRect : public Operation { +public: + FillRect(const FloatRect& rect) : m_rect(rect), m_hasColor(false) {} + void setColor(Color c) { m_color = c; m_hasColor = true; } + virtual void apply(PlatformGraphicsContext* context) { + if (m_hasColor) + context->fillRect(m_rect, m_color); + else + context->fillRect(m_rect); + } + virtual OperationType type() { return FillRectOperation; } +private: + FloatRect m_rect; + Color m_color; + bool m_hasColor; +}; + +class FillRoundedRect : public Operation { +public: + FillRoundedRect(const IntRect& rect, + const IntSize& topLeft, + const IntSize& topRight, + const IntSize& bottomLeft, + const IntSize& bottomRight, + const Color& color) + : m_rect(rect) + , m_topLeft(topLeft) + , m_topRight(topRight) + , m_bottomLeft(bottomLeft) + , m_bottomRight(bottomRight) + , m_color(color) + {} + virtual void apply(PlatformGraphicsContext* context) { + context->fillRoundedRect(m_rect, m_topLeft, m_topRight, + m_bottomLeft, m_bottomRight, + m_color); + } + virtual OperationType type() { return FillRoundedRectOperation; } +private: + IntRect m_rect; + IntSize m_topLeft; + IntSize m_topRight; + IntSize m_bottomLeft; + IntSize m_bottomRight; + Color m_color; +}; + +class StrokeArc : public Operation { +public: + StrokeArc(const IntRect& r, int startAngle, int angleSpan) + : m_rect(r) + , m_startAngle(startAngle) + , m_angleSpan(angleSpan) + {} + virtual void apply(PlatformGraphicsContext* context) { + context->strokeArc(m_rect, m_startAngle, m_angleSpan); + } + virtual OperationType type() { return StrokeArcOperation; } +private: + IntRect m_rect; + int m_startAngle; + int m_angleSpan; +}; + +class StrokePath : public Operation { +public: + StrokePath(const Path& path) : m_path(path) {} + virtual void apply(PlatformGraphicsContext* context) { + context->strokePath(m_path); + } + virtual OperationType type() { return StrokePathOperation; } +private: + Path m_path; +}; + + +class StrokeRect : public Operation { +public: + StrokeRect(const FloatRect& rect, float lineWidth) + : m_rect(rect), m_lineWidth(lineWidth) {} + virtual void apply(PlatformGraphicsContext* context) { + context->strokeRect(m_rect, m_lineWidth); + } + virtual OperationType type() { return StrokeRectOperation; } +private: + FloatRect m_rect; + float m_lineWidth; +}; + +//************************************** +// Text +//************************************** + +class DrawComplexText : public Operation { +public: + DrawComplexText(SkPicture* picture) : m_picture(picture) { + SkSafeRef(m_picture); + } + ~DrawComplexText() { SkSafeUnref(m_picture); } + virtual void apply(PlatformGraphicsContext* context) { + if (!context->getCanvas()) + return; + context->getCanvas()->drawPicture(*m_picture); + } + virtual OperationType type() { return DrawComplexTextOperation; } +private: + SkPicture* m_picture; +}; + +class DrawText : public Operation { +public: + DrawText(const Font* font, const SimpleFontData* simpleFont, + const GlyphBuffer& glyphBuffer, + int from, int numGlyphs, const FloatPoint& point) + : m_font(font), m_simpleFont(simpleFont) + , m_glyphBuffer(glyphBuffer), m_from(from) + , m_numGlyphs(numGlyphs), m_point(point) { + + SkPicture* picture = new SkPicture(); + SkCanvas* canvas = picture->beginRecording(0, 0, 0); + PlatformGraphicsContextSkia platformContext(canvas); + GraphicsContext graphicsContext(&platformContext); + m_font->drawGlyphs(&graphicsContext, m_simpleFont, + m_glyphBuffer, m_from, m_numGlyphs, m_point); + picture->endRecording(); + m_picture = picture; + } + ~DrawText() { SkSafeUnref(m_picture); } + virtual void apply(PlatformGraphicsContext* context) { + if (!context->getCanvas()) + return; + context->getCanvas()->drawPicture(*m_picture); + } + virtual OperationType type() { return DrawTextOperation; } +private: + SkPicture* m_picture; + const Font* m_font; + const SimpleFontData* m_simpleFont; + const GlyphBuffer m_glyphBuffer; + int m_from; + int m_numGlyphs; + const FloatPoint m_point; +}; + +} + +} + +#endif // USE(ACCELERATED_COMPOSITING) + +#endif // GraphicsOperation_h |