forked from chromium/chromium
-
Notifications
You must be signed in to change notification settings - Fork 0
/
paint_canvas.h
207 lines (176 loc) · 7.19 KB
/
paint_canvas.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CC_PAINT_PAINT_CANVAS_H_
#define CC_PAINT_PAINT_CANVAS_H_
#include "base/compiler_specific.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "build/build_config.h"
#include "cc/paint/paint_export.h"
#include "cc/paint/paint_image.h"
#include "cc/paint/paint_text_blob.h"
#include "third_party/skia/include/core/SkCanvas.h"
namespace cc {
class PaintFlags;
class PaintOpBuffer;
using PaintRecord = PaintOpBuffer;
class CC_PAINT_EXPORT PaintCanvas {
public:
PaintCanvas() {}
virtual ~PaintCanvas() {}
virtual SkMetaData& getMetaData() = 0;
// TODO(enne): this only appears to mostly be used to determine if this is
// recording or not, so could be simplified or removed.
virtual SkImageInfo imageInfo() const = 0;
// TODO(enne): It would be nice to get rid of flush() entirely, as it
// doesn't really make sense for recording. However, this gets used by
// PaintCanvasVideoRenderer which takes a PaintCanvas to paint both
// software and hardware video. This is super entangled with ImageBuffer
// and canvas/video painting in Blink where the same paths are used for
// both recording and gpu work.
virtual void flush() = 0;
virtual int save() = 0;
virtual int saveLayer(const SkRect* bounds, const PaintFlags* flags) = 0;
virtual int saveLayerAlpha(const SkRect* bounds,
uint8_t alpha,
bool preserve_lcd_text_requests) = 0;
virtual void restore() = 0;
virtual int getSaveCount() const = 0;
virtual void restoreToCount(int save_count) = 0;
virtual void translate(SkScalar dx, SkScalar dy) = 0;
virtual void scale(SkScalar sx, SkScalar sy) = 0;
virtual void rotate(SkScalar degrees) = 0;
virtual void concat(const SkMatrix& matrix) = 0;
virtual void setMatrix(const SkMatrix& matrix) = 0;
virtual void clipRect(const SkRect& rect,
SkClipOp op,
bool do_anti_alias) = 0;
void clipRect(const SkRect& rect, SkClipOp op) { clipRect(rect, op, false); }
void clipRect(const SkRect& rect, bool do_anti_alias) {
clipRect(rect, SkClipOp::kIntersect, do_anti_alias);
}
void clipRect(const SkRect& rect) {
clipRect(rect, SkClipOp::kIntersect, false);
}
virtual void clipRRect(const SkRRect& rrect,
SkClipOp op,
bool do_anti_alias) = 0;
void clipRRect(const SkRRect& rrect, bool do_anti_alias) {
clipRRect(rrect, SkClipOp::kIntersect, do_anti_alias);
}
void clipRRect(const SkRRect& rrect, SkClipOp op) {
clipRRect(rrect, op, false);
}
void clipRRect(const SkRRect& rrect) {
clipRRect(rrect, SkClipOp::kIntersect, false);
}
virtual void clipPath(const SkPath& path,
SkClipOp op,
bool do_anti_alias) = 0;
void clipPath(const SkPath& path, SkClipOp op) { clipPath(path, op, false); }
void clipPath(const SkPath& path, bool do_anti_alias) {
clipPath(path, SkClipOp::kIntersect, do_anti_alias);
}
virtual SkRect getLocalClipBounds() const = 0;
virtual bool getLocalClipBounds(SkRect* bounds) const = 0;
virtual SkIRect getDeviceClipBounds() const = 0;
virtual bool getDeviceClipBounds(SkIRect* bounds) const = 0;
virtual void drawColor(SkColor color, SkBlendMode mode) = 0;
void drawColor(SkColor color) { drawColor(color, SkBlendMode::kSrcOver); }
// TODO(enne): This is a synonym for drawColor with kSrc. Remove it.
virtual void clear(SkColor color) = 0;
virtual void drawLine(SkScalar x0,
SkScalar y0,
SkScalar x1,
SkScalar y1,
const PaintFlags& flags) = 0;
virtual void drawRect(const SkRect& rect, const PaintFlags& flags) = 0;
virtual void drawIRect(const SkIRect& rect, const PaintFlags& flags) = 0;
virtual void drawOval(const SkRect& oval, const PaintFlags& flags) = 0;
virtual void drawRRect(const SkRRect& rrect, const PaintFlags& flags) = 0;
virtual void drawDRRect(const SkRRect& outer,
const SkRRect& inner,
const PaintFlags& flags) = 0;
virtual void drawRoundRect(const SkRect& rect,
SkScalar rx,
SkScalar ry,
const PaintFlags& flags) = 0;
virtual void drawPath(const SkPath& path, const PaintFlags& flags) = 0;
virtual void drawImage(const PaintImage& image,
SkScalar left,
SkScalar top,
const PaintFlags* flags) = 0;
void drawImage(const PaintImage& image, SkScalar left, SkScalar top) {
drawImage(image, left, top, nullptr);
}
enum SrcRectConstraint {
kStrict_SrcRectConstraint = SkCanvas::kStrict_SrcRectConstraint,
kFast_SrcRectConstraint = SkCanvas::kFast_SrcRectConstraint,
};
virtual void drawImageRect(const PaintImage& image,
const SkRect& src,
const SkRect& dst,
const PaintFlags* flags,
SrcRectConstraint constraint) = 0;
virtual void drawBitmap(const SkBitmap& bitmap,
SkScalar left,
SkScalar top,
const PaintFlags* flags) = 0;
void drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top) {
drawBitmap(bitmap, left, top, nullptr);
}
virtual void drawTextBlob(scoped_refptr<PaintTextBlob> blob,
SkScalar x,
SkScalar y,
const PaintFlags& flags) = 0;
// Unlike SkCanvas::drawPicture, this only plays back the PaintRecord and does
// not add an additional clip. This is closer to SkPicture::playback.
virtual void drawPicture(sk_sp<const PaintRecord> record) = 0;
virtual bool isClipEmpty() const = 0;
virtual bool isClipRect() const = 0;
virtual const SkMatrix& getTotalMatrix() const = 0;
enum class AnnotationType {
URL,
NAMED_DESTINATION,
LINK_TO_DESTINATION,
};
virtual void Annotate(AnnotationType type,
const SkRect& rect,
sk_sp<SkData> data) = 0;
private:
DISALLOW_COPY_AND_ASSIGN(PaintCanvas);
};
class CC_PAINT_EXPORT PaintCanvasAutoRestore {
public:
PaintCanvasAutoRestore(PaintCanvas* canvas, bool save) : canvas_(canvas) {
if (canvas_) {
save_count_ = canvas_->getSaveCount();
if (save) {
canvas_->save();
}
}
}
~PaintCanvasAutoRestore() {
if (canvas_) {
canvas_->restoreToCount(save_count_);
}
}
void restore() {
if (canvas_) {
canvas_->restoreToCount(save_count_);
canvas_ = nullptr;
}
}
private:
PaintCanvas* canvas_ = nullptr;
int save_count_ = 0;
};
// Following routines are used in print preview workflow to mark the
// preview metafile.
#if defined(OS_MACOSX)
CC_PAINT_EXPORT void SetIsPreviewMetafile(PaintCanvas* canvas, bool is_preview);
CC_PAINT_EXPORT bool IsPreviewMetafile(PaintCanvas* canvas);
#endif
} // namespace cc
#endif // CC_PAINT_PAINT_CANVAS_H_