# CLASS_GRAPH = YES
# COLLABORATION_GRAPH = YES
# UML_LOOK = YES
-# GRAPHICAL_HIERARCHY = YES
+# GRAPHICAL_HIERARCHY = YES
-# Make SkDEBUGCODE disappear, but not SK_OVERRIDE.
+# Make SkDEBUGCODE disappear.
ENABLE_PREPROCESSING = YES
MACRO_EXPANSION = YES
EXPAND_ONLY_PREDEF = YES
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
}
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(false);
paint.setFilterQuality(kLow_SkFilterQuality);
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- SkIPoint onGetSize() SK_OVERRIDE {
+ SkIPoint onGetSize() override {
return SkIPoint::Make(640, 100);
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
make_path(fPath);
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
INHERITED::onDraw(loops, canvas);
}
- void setupPaint(SkPaint* paint) SK_OVERRIDE {
+ void setupPaint(SkPaint* paint) override {
this->INHERITED::setupPaint(paint);
int index = 0;
return fFullName.c_str();
}
- void onDrawIntoBitmap(const SkBitmap& bm) SK_OVERRIDE {
+ void onDrawIntoBitmap(const SkBitmap& bm) override {
const int w = bm.width();
const int h = bm.height();
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
fName.printf("bitmaprect_%02X_%sfilter_%s",
fAlpha,
kNone_SkFilterQuality == fFilterQuality ? "no" : "",
return fName.c_str();
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
fBitmap.allocPixels();
fBitmap.setAlphaType(kOpaque_SkAlphaType);
fBitmap.eraseColor(SK_ColorBLACK);
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkRandom rand;
SkPaint paint;
return float(outputSize())/inputSize();
}
- SkIPoint onGetSize() SK_OVERRIDE {
+ SkIPoint onGetSize() override {
return SkIPoint::Make( fOutputSize, fOutputSize );
}
setName( "filter" );
}
protected:
- void doScaleImage() SK_OVERRIDE {
+ void doScaleImage() override {
SkCanvas canvas( fOutputBitmap );
SkPaint paint;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
if (!fInitialized) {
make_checkerboard();
fInitialized = true;
}
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPaint paint;
paint.setImageFilter(SkBlurImageFilter::Create(fSigmaX, fSigmaY))->unref();
this->setName(name);
}
protected:
- void makeBlurryRect(const SkRect& r) SK_OVERRIDE {
+ void makeBlurryRect(const SkRect& r) override {
SkMask mask;
SkBlurMask::BlurRect(SkBlurMask::ConvertRadiusToSigma(this->radius()),
&mask, r, kNormal_SkBlurStyle);
}
protected:
- void preBenchSetup(const SkRect& r) SK_OVERRIDE {
+ void preBenchSetup(const SkRect& r) override {
SkMask::FreeImage(fSrcMask.fImage);
r.roundOut(&fSrcMask.fBounds);
protected:
- void makeBlurryRect(const SkRect&) SK_OVERRIDE {
+ void makeBlurryRect(const SkRect&) override {
SkMask mask;
mask.fImage = NULL;
SkBlurMask::BoxBlur(&mask, fSrcMask, SkBlurMask::ConvertRadiusToSigma(this->radius()),
protected:
- void makeBlurryRect(const SkRect&) SK_OVERRIDE {
+ void makeBlurryRect(const SkRect&) override {
SkMask mask;
mask.fImage = NULL;
SkBlurMask::BlurGroundTruth(SkBlurMask::ConvertRadiusToSigma(this->radius()),
fInner = inner;
}
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
fName = name;
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPaint paint;
paint.setMaskFilter(SkBlurMaskFilter::Create(kNormal_SkBlurStyle, fRadius))->unref();
fRRect.setRectXY(r, SkIntToScalar(cornerRadius), SkIntToScalar(cornerRadius));
}
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- SkIPoint onGetSize() SK_OVERRIDE {
+ SkIPoint onGetSize() override {
return SkIPoint::Make(SkScalarCeilToInt(fRRect.rect().width()),
SkScalarCeilToInt(fRRect.rect().height()));
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkLayerDrawLooper::Builder looperBuilder;
{
SkLayerDrawLooper::LayerInfo info;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
if (fAA) {
return "chart_aa";
} else {
}
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
bool sizeChanged = false;
if (canvas->getDeviceSize() != fSize) {
fSize = canvas->getDeviceSize();
}
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
fProc(loops, fPaint, fText, sizeof(fText), NGLYPHS);
}
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return "colorcube";
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
if (!SkToBool(fCubeData)) {
this->makeCubeData();
this->make_bitmap();
}
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
this->test(loops, canvas);
}
- SkIPoint onGetSize() SK_OVERRIDE {
+ SkIPoint onGetSize() override {
return SkIPoint::Make(fSize.width(), fSize.height());
}
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return isSmall() ? "colorfilter_dim_bright_small" : "colorfilter_dim_bright_large";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkRect r = getFilterRect();
SkPaint paint;
paint.setColor(SK_ColorRED);
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return isSmall() ? "colorfilter_bright_gray_small" : "colorfilter_bright_gray_large";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkRect r = getFilterRect();
SkPaint paint;
paint.setColor(SK_ColorRED);
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return isSmall() ? "colorfilter_gray_bright_small" : "colorfilter_gray_bright_large";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkRect r = getFilterRect();
SkPaint paint;
paint.setColor(SK_ColorRED);
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return isSmall() ? "colorfilter_blue_bright_small" : "colorfilter_blue_bright_large";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkRect r = getFilterRect();
SkPaint paint;
paint.setColor(SK_ColorRED);
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return isSmall() ? "colorfilter_bright_blue_small" : "colorfilter_bright_blue_large";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkRect r = getFilterRect();
SkPaint paint;
paint.setColor(SK_ColorRED);
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return isSmall() ? "colorfilter_bright_small" : "colorfilter_bright_large";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkRect r = getFilterRect();
SkPaint paint;
paint.setColor(SK_ColorRED);
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return isSmall() ? "colorfilter_blue_small" : "colorfilter_blue_large";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkRect r = getFilterRect();
SkPaint paint;
paint.setColor(SK_ColorRED);
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return isSmall() ? "colorfilter_gray_small" : "colorfilter_gray_large";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkRect r = getFilterRect();
SkPaint paint;
paint.setColor(SK_ColorRED);
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return isSmall() ? "table_colorfilter_small" : "table_colorfilter_large";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkRect r = getFilterRect();
SkPaint paint;
paint.setColor(SK_ColorRED);
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return isSmall() ? "luma_colorfilter_small" : "luma_colorfilter_large";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkRect r = getFilterRect();
SkPaint paint;
paint.setColor(SK_ColorRED);
fName.append(kScale ? "_255" : "_256");
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
- const char* onGetName() SK_OVERRIDE { return fName.c_str(); }
+ const char* onGetName() override { return fName.c_str(); }
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
// A handful of random srcs and dsts.
SkRandom rand;
for (int i = 0; i < kInputs; i++) {
if (kScale) fScales[256] = 255; // We'll just do 255 twice if we're limited to [0,255].
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
// We xor results of FourByteInterp into junk to make sure the function runs.
volatile SkPMColor junk = 0;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
if (fDrawCoverage) {
for (int i = 0; i < loops; ++i) {
fDraw.drawPathCoverage(fPath, fPaint);
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPaint paint;
this->setupPaint(&paint);
paint.setStyle(SkPaint::kStroke_Style);
protected:
virtual void handlePath(SkCanvas* canvas, const SkPath& path,
- const SkPaint& paint, int N) SK_OVERRIDE {
+ const SkPaint& paint, int N) override {
SkPoint pts[2];
if (!path.isLine(pts) || pts[0].fY != pts[1].fY) {
this->INHERITED::handlePath(canvas, path, paint, N);
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
SkPath dst;
for (int i = 0; i < loops; ++i) {
SkStrokeRec rec(SkStrokeRec::kHairline_InitStyle);
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPaint paint;
this->setupPaint(&paint);
paint.setStrokeWidth(fStrokeWidth);
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPaint p;
this->setupPaint(&p);
p.setColor(SK_ColorBLACK);
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPaint p;
this->setupPaint(&p);
p.setStyle(SkPaint::kStroke_Style);
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPaint p;
this->setupPaint(&p);
p.setColor(SK_ColorBLACK);
DecodingBench(SkString path, SkColorType colorType);
protected:
- const char* onGetName() SK_OVERRIDE;
- bool isSuitableFor(Backend backend) SK_OVERRIDE;
- void onDraw(const int n, SkCanvas* canvas) SK_OVERRIDE;
+ const char* onGetName() override;
+ bool isSuitableFor(Backend backend) override;
+ void onDraw(const int n, SkCanvas* canvas) override;
private:
SkString fName;
const int divisor);
protected:
- const char* onGetName() SK_OVERRIDE;
- bool isSuitableFor(Backend backend) SK_OVERRIDE;
- void onDraw(const int n, SkCanvas* canvas) SK_OVERRIDE;
+ const char* onGetName() override;
+ bool isSuitableFor(Backend backend) override;
+ void onDraw(const int n, SkCanvas* canvas) override;
private:
SkString fName;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fDiscardableContents ? "DeferredSurfaceCopy_discardable" :
"DeferredSurfaceCopy_nonDiscardable";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
// The canvas is not actually used for this test except to provide
// configuration information: gpu, multisampling, size, etc?
SkImageInfo info = SkImageInfo::MakeN32Premul(kSurfaceWidth, kSurfaceHeight);
}
protected:
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
if (!fInitialized) {
this->makeBitmap();
this->makeCheckerboard();
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return this->isSmall() ? "displacement_zero_small" : "displacement_zero_large";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPaint paint;
SkAutoTUnref<SkImageFilter> displ(SkBitmapSource::Create(fCheckerboard));
// No displacement effect
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return isSmall() ? "displacement_alpha_small" : "displacement_alpha_large";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPaint paint;
SkAutoTUnref<SkImageFilter> displ(SkBitmapSource::Create(fCheckerboard));
// Displacement, with 1 alpha component (which isn't pre-multiplied)
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return isSmall() ? "displacement_full_small" : "displacement_full_large";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPaint paint;
SkAutoTUnref<SkImageFilter> displ(SkBitmapSource::Create(fCheckerboard));
// Displacement, with 2 non-alpha components
ETCBitmapBench(bool decompress, Backend backend)
: fDecompress(decompress), fBackend(backend) { }
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == this->fBackend;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
if (kGPU_Backend == this->fBackend) {
if (this->fDecompress) {
return "etc1bitmap_render_gpu_decompressed";
}
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
if (NULL == fPKMData) {
SkDebugf("Failed to load PKM data!\n");
return;
}
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
for (int i = 0; i < loops; ++i) {
canvas->drawBitmap(this->fBitmap, 0, 0, NULL);
}
: ETCBitmapBench(decompress, backend) { }
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
if (kGPU_Backend == this->backend()) {
if (this->decompress()) {
return "etc1bitmap_upload_gpu_decompressed";
}
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPixelRef* pr = fBitmap.pixelRef();
for (int i = 0; i < loops; ++i) {
if (pr) {
FSRectBench() : fInit(false) { }
protected:
- const char* onGetName() SK_OVERRIDE { return "fullscreen_rects"; }
+ const char* onGetName() override { return "fullscreen_rects"; }
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
if (!fInit) {
SkRandom rand;
static const SkScalar kMinOffset = 0;
}
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPaint paint;
for (int i = 0; i < loops; ++i) {
paint.setColor(fColors[i % N]);
FontCacheBench() {}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return "fontcache";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPaint paint;
this->setupPaint(&paint);
paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return "fontefficiency";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
static bool gDone;
if (gDone) {
return;
virtual ~GMBench();
protected:
- const char* onGetName() SK_OVERRIDE;
- bool isSuitableFor(Backend backend) SK_OVERRIDE;
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE;
- SkIPoint onGetSize() SK_OVERRIDE;
+ const char* onGetName() override;
+ bool isSuitableFor(Backend backend) override;
+ void onDraw(const int loops, SkCanvas* canvas) override;
+ SkIPoint onGetSize() override;
private:
skiagm::GM* fGM;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
if (!fInitialized) {
this->makeCheckerboard();
this->makeAtlas();
}
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkRandom scaleRand;
SkRandom transRand;
SkRandom rotRand;
fName.printf("geo_%s", suffix);
}
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return kNonRendering_Backend == backend;
}
GeoRectBench_intersect() : GeoRectBench("rect_intersect") {}
protected:
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
for (int outer = 0; outer < loops; ++outer) {
int count = 0;
for (size_t i = 0; i < SK_ARRAY_COUNT(fRects); ++i) {
GeoRectBench_intersect_rect() : GeoRectBench("rect_intersect_rect") {}
protected:
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
for (int outer = 0; outer < loops; ++outer) {
int count = 0;
SkRect r;
GeoRectBench_Intersects() : GeoRectBench("rect_Intersects") {}
protected:
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
for (int outer = 0; outer < loops; ++outer) {
int count = 0;
for (size_t i = 0; i < SK_ARRAY_COUNT(fRects); ++i) {
GeoRectBench_sort() : GeoRectBench("rect_sort") {}
protected:
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
for (int outer = 0; outer < loops; ++outer) {
for (size_t i = 0; i < SK_ARRAY_COUNT(fRects); ++i) {
fRects[i].sort();
public:
EvalQuadAt0() : QuadBenchBase("evalquadat0") {}
protected:
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPoint result;
for (int outer = 0; outer < loops; ++outer) {
SkEvalQuadAt(fPts, 0.5f, &result);
public:
EvalQuadAt1() : QuadBenchBase("evalquadat1") {}
protected:
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPoint result;
for (int outer = 0; outer < loops; ++outer) {
result = SkEvalQuadAt(fPts, 0.5f);
public:
EvalQuadTangentAt0() : QuadBenchBase("evalquadtangentat0") {}
protected:
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPoint result;
for (int outer = 0; outer < loops; ++outer) {
SkEvalQuadAt(fPts, 0.5f, NULL, &result);
public:
EvalQuadTangentAt1() : QuadBenchBase("evalquadtangentat1") {}
protected:
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPoint result;
for (int outer = 0; outer < loops; ++outer) {
result = SkEvalQuadTangentAt(fPts, 0.5f);
public:
ChopQuadAt0() : QuadBenchBase("chopquadat0") {}
protected:
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPoint dst[5];
for (int outer = 0; outer < loops; ++outer) {
SkChopQuadAt(fPts, dst, 0.5f);
public:
ChopQuadAt1() : QuadBenchBase("chopquadat1") {}
protected:
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPoint dst[5];
for (int outer = 0; outer < loops; ++outer) {
SkChopQuadAt2(fPts, dst, 0.5f);
public:
ChopCubicAt0() : QuadBenchBase("chopcubicat0") {}
protected:
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPoint dst[7];
for (int outer = 0; outer < loops; ++outer) {
SkChopCubicAt(fPts, dst, 0.5f);
public:
ChopCubicAt1() : QuadBenchBase("chopcubicat1") {}
protected:
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPoint dst[7];
for (int outer = 0; outer < loops; ++outer) {
SkChopCubicAt2(fPts, dst, 0.5f);
*/
class GrMemoryPoolBenchStack : public Benchmark {
public:
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
*/
class GrMemoryPoolBenchRandom : public Benchmark {
public:
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
M = 4 * (1 << 10),
};
public:
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
fName.append("ordered_set_build");
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return kNonRendering_Backend == backend;
}
virtual ~GrOrderedSetBuildBench() {}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
SkRandom rand;
for (int j = 0; j < NUM_ELEMENTS; ++j) {
fData[j] = rand.nextU() % NUM_ELEMENTS;
}
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
for (int i = 0; i < loops; ++i) {
GrOrderedSet<int> set;
for (int j = 0; j < NUM_ELEMENTS; ++j) {
fName.append("ordered_set_find");
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return kNonRendering_Backend == backend;
}
virtual ~GrOrderedSetFindBench() {}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
SkRandom rand;
for (int j = 0; j < NUM_ELEMENTS; ++j) {
fData[j] = rand.nextU() % 1500;
}
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
for (int i = 0; i < loops; ++i) {
for (int j = 0; j < NUM_ELEMENTS; ++j) {
fSet.find(fData[j]);
fName.append("ordered_set_remove");
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return kNonRendering_Backend == backend;
}
virtual ~GrOrderedSetRemoveBench() {}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
SkRandom rand;
for (int j = 0; j < NUM_ELEMENTS; ++j) {
fSet.insert(rand.nextU() % NUM_ELEMENTS);
}
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
typedef GrOrderedSet<int>::Iter SetIter;
for (int i = 0; i < loops; ++i) {
GrOrderedSet<int> testSet;
}
private:
- size_t onGpuMemorySize() const SK_OVERRIDE { return 100; }
+ size_t onGpuMemorySize() const override { return 100; }
typedef GrGpuResource INHERITED;
};
class GrResourceCacheBenchAdd : public Benchmark {
public:
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return "grresourcecache_add";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkAutoTUnref<GrContext> context(GrContext::CreateMockContext());
if (NULL == context) {
return;
class GrResourceCacheBenchFind : public Benchmark {
public:
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return "grresourcecache_find";
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
fContext.reset(GrContext::CreateMockContext());
if (!fContext) {
return;
populate_cache(gpu, CACHE_SIZE_COUNT);
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
if (!fContext) {
return;
}
virtual void makePath(SkPath*) = 0;
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
fName.printf("path_hairline_%s_%s_",
fFlags & kBig_Flag ? "big" : "small",
fFlags & kAA_Flag ? "AA" : "noAA");
return fName.c_str();
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPaint paint(fPaint);
this->setupPaint(&paint);
public:
LinePathBench(Flags flags) : INHERITED(flags) {}
- void appendName(SkString* name) SK_OVERRIDE {
+ void appendName(SkString* name) override {
name->append("line");
}
- void makePath(SkPath* path) SK_OVERRIDE {
+ void makePath(SkPath* path) override {
SkRandom rand;
int size = SK_ARRAY_COUNT(points);
int hSize = size / 2;
public:
QuadPathBench(Flags flags) : INHERITED(flags) {}
- void appendName(SkString* name) SK_OVERRIDE {
+ void appendName(SkString* name) override {
name->append("quad");
}
- void makePath(SkPath* path) SK_OVERRIDE {
+ void makePath(SkPath* path) override {
SkRandom rand;
int size = SK_ARRAY_COUNT(points);
int hSize = size / 2;
public:
ConicPathBench(Flags flags) : INHERITED(flags) {}
- void appendName(SkString* name) SK_OVERRIDE {
+ void appendName(SkString* name) override {
name->append("conic");
}
- void makePath(SkPath* path) SK_OVERRIDE {
+ void makePath(SkPath* path) override {
SkRandom rand;
SkRandom randWeight;
int size = SK_ARRAY_COUNT(points);
public:
CubicPathBench(Flags flags) : INHERITED(flags) {}
- void appendName(SkString* name) SK_OVERRIDE {
+ void appendName(SkString* name) override {
name->append("cubic");
}
- void makePath(SkPath* path) SK_OVERRIDE {
+ void makePath(SkPath* path) override {
SkRandom rand;
int size = SK_ARRAY_COUNT(points);
int hSize = size / 2;
TestRec(const TestKey& key, intptr_t value) : fKey(key), fValue(value) {}
- const Key& getKey() const SK_OVERRIDE { return fKey; }
- size_t bytesUsed() const SK_OVERRIDE { return sizeof(fKey) + sizeof(fValue); }
+ const Key& getKey() const override { return fKey; }
+ size_t bytesUsed() const override { return sizeof(fKey) + sizeof(fValue); }
static bool Visitor(const SkResourceCache::Rec&, void*) {
return true;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return "imagecache";
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
if (fCache.getTotalBytesUsed() == 0) {
this->populateCache();
}
}
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
makeBitmap();
for(int i = 0; i < loops; i++) {
virtual ~TableCollapseBench() {}
protected:
- virtual const char* onGetName() SK_OVERRIDE {
+ virtual const char* onGetName() override {
return "image_filter_collapse_table";
}
- virtual void onPreDraw() SK_OVERRIDE {
+ virtual void onPreDraw() override {
for (int i = 0; i < 256; ++i) {
int n = i >> 5;
table1[i] = (n << 5) | (n << 2) | (n >> 1);
virtual ~MatrixCollapseBench() {}
protected:
- virtual const char* onGetName() SK_OVERRIDE {
+ virtual const char* onGetName() override {
return "image_filter_collapse_matrix";
}
- virtual void onPreDraw() SK_OVERRIDE {
+ virtual void onPreDraw() override {
SkColorFilter* colorFilters[] = {
make_brightness(0.1f),
make_grayscale(),
ImageFilterDAGBench() {}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return "image_filter_dag";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
for (int j = 0; j < loops; j++) {
SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(20.0f, 20.0f));
SkImageFilter* inputs[kNumInputs];
fDx = 0.1257f;
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
Fixed16D16Interp() : INHERITED("16.16") {}
protected:
- void performTest(int16_t dst[], float fx, float dx, int count) SK_OVERRIDE {
+ void performTest(int16_t dst[], float fx, float dx, int count) override {
SkFixed curr = SkFloatToFixed(fx);
SkFixed step = SkFloatToFixed(dx);
for (int i = 0; i < count; i += 4) {
Fixed32D32Interp() : INHERITED("32.32") {}
protected:
- void performTest(int16_t dst[], float fx, float dx, int count) SK_OVERRIDE {
+ void performTest(int16_t dst[], float fx, float dx, int count) override {
int64_t curr = (int64_t)(fx * 65536 * 655536);
int64_t step = (int64_t)(dx * 65536 * 655536);
SkFixed tmp;
Fixed16D48Interp() : INHERITED("16.48") {}
protected:
- void performTest(int16_t dst[], float fx, float dx, int count) SK_OVERRIDE {
+ void performTest(int16_t dst[], float fx, float dx, int count) override {
int64_t curr = (int64_t)(fx * 65536 * 655536 * 65536);
int64_t step = (int64_t)(dx * 65536 * 655536 * 65536);
SkFixed tmp;
FloatInterp() : INHERITED("float") {}
protected:
- void performTest(int16_t dst[], float fx, float dx, int count) SK_OVERRIDE {
+ void performTest(int16_t dst[], float fx, float dx, int count) override {
SkFixed tmp;
for (int i = 0; i < count; i += 4) {
tmp = SkFloatToFixed(fx); dst[i + 0] = TILE(tmp, count); fx += dx;
DoubleInterp() : INHERITED("double") {}
protected:
- void performTest(int16_t dst[], float fx, float dx, int count) SK_OVERRIDE {
+ void performTest(int16_t dst[], float fx, float dx, int count) override {
double ffx = fx;
double ddx = dx;
SkFixed tmp;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fIsSmall ? "lightingpointlitdiffuse_small" : "lightingpointlitdiffuse_large";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
draw(loops, canvas, SkLightingImageFilter::CreatePointLitDiffuse(getPointLocation(),
getWhite(),
getSurfaceScale(),
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fIsSmall ? "lightingdistantlitdiffuse_small" : "lightingdistantlitdiffuse_large";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
draw(loops, canvas, SkLightingImageFilter::CreateDistantLitDiffuse(getDistantDirection(),
getWhite(),
getSurfaceScale(),
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fIsSmall ? "lightingspotlitdiffuse_small" : "lightingspotlitdiffuse_large";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
draw(loops, canvas, SkLightingImageFilter::CreateSpotLitDiffuse(getSpotLocation(),
getSpotTarget(),
getSpotExponent(),
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fIsSmall ? "lightingpointlitspecular_small" : "lightingpointlitspecular_large";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
draw(loops, canvas, SkLightingImageFilter::CreatePointLitSpecular(getPointLocation(),
getWhite(),
getSurfaceScale(),
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fIsSmall ? "lightingdistantlitspecular_small" : "lightingdistantlitspecular_large";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
draw(loops, canvas, SkLightingImageFilter::CreateDistantLitSpecular(getDistantDirection(),
getWhite(),
getSurfaceScale(),
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fIsSmall ? "lightingspotlitspecular_small" : "lightingspotlitspecular_large";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
draw(loops, canvas, SkLightingImageFilter::CreateSpotLitSpecular(getSpotLocation(),
getSpotTarget(),
getSpotExponent(),
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPaint paint;
this->setupPaint(&paint);
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fIsSmall ? "magnifier_small" : "magnifier_large";
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
if (!fInitialized) {
make_checkerboard();
fInitialized = true;
}
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
const int w = fIsSmall ? FILTER_WIDTH_SMALL : FILTER_WIDTH_LARGE;
const int h = fIsSmall ? FILTER_HEIGHT_SMALL : FILTER_HEIGHT_LARGE;
SkPaint paint;
}
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
virtual void performTest(float* SK_RESTRICT dst,
const float* SK_RESTRICT src,
- int count) SK_OVERRIDE {
+ int count) override {
uint32_t* d = SkTCast<uint32_t*>(dst);
const uint32_t* s = SkTCast<const uint32_t*>(src);
this->performITest(d, s, count);
protected:
virtual void performITest(uint32_t* SK_RESTRICT dst,
const uint32_t* SK_RESTRICT src,
- int count) SK_OVERRIDE {
+ int count) override {
for (int i = 0; i < count; ++i) {
dst[i] = QMul64(src[i], (uint8_t)i);
}
protected:
virtual void performITest(uint32_t* SK_RESTRICT dst,
const uint32_t* SK_RESTRICT src,
- int count) SK_OVERRIDE {
+ int count) override {
for (int i = 0; i < count; ++i) {
dst[i] = SkAlphaMulQ(src[i], (uint8_t)i);
}
}
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
}
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
}
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
fName = "point_normalize";
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
fName.printf("divmod_%s", name);
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
fName.printf("matrix44_%s", name);
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
fName.printf("matrix_%s", name);
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
}
}
- void performTest() SK_OVERRIDE {
+ void performTest() override {
if (fNewWay) {
for (int i = 0; i < 1000000; ++i) {
fM.mapPts(fDst, fSrc, N);
, fMemcpy32(memcpy32)
, fName(SkStringPrintf("%s_%d", name, count)) {}
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
fDst.reset(fCount);
fSrc.reset(fCount);
}
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
for (int i = 0; i < loops; i++) {
fMemcpy32(fDst, fSrc, fCount);
}
fName.printf("chunkalloc_" SK_SIZE_T_SPECIFIER, minSize);
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
size_t inc = fMinSize >> 4;
SkASSERT(inc > 0);
size_t total = fMinSize * 64;
fName.printf("memset%d_%d_%d", type, minSize, maxSize);
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
virtual void performTest() = 0;
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
for (int i = 0; i < loops; ++i) {
this->performTest();
}
: INHERITED(MEMSET32, minSize, maxSize) {}
protected:
- void performTest() SK_OVERRIDE {
+ void performTest() override {
for(int j = fMinSize; j < fMaxSize; ++j){
sk_memset32(kBuffer, VALUE32, j);
sk_memset32(kBuffer + 1, VALUE32, j);
: INHERITED(MEMSET16, minSize, maxSize) {}
protected:
- void performTest() SK_OVERRIDE {
+ void performTest() override {
for(int j = fMinSize; j < fMaxSize; ++j){
sk_memset16(kBuffer, VALUE16, j);
sk_memset16(kBuffer + 1, VALUE16, j);
MergeBench(bool small) : fIsSmall(small), fInitialized(false) { }
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fIsSmall ? "merge_small" : "merge_large";
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
if (!fInitialized) {
make_bitmap();
make_checkerboard();
}
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkRect r = fIsSmall ? SkRect::MakeWH(FILTER_WIDTH_SMALL, FILTER_HEIGHT_SMALL) :
SkRect::MakeWH(FILTER_WIDTH_LARGE, FILTER_HEIGHT_LARGE);
SkPaint paint;
MipMapBench() {}
protected:
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return kNonRendering_Backend == backend;
}
- const char* onGetName() SK_OVERRIDE { return "mipmap_build"; }
+ const char* onGetName() override { return "mipmap_build"; }
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
fBitmap.allocN32Pixels(1000, 1000, true);
fBitmap.eraseColor(SK_ColorWHITE); // so we don't read uninitialized memory
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
for (int i = 0; i < loops; i++) {
SkMipMap::Build(fBitmap, NULL)->unref();
}
class MutexBench : public Benchmark {
public:
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
struct PMFloatGetSetBench : public Benchmark {
PMFloatGetSetBench() {}
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
switch (kClamp << 1 | kWide) {
case 0: return "SkPMFloat_get_1x";
case 1: return "SkPMFloat_get_4x";
SkFAIL("unreachable");
return "oh bother";
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE { return backend == kNonRendering_Backend; }
+ bool isSuitableFor(Backend backend) override { return backend == kNonRendering_Backend; }
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
// Unlike blackhole, junk can and probably will be a register.
uint32_t junk = 0;
uint32_t seed = 0;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
SkString vertexMode;
switch (fVertexMode) {
case kNone_VertexMode:
return fName.c_str();
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
this->setCubics();
this->setColors();
this->setTexCoords();
}
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
canvas->scale(fScale.x(), fScale.y());
for (int i = 0; i < loops; i++) {
switch (fVertexMode) {
SquarePatchBench(SkPoint scale, VertexMode vertexMode)
: INHERITED(scale, vertexMode) { }
- void appendName(SkString* name) SK_OVERRIDE {
+ void appendName(SkString* name) override {
name->append("square");
}
- void setCubics() SK_OVERRIDE {
+ void setCubics() override {
const SkPoint points[SkPatchUtils::kNumCtrlPts] = {
//top points
{100,100},{150,100},{250,100}, {300,100},
LODDiffPatchBench(SkPoint scale, VertexMode vertexMode)
: INHERITED(scale, vertexMode) { }
- void appendName(SkString* name) SK_OVERRIDE {
+ void appendName(SkString* name) override {
name->append("LOD_Diff");
}
- void setCubics() SK_OVERRIDE {
+ void setCubics() override {
const SkPoint points[SkPatchUtils::kNumCtrlPts] = {
//top points
{100,175},{150,100},{250,100}, {300,0},
LoopPatchBench(SkPoint scale, VertexMode vertexMode)
: INHERITED(scale, vertexMode) { }
- void appendName(SkString* name) SK_OVERRIDE {
+ void appendName(SkString* name) override {
name->append("loop");
}
- void setCubics() SK_OVERRIDE {
+ void setCubics() override {
const SkPoint points[SkPatchUtils::kNumCtrlPts] = {
//top points
{100,100},{300,200},{100,200}, {300,100},
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
SkString vertexMode;
switch (fVertexMode) {
case kNone_VertexMode:
return fName.c_str();
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
this->setGrid();
switch (fVertexMode) {
case kTexCoords_VertexMode:
this->setupPaint(&fPaint);
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
this->setScale(canvas);
for (int i = 0; i < loops; i++) {
fGrid.draw(canvas, fPaint);
virtual int complexity() { return 0; }
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
fName.printf("path_%s_%s_",
fFlags & kStroke_Flag ? "stroke" : "fill",
fFlags & kBig_Flag ? "big" : "small");
return fName.c_str();
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPaint paint(fPaint);
this->setupPaint(&paint);
public:
TrianglePathBench(Flags flags) : INHERITED(flags) {}
- void appendName(SkString* name) SK_OVERRIDE {
+ void appendName(SkString* name) override {
name->append("triangle");
}
- void makePath(SkPath* path) SK_OVERRIDE {
+ void makePath(SkPath* path) override {
static const int gCoord[] = {
10, 10, 15, 5, 20, 20
};
public:
RectPathBench(Flags flags) : INHERITED(flags) {}
- void appendName(SkString* name) SK_OVERRIDE {
+ void appendName(SkString* name) override {
name->append("rect");
}
- void makePath(SkPath* path) SK_OVERRIDE {
+ void makePath(SkPath* path) override {
SkRect r = { 10, 10, 20, 20 };
path->addRect(r);
}
public:
OvalPathBench(Flags flags) : INHERITED(flags) {}
- void appendName(SkString* name) SK_OVERRIDE {
+ void appendName(SkString* name) override {
name->append("oval");
}
- void makePath(SkPath* path) SK_OVERRIDE {
+ void makePath(SkPath* path) override {
SkRect r = { 10, 10, 23, 20 };
path->addOval(r);
}
public:
CirclePathBench(Flags flags) : INHERITED(flags) {}
- void appendName(SkString* name) SK_OVERRIDE {
+ void appendName(SkString* name) override {
name->append("circle");
}
- void makePath(SkPath* path) SK_OVERRIDE {
+ void makePath(SkPath* path) override {
path->addCircle(SkIntToScalar(20), SkIntToScalar(20),
SkIntToScalar(10));
}
public:
SawToothPathBench(Flags flags) : INHERITED(flags) {}
- void appendName(SkString* name) SK_OVERRIDE {
+ void appendName(SkString* name) override {
name->append("sawtooth");
}
virtual void makePath(SkPath* path) {
path->lineTo(x0, y + 2 * dy);
path->close();
}
- int complexity() SK_OVERRIDE { return 1; }
+ int complexity() override { return 1; }
private:
typedef PathBench INHERITED;
};
public:
LongCurvedPathBench(Flags flags) : INHERITED(flags) {}
- void appendName(SkString* name) SK_OVERRIDE {
+ void appendName(SkString* name) override {
name->append("long_curved");
}
- void makePath(SkPath* path) SK_OVERRIDE {
+ void makePath(SkPath* path) override {
SkRandom rand (12);
int i;
for (i = 0; i < 100; i++) {
}
path->close();
}
- int complexity() SK_OVERRIDE { return 2; }
+ int complexity() override { return 2; }
private:
typedef PathBench INHERITED;
};
public:
LongLinePathBench(Flags flags) : INHERITED(flags) {}
- void appendName(SkString* name) SK_OVERRIDE {
+ void appendName(SkString* name) override {
name->append("long_line");
}
- void makePath(SkPath* path) SK_OVERRIDE {
+ void makePath(SkPath* path) override {
SkRandom rand;
path->moveTo(rand.nextUScalar1() * 640, rand.nextUScalar1() * 480);
for (size_t i = 1; i < 100; i++) {
path->lineTo(rand.nextUScalar1() * 640, rand.nextUScalar1() * 480);
}
}
- int complexity() SK_OVERRIDE { return 2; }
+ int complexity() override { return 2; }
private:
typedef PathBench INHERITED;
};
class RandomPathBench : public Benchmark {
public:
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return "path_create";
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
this->createData(10, 100);
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
for (int i = 0; i < loops; ++i) {
if (i % 1000 == 0) {
fPath.reset(); // PathRef memory can grow without bound otherwise.
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return "path_copy";
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
this->createData(10, 100);
fPaths.reset(kPathCnt);
fCopies.reset(kPathCnt);
}
this->finishedMakingPaths();
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
for (int i = 0; i < loops; ++i) {
int idx = i & (kPathCnt - 1);
fCopies[idx] = fPaths[idx];
PathTransformBench(bool inPlace) : fInPlace(inPlace) {}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fInPlace ? "path_transform_in_place" : "path_transform_copy";
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
fMatrix.setScale(5 * SK_Scalar1, 6 * SK_Scalar1);
this->createData(10, 100);
fPaths.reset(kPathCnt);
}
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
if (fInPlace) {
for (int i = 0; i < loops; ++i) {
fPaths[i & (kPathCnt - 1)].transform(fMatrix);
PathEqualityBench() { }
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return "path_equality_50%";
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
fParity = 0;
this->createData(10, 100);
fPaths.reset(kPathCnt);
this->finishedMakingPaths();
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
for (int i = 0; i < loops; ++i) {
int idx = i & (kPathCnt - 1);
fParity ^= (fPaths[idx] == fCopies[idx & ~0x1]);
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
switch (fType) {
case kAdd_AddType:
return "path_add_path";
}
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
// reversePathTo assumes a single contour path.
bool allowMoves = kReversePathTo_AddType != fType;
this->createData(10, 100, allowMoves);
this->finishedMakingPaths();
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
switch (fType) {
case kAdd_AddType:
for (int i = 0; i < loops; ++i) {
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPaint paint;
paint.setColor(SK_ColorBLACK);
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
SkASSERT(path->isConvex());
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkRandom rand;
SkRect r;
}
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
private:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
for (int i = 0; i < loops; ++i) {
const SkRect& rect = fQueryRects[i % kQueryRectCnt];
fParity = fParity != fPath.conservativelyContainsRect(rect);
}
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
fQueryRects.setCount(kQueryRectCnt);
SkRandom rand;
}
private:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return "ratquad-chop-0.5";
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
SkConic dst[2];
for (int i = 0; i < loops; ++i) {
fRQ.chopAt(0.5f, dst);
fName.printf("conic-chop-half%d", useV2);
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
private:
- const char* onGetName() SK_OVERRIDE { return fName.c_str(); }
+ const char* onGetName() override { return fName.c_str(); }
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
if (fUseV2) {
for (int i = 0; i < loops; ++i) {
fRQ.chop2(fDst);
ConicBench_EvalPos(bool useV2) : ConicBench_ChopHalf(useV2) {
fName.printf("conic-eval-pos%d", useV2);
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
if (fUseV2) {
for (int i = 0; i < loops; ++i) {
for (int j = 0; j < 1000; ++j) {
ConicBench_EvalTan(bool useV2) : ConicBench_ChopHalf(useV2) {
fName.printf("conic-eval-tan%d", useV2);
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
if (fUseV2) {
for (int i = 0; i < loops; ++i) {
for (int j = 0; j < 1000; ++j) {
}
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
ConicBench_ComputeError() {}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return "conic-compute-error";
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
SkVector err;
for (int i = 0; i < loops; ++i) {
for (int j = 0; j < CONICS; ++j) {
ConicBench_asQuadTol() {}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return "conic-asQuadTol";
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
for (int i = 0; i < loops; ++i) {
for (int j = 0; j < CONICS; ++j) {
fConics[j].asQuadTol(SK_ScalarHalf);
ConicBench_quadPow2() {}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return "conic-quadPow2";
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
for (int i = 0; i < loops; ++i) {
for (int j = 0; j < CONICS; ++j) {
fConics[j].computeQuadPOW2(SK_ScalarHalf);
}
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
if (fRaw) {
for (int i = 0; i < loops; ++i) {
SkPath::RawIter iter(fPath);
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return "perlinnoise";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
this->test(loops, canvas, 0, 0, SkPerlinNoiseShader::kFractalNoise_Type,
0.1f, 0.1f, 3, 0, false);
}
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
: INHERITED("playback", maxLevel, maxPictureLevel) {
}
protected:
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
this->INHERITED::onPreDraw();
SkIPoint canvasSize = onGetSize();
public:
TextPlaybackBench() : INHERITED("drawText") { }
protected:
- void recordCanvas(SkCanvas* canvas) SK_OVERRIDE {
+ void recordCanvas(SkCanvas* canvas) override {
SkPaint paint;
paint.setTextSize(fTextSize);
paint.setColor(SK_ColorBLACK);
: INHERITED(drawPosH ? "drawPosTextH" : "drawPosText")
, fDrawPosH(drawPosH) { }
protected:
- void recordCanvas(SkCanvas* canvas) SK_OVERRIDE {
+ void recordCanvas(SkCanvas* canvas) override {
SkPaint paint;
paint.setTextSize(fTextSize);
paint.setColor(SK_ColorBLACK);
}
}
- const char* onGetName() SK_OVERRIDE { return fName.c_str(); }
- SkIPoint onGetSize() SK_OVERRIDE { return SkIPoint::Make(1024,1024); }
+ const char* onGetName() override { return fName.c_str(); }
+ SkIPoint onGetSize() override { return SkIPoint::Make(1024,1024); }
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
SkAutoTDelete<SkBBHFactory> factory;
switch (fBBH) {
case kNone: break;
fPic.reset(recorder.endRecording());
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
for (int i = 0; i < loops; i++) {
// This inner loop guarantees we make the same choices for all bench variants.
SkRandom rand;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
SkImageInfo info = SkImageInfo::Make(W, H, fColorType, kUnpremul_SkAlphaType);
fBmp1.allocPixels(info); // used in writePixels
fBmp2.allocPixels(info); // used in readPixels()
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
canvas->clear(SK_ColorBLACK);
for (int loop = 0; loop < loops; ++loop) {
fName.printf("rtree_%s_build", name);
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkRandom rand;
SkAutoTMalloc<SkRect> rects(NUM_BUILD_RECTS);
for (int i = 0; i < NUM_BUILD_RECTS; ++i) {
fName.printf("rtree_%s_query", name);
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
SkRandom rand;
SkAutoTMalloc<SkRect> rects(NUM_QUERY_RECTS);
for (int i = 0; i < NUM_QUERY_RECTS; ++i) {
fTree.insert(rects.get(), NUM_QUERY_RECTS);
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkRandom rand;
for (int i = 0; i < loops; ++i) {
SkTDArray<unsigned> hits;
ReadPixBench() {}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return "readpix";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
canvas->clear(SK_ColorBLACK);
SkISize size = canvas->getDeviceSize();
RecordingBench(const char* name, const SkPicture*, bool useBBH);
protected:
- const char* onGetName() SK_OVERRIDE;
- bool isSuitableFor(Backend) SK_OVERRIDE;
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE;
- SkIPoint onGetSize() SK_OVERRIDE;
+ const char* onGetName() override;
+ bool isSuitableFor(Backend) override;
+ void onDraw(const int loops, SkCanvas*) override;
+ SkIPoint onGetSize() override;
private:
SkAutoTUnref<const SkPicture> fSrc;
}
protected:
- void setupPaint(SkPaint* paint) SK_OVERRIDE {
+ void setupPaint(SkPaint* paint) override {
this->INHERITED::setupPaint(paint);
// srcmode is most interesting when we're not opaque
paint->setAlpha(0x80);
paint->setXfermode(fMode);
}
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
fName.set(this->INHERITED::onGetName());
fName.prepend("srcmode_");
return fName.c_str();
}
protected:
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return kNonRendering_Backend == backend;
}
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
SkASSERT(NULL == fRectanizer.get());
if (kPow2_RectanizerType == fRectanizerType) {
}
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkRandom rand;
SkIPoint16 loc;
SkISize size;
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return "rectori";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkRandom Random;
for (int i = 0; i < loops; i++) {
public:
AtomicInc32() : fX(0) {}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
public:
AtomicInc64() : fX(0) {}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
class RefCntBench_Stack : public Benchmark {
public:
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
class RefCntBench_Heap : public Benchmark {
public:
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
class RefCntBench_New : public Benchmark {
public:
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
class WeakRefCntBench_Stack : public Benchmark {
public:
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
class WeakRefCntBench_Heap : public Benchmark {
public:
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return "ref_cnt_heap_weak";
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
char memory[sizeof(PlacedWeakRefCnt)];
for (int i = 0; i < loops; ++i) {
PlacedWeakRefCnt* ref = new (memory) PlacedWeakRefCnt();
class WeakRefCntBench_New : public Benchmark {
public:
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return "ref_cnt_new_weak";
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
for (int i = 0; i < loops; ++i) {
SkWeakRefCnt* ref = new SkWeakRefCnt();
for (int j = 0; j < M; ++j) {
}
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
fB.setRect(0, 0, H, W);
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
protected:
- const char* onGetName() SK_OVERRIDE { return fName.c_str(); }
+ const char* onGetName() override { return fName.c_str(); }
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
Proc proc = fProc;
for (int i = 0; i < loops; ++i) {
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
fBitmap.allocPixels();
fBitmap.eraseColor(kOpaque_SkAlphaType == fAlphaType ? SK_ColorWHITE : 0);
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPaint paint(fPaint);
this->setupPaint(&paint);
}
protected:
- const char* onGetName() SK_OVERRIDE { return fName.c_str(); }
+ const char* onGetName() override { return fName.c_str(); }
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(fAA);
paint.setXfermodeMode(fMode);
public:
SKPBench(const char* name, const SkPicture*, const SkIRect& devClip, SkScalar scale,
bool useMultiPictureDraw);
- ~SKPBench() SK_OVERRIDE;
+ ~SKPBench() override;
protected:
- const char* onGetName() SK_OVERRIDE;
- const char* onGetUniqueName() SK_OVERRIDE;
- void onPerCanvasPreDraw(SkCanvas*) SK_OVERRIDE;
- void onPerCanvasPostDraw(SkCanvas*) SK_OVERRIDE;
- bool isSuitableFor(Backend backend) SK_OVERRIDE;
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE;
- SkIPoint onGetSize() SK_OVERRIDE;
+ const char* onGetName() override;
+ const char* onGetUniqueName() override;
+ void onPerCanvasPreDraw(SkCanvas*) override;
+ void onPerCanvasPostDraw(SkCanvas*) override;
+ bool isSuitableFor(Backend backend) override;
+ void onDraw(const int loops, SkCanvas* canvas) override;
+ SkIPoint onGetSize() override;
private:
SkAutoTUnref<const SkPicture> fPic;
fName.printf("scalar_%s", name);
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
protected:
virtual int mulLoopCount() const { return 1; }
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
for (int i = 0; i < loops; i++) {
this->performTest();
}
}
}
protected:
- int mulLoopCount() const SK_OVERRIDE { return 1; }
- void performTest() SK_OVERRIDE {
+ int mulLoopCount() const override { return 1; }
+ void performTest() override {
int sum = 0;
for (size_t i = 0; i < ARRAY_N; ++i) {
// We pass -fArray[i], so the compiler can't cheat and treat the
}
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return "rect_bounds";
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkRect r;
for (int i = 0; i < loops; ++i) {
for (int i = 0; i < 1000; ++i) {
}
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
SkString resourcePath = GetResourcePath();
if (resourcePath.isEmpty()) {
fValid = false;
}
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
if (!fValid) {
#ifdef SK_DEBUG
SkDebugf("stream was invalid: %s\n", fFilename.c_str());
fName.printf("sort_%s_%s", gSorts[s].fName, gRec[t].fName);
}
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
// Delayed initialization only done if onDraw will be called.
- void onPreDraw() SK_OVERRIDE {
+ void onPreDraw() override {
fUnsorted.reset(N);
gRec[fType].fProc(fUnsorted.get());
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
SkAutoTMalloc<int> sorted(N);
for (int i = 0; i < loops; i++) {
memcpy(sorted.get(), fUnsorted.get(), N*sizeof(int));
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return fName.c_str();
}
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkISize size = canvas->getDeviceSize();
canvas->clear(0xFFFF0000);
class WriterBench : public Benchmark {
public:
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
protected:
- const char* onGetName() SK_OVERRIDE {
+ const char* onGetName() override {
return "writer";
}
- void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas*) override {
static const char gStr[] = "abcdefghimjklmnopqrstuvwxyz";
static const size_t gLen = strlen(gStr);
SkWriter32 writer;
}
protected:
- const char* onGetName() SK_OVERRIDE { return fName.c_str(); }
+ const char* onGetName() override { return fName.c_str(); }
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
SkISize size = canvas->getDeviceSize();
SkRandom random;
for (int i = 0; i < loops; ++i) {
class XferCreateBench : public Benchmark {
public:
- bool isSuitableFor(Backend backend) SK_OVERRIDE {
+ bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
protected:
- const char* onGetName() SK_OVERRIDE { return "xfermode_create"; }
+ const char* onGetName() override { return "xfermode_create"; }
- void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(const int loops, SkCanvas* canvas) override {
for (int outer = 0; outer < loops * 10; ++outer) {
for (int i = 0; i <= SkXfermode::kLastMode; ++i) {
SkXfermode* xfer = SkXfermode::Create(SkXfermode::Mode(i));
}
// Try a noop Src as a canary. If it fails, skip this sink.
struct : public Src {
- Error draw(SkCanvas*) const SK_OVERRIDE { return ""; }
- SkISize size() const SK_OVERRIDE { return SkISize::Make(16, 16); }
- Name name() const SK_OVERRIDE { return "noop"; }
+ Error draw(SkCanvas*) const override { return ""; }
+ SkISize size() const override { return SkISize::Make(16, 16); }
+ Name name() const override { return "noop"; }
} noop;
SkBitmap bitmap;
static void run_test(skiatest::Test* test) {
struct : public skiatest::Reporter {
- void reportFailed(const skiatest::Failure& failure) SK_OVERRIDE {
+ void reportFailed(const skiatest::Failure& failure) override {
fail(failure.toString());
JsonWriter::AddTestFailure(failure);
}
- bool allowExtendedTest() const SK_OVERRIDE {
+ bool allowExtendedTest() const override {
return FLAGS_pathOpsExtended;
}
- bool verbose() const SK_OVERRIDE { return FLAGS_veryVerbose; }
+ bool verbose() const override { return FLAGS_veryVerbose; }
} reporter;
WallTimer timer;
timer.start();
fSize = auto_compute_translate(&fMatrix, src.size().width(), src.size().height());
}
- Error draw(SkCanvas* canvas) const SK_OVERRIDE {
+ Error draw(SkCanvas* canvas) const override {
canvas->concat(fMatrix);
return fSrc.draw(canvas);
}
- SkISize size() const SK_OVERRIDE { return fSize; }
- Name name() const SK_OVERRIDE { sk_throw(); return ""; } // No one should be calling this.
+ SkISize size() const override { return fSize; }
+ Name name() const override { sk_throw(); return ""; } // No one should be calling this.
} proxy(src, fMatrix);
return fSink->draw(proxy, bitmap, stream, log);
}
const Src& fSrc;
ProxySrc(const Src& src) : fSrc(src) {}
- Error draw(SkCanvas* canvas) const SK_OVERRIDE {
+ Error draw(SkCanvas* canvas) const override {
SkISize size = this->size();
PipeController controller(canvas, &SkImageDecoder::DecodeMemory);
SkGPipeWriter pipe;
const uint32_t kFlags = 0; // We mirror SkDeferredCanvas, which doesn't use any flags.
return fSrc.draw(pipe.startRecording(&controller, kFlags, size.width(), size.height()));
}
- SkISize size() const SK_OVERRIDE { return fSrc.size(); }
- Name name() const SK_OVERRIDE { sk_throw(); return ""; } // No one should be calling this.
+ SkISize size() const override { return fSrc.size(); }
+ Name name() const override { sk_throw(); return ""; } // No one should be calling this.
} proxy(src);
return fSink->draw(proxy, bitmap, stream, log);
}
const SkISize fSize;
ProxySrc(const SkPicture* pic, SkISize size) : fPic(pic), fSize(size) {}
- Error draw(SkCanvas* canvas) const SK_OVERRIDE {
+ Error draw(SkCanvas* canvas) const override {
canvas->drawPicture(fPic);
return "";
}
- SkISize size() const SK_OVERRIDE { return fSize; }
- Name name() const SK_OVERRIDE { sk_throw(); return ""; } // No one should be calling this.
+ SkISize size() const override { return fSize; }
+ Name name() const override { sk_throw(); return ""; } // No one should be calling this.
} proxy(deserialized, src.size());
return fSink->draw(proxy, bitmap, stream, log);
}
ProxySrc(int w, int h, const SkPicture* pic, SkISize size)
: fW(w), fH(h), fPic(pic), fSize(size) {}
- Error draw(SkCanvas* canvas) const SK_OVERRIDE {
+ Error draw(SkCanvas* canvas) const override {
const int xTiles = (fSize.width() + fW - 1) / fW,
yTiles = (fSize.height() + fH - 1) / fH;
SkMultiPictureDraw mpd(xTiles*yTiles);
surfaces.unrefAll();
return "";
}
- SkISize size() const SK_OVERRIDE { return fSize; }
- Name name() const SK_OVERRIDE { sk_throw(); return ""; } // No one should be calling this.
+ SkISize size() const override { return fSize; }
+ Name name() const override { sk_throw(); return ""; } // No one should be calling this.
} proxy(fW, fH, pic, src.size());
return fSink->draw(proxy, bitmap, stream, log);
}
public:
explicit GMSrc(skiagm::GMRegistry::Factory);
- Error draw(SkCanvas*) const SK_OVERRIDE;
- SkISize size() const SK_OVERRIDE;
- Name name() const SK_OVERRIDE;
+ Error draw(SkCanvas*) const override;
+ SkISize size() const override;
+ Name name() const override;
private:
skiagm::GMRegistry::Factory fFactory;
};
};
CodecSrc(Path, Mode);
- Error draw(SkCanvas*) const SK_OVERRIDE;
- SkISize size() const SK_OVERRIDE;
- Name name() const SK_OVERRIDE;
+ Error draw(SkCanvas*) const override;
+ SkISize size() const override;
+ Name name() const override;
private:
Path fPath;
Mode fMode;
// divisor > 0 means decode in subsets, dividing into a divisor x divisor grid.
explicit ImageSrc(Path path, int divisor = 0);
- Error draw(SkCanvas*) const SK_OVERRIDE;
- SkISize size() const SK_OVERRIDE;
- Name name() const SK_OVERRIDE;
+ Error draw(SkCanvas*) const override;
+ SkISize size() const override;
+ Name name() const override;
private:
Path fPath;
const int fDivisor;
public:
explicit SKPSrc(Path path);
- Error draw(SkCanvas*) const SK_OVERRIDE;
- SkISize size() const SK_OVERRIDE;
- Name name() const SK_OVERRIDE;
+ Error draw(SkCanvas*) const override;
+ SkISize size() const override;
+ Name name() const override;
private:
Path fPath;
};
public:
NullSink() {}
- Error draw(const Src& src, SkBitmap*, SkWStream*, SkString*) const SK_OVERRIDE;
- int enclave() const SK_OVERRIDE { return kAnyThread_Enclave; }
- const char* fileExtension() const SK_OVERRIDE { return ""; }
+ Error draw(const Src& src, SkBitmap*, SkWStream*, SkString*) const override;
+ int enclave() const override { return kAnyThread_Enclave; }
+ const char* fileExtension() const override { return ""; }
};
public:
GPUSink(GrContextFactory::GLContextType, GrGLStandard, int samples, bool dfText, bool threaded);
- Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const SK_OVERRIDE;
- int enclave() const SK_OVERRIDE;
- const char* fileExtension() const SK_OVERRIDE { return "png"; }
+ Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
+ int enclave() const override;
+ const char* fileExtension() const override { return "png"; }
private:
GrContextFactory::GLContextType fContextType;
GrGLStandard fGpuAPI;
public:
PDFSink();
- Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const SK_OVERRIDE;
- int enclave() const SK_OVERRIDE { return kAnyThread_Enclave; }
- const char* fileExtension() const SK_OVERRIDE { return "pdf"; }
+ Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
+ int enclave() const override { return kAnyThread_Enclave; }
+ const char* fileExtension() const override { return "pdf"; }
};
class XPSSink : public Sink {
public:
XPSSink();
- Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const SK_OVERRIDE;
- int enclave() const SK_OVERRIDE { return kAnyThread_Enclave; }
- const char* fileExtension() const SK_OVERRIDE { return "xps"; }
+ Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
+ int enclave() const override { return kAnyThread_Enclave; }
+ const char* fileExtension() const override { return "xps"; }
};
class RasterSink : public Sink {
public:
explicit RasterSink(SkColorType);
- Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const SK_OVERRIDE;
- int enclave() const SK_OVERRIDE { return kAnyThread_Enclave; }
- const char* fileExtension() const SK_OVERRIDE { return "png"; }
+ Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
+ int enclave() const override { return kAnyThread_Enclave; }
+ const char* fileExtension() const override { return "png"; }
private:
SkColorType fColorType;
};
public:
SKPSink();
- Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const SK_OVERRIDE;
- int enclave() const SK_OVERRIDE { return kAnyThread_Enclave; }
- const char* fileExtension() const SK_OVERRIDE { return "skp"; }
+ Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
+ int enclave() const override { return kAnyThread_Enclave; }
+ const char* fileExtension() const override { return "skp"; }
};
class SVGSink : public Sink {
public:
SVGSink();
- Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const SK_OVERRIDE;
- int enclave() const SK_OVERRIDE { return kAnyThread_Enclave; }
- const char* fileExtension() const SK_OVERRIDE { return "svg"; }
+ Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
+ int enclave() const override { return kAnyThread_Enclave; }
+ const char* fileExtension() const override { return "svg"; }
};
public:
ViaMatrix(SkMatrix, Sink*);
- Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const SK_OVERRIDE;
- int enclave() const SK_OVERRIDE { return fSink->enclave(); }
- const char* fileExtension() const SK_OVERRIDE { return fSink->fileExtension(); }
+ Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
+ int enclave() const override { return fSink->enclave(); }
+ const char* fileExtension() const override { return fSink->fileExtension(); }
private:
SkMatrix fMatrix;
SkAutoTDelete<Sink> fSink;
public:
ViaUpright(SkMatrix, Sink*);
- Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const SK_OVERRIDE;
- int enclave() const SK_OVERRIDE { return fSink->enclave(); }
- const char* fileExtension() const SK_OVERRIDE { return fSink->fileExtension(); }
+ Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
+ int enclave() const override { return fSink->enclave(); }
+ const char* fileExtension() const override { return fSink->fileExtension(); }
private:
SkMatrix fMatrix;
SkAutoTDelete<Sink> fSink;
public:
explicit ViaPipe(Sink*);
- Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const SK_OVERRIDE;
- int enclave() const SK_OVERRIDE { return fSink->enclave(); }
- const char* fileExtension() const SK_OVERRIDE { return fSink->fileExtension(); }
+ Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
+ int enclave() const override { return fSink->enclave(); }
+ const char* fileExtension() const override { return fSink->fileExtension(); }
private:
SkAutoTDelete<Sink> fSink;
};
public:
explicit ViaSerialization(Sink*);
- Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const SK_OVERRIDE;
- int enclave() const SK_OVERRIDE { return fSink->enclave(); }
- const char* fileExtension() const SK_OVERRIDE { return fSink->fileExtension(); }
+ Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
+ int enclave() const override { return fSink->enclave(); }
+ const char* fileExtension() const override { return fSink->fileExtension(); }
private:
SkAutoTDelete<Sink> fSink;
};
public:
ViaTiles(int w, int h, SkBBHFactory*, Sink*);
- Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const SK_OVERRIDE;
- int enclave() const SK_OVERRIDE { return fSink->enclave(); }
- const char* fileExtension() const SK_OVERRIDE { return fSink->fileExtension(); }
+ Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
+ int enclave() const override { return fSink->enclave(); }
+ const char* fileExtension() const override { return fSink->fileExtension(); }
private:
const int fW, fH;
SkAutoTDelete<SkBBHFactory> fFactory;
class ContextFactory : public android::uirenderer::IContextFactory {
public:
android::uirenderer::AnimationContext* createAnimationContext
- (android::uirenderer::renderthread::TimeLord& clock) SK_OVERRIDE {
+ (android::uirenderer::renderthread::TimeLord& clock) override {
return new android::uirenderer::AnimationContext(clock);
}
};
ProxySrc(const Src& src)
: fSrc(src) {}
- Error draw(SkCanvas* canvas) const SK_OVERRIDE {
+ Error draw(SkCanvas* canvas) const override {
// Pass through HWUI's upper layers to get operational transforms
SkAutoTDelete<android::Canvas> ac (android::Canvas::create_canvas(canvas));
SkAutoTUnref<android::uirenderer::SkiaCanvasProxy> scProxy
return "";
}
- SkISize size() const SK_OVERRIDE { return fSrc.size(); }
- Name name() const SK_OVERRIDE { sk_throw(); return ""; }
+ SkISize size() const override { return fSrc.size(); }
+ Name name() const override { sk_throw(); return ""; }
} proxy(src);
return fSink->draw(proxy, bitmap, stream, log);
public:
HWUISink() { }
- Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const SK_OVERRIDE;
- int enclave() const SK_OVERRIDE { return kGPU_Enclave; }
- const char* fileExtension() const SK_OVERRIDE { return "png"; }
+ Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
+ int enclave() const override { return kGPU_Enclave; }
+ const char* fileExtension() const override { return "png"; }
};
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
public:
explicit ViaAndroidSDK(Sink*);
- Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const SK_OVERRIDE;
- int enclave() const SK_OVERRIDE { return fSink->enclave(); }
- const char* fileExtension() const SK_OVERRIDE { return fSink->fileExtension(); }
+ Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
+ int enclave() const override { return fSink->enclave(); }
+ const char* fileExtension() const override { return fSink->fileExtension(); }
private:
SkAutoTDelete<Sink> fSink;
kGPU_DeviceType,
};
HelloWorldWindow(void* hwnd);
- virtual ~HelloWorldWindow() SK_OVERRIDE;
+ virtual ~HelloWorldWindow() override;
// Changes the device type of the object.
bool setUpBackend();
DeviceType getDeviceType() const { return fType; }
protected:
- SkSurface* createSurface() SK_OVERRIDE {
+ SkSurface* createSurface() override {
if (kGPU_DeviceType == fType) {
SkSurfaceProps props(INHERITED::getSurfaceProps());
return SkSurface::NewRenderTargetDirect(fRenderTarget, &props);
return fSurface = SkSurface::NewRaster(info);
}
- void draw(SkCanvas* canvas) SK_OVERRIDE;
+ void draw(SkCanvas* canvas) override;
void drawContents(SkCanvas* canvas);
- void onSizeChange() SK_OVERRIDE;
+ void onSizeChange() override;
private:
bool findNextMatch(); // Set example to the first one that matches FLAGS_match.
void setTitle();
void setUpRenderTarget();
- bool onHandleChar(SkUnichar unichar) SK_OVERRIDE;
+ bool onHandleChar(SkUnichar unichar) override;
void tearDownBackend();
// draw contents
virtual bool canDrawPath(const SkPath& path,
const SkStrokeRec& stroke,
const GrDrawTarget* target,
- bool antiAlias) const SK_OVERRIDE;
+ bool antiAlias) const override;
protected:
virtual bool onDrawPath(const SkPath& path,
const SkStrokeRec& stroke,
GrDrawTarget* target,
- bool antiAlias) SK_OVERRIDE;
+ bool antiAlias) override;
private:
typedef GrPathRenderer INHERITED;
explicit SkNulCanvas(const SkBitmap& bitmap) : SkCanvas(bitmap) {}
virtual ~SkNulCanvas() {}
- void beginCommentGroup(const char* description) SK_OVERRIDE {}
- void addComment(const char* kywd, const char* value) SK_OVERRIDE {}
- void endCommentGroup() SK_OVERRIDE {}
- SkDrawFilter* setDrawFilter(SkDrawFilter* filter) SK_OVERRIDE {return NULL;}
+ void beginCommentGroup(const char* description) override {}
+ void addComment(const char* kywd, const char* value) override {}
+ void endCommentGroup() override {}
+ SkDrawFilter* setDrawFilter(SkDrawFilter* filter) override {return NULL;}
- bool isClipEmpty() const SK_OVERRIDE { return false; }
- bool getClipBounds(SkRect* bounds) const SK_OVERRIDE {
+ bool isClipEmpty() const override { return false; }
+ bool getClipBounds(SkRect* bounds) const override {
if (NULL != bounds) {
bounds->setXYWH(0, 0,
SkIntToScalar(this->imageInfo().width()),
}
return true;
}
- bool getClipDeviceBounds(SkIRect* bounds) const SK_OVERRIDE {
+ bool getClipDeviceBounds(SkIRect* bounds) const override {
if (NULL != bounds) {
bounds->setLargest();
}
virtual SkBaseDevice* setDevice(SkBaseDevice* device) {return NULL;}
virtual SaveLayerStrategy willSaveLayer(const SkRect* bounds, const SkPaint* paint,
- SaveFlags flags) SK_OVERRIDE {
+ SaveFlags flags) override {
this->INHERITED::willSaveLayer(bounds, paint, flags);
return kNoLayer_SaveLayerStrategy;
}
virtual void onDrawText(const void* text, size_t byteLength, SkScalar x,
- SkScalar y, const SkPaint& paint) SK_OVERRIDE {}
+ SkScalar y, const SkPaint& paint) override {}
virtual void onDrawPosText(const void* text, size_t byteLength,
- const SkPoint pos[], const SkPaint& paint) SK_OVERRIDE {}
+ const SkPoint pos[], const SkPaint& paint) override {}
virtual void onDrawPosTextH(const void* text, size_t byteLength,
const SkScalar xpos[], SkScalar constY,
- const SkPaint& paint) SK_OVERRIDE {}
+ const SkPaint& paint) override {}
virtual void onDrawTextOnPath(const void* text, size_t byteLength,
const SkPath& path, const SkMatrix* matrix,
- const SkPaint& paint) SK_OVERRIDE {}
+ const SkPaint& paint) override {}
- void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE {}
- void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE {}
- void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE {}
- void onClipRegion(const SkRegion&, SkRegion::Op) SK_OVERRIDE {}
+ void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) override {}
+ void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) override {}
+ void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) override {}
+ void onClipRegion(const SkRegion&, SkRegion::Op) override {}
- void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) SK_OVERRIDE {}
+ void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override {}
- void onDrawPaint(const SkPaint& paint) SK_OVERRIDE {}
+ void onDrawPaint(const SkPaint& paint) override {}
void onDrawPoints(PointMode mode, size_t count, const SkPoint pts[],
- const SkPaint& paint) SK_OVERRIDE {}
- void onDrawRect(const SkRect& rect, const SkPaint& paint) SK_OVERRIDE {}
- void onDrawOval(const SkRect& oval, const SkPaint&) SK_OVERRIDE {}
- void onDrawRRect(const SkRRect& rrect, const SkPaint& paint) SK_OVERRIDE {}
- void onDrawPath(const SkPath& path, const SkPaint& paint) SK_OVERRIDE {}
+ const SkPaint& paint) override {}
+ void onDrawRect(const SkRect& rect, const SkPaint& paint) override {}
+ void onDrawOval(const SkRect& oval, const SkPaint&) override {}
+ void onDrawRRect(const SkRRect& rrect, const SkPaint& paint) override {}
+ void onDrawPath(const SkPath& path, const SkPaint& paint) override {}
void onDrawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
- const SkPaint* paint = NULL) SK_OVERRIDE {}
+ const SkPaint* paint = NULL) override {}
void onDrawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
const SkRect& dst,
const SkPaint* paint,
- DrawBitmapRectFlags flags) SK_OVERRIDE {}
- void onDrawImage(const SkImage*, SkScalar left, SkScalar top, const SkPaint*) SK_OVERRIDE {}
+ DrawBitmapRectFlags flags) override {}
+ void onDrawImage(const SkImage*, SkScalar left, SkScalar top, const SkPaint*) override {}
void onDrawImageRect(const SkImage*, const SkRect* src, const SkRect& dst,
- const SkPaint*) SK_OVERRIDE{}
+ const SkPaint*) override{}
void onDrawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
- const SkRect& dst, const SkPaint* paint = NULL) SK_OVERRIDE {}
+ const SkRect& dst, const SkPaint* paint = NULL) override {}
void onDrawSprite(const SkBitmap& bitmap, int left, int top,
- const SkPaint* paint = NULL) SK_OVERRIDE {}
+ const SkPaint* paint = NULL) override {}
void onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
const SkColor colors[], SkXfermode* xmode,
const uint16_t indices[], int indexCount,
- const SkPaint& paint) SK_OVERRIDE {}
+ const SkPaint& paint) override {}
private:
SkCanvas* canvas)
: INHERITED(tokenizer, pdfContext, canvas) {}
- SkPdfResult consumeToken(PdfToken& token) SK_OVERRIDE;
- void loop() SK_OVERRIDE;
+ SkPdfResult consumeToken(PdfToken& token) override;
+ void loop() override;
private:
typedef SkPdfTokenLooper INHERITED;
explicit PdfInlineImageLooper(SkPdfTokenLooper* parent)
: INHERITED(parent) {}
- SkPdfResult consumeToken(PdfToken& token) SK_OVERRIDE;
- void loop() SK_OVERRIDE;
+ SkPdfResult consumeToken(PdfToken& token) override;
+ void loop() override;
private:
typedef SkPdfTokenLooper INHERITED;
explicit PdfCompatibilitySectionLooper(SkPdfTokenLooper* parent)
: INHERITED (parent) {}
- SkPdfResult consumeToken(PdfToken& token) SK_OVERRIDE;
- void loop() SK_OVERRIDE;
+ SkPdfResult consumeToken(PdfToken& token) override;
+ void loop() override;
private:
typedef SkPdfTokenLooper INHERITED;
virtual ~SkV8ExampleWindow();
protected:
- void onDraw(SkCanvas* canvas) SK_OVERRIDE;
- void onSizeChange() SK_OVERRIDE;
+ void onDraw(SkCanvas* canvas) override;
+ void onSizeChange() override;
#if SK_SUPPORT_GPU
- SkSurface* createSurface() SK_OVERRIDE;
+ SkSurface* createSurface() override;
#endif
#ifdef SK_BUILD_FOR_WIN
- void onHandleInval(const SkIRect&) SK_OVERRIDE;
+ void onHandleInval(const SkIRect&) override;
#endif
void windowSizeChanged();
virtual bool canDrawPath(const SkPath& path,
const SkStrokeRec& stroke,
const GrDrawTarget* target,
- bool antiAlias) const SK_OVERRIDE;
+ bool antiAlias) const override;
protected:
virtual bool onDrawPath(const SkPath& path,
const SkStrokeRec& stroke,
GrDrawTarget* target,
- bool antiAlias) SK_OVERRIDE;
+ bool antiAlias) override;
};
#endif
}
- void setUpBackend(SampleWindow* win, int msaaSampleCount) SK_OVERRIDE {
+ void setUpBackend(SampleWindow* win, int msaaSampleCount) override {
SkASSERT(SkOSWindow::kNone_BackEndType == fBackend);
fBackend = SkOSWindow::kNone_BackEndType;
this->windowSizeChanged(win);
}
- void tearDownBackend(SampleWindow *win) SK_OVERRIDE {
+ void tearDownBackend(SampleWindow *win) override {
#if SK_SUPPORT_GPU
SkSafeUnref(fCurContext);
fCurContext = NULL;
fBackend = SampleWindow::kNone_BackEndType;
}
- SkSurface* createSurface(SampleWindow::DeviceType dType, SampleWindow* win) SK_OVERRIDE{
+ SkSurface* createSurface(SampleWindow::DeviceType dType, SampleWindow* win) override{
#if SK_SUPPORT_GPU
if (SampleWindow::IsGpuDeviceType(dType) && fCurContext) {
SkSurfaceProps props(win->getSurfaceProps());
virtual void publishCanvas(SampleWindow::DeviceType dType,
SkCanvas* canvas,
- SampleWindow* win) SK_OVERRIDE {
+ SampleWindow* win) override {
#if SK_SUPPORT_GPU
if (NULL != fCurContext) {
fCurContext->flush();
win->present();
}
- void windowSizeChanged(SampleWindow* win) SK_OVERRIDE {
+ void windowSizeChanged(SampleWindow* win) override {
#if SK_SUPPORT_GPU
if (NULL != fCurContext) {
SkOSWindow::AttachmentInfo info;
#endif
}
- GrContext* getGrContext() SK_OVERRIDE {
+ GrContext* getGrContext() override {
#if SK_SUPPORT_GPU
return fCurContext;
#else
#endif
}
- GrRenderTarget* getGrRenderTarget() SK_OVERRIDE {
+ GrRenderTarget* getGrRenderTarget() override {
#if SK_SUPPORT_GPU
return fCurRenderTarget;
#else
virtual ~PageCachingDocument();
virtual SkCanvas* onBeginPage(SkScalar width,
SkScalar height,
- const SkRect& content) SK_OVERRIDE;
- void onEndPage() SK_OVERRIDE;
- bool onClose(SkWStream*) SK_OVERRIDE;
- void onAbort() SK_OVERRIDE;
+ const SkRect& content) override;
+ void onEndPage() override;
+ bool onClose(SkWStream*) override;
+ void onAbort() override;
private:
struct Page {
public:
SkDmuxWStream(SkWStream* const streamArray[], size_t count);
~SkDmuxWStream();
- virtual bool write(const void* buffer, size_t size) SK_OVERRIDE;
- virtual void newline() SK_OVERRIDE;
- virtual void flush() SK_OVERRIDE;
- virtual size_t bytesWritten() const SK_OVERRIDE;
+ virtual bool write(const void* buffer, size_t size) override;
+ virtual void newline() override;
+ virtual void flush() override;
+ virtual size_t bytesWritten() const override;
private:
SkTDArray<SkWStream*> fWStreams;
public:
NullWStream() : fBytesWritten(0) {
}
- bool write(const void*, size_t size) SK_OVERRIDE {
+ bool write(const void*, size_t size) override {
fBytesWritten += size;
return true;
}
- size_t bytesWritten() const SK_OVERRIDE {
+ size_t bytesWritten() const override {
return fBytesWritten;
}
size_t fBytesWritten;
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("aaclip");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(240, 120);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
// Initial pixel-boundary-aligned draw
draw_rect_tests(canvas);
CGImageGM() {}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("cgimage");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(800, 250);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
const struct {
SkColorType fCT;
SkAlphaType fAT;
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("aarectmodes");
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(640, 480); }
+ SkISize onISize() override { return SkISize::Make(640, 480); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
if (false) { // avoid bit rot, suppress warning
test4(canvas);
}
AddArcGM() : fRotate(0) {}
protected:
- SkString onShortName() SK_OVERRIDE { return SkString("addarc"); }
+ SkString onShortName() override { return SkString("addarc"); }
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(1040, 1040); }
+ SkISize onISize() override { return SkISize::Make(1040, 1040); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->translate(20, 20);
SkRect r = SkRect::MakeWH(1000, 1000);
}
}
- bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ bool onAnimate(const SkAnimTimer& timer) override {
fRotate = timer.scaled(1, 360);
return true;
}
AddArcMeasGM() {}
protected:
- SkString onShortName() SK_OVERRIDE { return SkString("addarc_meas"); }
+ SkString onShortName() override { return SkString("addarc_meas"); }
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(2*R + 40, 2*R + 40); }
+ SkISize onISize() override { return SkISize::Make(2*R + 40, 2*R + 40); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->translate(R + 20, R + 20);
SkPaint paint;
StrokeCircleGM() : fRotate(0) {}
protected:
- SkString onShortName() SK_OVERRIDE { return SkString("strokecircle"); }
+ SkString onShortName() override { return SkString("strokecircle"); }
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(520, 520); }
+ SkISize onISize() override { return SkISize::Make(520, 520); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->scale(20, 20);
canvas->translate(13, 13);
}
}
- bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ bool onAnimate(const SkAnimTimer& timer) override {
fRotate = timer.scaled(60, 360);
return true;
}
ManyArcsGM() {}
protected:
- SkString onShortName() SK_OVERRIDE { return SkString("manyarcs"); }
+ SkString onShortName() override { return SkString("manyarcs"); }
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(620, 330); }
+ SkISize onISize() override { return SkISize::Make(620, 330); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
AlphaGradientsGM() {}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("alphagradients");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(640, 480);
}
canvas->drawRect(r, paint);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
static const struct {
SkColor fColor0;
SkColor fColor1;
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("arcofzorro");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1000, 1000);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkRandom rand;
SkRect rect = SkRect::MakeXYWH(10, 10, 200, 200);
virtual ~ASTCBitmapGM() { }
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("astcbitmap");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(kGMDimension, kGMDimension);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
for (int j = 0; j < 4; ++j) {
for (int i = 0; i < 4; ++i) {
SkString filename = GetResourcePath(get_astc_filename(j*4+i));
SkRect fBounds;
};
- const char* name() const SK_OVERRIDE { return "BezierCubicOrConicTestBatch"; }
+ const char* name() const override { return "BezierCubicOrConicTestBatch"; }
static GrBatch* Create(const GrGeometryProcessor* gp, const Geometry& geo,
const SkScalar klmEqs[9], SkScalar sign) {
float fKLM[4]; // The last value is ignored. The effect expects a vec4f.
};
- Geometry* geoData(int index) SK_OVERRIDE {
+ Geometry* geoData(int index) override {
SkASSERT(0 == index);
return &fGeometry;
}
- void onGenerateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE {
+ void onGenerateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
size_t vertexStride = this->geometryProcessor()->getVertexStride();
const GrVertexBuffer* vertexBuffer;
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("bezier_cubic_effects");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(800, 800);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
if (NULL == rt) {
this->drawGpuOnlyMessage(canvas);
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("bezier_conic_effects");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(800, 800);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
if (NULL == rt) {
this->drawGpuOnlyMessage(canvas);
SkRect fBounds;
};
- const char* name() const SK_OVERRIDE { return "BezierQuadTestBatch"; }
+ const char* name() const override { return "BezierQuadTestBatch"; }
static GrBatch* Create(const GrGeometryProcessor* gp, const Geometry& geo,
const GrPathUtils::QuadUVMatrix& devToUV) {
float fKLM[4]; // The last value is ignored. The effect expects a vec4f.
};
- Geometry* geoData(int index) SK_OVERRIDE {
+ Geometry* geoData(int index) override {
SkASSERT(0 == index);
return &fGeometry;
}
- void onGenerateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE {
+ void onGenerateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
size_t vertexStride = this->geometryProcessor()->getVertexStride();
const GrVertexBuffer* vertexBuffer;
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("bezier_quad_effects");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(800, 800);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
if (NULL == rt) {
this->drawGpuOnlyMessage(canvas);
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("beziers");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(W, H*2);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(SkIntToScalar(9)/2);
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("bigblurs");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(kWidth, kHeight);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
static const int kBig = 65536;
static const SkScalar kSigma = SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(4));
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("bigtext");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(640, 480);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
sk_tool_utils::set_portable_typeface(&paint);
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("bitmap_premul");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(SLIDE_SIZE * 2, SLIDE_SIZE * 2);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkScalar slideSize = SkIntToScalar(SLIDE_SIZE);
canvas->drawBitmap(make_argb8888_gradient(), 0, 0);
canvas->drawBitmap(make_argb4444_gradient(), slideSize, 0);
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
SkString str;
str.printf("bitmaprect_%s", fUseIRect ? "i" : "s");
return str;
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(640, 480);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->drawColor(0xFFCCCCCC);
const SkIRect src[] = {
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
SkString str;
str.printf("3x3bitmaprect");
return str;
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(640, 480);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkBitmap bitmap;
make_3x3_bitmap(&bitmap);
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
SkString str;
str.printf("bigbitmaprect_%s", fUseIRect ? "i" : "s");
return str;
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(640, 480);
}
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
make_big_bitmap(&fBigBitmap);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkXfermode* mode = SkXfermode::Create(SkXfermode::kXor_Mode);
BitmapRectRounding() {}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
SkString str;
str.printf("bitmaprect_rounding");
return str;
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(640, 480);
}
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
fBM.allocN32Pixels(10, 10);
fBM.eraseColor(SK_ColorBLUE);
}
// If it does, we may see a red-line at the bottom, instead of the bitmap exactly matching
// the clip (in which case we should see all blue).
// The correct image should be all blue.
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setColor(SK_ColorRED);
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("bitmaprecttest");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(320, 240);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
test_bitmaprect(canvas);
}
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("bitmapscroll");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(800, 600);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
this->init();
SkIRect scrollCenterRegion = SkIRect::MakeXYWH(
quarterWidth, quarterHeight, quarterWidth*2+1, quarterHeight*2+1);
class BitmapShaderGM : public GM {
protected:
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
this->setBGColor(SK_ColorGRAY);
draw_bm(&fBitmap);
draw_mask(&fMask);
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("bitmapsource");
}
canvas.drawText(str, strlen(str), SkIntToScalar(20), SkIntToScalar(70), paint);
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(500, 150); }
+ SkISize onISize() override { return SkISize::Make(500, 150); }
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
this->makeBitmap();
}
canvas->restore();
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->clear(0x00000000);
{
SkRect srcRect = SkRect::MakeXYWH(20, 20, 30, 30);
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("bleed");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(kWidth, 780);
}
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
make_ringed_bitmap(&fBitmapSmall, kSmallTextureSize, kSmallTextureSize);
// To exercise the GPU's tiling path we need a texture
canvas->restore();
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->clear(SK_ColorGRAY);
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return fName;
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(950, 950);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->scale(1.5f, 1.5f);
canvas->translate(50,50);
BlurQuickRejectGM() {}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("blurquickreject");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(kWidth, kHeight);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
static const SkScalar kBlurRadius = SkIntToScalar(20);
static const SkScalar kBoxSize = SkIntToScalar(100);
}
protected:
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
for (int i = 0; i <= kLastEnum_SkBlurStyle; ++i) {
fMaskFilters[i].reset(SkBlurMaskFilter::Create((SkBlurStyle)i,
SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(STROKE_WIDTH/2)),
}
}
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return fName;
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(860, 820);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->translate(STROKE_WIDTH*3/2, STROKE_WIDTH*3/2);
SkRect r = { 0, 0, 100, 50 };
}
protected:
- bool makeMask(SkMask *m, const SkRect& r) SK_OVERRIDE {
+ bool makeMask(SkMask *m, const SkRect& r) override {
return SkBlurMask::BlurRect(SkBlurMask::ConvertRadiusToSigma(this->radius()),
m, r, this->style());
}
}
protected:
- bool makeMask(SkMask *m, const SkRect& r) SK_OVERRIDE {
+ bool makeMask(SkMask *m, const SkRect& r) override {
SkMask src;
r.roundOut(&src.fBounds);
src.fBounds.offset(-src.fBounds.fLeft, -src.fBounds.fTop); // move to origin
}
protected:
- SkBlurQuality getQuality() SK_OVERRIDE {
+ SkBlurQuality getQuality() override {
return kLow_SkBlurQuality;
}
private:
}
protected:
- bool makeMask(SkMask *m, const SkRect& r) SK_OVERRIDE {
+ bool makeMask(SkMask *m, const SkRect& r) override {
SkMask src;
r.roundOut(&src.fBounds);
src.fBounds.offset(-src.fBounds.fLeft, -src.fBounds.fTop); // move to origin
fRRect.setRectRadii(r, radii);
}
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return fName;
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(SkScalarCeilToInt(fRRect.rect().width()),
SkScalarCeilToInt(fRRect.rect().height()));
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkLayerDrawLooper::Builder looperBuilder;
{
SkLayerDrawLooper::LayerInfo info;
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return fName;
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1000, 500);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->scale(1.5f, 1.5f);
canvas->translate(50,50);
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("blurs");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(700, 500);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkBlurStyle NONE = SkBlurStyle(-999);
static const struct {
SkBlurStyle fStyle;
//
class Blur2RectsGM : public skiagm::GM {
public:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("blur2rects");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(700, 500);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setMaskFilter(SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
class Blur2RectsNonNinePatchGM : public skiagm::GM {
public:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("blur2rectsnonninepatch");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(700, 500);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setMaskFilter(SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
4.3f))->unref();
C_GM() {}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("c_gms");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(640, 480);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
sk_test_c_api((sk_canvas_t*)canvas);
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("circles");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1200, 900);
}
}
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
// Draw a giant AA circle as the background.
SkISize size = this->getISize();
SkScalar giantRadius = SkTMin(SkIntToScalar(size.fWidth),
SkPath fCircle1, fCircle2;
protected:
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
fX1 = 80;
fX2 = 120;
fY = 50;
}
- bool runAsBench() const SK_OVERRIDE { return true; }
+ bool runAsBench() const override { return true; }
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("circular-clips");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(800, 600);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkRegion::Op ops[] = {
SkRegion::kDifference_Op,
SkRegion::kIntersect_Op,
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("clip_strokerect");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(200, 400);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint p;
p.setColor(SK_ColorRED);
p.setAntiAlias(true);
ClipDrawDrawGM() { this->setBGColor(0xFFCCCCCC); }
protected:
- SkString onShortName() SK_OVERRIDE { return SkString("clipdrawdraw"); }
+ SkString onShortName() override { return SkString("clipdrawdraw"); }
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(512, 512); }
+ SkISize onISize() override { return SkISize::Make(512, 512); }
static void Draw(SkCanvas* canvas, const SkRect& rect) {
SkPaint p;
canvas->restore();
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
// Vertical remnant
const SkRect rect1 = SkRect::MakeLTRB(136.5f, 137.5f, 338.5f, 293.5f);
CMYKJpegGM() {}
protected:
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
// parameters to the "decode" call
bool dither = false;
}
}
- virtual SkString onShortName() SK_OVERRIDE {
+ virtual SkString onShortName() override {
return SkString("cmykjpeg");
}
- virtual SkISize onISize() SK_OVERRIDE {
+ virtual SkISize onISize() override {
return SkISize::Make(640, 480);
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(SkCanvas* canvas) override {
canvas->translate(20*SK_Scalar1, 20*SK_Scalar1);
canvas->drawBitmap(fBitmap, 0, 0);
SkTypeface* typeface;
const char* text;
} emojiFonts[2];
- virtual void onOnceBeforeDraw() SK_OVERRIDE {
+ virtual void onOnceBeforeDraw() override {
SkString filename = GetResourcePath("/Funkster.ttf");
SkAutoTDelete<SkFILEStream> stream(new SkFILEStream(filename.c_str()));
if (stream->isValid()) {
"\xF0\x9F\x87\xBA" "\xF0\x9F\x87\xB8" "\xF0\x9F\x87\xA6"; // 🇺🇸🇦
}
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("coloremoji");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(650, 900);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->drawColor(SK_ColorGRAY);
}
protected:
- virtual SkString onShortName() SK_OVERRIDE {
+ virtual SkString onShortName() override {
return fName;
}
- virtual SkISize onISize() SK_OVERRIDE {
+ virtual SkISize onISize() override {
return SkISize::Make(640, 480);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
SkRect r;
r.setWH(600, 50);
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("colortype");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(640, 480);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
paint.setTypeface(fColorType);
class ColorTypeXfermodeGM : public GM {
SkBitmap fBG;
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
fBG.installPixels(SkImageInfo::Make(2, 2, kARGB_4444_SkColorType,
kOpaque_SkAlphaType), gData, 4);
}
}
protected:
- virtual SkString onShortName() SK_OVERRIDE {
+ virtual SkString onShortName() override {
return SkString("colortype_xfermodes");
}
- virtual SkISize onISize() SK_OVERRIDE {
+ virtual SkISize onISize() override {
return SkISize::Make(400, 640);
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(SkCanvas* canvas) override {
canvas->translate(SkIntToScalar(10), SkIntToScalar(20));
const struct {
}
protected:
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
this->setBGColor(SkColorSetRGB(0xDD,0xA0,0xDD));
// offset the rects a bit so we get antialiasing even in the rect case
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("composeshader");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(120, 120);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
ComposeShaderAlphaGM() {}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("composeshader_alpha");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(220, 750);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkAutoTUnref<SkShader> shader0(make_shader(SkXfermode::kDstIn_Mode));
SkAutoTUnref<SkShader> shader1(make_shader(SkXfermode::kSrcOver_Mode));
SkShader* shaders[] = { shader0.get(), shader1.get() };
ConcavePathsGM() {}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("concavepaths");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(WIDTH, HEIGHT);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
class ConicPathsGM : public skiagm::GM {
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("conicpaths");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(920, 960);
}
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
{
const SkScalar w = SkScalarSqrt(2)/2;
SkPath* conicCirlce = &fPaths.push_back();
canvas->drawPath(fGiantCircle, paint);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
const SkAlpha kAlphaValue[] = { 0xFF, 0x40 };
const SkScalar margin = 15;
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("convex_poly_clip");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
// When benchmarking the saveLayer set of draws is skipped.
int w = 435;
if (kBench_Mode != this->getMode()) {
return SkISize::Make(w, 540);
}
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
SkPath tri;
tri.moveTo(5.f, 5.f);
tri.lineTo(100.f, 20.f);
fBmp = make_bmp(100, 100);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkScalar y = 0;
static const SkScalar kMargin = 10.f;
}
}
- bool runAsBench() const SK_OVERRIDE { return true; }
+ bool runAsBench() const override { return true; }
private:
class Clip {
SkRect fBounds;
};
- const char* name() const SK_OVERRIDE { return "ConvexPolyTestBatch"; }
+ const char* name() const override { return "ConvexPolyTestBatch"; }
static GrBatch* Create(const GrGeometryProcessor* gp, const Geometry& geo) {
return SkNEW_ARGS(ConvexPolyTestBatch, (gp, geo));
, fGeometry(geo) {
}
- Geometry* geoData(int index) SK_OVERRIDE {
+ Geometry* geoData(int index) override {
SkASSERT(0 == index);
return &fGeometry;
}
- void onGenerateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE {
+ void onGenerateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
size_t vertexStride = this->geometryProcessor()->getVertexStride();
const GrVertexBuffer* vertexBuffer;
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("convex_poly_effect");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(720, 800);
}
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
SkPath tri;
tri.moveTo(5.f, 5.f);
tri.lineTo(100.f, 20.f);
fRects.addToTail(SkRect::MakeLTRB(100.f, 50.5f, 5.f, 0.5f));
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
if (NULL == rt) {
this->drawGpuOnlyMessage(canvas);
protected:
- bool runAsBench() const SK_OVERRIDE { return true; }
+ bool runAsBench() const override { return true; }
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
if (fDoAA) {
return SkString("dashing5_aa");
} else {
}
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(400, 200); }
+ SkISize onISize() override { return SkISize::Make(400, 200); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
static const int kOn = 4;
static const int kOff = 4;
static const int kIntervalLength = kOn + kOff;
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(DCShader);
- void flatten(SkWriteBuffer& buf) const SK_OVERRIDE {
+ void flatten(SkWriteBuffer& buf) const override {
buf.writeMatrix(fDeviceMatrix);
}
bool asFragmentProcessor(GrContext*, const SkPaint& paint, const SkMatrix& viewM,
const SkMatrix* localMatrix, GrColor* color,
- GrFragmentProcessor** fp) const SK_OVERRIDE;
+ GrFragmentProcessor** fp) const override;
#ifndef SK_IGNORE_TO_STRING
- void toString(SkString* str) const SK_OVERRIDE {
+ void toString(SkString* str) const override {
str->appendf("DCShader: ()");
}
#endif
}
void getGLProcessorKey(const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE {}
+ GrProcessorKeyBuilder* b) const override {}
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ GrGLFragmentProcessor* createGLInstance() const override {
class DCGLFP : public GrGLFragmentProcessor {
void emitCode(GrGLFPBuilder* builder,
const GrFragmentProcessor& fp,
"%s = color * %s;",
outputColor, GrGLSLExpr4(inputColor).c_str());
}
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE {}
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override {}
};
return SkNEW(DCGLFP);
}
- const char* name() const SK_OVERRIDE { return "DCFP"; }
+ const char* name() const override { return "DCFP"; }
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE {
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
inout->mulByUnknownFourComponents();
}
private:
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE { return true; }
+ bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
GrCoordTransform fDeviceTransform;
};
this->setBGColor(0xFFAABBCC);
}
- ~DCShaderGM() SK_OVERRIDE {
+ ~DCShaderGM() override {
for (int i = 0; i < fPrims.count(); ++i) {
SkDELETE(fPrims[i]);
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("dcshader");
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(1000, 900); }
+ SkISize onISize() override { return SkISize::Make(1000, 900); }
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
struct Rect : public Prim {
- SkRect draw(SkCanvas* canvas, const SkPaint& paint) SK_OVERRIDE {
+ SkRect draw(SkCanvas* canvas, const SkPaint& paint) override {
SkRect rect = SkRect::MakeXYWH(0, 0, 50, 50);
canvas->drawRect(rect, paint);
return rect;
};
struct Circle : public Prim {
- SkRect draw(SkCanvas* canvas, const SkPaint& paint) SK_OVERRIDE {
+ SkRect draw(SkCanvas* canvas, const SkPaint& paint) override {
static const SkScalar radius = 25;
canvas->drawCircle(radius, radius, radius, paint);
return SkRect::MakeXYWH(0, 0, 2 * radius, 2 * radius);
};
struct RRect : public Prim {
- SkRect draw(SkCanvas* canvas, const SkPaint& paint) SK_OVERRIDE {
+ SkRect draw(SkCanvas* canvas, const SkPaint& paint) override {
SkRRect rrect;
rrect.setRectXY(SkRect::MakeXYWH(0, 0, 50, 50), 10, 10);
canvas->drawRRect(rrect, paint);
};
struct DRRect : public Prim {
- SkRect draw(SkCanvas* canvas, const SkPaint& paint) SK_OVERRIDE {
+ SkRect draw(SkCanvas* canvas, const SkPaint& paint) override {
SkRRect outerRRect;
outerRRect.setRectXY(SkRect::MakeXYWH(0, 0, 50, 50), 5, 5);
SkRRect innerRRect;
}
};
struct Path : public Prim {
- SkRect draw(SkCanvas* canvas, const SkPaint& paint) SK_OVERRIDE {
+ SkRect draw(SkCanvas* canvas, const SkPaint& paint) override {
SkPath path;
path.addCircle(15, 15, 10);
path.addOval(SkRect::MakeXYWH(2, 2, 22, 37));
struct Points : public Prim {
Points(SkCanvas::PointMode mode) : fMode(mode) {}
- SkRect draw(SkCanvas* canvas, const SkPaint& paint) SK_OVERRIDE {
+ SkRect draw(SkCanvas* canvas, const SkPaint& paint) override {
SkRandom random;
SkPoint points[500];
SkRect bounds = SkRect::MakeWH(50, 50);
};
struct Text : public Prim {
- SkRect draw(SkCanvas* canvas, const SkPaint& origPaint) SK_OVERRIDE {
+ SkRect draw(SkCanvas* canvas, const SkPaint& origPaint) override {
SkPaint paint = origPaint;
paint.setTextSize(30.f);
this->setFont(&paint);
};
struct BmpText : public Text {
- void setFont(SkPaint* paint) SK_OVERRIDE {
+ void setFont(SkPaint* paint) override {
if (!fTypeface) {
SkString filename = GetResourcePath("/Funkster.ttf");
SkAutoTDelete<SkFILEStream> stream(new SkFILEStream(filename.c_str()));
paint->setTypeface(fTypeface);
}
- const char* text() const SK_OVERRIDE { return "Hi, Skia!"; }
+ const char* text() const override { return "Hi, Skia!"; }
SkAutoTUnref<SkTypeface> fTypeface;
};
fPrims.push_back(SkNEW(BmpText));
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
// This GM exists to test a specific feature of the GPU backend. It does not work with the
// sw rasterizer, tile modes, etc.
if (NULL == canvas->getGrContext()) {
}
protected:
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
SkString filename = GetResourcePath("/Funkster.ttf");
SkAutoTDelete<SkFILEStream> stream(new SkFILEStream(filename.c_str()));
if (!stream->isValid()) {
fTypeface = SkTypeface::CreateFromStream(stream.detach());
}
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("dftext");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1024, 768);
}
canvas->translate(-px, -py);
}
- virtual void onDraw(SkCanvas* inputCanvas) SK_OVERRIDE {
+ virtual void onDraw(SkCanvas* inputCanvas) override {
#ifdef SK_BUILD_FOR_ANDROID
SkScalar textSizes[] = { 9.0f, 9.0f*2.0f, 9.0f*5.0f, 9.0f*2.0f*5.0f };
#else
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("discard");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(100, 100);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
GrContext* context = canvas->getGrContext();
if (NULL == context) {
return;
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return fName;
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
make_bitmap_wrapper();
return SkISize::Make(fBM.width(), 4 * fBM.height());
}
virtual void make_bitmap() = 0;
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
make_bitmap_wrapper();
int curY = 0;
protected:
float fTextSize;
- void make_bitmap() SK_OVERRIDE {
+ void make_bitmap() override {
fBM.allocN32Pixels(int(fTextSize * 8), int(fTextSize * 6));
SkCanvas canvas(fBM);
canvas.drawColor(SK_ColorWHITE);
int fSize;
int fNumChecks;
- void make_bitmap() SK_OVERRIDE {
+ void make_bitmap() override {
make_checker(&fBM, fSize, fNumChecks);
}
private:
SkString fFilename;
int fSize;
- void make_bitmap() SK_OVERRIDE {
+ void make_bitmap() override {
SkImageDecoder* codec = NULL;
SkString resourcePath = GetResourcePath(fFilename.c_str());
SkFILEStream stream(resourcePath.c_str());
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("showmiplevels");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(fBM.width() + 8, 2 * fBM.height() + 80);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkScalar x = 4;
SkScalar y = 4;
canvas->drawBitmap(fBM, x, y, NULL);
SkString fName;
protected:
- SkString onShortName() SK_OVERRIDE { return fName; }
+ SkString onShortName() override { return fName; }
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(gSize, gSize); }
+ SkISize onISize() override { return SkISize::Make(gSize, gSize); }
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
fImage.reset(makebm(&fLargeBitmap, gBmpSize, gBmpSize));
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkRect dstRect = { 0, 0, SkIntToScalar(64), SkIntToScalar(64)};
static const int kMaxSrcRectSize = 1 << (SkNextLog2(gBmpSize) + 2);
class TestFilter : public SkDrawFilter {
public:
- bool filter(SkPaint* p, Type) SK_OVERRIDE {
+ bool filter(SkPaint* p, Type) override {
p->setColor(SK_ColorRED);
p->setMaskFilter(NULL);
return true;
SkAutoTUnref<SkMaskFilter> fBlur;
protected:
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(320, 240);
}
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("drawfilter");
}
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
fBlur.reset(SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
SkBlurMask::ConvertRadiusToSigma(10.0f),
kLow_SkBlurQuality));
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint p;
p.setColor(SK_ColorBLUE);
p.setMaskFilter(fBlur.get());
}
protected:
- virtual SkISize onISize() SK_OVERRIDE {
+ virtual SkISize onISize() override {
return SkISize::Make(520, 160);
}
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("drawlooper");
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
this->init();
SkPaint paint;
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("drrect");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(640, 480);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
kNumShapeTypes
};
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("dstreadshuffle");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(kWidth, kHeight);
}
}
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkRandom random;
SkScalar y = 100;
for (int i = 0; i < kNumShapeTypes; i++) {
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("emboss");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(600, 120);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
SkBitmap bm = make_bm();
canvas->drawBitmap(bm, 10, 10, &paint);
virtual ~ETC1BitmapGM() { }
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
SkString str = SkString("etc1bitmap_");
str.append(this->fileExtension());
return str;
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(128, 128);
}
virtual SkString fileExtension() const = 0;
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkBitmap bm;
SkString filename = GetResourcePath("mandrill_128.");
filename.append(this->fileExtension());
protected:
- SkString fileExtension() const SK_OVERRIDE { return SkString("pkm"); }
+ SkString fileExtension() const override { return SkString("pkm"); }
private:
typedef ETC1BitmapGM INHERITED;
protected:
- SkString fileExtension() const SK_OVERRIDE { return SkString("ktx"); }
+ SkString fileExtension() const override { return SkString("ktx"); }
private:
typedef ETC1BitmapGM INHERITED;
protected:
- SkString fileExtension() const SK_OVERRIDE { return SkString("r11.ktx"); }
+ SkString fileExtension() const override { return SkString("r11.ktx"); }
private:
typedef ETC1BitmapGM INHERITED;
virtual ~ETC1Bitmap_NPOT_GM() { }
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("etc1bitmap_npot");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(124, 124);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkBitmap bm;
SkString pkmFilename = GetResourcePath("mandrill_128.pkm");
SkAutoDataUnref fileData(SkData::NewFromFileName(pkmFilename.c_str()));
protected:
// overrides from SkEventSink
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("extractbitmap");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(600, 600);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkBitmap bitmap;
create_bitmap(&bitmap);
int x = bitmap.width() / 2;
FactoryGM() {}
protected:
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
// Copyright-free file from http://openclipart.org/detail/29213/paper-plane-by-ddoo
SkString pngFilename = GetResourcePath("plane.png");
SkAutoDataUnref data(SkData::NewFromFileName(pngFilename.c_str()));
}
}
- virtual SkString onShortName() SK_OVERRIDE {
+ virtual SkString onShortName() override {
return SkString("factory");
}
- virtual SkISize onISize() SK_OVERRIDE {
+ virtual SkISize onISize() override {
return SkISize::Make(640, 480);
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(SkCanvas* canvas) override {
canvas->drawBitmap(fBitmap, 0, 0);
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("filltypes");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(835, 840);
}
scale, paint);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
this->makePath();
canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("filltypespersp");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(835, 840);
}
scale, paint);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
this->makePath();
// do perspective drawPaint as the background;
}
class FilterBitmapGM : public skiagm::GM {
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
this->makeBitmap();
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return fName;
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1024, 768);
}
virtual void makeBitmap() = 0;
virtual SkScalar getScale() = 0;
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->translate(10, 10);
for (size_t i = 0; i < SK_ARRAY_COUNT(fMatrix); ++i) {
protected:
float fTextSize;
- SkScalar getScale() SK_OVERRIDE {
+ SkScalar getScale() override {
return 32.f/fTextSize;
}
- void makeBitmap() SK_OVERRIDE {
+ void makeBitmap() override {
fBM.allocN32Pixels(int(fTextSize * 8), int(fTextSize * 6));
SkCanvas canvas(fBM);
canvas.drawColor(SK_ColorWHITE);
int fSize;
int fNumChecks;
- SkScalar getScale() SK_OVERRIDE {
+ SkScalar getScale() override {
return 192.f/fSize;
}
- void makeBitmap() SK_OVERRIDE {
+ void makeBitmap() override {
fBM.allocN32Pixels(fSize, fSize);
for (int y = 0; y < fSize; y ++) {
for (int x = 0; x < fSize; x ++) {
SkString fFilename;
int fSize;
- SkScalar getScale() SK_OVERRIDE {
+ SkScalar getScale() override {
return 192.f/fSize;
}
- void makeBitmap() SK_OVERRIDE {
+ void makeBitmap() override {
SkImageDecoder* codec = NULL;
SkString resourcePath = GetResourcePath(fFilename.c_str());
SkFILEStream stream(resourcePath.c_str());
static const int kNumVertTiles = 6;
static const int kNumXtraCols = 2;
- SkString onShortName() SK_OVERRIDE{ return SkString("filterfastbounds"); }
+ SkString onShortName() override{ return SkString("filterfastbounds"); }
- SkISize onISize() SK_OVERRIDE{
+ SkISize onISize() override{
return SkISize::Make((SK_ARRAY_COUNT(gDrawMthds) + kNumXtraCols) * kTileWidth,
kNumVertTiles * kTileHeight);
}
canvas->restore();
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE{
+ void onDraw(SkCanvas* canvas) override{
SkPaint blackFill;
}
class FilterIndiaBoxGM : public skiagm::GM {
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
this->makeBitmap();
SkScalar cx = SkScalarHalf(fBM.width());
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return fName;
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1024, 768);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->translate(10, 10);
for (size_t i = 0; i < SK_ARRAY_COUNT(fMatrix); ++i) {
SkSize size = computeSize(fBM, fMatrix[i]);
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("fontcache");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1280, 640);
}
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
fTypefaces[0] = sk_tool_utils::create_portable_typeface("serif", SkTypeface::kItalic);
fTypefaces[1] = sk_tool_utils::create_portable_typeface("sans-serif", SkTypeface::kItalic);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
paint.setLCDRenderText(true);
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return fName;
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1536, 768);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkScalar y = 20;
SkPaint paint;
paint.setAntiAlias(true);
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("fontmgr_match");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(640, 1024);
}
}
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
paint.setLCDRenderText(true);
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return fName;
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1024, 850);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
paint.setSubpixelText(true);
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("fontscaler");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1450, 750);
}
canvas->translate(-px, -py);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
class GammaTextGM : public skiagm::GM {
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("gammatext");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1024, HEIGHT);
}
canvas->drawRect(r, paint);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
drawGrad(canvas);
const SkColor fg[] = {
}
}
- ~GammaShaderTextGM() SK_OVERRIDE {
+ ~GammaShaderTextGM() override {
for (size_t i = 0; i < SK_ARRAY_COUNT(fShaders); ++i) {
SkSafeUnref(fShaders[i]);
}
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("gammagradienttext");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(300, 300);
}
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
for (size_t i = 0; i < SK_ARRAY_COUNT(fShaders); ++i) {
fShaders[i] = make_gradient(fColors[i]);
}
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
paint.setLCDRenderText(true);
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("getpostextpath");
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(480, 780); }
+ SkISize onISize() override { return SkISize::Make(480, 780); }
static void strokePath(SkCanvas* canvas, const SkPath& path) {
SkPaint paint;
canvas->drawPath(path, paint);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
// explicitly add spaces, to test a prev. bug
const char* text = "Ham bur ge fons";
int len = SkToInt(strlen(text));
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
SkString str("giantbitmap_");
switch (fMode) {
case SkShader::kClamp_TileMode:
return str;
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(640, 480); }
+ SkISize onISize() override { return SkISize::Make(640, 480); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
SkMatrix m;
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
SkString str("glyph_pos");
if (fStrokeWidth == 0.0f) {
str.append("_h"); // h == Hairline.
return str;
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(800, 600); }
+ SkISize onISize() override { return SkISize::Make(800, 600); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
if (!fProp) {
fProp.reset(sk_tool_utils::create_portable_typeface("Helvetica", SkTypeface::kNormal));
}
class GlyphPosAlignGM : public GM {
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("glyph_pos_align");
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(kWidth, kHeight); }
+ SkISize onISize() override { return SkISize::Make(kWidth, kHeight); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->clear(SK_ColorBLACK);
SkPaint paint;
const SkISize& size)
: fName(name), fDrawProc(drawProc), fSize(size) {}
protected:
- void onDraw(SkCanvas* canvas) SK_OVERRIDE;
- SkISize onISize() SK_OVERRIDE;
- SkString onShortName() SK_OVERRIDE;
+ void onDraw(SkCanvas* canvas) override;
+ SkISize onISize() override;
+ SkString onShortName() override;
private:
SkString fName;
void (*fDrawProc)(SkCanvas*);
*/
explicit IndividualImageExpectationsSource(const char *rootDir) : fRootDir(rootDir) {}
- Expectations get(const char *testName) const SK_OVERRIDE ;
+ Expectations get(const char *testName) const override ;
private:
const SkString fRootDir;
*/
explicit JsonExpectationsSource(const char *jsonPath);
- Expectations get(const char *testName) const SK_OVERRIDE;
+ Expectations get(const char *testName) const override;
private:
}
protected:
- SkString onShortName() SK_OVERRIDE { return SkString("gradient_dirty_laundry"); }
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(640, 615); }
+ SkString onShortName() override { return SkString("gradient_dirty_laundry"); }
+ SkISize onISize() override { return SkISize::Make(640, 615); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPoint pts[2] = { { 0, 0 },
{ SkIntToScalar(100), SkIntToScalar(100) }
};
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("gradient_matrix");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(800, 800);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
draw_gradients(canvas, &make_linear_gradient,
linearPts, SK_ARRAY_COUNT(linearPts));
protected:
- SkString onShortName() SK_OVERRIDE { return SkString("radial_gradient"); }
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(1280, 1280); }
+ SkString onShortName() override { return SkString("radial_gradient"); }
+ SkISize onISize() override { return SkISize::Make(1280, 1280); }
void drawBG(SkCanvas* canvas) {
canvas->drawColor(0xFF000000);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
const SkISize dim = this->getISize();
this->drawBG(canvas);
protected:
- SkString onShortName() SK_OVERRIDE { return SkString("radial_gradient2"); }
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(800, 400); }
+ SkString onShortName() override { return SkString("radial_gradient2"); }
+ SkISize onISize() override { return SkISize::Make(800, 400); }
void drawBG(SkCanvas* canvas) {
canvas->drawColor(0xFF000000);
}
// Reproduces the example given in bug 7671058.
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint1, paint2, paint3;
paint1.setStyle(SkPaint::kFill_Style);
paint2.setStyle(SkPaint::kFill_Style);
protected:
- SkString onShortName() SK_OVERRIDE { return SkString("gradients_no_texture"); }
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(640, 615); }
+ SkString onShortName() override { return SkString("gradients_no_texture"); }
+ SkISize onISize() override { return SkISize::Make(640, 615); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
static const SkPoint kPts[2] = { { 0, 0 },
{ SkIntToScalar(50), SkIntToScalar(50) } };
static const SkShader::TileMode kTM = SkShader::kClamp_TileMode;
protected:
- SkString onShortName() SK_OVERRIDE { return SkString("gradients_many"); }
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(850, 100); }
+ SkString onShortName() override { return SkString("gradients_many"); }
+ SkISize onISize() override { return SkISize::Make(850, 100); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
const Proc procs[] = {
make0, make1, make2,
};
GradTextGM () {}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("gradtext");
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(500, 480); }
+ SkISize onISize() override { return SkISize::Make(500, 480); }
static void draw_text(SkCanvas* canvas, const SkPaint& paint) {
const char* text = "When in the course of human events";
draw_text(canvas, p);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
sk_tool_utils::set_portable_typeface(&paint);
paint.setTextSize(SkIntToScalar(26));
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("hairlines");
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(1250, 1250); }
+ SkISize onISize() override { return SkISize::Make(1250, 1250); }
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
{
SkPath* lineAnglesPath = &fPaths.push_back();
enum {
}
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
static const SkAlpha kAlphaValue[] = { 0xFF, 0x40 };
static const SkScalar kWidths[] = { 0, 0.5f, 1.5f };
SkPaint fBGPaint;
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("hairmodes");
}
- virtual SkISize onISize() SK_OVERRIDE { return SkISize::Make(640, 480); }
+ virtual SkISize onISize() override { return SkISize::Make(640, 480); }
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
fBGPaint.setShader(make_bg_shader())->unref();
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
const SkRect bounds = SkRect::MakeWH(W, H);
static const SkAlpha gAlphaValue[] = { 0xFF, 0x88, 0x88 };
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("hittestpath");
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(700, 460); }
+ SkISize onISize() override { return SkISize::Make(700, 460); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPath path;
SkRandom rand;
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("image-surface");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(960, 1200);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
drawJpeg(canvas, this->getISize());
canvas->scale(2, 2);
ImageResizeGM() {}
protected:
- SkString onShortName() SK_OVERRIDE { return SkString("image-resize"); }
+ SkString onShortName() override { return SkString("image-resize"); }
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(510, 480); }
+ SkISize onISize() override { return SkISize::Make(510, 480); }
void drawIntoImage(SkCanvas* canvas) {
SkPaint paint;
this->drawResized(canvas, image, W, H, &subset, fq);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->translate(10, 10);
SkAutoTUnref<SkImage> image(this->makeImage(canvas));
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("imagealphathreshold");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(WIDTH, HEIGHT);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkIRect rects[2];
rects[0] = SkIRect::MakeXYWH(0, 150, WIDTH, HEIGHT - 300);
rects[1] = SkIRect::MakeXYWH(150, 0, WIDTH - 300, HEIGHT);
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return fName;
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(WIDTH, HEIGHT);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setImageFilter(SkBlurImageFilter::Create(fSigmaX, fSigmaY))->unref();
canvas->saveLayer(NULL, &paint);
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return fName;
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(WIDTH, HEIGHT);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
const int sigmaCount = SK_ARRAY_COUNT(kBlurSigmas);
const int testStringCount = SK_ARRAY_COUNT(kTestStrings);
SkScalar dx = WIDTH / sigmaCount;
FailImageFilter() : INHERITED(0, NULL) {}
bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE {
+ SkBitmap* result, SkIPoint* offset) const override {
return false;
}
IdentityImageFilter(SkImageFilter* input) : INHERITED(1, &input) {}
bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE {
+ SkBitmap* result, SkIPoint* offset) const override {
*result = src;
offset->set(0, 0);
return true;
ImageFiltersBaseGM () {}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("imagefiltersbase");
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(700, 500); }
+ SkISize onISize() override { return SkISize::Make(700, 500); }
void draw_frame(SkCanvas* canvas, const SkRect& r) {
SkPaint paint;
canvas->drawRect(r, paint);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
void (*drawProc[])(SkCanvas*, const SkRect&, SkImageFilter*) = {
draw_paint,
draw_line, draw_rect, draw_path, draw_text,
ImageFiltersTextBaseGM(const char suffix[]) : fSuffix(suffix) {}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
SkString name;
name.printf("%s_%s", "textfilter", fSuffix.c_str());
return name;
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(512, 342); }
+ SkISize onISize() override { return SkISize::Make(512, 342); }
void drawWaterfall(SkCanvas* canvas, const SkPaint& origPaint) {
const uint32_t flags[] = {
virtual void installFilter(SkPaint* paint) = 0;
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
canvas->translate(20, 40);
public:
ImageFiltersText_IF() : ImageFiltersTextBaseGM("image") {}
- void installFilter(SkPaint* paint) SK_OVERRIDE {
+ void installFilter(SkPaint* paint) override {
paint->setImageFilter(SkBlurImageFilter::Create(1.5f, 1.5f))->unref();
}
};
public:
ImageFiltersText_CF() : ImageFiltersTextBaseGM("color") {}
- void installFilter(SkPaint* paint) SK_OVERRIDE {
+ void installFilter(SkPaint* paint) override {
paint->setColorFilter(SkColorFilter::CreateModeFilter(SK_ColorBLUE, SkXfermode::kSrcIn_Mode))->unref();
}
};
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("imagefiltersclipped");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(860, 500);
}
canvas.drawCircle(x, y, radius, paint);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
if (!fInitialized) {
fCheckerboard.allocN32Pixels(64, 64);
SkCanvas checkerboardCanvas(fCheckerboard);
ImageFiltersCroppedGM () {}
protected:
- virtual SkString onShortName() SK_OVERRIDE {
+ virtual SkString onShortName() override {
return SkString("imagefilterscropped");
}
- virtual SkISize onISize() SK_OVERRIDE { return SkISize::Make(400, 880); }
+ virtual SkISize onISize() override { return SkISize::Make(400, 880); }
void make_checkerboard() {
fCheckerboard.allocN32Pixels(80, 80);
canvas->drawRect(r, paint);
}
- virtual void onOnceBeforeDraw() SK_OVERRIDE{
+ virtual void onOnceBeforeDraw() override{
make_checkerboard();
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(SkCanvas* canvas) override {
void (*drawProc[])(SkCanvas*, const SkRect&, SkImageFilter*) = {
draw_sprite, draw_bitmap, draw_path, draw_paint, draw_text
};
}
virtual bool onFilterImage(Proxy* proxy, const SkBitmap& src, const Context& ctx,
- SkBitmap* dst, SkIPoint* offset) const SK_OVERRIDE {
+ SkBitmap* dst, SkIPoint* offset) const override {
SkBitmap source = src;
SkImageFilter* input = getInput(0);
SkIPoint srcOffset = SkIPoint::Make(0, 0);
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SimpleOffsetFilter);
protected:
- void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
+ void flatten(SkWriteBuffer& buffer) const override {
this->INHERITED::flatten(buffer);
buffer.writeScalar(fDX);
buffer.writeScalar(fDY);
protected:
- SkString onShortName() SK_OVERRIDE { return SkString("imagefilterstransformed"); }
+ SkString onShortName() override { return SkString("imagefilterstransformed"); }
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(420, 240); }
+ SkISize onISize() override { return SkISize::Make(420, 240); }
void makeGradientCircle(int width, int height) {
SkScalar x = SkIntToScalar(width / 2);
canvas.drawCircle(x, y, radius, paint);
}
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
fCheckerboard.allocN32Pixels(64, 64);
SkCanvas checkerboardCanvas(fCheckerboard);
sk_tool_utils::draw_checkerboard(&checkerboardCanvas, 0xFFA0A0A0, 0xFF404040, 8);
this->makeGradientCircle(64, 64);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkAutoTUnref<SkImageFilter> gradient(SkBitmapSource::Create(fGradientCircle));
SkAutoTUnref<SkImageFilter> checkerboard(SkBitmapSource::Create(fCheckerboard));
SkImageFilter* filters[] = {
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("imagemagnifier");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(WIDTH, HEIGHT);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint filterPaint;
filterPaint.setImageFilter(
SkMagnifierImageFilter::Create(
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("imageresizetiled");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(WIDTH, HEIGHT);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
SkMatrix matrix;
matrix.setScale(RESIZE_FACTOR, RESIZE_FACTOR);
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("inverse_paths");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(800, 900);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkScalar cx = slideWidth / 2 + slideBoundary;
SkScalar cy = slideHeight / 2 + slideBoundary;
SkScalar dx = slideWidth + 2 * slideBoundary;
LerpXfermodeGM() {}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("lerpmode");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(240, 120);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
show_circlelayers(canvas, NULL);
canvas->translate(150, 0);
SkAutoTUnref<SkXfermode> mode(SkLerpXfermode::Create(0.5f));
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("lighting");
}
canvas.drawText(str, strlen(str), SkIntToScalar(20), SkIntToScalar(70), paint);
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(WIDTH, HEIGHT);
}
canvas->restore();
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
if (!fInitialized) {
make_bitmap();
fInitialized = true;
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("lumafilter");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(600, 420);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkXfermode::Mode modes[] = { SkXfermode::kSrcOver_Mode,
SkXfermode::kDstOver_Mode,
SkXfermode::kSrcATop_Mode,
MipMapGM() {}
protected:
- SkString onShortName() SK_OVERRIDE { return SkString("mipmap"); }
+ SkString onShortName() override { return SkString("mipmap"); }
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(400, 200); }
+ SkISize onISize() override { return SkISize::Make(400, 200); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
test_mip(canvas);
}
kNumShapeTypes
};
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("mixed_xfermodes");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(790, 640);
}
}
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
if (NULL == fBG.get()) {
static uint32_t kCheckerPixelData[] = { 0xFFFFFFFF,
0xFFCCCCCC,
Layout fLayout;
const SkPicture* fPictures[kNumPictures];
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
fPictures[0] = make_hex_plane_picture(SK_ColorWHITE);
fPictures[1] = make_hex_plane_picture(SK_ColorGRAY);
fPictures[2] = make_sierpinski_picture();
fPictures[3] = make_single_layer_hex_plane_picture();
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkMultiPictureDraw mpd;
SkTArray<ComposeStep> composeSteps;
}
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(kPicWidth, kPicHeight); }
+ SkISize onISize() override { return SkISize::Make(kPicWidth, kPicHeight); }
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
static const char* gContentNames[] = {
"noclip", "rectclip", "rrectclip", "pathclip",
"invpathclip", "sierpinski", "biglayer"
return name;
}
- bool runAsBench() const SK_OVERRIDE { return true; }
+ bool runAsBench() const override { return true; }
private:
typedef GM INHERITED;
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
SkString name("nested");
if (fDoAA) {
name.append("_aa");
return name;
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(kImageWidth, kImageHeight);
}
}
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint shapePaint;
shapePaint.setColor(SK_ColorBLACK);
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("nonclosedpaths");
}
// 12 * 18 + 3 cases, every case is 100 * 100 pixels.
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1220, 1920);
}
canvas->translate(x, y);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
// Stroke widths are:
// 0(may use hairline rendering), 10(common case for stroke-style)
// 40 and 50(>= geometry width/height, make the contour filled in fact)
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("ovals");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1200, 900);
}
return SkHSVToColor(hsv);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkRandom rand(1);
canvas->translate(20 * SK_Scalar1, 20 * SK_Scalar1);
SkRect oval = SkRect::MakeLTRB(-20, -30, 20, 30);
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("patch_primitive");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(800, 800);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("patch_grid");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(800, 800);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("patheffect");
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(800, 600); }
+ SkISize onISize() override { return SkISize::Make(800, 600); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
SkPath fPath[N];
SkScalar fDY[N];
protected:
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
for (size_t i = 0; i < N; i++) {
fDY[i] = gProcs[i](&fPath[i]);
}
}
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("pathfill");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(640, 480);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
SkPath fPath[N];
SkScalar fDY[N];
protected:
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
for (size_t i = 0; i < N; i++) {
fDY[i] = gProcs[i](&fPath[i]);
}
}
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("pathinvfill");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(450, 220);
}
canvas->restore();
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPath path;
path.addCircle(SkIntToScalar(50), SkIntToScalar(50), SkIntToScalar(40));
}
protected:
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(770, 770);
}
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("pathinterior");
}
}
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->translate(8.5f, 8.5f);
const SkRect rect = { 0, 0, 80, 80 };
}
protected:
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
const unsigned oneColor = 0xFF8080FF;
const unsigned twoColor = 0x807F1f1f;
SkColor blendColor = blend(oneColor, twoColor);
paint->setColor(color);
}
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("pathopsinverse");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1200, 900);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPath one, two;
int yPos = 0;
for (int oneFill = 0; oneFill <= 1; ++oneFill) {
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("pathopsskpclip");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1200, 900);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPictureRecorder recorder;
SkCanvas* rec = recorder.beginRecording(1200, 900, NULL, 0);
SkPath p;
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("path-reverse");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(640, 480);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
if (false) test_rev(canvas); // avoid bit rot, suppress warning
SkRect r = { 10, 10, 100, 60 };
PeekPixelsGM() {}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("peekpixels");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(360, 120);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100);
SkAutoTUnref<SkSurface> surface(canvas->newSurface(info));
if (surface.get()) {
{}
protected:
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
fPicture.reset(make_picture());
}
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("pictures");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(450, 120);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->translate(10, 10);
SkMatrix matrix;
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("pictureimagefilter");
}
fPicture.reset(recorder.endRecording());
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(600, 300); }
+ SkISize onISize() override { return SkISize::Make(600, 300); }
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
this->makePicture();
}
canvas->restore();
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->clear(0x00000000);
{
SkRect srcRect = SkRect::MakeXYWH(20, 20, 30, 30);
}
protected:
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
// Build the picture.
SkPictureRecorder recorder;
SkCanvas* pictureCanvas = recorder.beginRecording(fTileSize, fTileSize, NULL, 0);
}
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("pictureshader");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1400, 1450);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
this->drawSceneColumn(canvas, SkPoint::Make(0, 0), 1, 1, 0);
this->drawSceneColumn(canvas, SkPoint::Make(0, fSceneSize * 6.4f), 1, 2, 0);
this->drawSceneColumn(canvas, SkPoint::Make(fSceneSize * 2.4f, 0), 1, 1, 1);
class PictureShaderTileGM : public skiagm::GM {
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("pictureshadertile");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(800, 600);
}
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
SkPictureRecorder recorder;
SkCanvas* pictureCanvas = recorder.beginRecording(kPictureSize, kPictureSize);
draw_scene(pictureCanvas, kPictureSize);
}
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->clear(SK_ColorBLACK);
SkPaint paint;
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("points");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(640, 490);
}
}
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->translate(SK_Scalar1, SK_Scalar1);
SkRandom rand;
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("poly2poly");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(835, 840);
}
canvas->restore();
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
if (false) { test_stroke(canvas); return; }
SkPaint paint;
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("polygons");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
int width = kNumPolygons * kCellSize + 40;
int height = (kNumJoins * kNumStrokeWidths + kNumExtraStyles) * kCellSize + 40;
return SkISize::Make(width, height);
}
// Construct all polygons
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
SkPoint p0[] = {{0, 0}, {60, 0}, {90, 40}}; // triangle
SkPoint p1[] = {{0, 0}, {0, 40}, {60, 40}, {40, 0}}; // trapezoid
SkPoint p2[] = {{0, 0}, {40, 40}, {80, 40}, {40, 0}}; // diamond
}
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
// Stroke widths are:
// 0(may use hairline rendering), 10(common case for stroke-style)
// 40(>= geometry width/height, make the contour filled in fact)
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("quadpath");
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(1240, 390); }
+ SkISize onISize() override { return SkISize::Make(1240, 390); }
void drawPath(SkPath& path,SkCanvas* canvas,SkColor color,
const SkRect& clip,SkPaint::Cap cap, SkPaint::Join join,
canvas->restore();
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
struct FillAndName {
SkPath::FillType fFill;
const char* fName;
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("quadclosepath");
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(1240, 390); }
+ SkISize onISize() override { return SkISize::Make(1240, 390); }
void drawPath(SkPath& path,SkCanvas* canvas,SkColor color,
const SkRect& clip,SkPaint::Cap cap, SkPaint::Join join,
canvas->restore();
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
struct FillAndName {
SkPath::FillType fFill;
const char* fName;
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("rects");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1200, 900);
}
SK_Scalar1 * 100 * (testCount / 10) + 3 * SK_Scalar1 / 4);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkAutoCommentBlock acb(canvas, "onDraw");
canvas->translate(20 * SK_Scalar1, 20 * SK_Scalar1);
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("roundrects");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1200, 900);
}
return SkHSVToColor(hsv);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkRandom rand(1);
canvas->translate(20 * SK_Scalar1, 20 * SK_Scalar1);
SkRect rect = SkRect::MakeLTRB(-20, -30, 20, 30);
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("rrect");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(820, 710);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
static const InsetProc insetProcs[] = {
inset0, inset1, inset2, inset3
};
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
SkString name("rrect");
switch (fType) {
case kBW_Draw_Type:
return name;
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(kImageWidth, kImageHeight); }
+ SkISize onISize() override { return SkISize::Make(kImageWidth, kImageHeight); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
GrContext* context = NULL;
#if SK_SUPPORT_GPU
GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("gpusamplerstress");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(640, 480);
}
fMaskFilter.reset(SkBlurMaskFilter::Create(kNormal_SkBlurStyle, sigma));
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
createShader();
createMaskFilter();
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return fName;
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(320, 240); }
+ SkISize onISize() override { return SkISize::Make(320, 240); }
- SkMatrix onGetInitialTransform() const SK_OVERRIDE {
+ SkMatrix onGetInitialTransform() const override {
SkMatrix result;
SkScalar scale = 0.8f;
result.setScale(scale, scale);
return result;
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
// The PDF device has already clipped to the content area, but we
// do it again here so that the raster and pdf results are consistent.
canvas->clipRect(SkRect::MakeWH(SkIntToScalar(320),
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("shadertext");
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(1450, 500); }
+ SkISize onISize() override { return SkISize::Make(1450, 500); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
const char text[] = "Shaded Text";
const int textLen = SK_ARRAY_COUNT(text) - 1;
const int pointSize = 36;
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("shadertext2");
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(1800, 900); }
+ SkISize onISize() override { return SkISize::Make(1800, 900); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
static const char kText[] = "SKIA";
static const int kTextLen = SK_ARRAY_COUNT(kText) - 1;
static const int kPointSize = 55;
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("shadertext3");
}
- SkISize onISize() SK_OVERRIDE{ return SkISize::Make(800, 1000); }
+ SkISize onISize() override{ return SkISize::Make(800, 1000); }
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
makebm(&fBmp, kPointSize / 4, kPointSize / 4);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint bmpPaint;
bmpPaint.setAntiAlias(true);
SkRect fRect;
protected:
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
this->setBGColor(0xFFDDDDDD);
fCirclePath.addCircle(SkIntToScalar(20), SkIntToScalar(20), SkIntToScalar(10) );
fRect.set(SkIntToScalar(10), SkIntToScalar(10),
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return fName;
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(800, 800);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
const SkColor colors[] = { 0xFF555555, 0xFF444444 };
const int colorCount = SK_ARRAY_COUNT(colors);
}
protected:
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
// offset the rects a bit so we get anti-aliasing in the rect case
fBase.set(100.65f,
100.65f,
SkBug1719GM() {}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("skbug1719");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(300, 100);
}
- void onDrawBackground(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawBackground(SkCanvas* canvas) override {
SkPaint bgPaint;
bgPaint.setColor(0xFF303030);
canvas->drawPaint(bgPaint);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->translate(SkIntToScalar(-800), SkIntToScalar(-650));
// The data is lifted from an SKP that exhibited the bug.
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("smallarc");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(762, 762);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint p;
p.setColor(SK_ColorRED);
p.setAntiAlias(true);
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("spritebitmap");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(640, 480);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkBitmap bm;
make_bm(&bm);
// this GM tests hairlines which fill nearly the entire render target
class StLouisArchGM : public GM {
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("stlouisarch");
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make((int)kWidth, (int)kHeight); }
+ SkISize onISize() override { return SkISize::Make((int)kWidth, (int)kHeight); }
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
{
SkPath* bigQuad = &fPaths.push_back();
bigQuad->moveTo(0, 0);
}
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->save();
canvas->scale(1, -1);
canvas->translate(0, -kHeight);
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("stringart");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(kWidth, kHeight);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkScalar angle = kAngle*SK_ScalarPI + SkScalarHalf(SK_ScalarPI);
SkScalar size = SkIntToScalar(SkMin32(kWidth, kHeight));
SkPoint center = SkPoint::Make(SkScalarHalf(kWidth), SkScalarHalf(kHeight));
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("stroke-fill");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(640, 480);
}
canvas->drawText(text, len, x, y + SkIntToScalar(120), p);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkScalar x = SkIntToScalar(100);
SkScalar y = SkIntToScalar(88);
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("strokerect");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1024, 740);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->drawColor(SK_ColorWHITE);
canvas->translate(STROKE_WIDTH*3/2, STROKE_WIDTH*3/2);
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("strokerects");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(W*2, H*2);
}
r->offset(-w/2 + woffset, -h/2 + hoffset);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setStyle(SkPaint::kStroke_Style);
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("strokes_round");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(W, H*2);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(SkIntToScalar(9)/2);
class Strokes2GM : public skiagm::GM {
SkPath fPath;
protected:
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
SkRandom rand;
fPath.moveTo(0, 0);
for (int i = 0; i < 13; i++) {
}
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("strokes_poly");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(W, H*2);
}
canvas->concat(matrix);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->drawColor(SK_ColorWHITE);
SkPaint paint;
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("strokes3");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1500, 1500);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint origPaint;
origPaint.setAntiAlias(true);
origPaint.setStyle(SkPaint::kStroke_Style);
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("stroketext");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1200, 480);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
if (true) { test_nulldev(canvas); }
SkPaint paint;
paint.setAntiAlias(true);
SurfacePropsGM() {}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("surfaceprops");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(W * 4, H * 5);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
GrContext* ctx = canvas->getGrContext();
// must be opaque to have a hope of testing LCD text
NewSurfaceGM() {}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("surfacenew");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(300, 140);
}
canvas->drawColor(SK_ColorRED);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100);
SkAutoTUnref<SkSurface> surf(canvas->newSurface(info, NULL));
TallStretchedBitmapsGM() {}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("tall_stretched_bitmaps");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(750, 750);
}
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
for (size_t i = 0; i < SK_ARRAY_COUNT(fTallBmps); ++i) {
int h = SkToInt((4 + i) * 1024);
}
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->scale(1.3f, 1.3f);
for (size_t i = 0; i < SK_ARRAY_COUNT(fTallBmps); ++i) {
SkASSERT(fTallBmps[i].fItemCnt > 10);
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("testimagefilters");
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(700, 460); }
+ SkISize onISize() override { return SkISize::Make(700, 460); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
// this->drawSizeBounds(canvas, 0xFFCCCCCC);
static SkImageFilter* (*gFilterProc[])() = {
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("texdata");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(2*S, 2*S);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
GrRenderTarget* target = canvas->internal_private_accessTopLayerRenderTarget();
GrContext* ctx = canvas->getGrContext();
if (ctx && target) {
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("textblob");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(640, 480);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
for (unsigned b = 0; b < SK_ARRAY_COUNT(blobConfigs); ++b) {
SkAutoTUnref<const SkTextBlob> blob(this->makeBlob(b));
protected:
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
SkPaint p;
p.setAntiAlias(true);
p.setSubpixelText(true);
SkShader::kRepeat_TileMode));
}
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("textblobshader");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(640, 480);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint p;
p.setStyle(SkPaint::kFill_Style);
p.setShader(fShader);
TextEffectsGM() {}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("texteffects");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(460, 680);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->save();
SkPaint paint;
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("texture_domain_effect");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
const SkScalar canvasWidth = kDrawPad +
(kTargetWidth + 2 * kDrawPad) * GrTextureDomain::kModeCount +
kTestPad * GrTextureDomain::kModeCount;
return SkISize::Make(SkScalarCeilToInt(canvasWidth), 800);
}
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
fBmp.allocN32Pixels(kTargetWidth, kTargetHeight);
SkCanvas canvas(fBmp);
canvas.clear(0x00000000);
fBmp.width() + 10.f, fBmp.height() + 10.f), paint);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
if (NULL == rt) {
return;
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("thinrects");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(240, 320);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint white;
white.setColor(SK_ColorWHITE);
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("thinstrokedrects");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(240, 320);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setColor(SK_ColorWHITE);
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("tiledscaledbitmap");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1016, 616);
}
return bm;
}
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
fBitmap = make_bm(360, 288);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
kNPOTSize = 21,
};
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
SkString name("tilemodes");
if (!fPowerOfTwoSize) {
name.append("_npot");
return name;
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(880, 560); }
+ SkISize onISize() override { return SkISize::Make(880, 560); }
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
int size = fPowerOfTwoSize ? kPOTSize : kNPOTSize;
for (size_t i = 0; i < SK_ARRAY_COUNT(gColorTypes); i++) {
makebm(&fTexture[i], gColorTypes[i], size, size);
}
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
int size = fPowerOfTwoSize ? kPOTSize : kNPOTSize;
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return fName;
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(880, 560); }
+ SkISize onISize() override { return SkISize::Make(880, 560); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->scale(SkIntToScalar(3)/2, SkIntToScalar(3)/2);
const SkScalar w = SkIntToScalar(gWidth);
kNPOTSize = 3,
};
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
SkString name("scaled_tilemodes");
if (!fPowerOfTwoSize) {
name.append("_npot");
return name;
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(880, 760); }
+ SkISize onISize() override { return SkISize::Make(880, 760); }
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
int size = fPowerOfTwoSize ? kPOTSize : kNPOTSize;
for (size_t i = 0; i < SK_ARRAY_COUNT(gColorTypes); i++) {
makebm(&fTexture[i], gColorTypes[i], size, size);
}
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
float scale = 32.f/kPOTSize;
int size = fPowerOfTwoSize ? kPOTSize : kNPOTSize;
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return fName;
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(880, 560); }
+ SkISize onISize() override { return SkISize::Make(880, 560); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->scale(SkIntToScalar(3)/2, SkIntToScalar(3)/2);
const SkScalar w = SkIntToScalar(gWidth);
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("typeface");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(640, 480);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkString text("Typefaces are fun!");
SkScalar y = 0;
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
SkString name("typefacestyles");
if (fApplyKerning) {
name.append("_kerning");
return name;
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(640, 480);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
paint.setTextSize(SkIntToScalar(30));
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
SkString name("varied_text");
if (fEffectiveClip) {
name.append("_clipped");
return name;
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(640, 480);
}
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
fPaint.setAntiAlias(true);
fPaint.setLCDRenderText(fLCD);
}
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
for (int i = 0; i < kCnt; ++i) {
fPaint.setColor(fColors[i]);
fPaint.setTextSize(fPtSizes[i]);
}
}
- bool runAsBench() const SK_OVERRIDE { return true; }
+ bool runAsBench() const override { return true; }
private:
static const int kCnt = 30;
protected:
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
const SkScalar X = 150;
const SkScalar Y = 150;
}
}
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
SkString name("vertices");
if (0xFF != fAlpha) {
name.appendf("_%02X", fAlpha);
return name;
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(600, 600);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
// start with the center of a 3x3 grid
static const uint16_t fan[] = {
4,
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("verttext");
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(640, 480); }
+ SkISize onISize() override { return SkISize::Make(640, 480); }
static void drawBaseline(SkCanvas* canvas, const SkPaint& paint,
SkScalar x, SkScalar y) {
canvas->drawCircle(x, y, SK_Scalar1 * 3 / 2, p);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkScalar x = SkIntToScalar(100);
SkScalar y = SkIntToScalar(50);
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("verttext2");
}
- SkISize onISize() SK_OVERRIDE { return SkISize::Make(640, 480); }
+ SkISize onISize() override { return SkISize::Make(640, 480); }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
for (int i = 0; i < 3; ++i) {
SkPaint paint;
paint.setColor(SK_ColorRED);
VeryLargeBitmapGM() {}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("verylargebitmap");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(500, 600);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
int veryBig = 65*1024; // 64K < size
int big = 33*1024; // 32K < size < 64K
// smaller than many max texture sizes, but large enough to gpu-tile for memory reasons.
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("xfermodeimagefilter");
}
canvas.drawText(str, strlen(str), SkIntToScalar(15), SkIntToScalar(65), paint);
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(WIDTH, HEIGHT);
}
canvas->restore();
}
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
make_bitmap();
fCheckerboard.allocN32Pixels(80, 80);
sk_tool_utils::draw_checkerboard(&checkerboardCanvas, 0xFFA0A0A0, 0xFF404040, 8);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->clear(0x00000000);
SkPaint paint;
}
}
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
fBG.installPixels(SkImageInfo::Make(2, 2, kARGB_4444_SkColorType,
kOpaque_SkAlphaType),
gData, 4);
XfermodesGM() {}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("xfermodes");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(1990, 640);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->translate(SkIntToScalar(10), SkIntToScalar(20));
const struct {
Xfermodes2GM() {}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("xfermodes2");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(455, 475);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->translate(SkIntToScalar(10), SkIntToScalar(20));
const SkScalar w = SkIntToScalar(kSize);
}
private:
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
static const uint32_t kCheckData[] = {
SkPackARGB32(0xFF, 0x40, 0x40, 0x40),
SkPackARGB32(0xFF, 0xD0, 0xD0, 0xD0),
Xfermodes3GM() {}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("xfermodes3");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(630, 1215);
}
- void onDrawBackground(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawBackground(SkCanvas* canvas) override {
SkPaint bgPaint;
bgPaint.setColor(0xFF70D0E0);
canvas->drawPaint(bgPaint);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
canvas->translate(SkIntToScalar(10), SkIntToScalar(20));
SkPaint labelP;
canvas->restore();
}
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
static const uint32_t kCheckData[] = {
SkPackARGB32(0xFF, 0x40, 0x40, 0x40),
SkPackARGB32(0xFF, 0xD0, 0xD0, 0xD0),
}
protected:
- SkString onShortName() SK_OVERRIDE {
+ SkString onShortName() override {
return SkString("yuv_to_rgb_effect");
}
- SkISize onISize() SK_OVERRIDE {
+ SkISize onISize() override {
return SkISize::Make(238, 84);
}
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
SkImageInfo yinfo = SkImageInfo::MakeA8(YSIZE, YSIZE);
fBmp[0].allocPixels(yinfo);
SkImageInfo uinfo = SkImageInfo::MakeA8(USIZE, USIZE);
}
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
if (NULL == rt) {
return;
# We can't use the skia_shared_library gyp setting because we need expose
# this define globally and the the implemention define as a cflag.
'SKIA_DLL',
- 'SK_OVERRIDE override',
+ 'override override',
# Defines from skia_for_android_framework_defines.gypi
'<@(skia_for_android_framework_defines)',
],
* reveals that the image is actually opaque.
*/
#ifdef SK_SUPPORT_LEGACY_BOOL_ONGETINFO
- bool onGetInfo(SkImageInfo* info) SK_OVERRIDE {
+ bool onGetInfo(SkImageInfo* info) override {
*info = fInfo;
return true;
}
class SK_API SkRTreeFactory : public SkBBHFactory {
public:
- SkBBoxHierarchy* operator()(const SkRect& bounds) const SK_OVERRIDE;
+ SkBBoxHierarchy* operator()(const SkRect& bounds) const override;
private:
typedef SkBBHFactory INHERITED;
};
*/
class HeapAllocator : public Allocator {
public:
- bool allocPixelRef(SkBitmap*, SkColorTable*) SK_OVERRIDE;
+ bool allocPixelRef(SkBitmap*, SkColorTable*) override;
};
class RLEPixels {
return Create(info, NULL);
}
- SkImageInfo imageInfo() const SK_OVERRIDE;
+ SkImageInfo imageInfo() const override;
protected:
- bool onShouldDisableLCD(const SkPaint&) const SK_OVERRIDE;
+ bool onShouldDisableLCD(const SkPaint&) const override;
/** These are called inside the per-device-layer loop for each draw call.
When these are called, we have already applied any saveLayer operations,
and are handling any looping from the paint, and any effects from the
DrawFilter.
*/
- void drawPaint(const SkDraw&, const SkPaint& paint) SK_OVERRIDE;
+ void drawPaint(const SkDraw&, const SkPaint& paint) override;
virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count,
- const SkPoint[], const SkPaint& paint) SK_OVERRIDE;
+ const SkPoint[], const SkPaint& paint) override;
virtual void drawRect(const SkDraw&, const SkRect& r,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
virtual void drawOval(const SkDraw&, const SkRect& oval,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
virtual void drawRRect(const SkDraw&, const SkRRect& rr,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
/**
* If pathIsMutable, then the implementation is allowed to cast path to a
virtual void drawPath(const SkDraw&, const SkPath& path,
const SkPaint& paint,
const SkMatrix* prePathMatrix = NULL,
- bool pathIsMutable = false) SK_OVERRIDE;
+ bool pathIsMutable = false) override;
virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
- const SkMatrix& matrix, const SkPaint& paint) SK_OVERRIDE;
+ const SkMatrix& matrix, const SkPaint& paint) override;
virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap,
- int x, int y, const SkPaint& paint) SK_OVERRIDE;
+ int x, int y, const SkPaint& paint) override;
/**
* The default impl. will create a bitmap-shader from the bitmap,
virtual void drawBitmapRect(const SkDraw&, const SkBitmap&,
const SkRect* srcOrNull, const SkRect& dst,
const SkPaint& paint,
- SkCanvas::DrawBitmapRectFlags flags) SK_OVERRIDE;
+ SkCanvas::DrawBitmapRectFlags flags) override;
/**
* Does not handle text decoration.
* Decorations (underline and stike-thru) will be handled by SkCanvas.
*/
virtual void drawText(const SkDraw&, const void* text, size_t len,
- SkScalar x, SkScalar y, const SkPaint& paint) SK_OVERRIDE;
+ SkScalar x, SkScalar y, const SkPaint& paint) override;
virtual void drawPosText(const SkDraw&, const void* text, size_t len,
const SkScalar pos[], int scalarsPerPos,
- const SkPoint& offset, const SkPaint& paint) SK_OVERRIDE;
+ const SkPoint& offset, const SkPaint& paint) override;
virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount,
const SkPoint verts[], const SkPoint texs[],
const SkColor colors[], SkXfermode* xmode,
const uint16_t indices[], int indexCount,
- const SkPaint& paint) SK_OVERRIDE;
- virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y, const SkPaint&) SK_OVERRIDE;
+ const SkPaint& paint) override;
+ virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y, const SkPaint&) override;
///////////////////////////////////////////////////////////////////////////
altered. The config/width/height/rowbytes must remain unchanged.
@return the device contents as a bitmap
*/
- const SkBitmap& onAccessBitmap() SK_OVERRIDE;
+ const SkBitmap& onAccessBitmap() override;
SkPixelRef* getPixelRef() const { return fBitmap.pixelRef(); }
// just for subclasses, to assign a custom pixelref
return pr;
}
- bool onReadPixels(const SkImageInfo&, void*, size_t, int x, int y) SK_OVERRIDE;
- bool onWritePixels(const SkImageInfo&, const void*, size_t, int, int) SK_OVERRIDE;
- void* onAccessPixels(SkImageInfo* info, size_t* rowBytes) SK_OVERRIDE;
+ bool onReadPixels(const SkImageInfo&, void*, size_t, int x, int y) override;
+ bool onWritePixels(const SkImageInfo&, const void*, size_t, int, int) override;
+ void* onAccessPixels(SkImageInfo* info, size_t* rowBytes) override;
/** Called when this device is installed into a Canvas. Balanced by a call
to unlockPixels() when the device is removed from a Canvas.
*/
- void lockPixels() SK_OVERRIDE;
- void unlockPixels() SK_OVERRIDE;
+ void lockPixels() override;
+ void unlockPixels() override;
private:
friend class SkCanvas;
// used to change the backend's pixels (and possibly config/rowbytes)
// but cannot change the width/height, so there should be no change to
// any clip information.
- void replaceBitmapBackendForRasterSurface(const SkBitmap&) SK_OVERRIDE;
+ void replaceBitmapBackendForRasterSurface(const SkBitmap&) override;
- SkBaseDevice* onCreateDevice(const CreateInfo&, const SkPaint*) SK_OVERRIDE;
+ SkBaseDevice* onCreateDevice(const CreateInfo&, const SkPaint*) override;
- SkSurface* newSurface(const SkImageInfo&, const SkSurfaceProps&) SK_OVERRIDE;
- const void* peekPixels(SkImageInfo*, size_t* rowBytes) SK_OVERRIDE;
+ SkSurface* newSurface(const SkImageInfo&, const SkSurfaceProps&) override;
+ const void* peekPixels(SkImageInfo*, size_t* rowBytes) override;
- SkImageFilter::Cache* getImageFilterCache() SK_OVERRIDE;
+ SkImageFilter::Cache* getImageFilterCache() override;
SkBitmap fBitmap;
SkComposeShader(SkShader* sA, SkShader* sB, SkXfermode* mode = NULL);
virtual ~SkComposeShader();
- size_t contextSize() const SK_OVERRIDE;
+ size_t contextSize() const override;
class ComposeShaderContext : public SkShader::Context {
public:
virtual ~ComposeShaderContext();
- void shadeSpan(int x, int y, SkPMColor[], int count) SK_OVERRIDE;
+ void shadeSpan(int x, int y, SkPMColor[], int count) override;
private:
SkShader::Context* fShaderContextA;
SkShader* getShaderB() { return fShaderB; }
#endif
- bool asACompose(ComposeRec* rec) const SK_OVERRIDE;
+ bool asACompose(ComposeRec* rec) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkComposeShader)
protected:
SkComposeShader(SkReadBuffer& );
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
- Context* onCreateContext(const ContextRec&, void*) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
+ Context* onCreateContext(const ContextRec&, void*) const override;
private:
SkShader* fShaderA;
public:
virtual bool abortDrawing() = 0;
- bool abort() SK_OVERRIDE { return this->abortDrawing(); }
+ bool abort() override { return this->abortDrawing(); }
};
#endif
static SkFlattenable* CreateProc(SkReadBuffer&); \
friend class SkPrivateEffectInitializer; \
public: \
- Factory getFactory() const SK_OVERRIDE { return CreateProc; }
+ Factory getFactory() const override { return CreateProc; }
/** For SkFlattenable derived objects with a valid type
This macro should only be used in base class objects in core
*/
explicit SkImageFilter(int inputCount, SkReadBuffer& rb);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
/**
* This is the virtual which should be overridden by the derived class
public:
virtual SkPixelRef* create(const SkImageInfo&,
size_t rowBytes,
- SkColorTable*) SK_OVERRIDE;
+ SkColorTable*) override;
};
protected:
bool ownPixels);
virtual ~SkMallocPixelRef();
- bool onNewLockPixels(LockRec*) SK_OVERRIDE;
- void onUnlockPixels() SK_OVERRIDE;
- size_t getAllocatedSizeInBytes() const SK_OVERRIDE;
+ bool onNewLockPixels(LockRec*) override;
+ void onUnlockPixels() override;
+ size_t getAllocatedSizeInBytes() const override;
private:
void* fStorage;
protected:
SkPairPathEffect(SkPathEffect* pe0, SkPathEffect* pe1);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
// these are visible to our subclasses
SkPathEffect* fPE0, *fPE1;
}
virtual bool filterPath(SkPath* dst, const SkPath& src,
- SkStrokeRec*, const SkRect*) const SK_OVERRIDE;
+ SkStrokeRec*, const SkRect*) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkComposePathEffect)
#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
- bool exposedInAndroidJavaAPI() const SK_OVERRIDE { return true; }
+ bool exposedInAndroidJavaAPI() const override { return true; }
#endif
protected:
}
virtual bool filterPath(SkPath* dst, const SkPath& src,
- SkStrokeRec*, const SkRect*) const SK_OVERRIDE;
+ SkStrokeRec*, const SkRect*) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSumPathEffect)
#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
- bool exposedInAndroidJavaAPI() const SK_OVERRIDE { return true; }
+ bool exposedInAndroidJavaAPI() const override { return true; }
#endif
protected:
//////////////////////////////////////////////////////////////////////
-#ifndef SK_OVERRIDE
-# if defined(_MSC_VER)
-# define SK_OVERRIDE override
-# elif defined(__clang__)
- // Using __attribute__((override)) on clang does not appear to always work.
- // Clang defaults to C++03 and warns about using override. Squelch that. Intentionally no
- // push/pop here so all users of SK_OVERRIDE ignore the warning too. This is like passing
- // -Wno-c++11-extensions, except that GCC won't die (because it won't see this pragma).
-# pragma clang diagnostic ignored "-Wc++11-extensions"
-#
-# if __has_feature(cxx_override_control)
-# define SK_OVERRIDE override
-# elif defined(__has_extension) && __has_extension(cxx_override_control)
-# define SK_OVERRIDE override
-# endif
- // if GCC >= 4.7
-# elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7))
-# define SK_OVERRIDE override
-# endif
-# ifndef SK_OVERRIDE
-# define SK_OVERRIDE
-# endif
-#endif
-
-//////////////////////////////////////////////////////////////////////
-
#if !defined(SK_UNUSED)
# define SK_UNUSED SK_ATTRIBUTE(unused)
#endif
SK_DEFINE_FLATTENABLE_TYPE(SkShader)
protected:
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
bool computeTotalInverse(const ContextRec&, SkMatrix* totalInverse) const;
/** SkStreamRewindable is a SkStream for which rewind and duplicate are required. */
class SK_API SkStreamRewindable : public SkStream {
public:
- bool rewind() SK_OVERRIDE = 0;
- SkStreamRewindable* duplicate() const SK_OVERRIDE = 0;
+ bool rewind() override = 0;
+ SkStreamRewindable* duplicate() const override = 0;
};
/** SkStreamSeekable is a SkStreamRewindable for which position, seek, move, and fork are required. */
class SK_API SkStreamSeekable : public SkStreamRewindable {
public:
- SkStreamSeekable* duplicate() const SK_OVERRIDE = 0;
+ SkStreamSeekable* duplicate() const override = 0;
- bool hasPosition() const SK_OVERRIDE { return true; }
- size_t getPosition() const SK_OVERRIDE = 0;
- bool seek(size_t position) SK_OVERRIDE = 0;
- bool move(long offset) SK_OVERRIDE = 0;
- SkStreamSeekable* fork() const SK_OVERRIDE = 0;
+ bool hasPosition() const override { return true; }
+ size_t getPosition() const override = 0;
+ bool seek(size_t position) override = 0;
+ bool move(long offset) override = 0;
+ SkStreamSeekable* fork() const override = 0;
};
/** SkStreamAsset is a SkStreamSeekable for which getLength is required. */
class SK_API SkStreamAsset : public SkStreamSeekable {
public:
- SkStreamAsset* duplicate() const SK_OVERRIDE = 0;
- SkStreamAsset* fork() const SK_OVERRIDE = 0;
+ SkStreamAsset* duplicate() const override = 0;
+ SkStreamAsset* fork() const override = 0;
- bool hasLength() const SK_OVERRIDE { return true; }
- size_t getLength() const SK_OVERRIDE = 0;
+ bool hasLength() const override { return true; }
+ size_t getLength() const override = 0;
};
/** SkStreamMemory is a SkStreamAsset for which getMemoryBase is required. */
class SK_API SkStreamMemory : public SkStreamAsset {
public:
- SkStreamMemory* duplicate() const SK_OVERRIDE = 0;
- SkStreamMemory* fork() const SK_OVERRIDE = 0;
+ SkStreamMemory* duplicate() const override = 0;
+ SkStreamMemory* fork() const override = 0;
- const void* getMemoryBase() SK_OVERRIDE = 0;
+ const void* getMemoryBase() override = 0;
};
class SK_API SkWStream : SkNoncopyable {
*/
void setPath(const char path[]);
- size_t read(void* buffer, size_t size) SK_OVERRIDE;
- bool isAtEnd() const SK_OVERRIDE;
+ size_t read(void* buffer, size_t size) override;
+ bool isAtEnd() const override;
- bool rewind() SK_OVERRIDE;
- SkStreamAsset* duplicate() const SK_OVERRIDE;
+ bool rewind() override;
+ SkStreamAsset* duplicate() const override;
- size_t getPosition() const SK_OVERRIDE;
- bool seek(size_t position) SK_OVERRIDE;
- bool move(long offset) SK_OVERRIDE;
- SkStreamAsset* fork() const SK_OVERRIDE;
+ size_t getPosition() const override;
+ bool seek(size_t position) override;
+ bool move(long offset) override;
+ SkStreamAsset* fork() const override;
- size_t getLength() const SK_OVERRIDE;
+ size_t getLength() const override;
- const void* getMemoryBase() SK_OVERRIDE;
+ const void* getMemoryBase() override;
private:
SkFILE* fFILE;
const void* getAtPos();
size_t peek() const { return fOffset; }
- size_t read(void* buffer, size_t size) SK_OVERRIDE;
- bool isAtEnd() const SK_OVERRIDE;
+ size_t read(void* buffer, size_t size) override;
+ bool isAtEnd() const override;
- bool rewind() SK_OVERRIDE;
- SkMemoryStream* duplicate() const SK_OVERRIDE;
+ bool rewind() override;
+ SkMemoryStream* duplicate() const override;
- size_t getPosition() const SK_OVERRIDE;
- bool seek(size_t position) SK_OVERRIDE;
- bool move(long offset) SK_OVERRIDE;
- SkMemoryStream* fork() const SK_OVERRIDE;
+ size_t getPosition() const override;
+ bool seek(size_t position) override;
+ bool move(long offset) override;
+ SkMemoryStream* fork() const override;
- size_t getLength() const SK_OVERRIDE;
+ size_t getLength() const override;
- const void* getMemoryBase() SK_OVERRIDE;
+ const void* getMemoryBase() override;
private:
SkData* fData;
*/
bool isValid() const { return fFILE != NULL; }
- bool write(const void* buffer, size_t size) SK_OVERRIDE;
- void flush() SK_OVERRIDE;
- size_t bytesWritten() const SK_OVERRIDE;
+ bool write(const void* buffer, size_t size) override;
+ void flush() override;
+ size_t bytesWritten() const override;
private:
SkFILE* fFILE;
SK_DECLARE_INST_COUNT(SkMemoryWStream)
SkMemoryWStream(void* buffer, size_t size);
- bool write(const void* buffer, size_t size) SK_OVERRIDE;
- size_t bytesWritten() const SK_OVERRIDE { return fBytesWritten; }
+ bool write(const void* buffer, size_t size) override;
+ size_t bytesWritten() const override { return fBytesWritten; }
private:
char* fBuffer;
SkDynamicMemoryWStream();
virtual ~SkDynamicMemoryWStream();
- bool write(const void* buffer, size_t size) SK_OVERRIDE;
- size_t bytesWritten() const SK_OVERRIDE { return fBytesWritten; }
+ bool write(const void* buffer, size_t size) override;
+ size_t bytesWritten() const override { return fBytesWritten; }
// random access write
// modifies stream and returns true if offset + size is less than or equal to getOffset()
bool write(const void* buffer, size_t offset, size_t size);
SK_DECLARE_INST_COUNT(SkDebugWStream)
// overrides
- bool write(const void* buffer, size_t size) SK_OVERRIDE;
- void newline() SK_OVERRIDE;
- size_t bytesWritten() const SK_OVERRIDE { return fBytesWritten; }
+ bool write(const void* buffer, size_t size) override;
+ void newline() override;
+ size_t bytesWritten() const override { return fBytesWritten; }
private:
size_t fBytesWritten;
///////////////////////////////////////////////////////////////////////////////
-#ifdef SK_OVERRIDE_GLOBAL_NEW
+#ifdef override_GLOBAL_NEW
#include <new>
inline void* operator new(size_t size) {
#define SK_TO_STRING_NONVIRT() void toString(SkString* str) const;
#define SK_TO_STRING_VIRT() virtual void toString(SkString* str) const;
#define SK_TO_STRING_PUREVIRT() virtual void toString(SkString* str) const = 0;
- #define SK_TO_STRING_OVERRIDE() void toString(SkString* str) const SK_OVERRIDE;
+ #define SK_TO_STRING_OVERRIDE() void toString(SkString* str) const override;
#endif
template <bool>
on the object and releases the implicit weak reference held
collectively by the strong references.
*/
- void internal_dispose() const SK_OVERRIDE {
+ void internal_dispose() const override {
weak_dispose();
weak_unref();
}
virtual bool endPortfolio();
protected:
- void drawPaint(const SkDraw&, const SkPaint& paint) SK_OVERRIDE;
+ void drawPaint(const SkDraw&, const SkPaint& paint) override;
virtual void drawPoints(
const SkDraw&,
SkCanvas::PointMode mode,
size_t count, const SkPoint[],
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
virtual void drawRect(
const SkDraw&,
const SkRect& r,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
virtual void drawRRect(
const SkDraw&,
const SkRRect&,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
virtual void drawPath(
const SkDraw&,
const SkPath& platonicPath,
const SkPaint& paint,
const SkMatrix* prePathMatrix,
- bool pathIsMutable) SK_OVERRIDE;
+ bool pathIsMutable) override;
virtual void drawBitmap(
const SkDraw&,
const SkBitmap& bitmap,
const SkMatrix& matrix,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
virtual void drawSprite(
const SkDraw&,
const SkBitmap& bitmap,
int x, int y,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
virtual void drawText(
const SkDraw&,
const void* text, size_t len,
SkScalar x, SkScalar y,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
virtual void drawPosText(
const SkDraw&,
const void* text, size_t len,
const SkScalar pos[], int scalarsPerPos,
- const SkPoint& offset, const SkPaint& paint) SK_OVERRIDE;
+ const SkPoint& offset, const SkPaint& paint) override;
virtual void drawVertices(
const SkDraw&,
const SkPoint texs[], const SkColor colors[],
SkXfermode* xmode,
const uint16_t indices[], int indexCount,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
virtual void drawDevice(
const SkDraw&,
SkBaseDevice* device,
int x, int y,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
private:
class TypefaceUse : ::SkNoncopyable {
const SkVector& ppuScale,
IXpsOMPath* shadedPath);
- SkBaseDevice* onCreateDevice(const CreateInfo&, const SkPaint*) SK_OVERRIDE;
+ SkBaseDevice* onCreateDevice(const CreateInfo&, const SkPaint*) override;
// Disable the default copy and assign implementation.
SkXPSDevice(const SkXPSDevice&);
class SK_API Sk1DPathEffect : public SkPathEffect {
public:
virtual bool filterPath(SkPath* dst, const SkPath& src,
- SkStrokeRec*, const SkRect*) const SK_OVERRIDE;
+ SkStrokeRec*, const SkRect*) const override;
protected:
/** Called at the start of each contour, returns the initial offset
virtual SkScalar next(SkPath* dst, SkScalar dist, SkPathMeasure&) const = 0;
#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
- bool exposedInAndroidJavaAPI() const SK_OVERRIDE { return true; }
+ bool exposedInAndroidJavaAPI() const override { return true; }
#endif
private:
}
virtual bool filterPath(SkPath*, const SkPath&,
- SkStrokeRec*, const SkRect*) const SK_OVERRIDE;
+ SkStrokeRec*, const SkRect*) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPath1DPathEffect)
protected:
SkPath1DPathEffect(const SkPath& path, SkScalar advance, SkScalar phase, Style);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
// overrides from Sk1DPathEffect
- SkScalar begin(SkScalar contourLength) const SK_OVERRIDE;
- SkScalar next(SkPath*, SkScalar, SkPathMeasure&) const SK_OVERRIDE;
+ SkScalar begin(SkScalar contourLength) const override;
+ SkScalar next(SkPath*, SkScalar, SkPathMeasure&) const override;
private:
SkPath fPath; // copied from constructor
class SK_API Sk2DPathEffect : public SkPathEffect {
public:
- bool filterPath(SkPath*, const SkPath&, SkStrokeRec*, const SkRect*) const SK_OVERRIDE;
+ bool filterPath(SkPath*, const SkPath&, SkStrokeRec*, const SkRect*) const override;
protected:
/** New virtual, to be overridden by subclasses.
// protected so that subclasses can call this during unflattening
explicit Sk2DPathEffect(const SkMatrix& mat);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
SK_TO_STRING_OVERRIDE()
}
virtual bool filterPath(SkPath* dst, const SkPath& src,
- SkStrokeRec*, const SkRect*) const SK_OVERRIDE;
+ SkStrokeRec*, const SkRect*) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLine2DPathEffect)
protected:
SkLine2DPathEffect(SkScalar width, const SkMatrix& matrix)
: Sk2DPathEffect(matrix), fWidth(width) {}
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
- void nextSpan(int u, int v, int ucount, SkPath*) const SK_OVERRIDE;
+ void nextSpan(int u, int v, int ucount, SkPath*) const override;
private:
SkScalar fWidth;
protected:
SkPath2DPathEffect(const SkMatrix&, const SkPath&);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
- void next(const SkPoint&, int u, int v, SkPath*) const SK_OVERRIDE;
+ void next(const SkPoint&, int u, int v, SkPath*) const override;
private:
SkPath fPath;
return SkNEW_ARGS(SkArcToPathEffect, (radius));
}
- bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, const SkRect*) const SK_OVERRIDE;
+ bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, const SkRect*) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkArcToPathEffect)
protected:
explicit SkArcToPathEffect(SkScalar radius);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
private:
SkScalar fRadius;
const SkRect& dstRect) {
return SkNEW_ARGS(SkBitmapSource, (bitmap, srcRect, dstRect));
}
- void computeFastBounds(const SkRect& src, SkRect* dst) const SK_OVERRIDE;
+ void computeFastBounds(const SkRect& src, SkRect* dst) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBitmapSource)
protected:
explicit SkBitmapSource(const SkBitmap& bitmap);
SkBitmapSource(const SkBitmap& bitmap, const SkRect& srcRect, const SkRect& dstRect);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* offset) const override;
private:
SkBitmap fBitmap;
virtual ~SkBlurDrawLooper();
- SkDrawLooper::Context* createContext(SkCanvas*, void* storage) const SK_OVERRIDE;
+ SkDrawLooper::Context* createContext(SkCanvas*, void* storage) const override;
- size_t contextSize() const SK_OVERRIDE { return sizeof(BlurDrawLooperContext); }
+ size_t contextSize() const override { return sizeof(BlurDrawLooperContext); }
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBlurDrawLooper)
SkBlurDrawLooper(SkColor color, SkScalar sigma, SkScalar dx, SkScalar dy,
uint32_t flags);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
- bool asABlurShadow(BlurShadowRec*) const SK_OVERRIDE;
+ bool asABlurShadow(BlurShadowRec*) const override;
private:
SkMaskFilter* fBlur;
public:
explicit BlurDrawLooperContext(const SkBlurDrawLooper* looper);
- bool next(SkCanvas* canvas, SkPaint* paint) SK_OVERRIDE;
+ bool next(SkCanvas* canvas, SkPaint* paint) override;
private:
const SkBlurDrawLooper* fLooper;
return SkNEW_ARGS(SkBlurImageFilter, (sigmaX, sigmaY, input, cropRect));
}
- void computeFastBounds(const SkRect&, SkRect*) const SK_OVERRIDE;
+ void computeFastBounds(const SkRect&, SkRect*) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBlurImageFilter)
SkScalar sigmaY,
SkImageFilter* input,
const CropRect* cropRect);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* offset) const override;
virtual bool onFilterBounds(const SkIRect& src, const SkMatrix&,
- SkIRect* dst) const SK_OVERRIDE;
+ SkIRect* dst) const override;
- bool canFilterImageGPU() const SK_OVERRIDE { return true; }
+ bool canFilterImageGPU() const override { return true; }
virtual bool filterImageGPU(Proxy* proxy, const SkBitmap& src, const Context& ctx,
- SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* offset) const override;
private:
SkSize fSigma;
*/
static SkColorFilter* Create(SkData* cubeData, int cubeDimension);
- void filterSpan(const SkPMColor src[], int count, SkPMColor[]) const SK_OVERRIDE;
- uint32_t getFlags() const SK_OVERRIDE;
+ void filterSpan(const SkPMColor src[], int count, SkPMColor[]) const override;
+ uint32_t getFlags() const override;
#if SK_SUPPORT_GPU
- bool asFragmentProcessors(GrContext*, SkTDArray<GrFragmentProcessor*>*) const SK_OVERRIDE;
+ bool asFragmentProcessors(GrContext*, SkTDArray<GrFragmentProcessor*>*) const override;
#endif
SK_TO_STRING_OVERRIDE()
protected:
SkColorCubeFilter(SkData* cubeData, int cubeDimension);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
private:
/** The cache is initialized on-demand when getProcessingLuts is called.
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkColorFilterImageFilter)
protected:
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* loc) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* loc) const override;
- bool onIsColorFilterNode(SkColorFilter**) const SK_OVERRIDE;
+ bool onIsColorFilterNode(SkColorFilter**) const override;
private:
SkColorFilterImageFilter(SkColorFilter* cf,
return SkNEW_ARGS(SkColorMatrixFilter, (array));
}
- void filterSpan(const SkPMColor src[], int count, SkPMColor[]) const SK_OVERRIDE;
- uint32_t getFlags() const SK_OVERRIDE;
- bool asColorMatrix(SkScalar matrix[20]) const SK_OVERRIDE;
- SkColorFilter* newComposed(const SkColorFilter*) const SK_OVERRIDE;
+ void filterSpan(const SkPMColor src[], int count, SkPMColor[]) const override;
+ uint32_t getFlags() const override;
+ bool asColorMatrix(SkScalar matrix[20]) const override;
+ SkColorFilter* newComposed(const SkColorFilter*) const override;
#if SK_SUPPORT_GPU
- bool asFragmentProcessors(GrContext*, SkTDArray<GrFragmentProcessor*>*) const SK_OVERRIDE;
+ bool asFragmentProcessors(GrContext*, SkTDArray<GrFragmentProcessor*>*) const override;
#endif
struct State {
protected:
explicit SkColorMatrixFilter(const SkColorMatrix&);
explicit SkColorMatrixFilter(const SkScalar array[20]);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
private:
SkColorMatrix fMatrix;
SkImageFilter* inputs[2] = { outer, inner };
return SkNEW_ARGS(SkComposeImageFilter, (inputs));
}
- void computeFastBounds(const SkRect& src, SkRect* dst) const SK_OVERRIDE;
+ void computeFastBounds(const SkRect& src, SkRect* dst) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkComposeImageFilter)
SkASSERT(inputs[1]);
}
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* loc) const SK_OVERRIDE;
- bool onFilterBounds(const SkIRect&, const SkMatrix&, SkIRect*) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* loc) const override;
+ bool onFilterBounds(const SkIRect&, const SkMatrix&, SkIRect*) const override;
private:
typedef SkImageFilter INHERITED;
virtual ~SkCornerPathEffect();
virtual bool filterPath(SkPath* dst, const SkPath& src,
- SkStrokeRec*, const SkRect*) const SK_OVERRIDE;
+ SkStrokeRec*, const SkRect*) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkCornerPathEffect)
#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
- bool exposedInAndroidJavaAPI() const SK_OVERRIDE { return true; }
+ bool exposedInAndroidJavaAPI() const override { return true; }
#endif
protected:
explicit SkCornerPathEffect(SkScalar radius);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
private:
SkScalar fRadius;
virtual ~SkDashPathEffect();
virtual bool filterPath(SkPath* dst, const SkPath& src,
- SkStrokeRec*, const SkRect*) const SK_OVERRIDE;
+ SkStrokeRec*, const SkRect*) const override;
virtual bool asPoints(PointData* results, const SkPath& src,
const SkStrokeRec&, const SkMatrix&,
- const SkRect*) const SK_OVERRIDE;
+ const SkRect*) const override;
- DashType asADash(DashInfo* info) const SK_OVERRIDE;
+ DashType asADash(DashInfo* info) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDashPathEffect)
#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
- bool exposedInAndroidJavaAPI() const SK_OVERRIDE { return true; }
+ bool exposedInAndroidJavaAPI() const override { return true; }
#endif
protected:
SkDashPathEffect(const SkScalar intervals[], int count, SkScalar phase);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
private:
SkScalar* fIntervals;
}
virtual bool filterPath(SkPath* dst, const SkPath& src,
- SkStrokeRec*, const SkRect*) const SK_OVERRIDE;
+ SkStrokeRec*, const SkRect*) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDiscretePathEffect)
#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
- bool exposedInAndroidJavaAPI() const SK_OVERRIDE { return true; }
+ bool exposedInAndroidJavaAPI() const override { return true; }
#endif
protected:
SkDiscretePathEffect(SkScalar segLength,
SkScalar deviation,
uint32_t seedAssist);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
private:
SkScalar fSegLength, fPerterb;
const SkBitmap& src,
const Context& ctx,
SkBitmap* dst,
- SkIPoint* offset) const SK_OVERRIDE;
- void computeFastBounds(const SkRect& src, SkRect* dst) const SK_OVERRIDE;
+ SkIPoint* offset) const override;
+ void computeFastBounds(const SkRect& src, SkRect* dst) const override;
virtual bool onFilterBounds(const SkIRect& src, const SkMatrix&,
- SkIRect* dst) const SK_OVERRIDE;
+ SkIRect* dst) const override;
#if SK_SUPPORT_GPU
- bool canFilterImageGPU() const SK_OVERRIDE { return true; }
+ bool canFilterImageGPU() const override { return true; }
virtual bool filterImageGPU(Proxy* proxy, const SkBitmap& src, const Context& ctx,
- SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* offset) const override;
#endif
SK_TO_STRING_OVERRIDE()
ChannelSelectorType yChannelSelector,
SkScalar scale, SkImageFilter* inputs[2],
const CropRect* cropRect);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
private:
ChannelSelectorType fXChannelSelector;
shadowMode, input, cropRect));
}
- void computeFastBounds(const SkRect&, SkRect*) const SK_OVERRIDE;
+ void computeFastBounds(const SkRect&, SkRect*) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDropShadowImageFilter)
protected:
SkDropShadowImageFilter(SkScalar dx, SkScalar dy, SkScalar sigmaX, SkScalar sigmaY, SkColor,
ShadowMode shadowMode, SkImageFilter* input, const CropRect* cropRect);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
- bool onFilterImage(Proxy*, const SkBitmap& source, const Context&, SkBitmap* result, SkIPoint* loc) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
+ bool onFilterImage(Proxy*, const SkBitmap& source, const Context&, SkBitmap* result, SkIPoint* loc) const override;
virtual bool onFilterBounds(const SkIRect& src, const SkMatrix&,
- SkIRect* dst) const SK_OVERRIDE;
+ SkIRect* dst) const override;
private:
SkScalar fDx, fDy, fSigmaX, fSigmaY;
// overrides from SkMaskFilter
// This method is not exported to java.
- SkMask::Format getFormat() const SK_OVERRIDE;
+ SkMask::Format getFormat() const override;
// This method is not exported to java.
virtual bool filterMask(SkMask* dst, const SkMask& src, const SkMatrix&,
- SkIPoint* margin) const SK_OVERRIDE;
+ SkIPoint* margin) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkEmbossMaskFilter)
protected:
SkEmbossMaskFilter(SkScalar blurSigma, const Light& light);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
private:
Light fLight;
LayerInfo();
};
- SkDrawLooper::Context* createContext(SkCanvas*, void* storage) const SK_OVERRIDE;
+ SkDrawLooper::Context* createContext(SkCanvas*, void* storage) const override;
- size_t contextSize() const SK_OVERRIDE { return sizeof(LayerDrawLooperContext); }
+ size_t contextSize() const override { return sizeof(LayerDrawLooperContext); }
- bool asABlurShadow(BlurShadowRec* rec) const SK_OVERRIDE;
+ bool asABlurShadow(BlurShadowRec* rec) const override;
SK_TO_STRING_OVERRIDE()
- Factory getFactory() const SK_OVERRIDE { return CreateProc; }
+ Factory getFactory() const override { return CreateProc; }
static SkFlattenable* CreateProc(SkReadBuffer& buffer);
protected:
SkLayerDrawLooper();
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
private:
struct Rec {
explicit LayerDrawLooperContext(const SkLayerDrawLooper* looper);
protected:
- bool next(SkCanvas*, SkPaint* paint) SK_OVERRIDE;
+ bool next(SkCanvas*, SkPaint* paint) override;
private:
Rec* fCurrRec;
protected:
SkLayerRasterizer();
SkLayerRasterizer(SkDeque* layers);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
// override from SkRasterizer
virtual bool onRasterize(const SkPath& path, const SkMatrix& matrix,
const SkIRect* clipBounds,
- SkMask* mask, SkMask::CreateMode mode) const SK_OVERRIDE;
+ SkMask* mask, SkMask::CreateMode mode) const override;
private:
const SkDeque* const fLayers;
// overrides from SkXfermode
virtual void xfer32(SkPMColor dst[], const SkPMColor src[], int count,
- const SkAlpha aa[]) const SK_OVERRIDE;
+ const SkAlpha aa[]) const override;
virtual void xfer16(uint16_t dst[], const SkPMColor src[], int count,
- const SkAlpha aa[]) const SK_OVERRIDE;
+ const SkAlpha aa[]) const override;
virtual void xferA8(SkAlpha dst[], const SkPMColor src[], int count,
- const SkAlpha aa[]) const SK_OVERRIDE;
+ const SkAlpha aa[]) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLerpXfermode)
protected:
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
private:
SkLerpXfermode(unsigned scale256);
SkScalar surfaceScale,
SkImageFilter* input,
const CropRect* cropRect);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
const SkLight* light() const { return fLight.get(); }
SkScalar surfaceScale() const { return fSurfaceScale; }
public:
static SkColorFilter* Create();
- void filterSpan(const SkPMColor src[], int count, SkPMColor[]) const SK_OVERRIDE;
+ void filterSpan(const SkPMColor src[], int count, SkPMColor[]) const override;
#if SK_SUPPORT_GPU
- bool asFragmentProcessors(GrContext*, SkTDArray<GrFragmentProcessor*>*) const SK_OVERRIDE;
+ bool asFragmentProcessors(GrContext*, SkTDArray<GrFragmentProcessor*>*) const override;
#endif
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLumaColorFilter)
protected:
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
private:
SkLumaColorFilter();
protected:
SkMagnifierImageFilter(const SkRect& srcRect, SkScalar inset, SkImageFilter* input);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* offset) const override;
#if SK_SUPPORT_GPU
virtual bool asFragmentProcessor(GrFragmentProcessor**, GrTexture*, const SkMatrix&,
- const SkIRect& bounds) const SK_OVERRIDE;
+ const SkIRect& bounds) const override;
#endif
private:
bool convolveAlpha,
SkImageFilter* input,
const CropRect* cropRect);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* loc) const SK_OVERRIDE;
- bool onFilterBounds(const SkIRect&, const SkMatrix&, SkIRect*) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* loc) const override;
+ bool onFilterBounds(const SkIRect&, const SkMatrix&, SkIRect*) const override;
#if SK_SUPPORT_GPU
virtual bool asFragmentProcessor(GrFragmentProcessor**, GrTexture*, const SkMatrix&,
- const SkIRect& bounds) const SK_OVERRIDE;
+ const SkIRect& bounds) const override;
#endif
private:
SkMergeImageFilter(SkImageFilter* filters[], int count,
const SkXfermode::Mode modes[],
const CropRect* cropRect);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* loc) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* loc) const override;
private:
uint8_t* fModes; // SkXfermode::Mode
SkXfermode::Mode getMode() const { return fMode; }
SkPMColor getPMColor() const { return fPMColor; }
- bool asColorMode(SkColor*, SkXfermode::Mode*) const SK_OVERRIDE;
- uint32_t getFlags() const SK_OVERRIDE;
- void filterSpan(const SkPMColor shader[], int count, SkPMColor result[]) const SK_OVERRIDE;
+ bool asColorMode(SkColor*, SkXfermode::Mode*) const override;
+ uint32_t getFlags() const override;
+ void filterSpan(const SkPMColor shader[], int count, SkPMColor result[]) const override;
#ifndef SK_IGNORE_TO_STRING
- void toString(SkString* str) const SK_OVERRIDE {
+ void toString(SkString* str) const override {
str->append("SkModeColorFilter: color: 0x");
str->appendHex(fColor);
str->append(" mode: ");
#endif
#if SK_SUPPORT_GPU
- bool asFragmentProcessors(GrContext*, SkTDArray<GrFragmentProcessor*>*) const SK_OVERRIDE;
+ bool asFragmentProcessors(GrContext*, SkTDArray<GrFragmentProcessor*>*) const override;
#endif
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkModeColorFilter)
protected:
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
private:
SkColor fColor;
class SK_API SkMorphologyImageFilter : public SkImageFilter {
public:
- void computeFastBounds(const SkRect& src, SkRect* dst) const SK_OVERRIDE;
- bool onFilterBounds(const SkIRect& src, const SkMatrix& ctm, SkIRect* dst) const SK_OVERRIDE;
+ void computeFastBounds(const SkRect& src, SkRect* dst) const override;
+ bool onFilterBounds(const SkIRect& src, const SkMatrix& ctm, SkIRect* dst) const override;
/**
* All morphology procs have the same signature: src is the source buffer, dst the
bool filterImageGeneric(Proc procX, Proc procY,
Proxy*, const SkBitmap& src, const Context&,
SkBitmap* result, SkIPoint* offset) const;
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
#if SK_SUPPORT_GPU
- bool canFilterImageGPU() const SK_OVERRIDE { return true; }
+ bool canFilterImageGPU() const override { return true; }
bool filterImageGPUGeneric(bool dilate, Proxy* proxy, const SkBitmap& src,
const Context& ctm, SkBitmap* result,
SkIPoint* offset) const;
}
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* offset) const override;
#if SK_SUPPORT_GPU
virtual bool filterImageGPU(Proxy* proxy, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* offset) const override;
#endif
SK_TO_STRING_OVERRIDE()
}
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* offset) const override;
#if SK_SUPPORT_GPU
virtual bool filterImageGPU(Proxy* proxy, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* offset) const override;
#endif
SK_TO_STRING_OVERRIDE()
}
return SkNEW_ARGS(SkOffsetImageFilter, (dx, dy, input, cropRect));
}
- void computeFastBounds(const SkRect& src, SkRect* dst) const SK_OVERRIDE;
+ void computeFastBounds(const SkRect& src, SkRect* dst) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkOffsetImageFilter)
protected:
SkOffsetImageFilter(SkScalar dx, SkScalar dy, SkImageFilter* input, const CropRect* cropRect);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* loc) const SK_OVERRIDE;
- bool onFilterBounds(const SkIRect&, const SkMatrix&, SkIRect*) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* loc) const override;
+ bool onFilterBounds(const SkIRect&, const SkMatrix&, SkIRect*) const override;
private:
SkVector fOffset;
public:
SkPaintFlagsDrawFilter(uint32_t clearFlags, uint32_t setFlags);
- bool filter(SkPaint*, Type) SK_OVERRIDE;
+ bool filter(SkPaint*, Type) override;
private:
uint16_t fClearFlags; // user specified
}
- size_t contextSize() const SK_OVERRIDE;
+ size_t contextSize() const override;
class PerlinNoiseShaderContext : public SkShader::Context {
public:
PerlinNoiseShaderContext(const SkPerlinNoiseShader& shader, const ContextRec&);
virtual ~PerlinNoiseShaderContext();
- void shadeSpan(int x, int y, SkPMColor[], int count) SK_OVERRIDE;
- void shadeSpan16(int x, int y, uint16_t[], int count) SK_OVERRIDE;
+ void shadeSpan(int x, int y, SkPMColor[], int count) override;
+ void shadeSpan16(int x, int y, uint16_t[], int count) override;
private:
SkPMColor shade(const SkPoint& point, StitchData& stitchData) const;
virtual bool asFragmentProcessor(GrContext* context, const SkPaint&, const SkMatrix& viewM,
const SkMatrix*, GrColor*,
- GrFragmentProcessor**) const SK_OVERRIDE;
+ GrFragmentProcessor**) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPerlinNoiseShader)
protected:
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
- Context* onCreateContext(const ContextRec&, void* storage) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
+ Context* onCreateContext(const ContextRec&, void* storage) const override;
private:
SkPerlinNoiseShader(SkPerlinNoiseShader::Type type, SkScalar baseFrequencyX,
* SkReadBuffer::setBitmapDecoder() before calling this constructor.
* @param SkReadBuffer Serialized picture data.
*/
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* offset) const override;
private:
protected:
explicit SkPixelXorXfermode(SkColor opColor) : fOpColor(opColor) {}
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
// override from SkXfermode
- SkPMColor xferColor(SkPMColor src, SkPMColor dst) const SK_OVERRIDE;
+ SkPMColor xferColor(SkPMColor src, SkPMColor dst) const override;
private:
SkColor fOpColor;
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkRectShaderImageFilter)
protected:
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* loc) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* loc) const override;
private:
SkRectShaderImageFilter(SkShader* s, const CropRect* rect);
return SkNEW_ARGS(SkTableMaskFilter, (table));
}
- SkMask::Format getFormat() const SK_OVERRIDE;
+ SkMask::Format getFormat() const override;
virtual bool filterMask(SkMask*, const SkMask&, const SkMatrix&,
- SkIPoint*) const SK_OVERRIDE;
+ SkIPoint*) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkTableMaskFilter)
protected:
SkTableMaskFilter();
explicit SkTableMaskFilter(const uint8_t table[256]);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
private:
uint8_t fTable[256];
protected:
SkDownSampleImageFilter(SkScalar scale, SkImageFilter* input)
: INHERITED(1, &input), fScale(scale) {}
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* loc) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* loc) const override;
private:
SkScalar fScale;
SkImageFilter* input);
virtual bool onFilterImage(Proxy* proxy, const SkBitmap& src, const Context& ctx,
- SkBitmap* dst, SkIPoint* offset) const SK_OVERRIDE;
+ SkBitmap* dst, SkIPoint* offset) const override;
virtual bool onFilterBounds(const SkIRect& src, const SkMatrix&,
- SkIRect* dst) const SK_OVERRIDE;
+ SkIRect* dst) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkTileImageFilter)
SkTileImageFilter(const SkRect& srcRect, const SkRect& dstRect, SkImageFilter* input)
: INHERITED(1, &input, NULL), fSrcRect(srcRect), fDstRect(dstRect) {}
- void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer& buffer) const override;
private:
SkRect fSrcRect;
public:
SkTransparentShader() {}
- size_t contextSize() const SK_OVERRIDE;
+ size_t contextSize() const override;
class TransparentShaderContext : public SkShader::Context {
public:
TransparentShaderContext(const SkTransparentShader& shader, const ContextRec&);
virtual ~TransparentShaderContext();
- uint32_t getFlags() const SK_OVERRIDE;
- void shadeSpan(int x, int y, SkPMColor[], int count) SK_OVERRIDE;
- void shadeSpan16(int x, int y, uint16_t span[], int count) SK_OVERRIDE;
+ uint32_t getFlags() const override;
+ void shadeSpan(int x, int y, SkPMColor[], int count) override;
+ void shadeSpan16(int x, int y, uint16_t span[], int count) override;
private:
const SkBitmap* fDevice;
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkTransparentShader)
protected:
- Context* onCreateContext(const ContextRec&, void* storage) const SK_OVERRIDE;
+ Context* onCreateContext(const ContextRec&, void* storage) const override;
// we don't need to flatten anything at all
- void flatten(SkWriteBuffer&) const SK_OVERRIDE {}
+ void flatten(SkWriteBuffer&) const override {}
private:
typedef SkShader INHERITED;
const SkBitmap& src,
const Context& ctx,
SkBitmap* dst,
- SkIPoint* offset) const SK_OVERRIDE;
+ SkIPoint* offset) const override;
#if SK_SUPPORT_GPU
- bool canFilterImageGPU() const SK_OVERRIDE;
+ bool canFilterImageGPU() const override;
virtual bool filterImageGPU(Proxy* proxy, const SkBitmap& src, const Context& ctx,
- SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* offset) const override;
#endif
protected:
SkXfermodeImageFilter(SkXfermode* mode, SkImageFilter* inputs[2],
const CropRect* cropRect);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
private:
SkXfermode* fMode;
SK_DECLARE_INST_COUNT(GrRenderTarget)
// GrSurface overrides
- GrRenderTarget* asRenderTarget() SK_OVERRIDE { return this; }
- const GrRenderTarget* asRenderTarget() const SK_OVERRIDE { return this; }
+ GrRenderTarget* asRenderTarget() override { return this; }
+ const GrRenderTarget* asRenderTarget() const override { return this; }
// GrRenderTarget
/**
}
// override of GrResource
- void onAbandon() SK_OVERRIDE;
- void onRelease() SK_OVERRIDE;
+ void onAbandon() override;
+ void onRelease() override;
private:
// Checked when this object is asked to attach a stencil buffer.
class GrTexture : virtual public GrSurface {
public:
- GrTexture* asTexture() SK_OVERRIDE { return this; }
- const GrTexture* asTexture() const SK_OVERRIDE { return this; }
+ GrTexture* asTexture() override { return this; }
+ const GrTexture* asTexture() const override { return this; }
/**
* Return the native ID or handle to the texture, depending on the
void validateDesc() const;
private:
- size_t onGpuMemorySize() const SK_OVERRIDE;
+ size_t onGpuMemorySize() const override;
void dirtyMipMaps(bool mipMapsDirty);
enum MipMapsStatus {
virtual ~SkROLockPixelsPixelRef();
protected:
- bool onNewLockPixels(LockRec*) SK_OVERRIDE;
- void onUnlockPixels() SK_OVERRIDE;
- bool onLockPixelsAreWritable() const SK_OVERRIDE; // return false;
+ bool onNewLockPixels(LockRec*) override;
+ void onUnlockPixels() override;
+ bool onLockPixelsAreWritable() const override; // return false;
private:
SkBitmap fBitmap;
virtual ~SkGrPixelRef();
// override from SkPixelRef
- GrTexture* getTexture() SK_OVERRIDE;
+ GrTexture* getTexture() override;
protected:
// overrides from SkPixelRef
- bool onReadPixels(SkBitmap* dst, const SkIRect* subset) SK_OVERRIDE;
+ bool onReadPixels(SkBitmap* dst, const SkIRect* subset) override;
virtual SkPixelRef* deepCopy(SkColorType, SkColorProfileType,
- const SkIRect* subset) SK_OVERRIDE;
+ const SkIRect* subset) override;
private:
GrSurface* fSurface;
static GrXPFactory* Create(SkRegion::Op regionOp, bool invertCoverage = false);
bool supportsRGBCoverage(GrColor /*knownColor*/,
- uint32_t /*knownColorFlags*/) const SK_OVERRIDE {
+ uint32_t /*knownColorFlags*/) const override {
return true;
}
- bool canTweakAlphaForCoverage() const SK_OVERRIDE { return false; }
+ bool canTweakAlphaForCoverage() const override { return false; }
void getInvariantOutput(const GrProcOptInfo& colorPOI, const GrProcOptInfo& coveragePOI,
- GrXPFactory::InvariantOutput*) const SK_OVERRIDE;
+ GrXPFactory::InvariantOutput*) const override;
private:
GrCoverageSetOpXPFactory(SkRegion::Op regionOp, bool invertCoverage);
GrXferProcessor* onCreateXferProcessor(const GrDrawTargetCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
- const GrDeviceCoordTexture* dstCopy) const SK_OVERRIDE;
+ const GrDeviceCoordTexture* dstCopy) const override;
bool willReadDstColor(const GrDrawTargetCaps& /*caps*/,
const GrProcOptInfo& /*colorPOI*/,
- const GrProcOptInfo& /*coveragePOI*/) const SK_OVERRIDE {
+ const GrProcOptInfo& /*coveragePOI*/) const override {
return false;
}
- bool onIsEqual(const GrXPFactory& xpfBase) const SK_OVERRIDE {
+ bool onIsEqual(const GrXPFactory& xpfBase) const override {
const GrCoverageSetOpXPFactory& xpf = xpfBase.cast<GrCoverageSetOpXPFactory>();
return fRegionOp == xpf.fRegionOp;
}
public:
static GrXPFactory* Create(SkXfermode::Mode mode);
- bool supportsRGBCoverage(GrColor knownColor, uint32_t knownColorFlags) const SK_OVERRIDE;
+ bool supportsRGBCoverage(GrColor knownColor, uint32_t knownColorFlags) const override;
- bool canTweakAlphaForCoverage() const SK_OVERRIDE;
+ bool canTweakAlphaForCoverage() const override;
void getInvariantOutput(const GrProcOptInfo& colorPOI, const GrProcOptInfo& coveragePOI,
- GrXPFactory::InvariantOutput*) const SK_OVERRIDE;
+ GrXPFactory::InvariantOutput*) const override;
private:
GrPorterDuffXPFactory(GrBlendCoeff src, GrBlendCoeff dst);
GrXferProcessor* onCreateXferProcessor(const GrDrawTargetCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
- const GrDeviceCoordTexture* dstCopy) const SK_OVERRIDE;
+ const GrDeviceCoordTexture* dstCopy) const override;
bool willReadDstColor(const GrDrawTargetCaps& caps,
const GrProcOptInfo& colorPOI,
- const GrProcOptInfo& coveragePOI) const SK_OVERRIDE;
+ const GrProcOptInfo& coveragePOI) const override;
- bool onIsEqual(const GrXPFactory& xpfBase) const SK_OVERRIDE {
+ bool onIsEqual(const GrXPFactory& xpfBase) const override {
const GrPorterDuffXPFactory& xpf = xpfBase.cast<GrPorterDuffXPFactory>();
return (fSrcCoeff == xpf.fSrcCoeff && fDstCoeff == xpf.fDstCoeff);
}
public:
SK_DECLARE_INST_COUNT(SkGLContext)
- ~SkGLContext() SK_OVERRIDE;
+ ~SkGLContext() override;
bool isValid() const { return NULL != gl(); }
class SK_API SkNullGLContext : public SkGLContext {
public:
- ~SkNullGLContext() SK_OVERRIDE;
- void makeCurrent() const SK_OVERRIDE;
- void swapBuffers() const SK_OVERRIDE {};
+ ~SkNullGLContext() override;
+ void makeCurrent() const override;
+ void swapBuffers() const override {};
static SkNullGLContext* Create(GrGLStandard);
class SkANGLEGLContext : public SkGLContext {
public:
- ~SkANGLEGLContext() SK_OVERRIDE;
- void makeCurrent() const SK_OVERRIDE;
- void swapBuffers() const SK_OVERRIDE;
+ ~SkANGLEGLContext() override;
+ void makeCurrent() const override;
+ void swapBuffers() const override;
static SkANGLEGLContext* Create(GrGLStandard forcedGpuAPI) {
if (kGL_GrGLStandard == forcedGpuAPI) {
{ }
protected:
- int onCountFamilies() const SK_OVERRIDE;
- void onGetFamilyName(int index, SkString* familyName) const SK_OVERRIDE;
- SkFontStyleSet* onCreateStyleSet(int index) const SK_OVERRIDE;
+ int onCountFamilies() const override;
+ void onGetFamilyName(int index, SkString* familyName) const override;
+ SkFontStyleSet* onCreateStyleSet(int index) const override;
- SkFontStyleSet* onMatchFamily(const char familyName[]) const SK_OVERRIDE;
+ SkFontStyleSet* onMatchFamily(const char familyName[]) const override;
virtual SkTypeface* onMatchFamilyStyle(const char familyName[],
- const SkFontStyle& fontStyle) const SK_OVERRIDE;
+ const SkFontStyle& fontStyle) const override;
virtual SkTypeface* onMatchFamilyStyleCharacter(const char familyName[],
const SkFontStyle&,
const char* bcp47[],
int bcp47Count,
- SkUnichar character) const SK_OVERRIDE;
+ SkUnichar character) const override;
virtual SkTypeface* onMatchFaceStyle(const SkTypeface* familyMember,
- const SkFontStyle& fontStyle) const SK_OVERRIDE;
+ const SkFontStyle& fontStyle) const override;
- SkTypeface* onCreateFromStream(SkStreamAsset* stream, int ttcIndex) const SK_OVERRIDE;
- SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const SK_OVERRIDE;
- SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const SK_OVERRIDE;
+ SkTypeface* onCreateFromStream(SkStreamAsset* stream, int ttcIndex) const override;
+ SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override;
+ SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const override;
virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
- unsigned styleBits) const SK_OVERRIDE;
+ unsigned styleBits) const override;
private:
SkTypeface* createTypefaceFromFontId(const SkFontIdentity& fontId) const;
*/
void silentFlush();
- SkDrawFilter* setDrawFilter(SkDrawFilter* filter) SK_OVERRIDE;
+ SkDrawFilter* setDrawFilter(SkDrawFilter* filter) override;
protected:
- void willSave() SK_OVERRIDE;
- SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) SK_OVERRIDE;
- void willRestore() SK_OVERRIDE;
+ void willSave() override;
+ SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) override;
+ void willRestore() override;
- void didConcat(const SkMatrix&) SK_OVERRIDE;
- void didSetMatrix(const SkMatrix&) SK_OVERRIDE;
+ void didConcat(const SkMatrix&) override;
+ void didSetMatrix(const SkMatrix&) override;
- void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) SK_OVERRIDE;
+ void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) override;
virtual void onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
virtual void onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
virtual void onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
- SkScalar constY, const SkPaint&) SK_OVERRIDE;
+ SkScalar constY, const SkPaint&) override;
virtual void onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
- const SkMatrix* matrix, const SkPaint&) SK_OVERRIDE;
+ const SkMatrix* matrix, const SkPaint&) override;
virtual void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
virtual void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
const SkPoint texCoords[4], SkXfermode* xmode,
- const SkPaint& paint) SK_OVERRIDE;
-
- void onDrawPaint(const SkPaint&) SK_OVERRIDE;
- void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) SK_OVERRIDE;
- void onDrawRect(const SkRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawOval(const SkRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawRRect(const SkRRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawPath(const SkPath&, const SkPaint&) SK_OVERRIDE;
- void onDrawBitmap(const SkBitmap&, SkScalar left, SkScalar top, const SkPaint*) SK_OVERRIDE;
+ const SkPaint& paint) override;
+
+ void onDrawPaint(const SkPaint&) override;
+ void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) override;
+ void onDrawRect(const SkRect&, const SkPaint&) override;
+ void onDrawOval(const SkRect&, const SkPaint&) override;
+ void onDrawRRect(const SkRRect&, const SkPaint&) override;
+ void onDrawPath(const SkPath&, const SkPaint&) override;
+ void onDrawBitmap(const SkBitmap&, SkScalar left, SkScalar top, const SkPaint*) override;
void onDrawBitmapRect(const SkBitmap&, const SkRect* src, const SkRect& dst, const SkPaint*,
- DrawBitmapRectFlags flags) SK_OVERRIDE;
+ DrawBitmapRectFlags flags) override;
#if 0
// rely on conversion to bitmap(for now)
- void onDrawImage(const SkImage*, SkScalar left, SkScalar top, const SkPaint*) SK_OVERRIDE;
+ void onDrawImage(const SkImage*, SkScalar left, SkScalar top, const SkPaint*) override;
void onDrawImageRect(const SkImage*, const SkRect* src, const SkRect& dst,
- const SkPaint*) SK_OVERRIDE;
+ const SkPaint*) override;
#endif
void onDrawBitmapNine(const SkBitmap&, const SkIRect& center, const SkRect& dst,
- const SkPaint*) SK_OVERRIDE;
- void onDrawSprite(const SkBitmap&, int left, int top, const SkPaint*) SK_OVERRIDE;
+ const SkPaint*) override;
+ void onDrawSprite(const SkBitmap&, int left, int top, const SkPaint*) override;
void onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
const SkColor colors[], SkXfermode* xmode,
const uint16_t indices[], int indexCount,
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
- void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipRegion(const SkRegion&, SkRegion::Op) SK_OVERRIDE;
+ void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipRegion(const SkRegion&, SkRegion::Op) override;
- void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) SK_OVERRIDE;
+ void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;
public:
class NotificationClient {
};
protected:
- SkCanvas* canvasForDrawIter() SK_OVERRIDE;
+ SkCanvas* canvasForDrawIter() override;
SkDeferredDevice* getDeferredDevice() const;
private:
int getNestLevel() const { return fNestLevel; }
- void beginCommentGroup(const char* description) SK_OVERRIDE;
- void addComment(const char* kywd, const char* value) SK_OVERRIDE;
- void endCommentGroup() SK_OVERRIDE;
+ void beginCommentGroup(const char* description) override;
+ void addComment(const char* kywd, const char* value) override;
+ void endCommentGroup() override;
protected:
- void willSave() SK_OVERRIDE;
- SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) SK_OVERRIDE;
- void willRestore() SK_OVERRIDE;
+ void willSave() override;
+ SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) override;
+ void willRestore() override;
- void didConcat(const SkMatrix&) SK_OVERRIDE;
- void didSetMatrix(const SkMatrix&) SK_OVERRIDE;
+ void didConcat(const SkMatrix&) override;
+ void didSetMatrix(const SkMatrix&) override;
- void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) SK_OVERRIDE;
+ void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) override;
virtual void onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
virtual void onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
virtual void onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
- SkScalar constY, const SkPaint&) SK_OVERRIDE;
+ SkScalar constY, const SkPaint&) override;
virtual void onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
- const SkMatrix* matrix, const SkPaint&) SK_OVERRIDE;
+ const SkMatrix* matrix, const SkPaint&) override;
virtual void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
virtual void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
const SkPoint texCoords[4], SkXfermode* xmode,
- const SkPaint& paint) SK_OVERRIDE;
-
- void onDrawPaint(const SkPaint&) SK_OVERRIDE;
- void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) SK_OVERRIDE;
- void onDrawRect(const SkRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawOval(const SkRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawRRect(const SkRRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawPath(const SkPath&, const SkPaint&) SK_OVERRIDE;
- void onDrawBitmap(const SkBitmap&, SkScalar left, SkScalar top, const SkPaint*) SK_OVERRIDE;
+ const SkPaint& paint) override;
+
+ void onDrawPaint(const SkPaint&) override;
+ void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) override;
+ void onDrawRect(const SkRect&, const SkPaint&) override;
+ void onDrawOval(const SkRect&, const SkPaint&) override;
+ void onDrawRRect(const SkRRect&, const SkPaint&) override;
+ void onDrawPath(const SkPath&, const SkPaint&) override;
+ void onDrawBitmap(const SkBitmap&, SkScalar left, SkScalar top, const SkPaint*) override;
void onDrawBitmapRect(const SkBitmap&, const SkRect* src, const SkRect& dst, const SkPaint*,
- DrawBitmapRectFlags flags) SK_OVERRIDE;
- void onDrawImage(const SkImage*, SkScalar left, SkScalar top, const SkPaint*) SK_OVERRIDE;
+ DrawBitmapRectFlags flags) override;
+ void onDrawImage(const SkImage*, SkScalar left, SkScalar top, const SkPaint*) override;
void onDrawImageRect(const SkImage*, const SkRect* src, const SkRect& dst,
- const SkPaint*) SK_OVERRIDE;
+ const SkPaint*) override;
void onDrawBitmapNine(const SkBitmap&, const SkIRect& center, const SkRect& dst,
- const SkPaint*) SK_OVERRIDE;
- void onDrawSprite(const SkBitmap&, int left, int top, const SkPaint*) SK_OVERRIDE;
+ const SkPaint*) override;
+ void onDrawSprite(const SkBitmap&, int left, int top, const SkPaint*) override;
void onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
const SkColor colors[], SkXfermode* xmode,
const uint16_t indices[], int indexCount,
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
- void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipRegion(const SkRegion&, SkRegion::Op) SK_OVERRIDE;
+ void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipRegion(const SkRegion&, SkRegion::Op) override;
- void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) SK_OVERRIDE;
+ void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;
static const char* EdgeStyleToAAString(ClipEdgeStyle edgeStyle);
// override from baseclass that does the formatting, and in turn calls
// the function pointer that was passed to the constructor
virtual void dump(SkDumpCanvas*, SkDumpCanvas::Verb, const char str[],
- const SkPaint*) SK_OVERRIDE;
+ const SkPaint*) override;
private:
void (*fProc)(const char*, void*);
virtual ~SkLuaCanvas();
protected:
- void willSave() SK_OVERRIDE;
- SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) SK_OVERRIDE;
- void willRestore() SK_OVERRIDE;
+ void willSave() override;
+ SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) override;
+ void willRestore() override;
- void didConcat(const SkMatrix&) SK_OVERRIDE;
- void didSetMatrix(const SkMatrix&) SK_OVERRIDE;
+ void didConcat(const SkMatrix&) override;
+ void didSetMatrix(const SkMatrix&) override;
- void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) SK_OVERRIDE;
+ void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) override;
virtual void onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
virtual void onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
virtual void onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
- SkScalar constY, const SkPaint&) SK_OVERRIDE;
+ SkScalar constY, const SkPaint&) override;
virtual void onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
- const SkMatrix* matrix, const SkPaint&) SK_OVERRIDE;
+ const SkMatrix* matrix, const SkPaint&) override;
virtual void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
- void onDrawPaint(const SkPaint&) SK_OVERRIDE;
- void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) SK_OVERRIDE;
- void onDrawRect(const SkRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawOval(const SkRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawRRect(const SkRRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawPath(const SkPath&, const SkPaint&) SK_OVERRIDE;
- void onDrawBitmap(const SkBitmap&, SkScalar left, SkScalar top, const SkPaint*) SK_OVERRIDE;
+ void onDrawPaint(const SkPaint&) override;
+ void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) override;
+ void onDrawRect(const SkRect&, const SkPaint&) override;
+ void onDrawOval(const SkRect&, const SkPaint&) override;
+ void onDrawRRect(const SkRRect&, const SkPaint&) override;
+ void onDrawPath(const SkPath&, const SkPaint&) override;
+ void onDrawBitmap(const SkBitmap&, SkScalar left, SkScalar top, const SkPaint*) override;
void onDrawBitmapRect(const SkBitmap&, const SkRect* src, const SkRect& dst, const SkPaint*,
- DrawBitmapRectFlags flags) SK_OVERRIDE;
- void onDrawImage(const SkImage*, SkScalar left, SkScalar top, const SkPaint*) SK_OVERRIDE;
+ DrawBitmapRectFlags flags) override;
+ void onDrawImage(const SkImage*, SkScalar left, SkScalar top, const SkPaint*) override;
void onDrawImageRect(const SkImage*, const SkRect* src, const SkRect& dst,
- const SkPaint*) SK_OVERRIDE;
+ const SkPaint*) override;
void onDrawBitmapNine(const SkBitmap&, const SkIRect& center, const SkRect& dst,
- const SkPaint*) SK_OVERRIDE;
- void onDrawSprite(const SkBitmap&, int left, int top, const SkPaint*) SK_OVERRIDE;
+ const SkPaint*) override;
+ void onDrawSprite(const SkBitmap&, int left, int top, const SkPaint*) override;
void onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
const SkColor colors[], SkXfermode* xmode,
const uint16_t indices[], int indexCount,
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
- void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipRegion(const SkRegion&, SkRegion::Op) SK_OVERRIDE;
+ void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipRegion(const SkRegion&, SkRegion::Op) override;
- void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) SK_OVERRIDE;
+ void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;
private:
lua_State* fL;
///////////////////////////////////////////////////////////////////////////
// These are forwarded to the N canvases we're referencing
- SkDrawFilter* setDrawFilter(SkDrawFilter*) SK_OVERRIDE;
+ SkDrawFilter* setDrawFilter(SkDrawFilter*) override;
- void beginCommentGroup(const char* description) SK_OVERRIDE;
- void addComment(const char* kywd, const char* value) SK_OVERRIDE;
- void endCommentGroup() SK_OVERRIDE;
+ void beginCommentGroup(const char* description) override;
+ void addComment(const char* kywd, const char* value) override;
+ void endCommentGroup() override;
protected:
SkTDArray<SkCanvas*> fList;
- void willSave() SK_OVERRIDE;
- SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) SK_OVERRIDE;
- void willRestore() SK_OVERRIDE;
+ void willSave() override;
+ SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) override;
+ void willRestore() override;
- void didConcat(const SkMatrix&) SK_OVERRIDE;
- void didSetMatrix(const SkMatrix&) SK_OVERRIDE;
+ void didConcat(const SkMatrix&) override;
+ void didSetMatrix(const SkMatrix&) override;
- void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) SK_OVERRIDE;
+ void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) override;
virtual void onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
virtual void onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
virtual void onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
- SkScalar constY, const SkPaint&) SK_OVERRIDE;
+ SkScalar constY, const SkPaint&) override;
virtual void onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
- const SkMatrix* matrix, const SkPaint&) SK_OVERRIDE;
+ const SkMatrix* matrix, const SkPaint&) override;
virtual void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
virtual void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
const SkPoint texCoords[4], SkXfermode* xmode,
- const SkPaint& paint) SK_OVERRIDE;
-
- void onDrawPaint(const SkPaint&) SK_OVERRIDE;
- void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) SK_OVERRIDE;
- void onDrawRect(const SkRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawOval(const SkRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawRRect(const SkRRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawPath(const SkPath&, const SkPaint&) SK_OVERRIDE;
- void onDrawBitmap(const SkBitmap&, SkScalar left, SkScalar top, const SkPaint*) SK_OVERRIDE;
+ const SkPaint& paint) override;
+
+ void onDrawPaint(const SkPaint&) override;
+ void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) override;
+ void onDrawRect(const SkRect&, const SkPaint&) override;
+ void onDrawOval(const SkRect&, const SkPaint&) override;
+ void onDrawRRect(const SkRRect&, const SkPaint&) override;
+ void onDrawPath(const SkPath&, const SkPaint&) override;
+ void onDrawBitmap(const SkBitmap&, SkScalar left, SkScalar top, const SkPaint*) override;
void onDrawBitmapRect(const SkBitmap&, const SkRect* src, const SkRect& dst, const SkPaint*,
- DrawBitmapRectFlags flags) SK_OVERRIDE;
- void onDrawImage(const SkImage*, SkScalar left, SkScalar top, const SkPaint*) SK_OVERRIDE;
+ DrawBitmapRectFlags flags) override;
+ void onDrawImage(const SkImage*, SkScalar left, SkScalar top, const SkPaint*) override;
void onDrawImageRect(const SkImage*, const SkRect* src, const SkRect& dst,
- const SkPaint*) SK_OVERRIDE;
+ const SkPaint*) override;
void onDrawBitmapNine(const SkBitmap&, const SkIRect& center, const SkRect& dst,
- const SkPaint*) SK_OVERRIDE;
- void onDrawSprite(const SkBitmap&, int left, int top, const SkPaint*) SK_OVERRIDE;
+ const SkPaint*) override;
+ void onDrawSprite(const SkBitmap&, int left, int top, const SkPaint*) override;
void onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
const SkColor colors[], SkXfermode* xmode,
const uint16_t indices[], int indexCount,
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
- void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipRegion(const SkRegion&, SkRegion::Op) SK_OVERRIDE;
+ void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipRegion(const SkRegion&, SkRegion::Op) override;
- void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) SK_OVERRIDE;
+ void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;
class Iter;
protected:
virtual SaveLayerStrategy willSaveLayer(const SkRect* bounds, const SkPaint* paint,
- SaveFlags flags) SK_OVERRIDE {
+ SaveFlags flags) override {
this->INHERITED::willSaveLayer(bounds, paint, flags);
return kNoLayer_SaveLayerStrategy;
}
protected:
// Overridden from from SkWindow:
- void onSetTitle(const char title[]) SK_OVERRIDE;
+ void onSetTitle(const char title[]) override;
private:
enum NextXEventResult {
SkPushButtonWidget(uint32_t flags = 0) : SkButtonWidget(flags) {}
protected:
- bool onEvent(const SkEvent&) SK_OVERRIDE;
- void onDraw(SkCanvas*) SK_OVERRIDE;
- Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) SK_OVERRIDE;
- bool onClick(Click* click) SK_OVERRIDE;
+ bool onEvent(const SkEvent&) override;
+ void onDraw(SkCanvas*) override;
+ Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) override;
+ bool onClick(Click* click) override;
private:
typedef SkButtonWidget INHERITED;
SkDEBUGCODE(static void UnitTest();)
protected:
- void onStartElementLen(const char elem[], size_t length) SK_OVERRIDE;
- void onEndElement() SK_OVERRIDE;
- void onAddAttributeLen(const char name[], const char value[], size_t length) SK_OVERRIDE;
- void onAddText(const char text[], size_t length) SK_OVERRIDE;
+ void onStartElementLen(const char elem[], size_t length) override;
+ void onEndElement() override;
+ void onAddAttributeLen(const char name[], const char value[], size_t length) override;
+ void onAddText(const char text[], size_t length) override;
private:
SkWStream& fStream;
virtual void onStartElementLen(const char elem[], size_t length);
virtual void onEndElement();
virtual void onAddAttributeLen(const char name[], const char value[], size_t length);
- virtual void onAddText(const char text[], size_t length) SK_OVERRIDE;
+ virtual void onAddText(const char text[], size_t length) override;
private:
SkXMLParser& fParser;
};
class SkGrayScaleColorFilter : public SkColorFilter {
public:
virtual void filterSpan(const SkPMColor src[], int count,
- SkPMColor result[]) const SK_OVERRIDE {
+ SkPMColor result[]) const override {
for (int i = 0; i < count; i++) {
result[i] = rgb2gray(src[i]);
}
}
virtual void filterSpan(const SkPMColor src[], int count,
- SkPMColor result[]) const SK_OVERRIDE {
+ SkPMColor result[]) const override {
SkPMColor mask = fMask;
for (int i = 0; i < count; i++) {
result[i] = src[i] & mask;
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(Dot2DPathEffect)
protected:
- void begin(const SkIRect& uvBounds, SkPath* dst) const SK_OVERRIDE {
+ void begin(const SkIRect& uvBounds, SkPath* dst) const override {
if (fPts) {
fPts->reset();
}
}
virtual void next(const SkPoint& loc, int u, int v,
- SkPath* dst) const SK_OVERRIDE {
+ SkPath* dst) const override {
if (fPts) {
*fPts->append() = loc;
}
dst->addCircle(loc.fX, loc.fY, fRadius);
}
- void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
+ void flatten(SkWriteBuffer& buffer) const override {
buffer.writeMatrix(this->getMatrix());
buffer.writeScalar(fRadius);
}
public:
InverseFillPE() {}
virtual bool filterPath(SkPath* dst, const SkPath& src,
- SkStrokeRec*, const SkRect*) const SK_OVERRIDE {
+ SkStrokeRec*, const SkRect*) const override {
*dst = src;
dst->setFillType(SkPath::kInverseWinding_FillType);
return true;
}
#ifndef SK_IGNORE_TO_STRING
- void toString(SkString* str) const SK_OVERRIDE {
+ void toString(SkString* str) const override {
str->appendf("InverseFillPE: ()");
}
#endif
static SkEvent* NewShowSizeEvt(bool doShowSize);
protected:
- bool onQuery(SkEvent*) SK_OVERRIDE;
- bool onEvent(const SkEvent&) SK_OVERRIDE;
- void onDrawContent(SkCanvas*) SK_OVERRIDE;
- void onDrawBackground(SkCanvas*) SK_OVERRIDE;
- bool onAnimate(const SkAnimTimer&) SK_OVERRIDE;
+ bool onQuery(SkEvent*) override;
+ bool onEvent(const SkEvent&) override;
+ void onDrawContent(SkCanvas*) override;
+ void onDrawBackground(SkCanvas*) override;
+ bool onAnimate(const SkAnimTimer&) override;
private:
GM* fGM;
virtual ~OverView();
protected:
- bool onEvent(const SkEvent&) SK_OVERRIDE;
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onEvent(const SkEvent&) override;
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "Overview");
return true;
return this->INHERITED::onQuery(evt);
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE;
+ void onDraw(SkCanvas* canvas) override;
- bool onSendClickToChildren(SkScalar x, SkScalar y, unsigned modi) SK_OVERRIDE {
+ bool onSendClickToChildren(SkScalar x, SkScalar y, unsigned modi) override {
return false;
}
- Click* onFindClickHandler(SkScalar cx, SkScalar cy, unsigned modi) SK_OVERRIDE {
+ Click* onFindClickHandler(SkScalar cx, SkScalar cy, unsigned modi) override {
const SkRect crect = SkRect::MakeXYWH(cx - 0.5f, cy - 0.5f, 1, 1);
SkPoint loc = this->start();
for (int i = 0; i < fCount; ++i) {
class SkGrayScaleColorFilter : public SkColorFilter {
public:
virtual void filterSpan(const SkPMColor src[], int count,
- SkPMColor result[]) const SK_OVERRIDE {
+ SkPMColor result[]) const override {
for (int i = 0; i < count; i++)
result[i] = rgb2gray(src[i]);
}
}
virtual void filterSpan(const SkPMColor src[], int count,
- SkPMColor result[]) const SK_OVERRIDE {
+ SkPMColor result[]) const override {
SkPMColor mask = fMask;
for (int i = 0; i < count; i++) {
result[i] = src[i] & mask;
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(Dot2DPathEffect)
protected:
- void next(const SkPoint& loc, int u, int v, SkPath* dst) const SK_OVERRIDE {
+ void next(const SkPoint& loc, int u, int v, SkPath* dst) const override {
dst->addCircle(loc.fX, loc.fY, fRadius);
}
- void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
+ void flatten(SkWriteBuffer& buffer) const override {
this->INHERITED::flatten(buffer);
buffer.writeScalar(fRadius);
}
protected:
// overrides from SkEventSink
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "AnimBlur");
return true;
return this->INHERITED::onQuery(evt);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
static const SkBlurStyle gStyles[] = {
kNormal_SkBlurStyle,
kInner_SkBlurStyle,
}
}
- bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ bool onAnimate(const SkAnimTimer& timer) override {
fBlurSigma = get_anim_sin(timer.secs(), 100, 4, 5);
fCircleRadius = 3 + get_anim_sin(timer.secs(), 150, 25, 3);
return true;
SkString fFilename;
public:
PictFileFactory(const SkString& filename) : fFilename(filename) {}
- SkView* operator() () const SK_OVERRIDE {
+ SkView* operator() () const override {
return CreateSamplePictFileView(fFilename.c_str());
}
};
SkString fFilename;
public:
PdfFileViewerFactory(const SkString& filename) : fFilename(filename) {}
- SkView* operator() () const SK_OVERRIDE {
+ SkView* operator() () const override {
return CreateSamplePdfFileViewer(fFilename.c_str());
}
};
}
virtual SkSurface* createSurface(SampleWindow::DeviceType dType,
- SampleWindow* win) SK_OVERRIDE {
+ SampleWindow* win) override {
#if SK_SUPPORT_GPU
if (IsGpuDeviceType(dType) && fCurContext) {
SkSurfaceProps props(win->getSurfaceProps());
#endif
}
- GrRenderTarget* getGrRenderTarget() SK_OVERRIDE {
+ GrRenderTarget* getGrRenderTarget() override {
#if SK_SUPPORT_GPU
return fCurRenderTarget;
#else
SampleWindow(void* hwnd, int argc, char** argv, DeviceManager*);
virtual ~SampleWindow();
- SkSurface* createSurface() SK_OVERRIDE {
+ SkSurface* createSurface() override {
SkSurface* surface = NULL;
if (fDevManager) {
surface = fDevManager->createSurface(fDeviceType, this);
return surface;
}
- void draw(SkCanvas*) SK_OVERRIDE;
+ void draw(SkCanvas*) override;
void setDeviceType(DeviceType type);
void toggleRendering();
DeviceType getDeviceType() const { return fDeviceType; }
protected:
- void onDraw(SkCanvas* canvas) SK_OVERRIDE;
- bool onHandleKey(SkKey key) SK_OVERRIDE;
- bool onHandleChar(SkUnichar) SK_OVERRIDE;
- void onSizeChange() SK_OVERRIDE;
+ void onDraw(SkCanvas* canvas) override;
+ bool onHandleKey(SkKey key) override;
+ bool onHandleChar(SkUnichar) override;
+ void onSizeChange() override;
- SkCanvas* beforeChildren(SkCanvas*) SK_OVERRIDE;
- void afterChildren(SkCanvas*) SK_OVERRIDE;
- void beforeChild(SkView* child, SkCanvas* canvas) SK_OVERRIDE;
- void afterChild(SkView* child, SkCanvas* canvas) SK_OVERRIDE;
+ SkCanvas* beforeChildren(SkCanvas*) override;
+ void afterChildren(SkCanvas*) override;
+ void beforeChild(SkView* child, SkCanvas* canvas) override;
+ void afterChild(SkView* child, SkCanvas* canvas) override;
- bool onEvent(const SkEvent& evt) SK_OVERRIDE;
- bool onQuery(SkEvent* evt) SK_OVERRIDE;
+ bool onEvent(const SkEvent& evt) override;
+ bool onQuery(SkEvent* evt) override;
virtual bool onDispatchClick(int x, int y, Click::State, void* owner,
- unsigned modi) SK_OVERRIDE;
- bool onClick(Click* click) SK_OVERRIDE;
+ unsigned modi) override;
+ bool onClick(Click* click) override;
virtual Click* onFindClickHandler(SkScalar x, SkScalar y,
- unsigned modi) SK_OVERRIDE;
+ unsigned modi) override;
private:
class DefaultDeviceManager;
}
}
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
paint.setStrokeWidth(SkIntToScalar(2));
canvas->drawArc(fR, 0, fSweep, false, paint);
}
- SkRect onGetBounds() SK_OVERRIDE {
+ SkRect onGetBounds() override {
SkRect r(fR);
r.outset(2, 2);
return r;
fRootDrawable = recorder.endRecordingAsDrawable();
}
- ~ArcsView() SK_OVERRIDE {
+ ~ArcsView() override {
fAnimatingDrawable->unref();
fRootDrawable->unref();
}
protected:
// overrides from SkEventSink
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "Arcs");
return true;
DrawArcs(canvas);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
canvas->drawDrawable(fRootDrawable);
}
- bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ bool onAnimate(const SkAnimTimer& timer) override {
SkScalar angle = SkDoubleToScalar(fmod(timer.secs() * 360 / 24, 360));
fAnimatingDrawable->setSweep(angle);
return true;
}
- SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) SK_OVERRIDE {
+ SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) override {
// fSweep += SK_Scalar1;
this->inval(NULL);
return this->INHERITED::onFindClickHandler(x, y, modi);
}
protected:
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "BitmapRect");
return true;
return this->INHERITED::onQuery(evt);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
SkRect srcR;
srcR.set(fSrcPts[0], fSrcPts[1]);
srcR = SkRect::MakeXYWH(fSrcPts[0].fX, fSrcPts[0].fY, 32, 32);
}
}
- bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ bool onAnimate(const SkAnimTimer& timer) override {
if (timer.isStopped()) {
this->resetBounce();
} else if (timer.isRunning()) {
}
protected:
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "BigBitmapRect");
return true;
return this->INHERITED::onQuery(evt);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
SkPaint paint;
paint.setStyle(SkPaint::kStroke_Style);
paint.setColor(SK_ColorYELLOW);
}
}
- bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ bool onAnimate(const SkAnimTimer& timer) override {
if (timer.isStopped()) {
this->resetBounce();
} else if (timer.isRunning()) {
}
}
- bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ bool onAnimate(const SkAnimTimer& timer) override {
if (timer.isStopped()) {
fRY = 0;
} else {
}
protected:
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "Chart");
return true;
return this->INHERITED::onQuery(evt);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
bool sizeChanged = false;
if (canvas->getDeviceSize() != fSize) {
fSize = canvas->getDeviceSize();
}
protected:
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "ClipDrawMatch");
return true;
}
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
SkScalar trans[2];
fTrans.timeToValues(SkTime::GetMSecs(), trans);
protected:
// overrides from SkEventSink
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "Clock");
return true;
return this->INHERITED::onQuery(evt);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
SkPaint paintFill;
SkPaint paintStroke;
SkPath path;
class SkFuncViewFactory : public SkViewFactory {
public:
SkFuncViewFactory(SkViewCreateFunc func);
- SkView* operator() () const SK_OVERRIDE;
+ SkView* operator() () const override;
private:
SkViewCreateFunc fCreateFunc;
class SkGMSampleViewFactory : public SkViewFactory {
public:
SkGMSampleViewFactory(GMFactoryFunc func);
- SkView* operator() () const SK_OVERRIDE;
+ SkView* operator() () const override;
private:
GMFactoryFunc fFunc;
};
}
protected:
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "DegenerateTwoPtRadials");
return true;
return this->INHERITED::onQuery(evt);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
SkScalar delta = fTime / 15.f;
int intPart = SkScalarFloorToInt(delta);
delta = delta - SK_Scalar1 * intPart;
canvas->drawText(txt.c_str(), txt.size(), l + w/2 + w*DELTA_SCALE*delta, t + h + SK_Scalar1 * 10, paint);
}
- bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ bool onAnimate(const SkAnimTimer& timer) override {
fTime = SkDoubleToScalar(timer.secs() / 15);
return true;
}
}
protected:
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "FatBits");
return true;
}
virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y,
- unsigned modi) SK_OVERRIDE {
+ unsigned modi) override {
SkPoint pt = { x, y };
int index = -1;
int count = fFB.getTriangle() ? 3 : 2;
return new IndexClick(this, index);
}
- bool onClick(Click* click) SK_OVERRIDE {
+ bool onClick(Click* click) override {
int index = IndexClick::GetIndex(click);
if (index >= 0 && index <= 2) {
fPts[index] = click->fCurr;
}
protected:
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "FilterQuality");
return true;
canvas->drawLine(r.centerX(), r.top(), r.centerX(), r.bottom(), p);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
fCell.set(this->height() / 2, this->height() / 2);
SkScalar trans[2];
canvas->drawText(str.c_str(), str.size(), textX, 250, paint);
}
- bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ bool onAnimate(const SkAnimTimer& timer) override {
fCurrTime = timer.msec();
return true;
}
void setTime(SkMSec time) { fTime = time; }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkAutoCanvasRestore acr(canvas, false);
SkPaint paint;
canvas->drawRect(fR, paint);
}
- SkRect onGetBounds() SK_OVERRIDE { return fR; }
+ SkRect onGetBounds() override { return fR; }
};
class HTView : public SampleView {
}
protected:
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "HT");
return true;
return this->INHERITED::onQuery(evt);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
canvas->drawDrawable(fRoot);
}
- bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ bool onAnimate(const SkAnimTimer& timer) override {
fTime = timer.msec();
for (int i = 0; i < N; ++i) {
fArray[i].fDrawable->setTime(fTime);
return true;
}
- SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) SK_OVERRIDE {
+ SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) override {
// search backwards to find the top-most
for (int i = N - 1; i >= 0; --i) {
if (fArray[i].fDrawable->hitTest(x, y)) {
protected:
// overrides from SkEventSink
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SkString str;
str.printf("Hair-%s", gProcs[fProcIndex].fName);
canvas->drawBitmap(b1, SkIntToScalar(b0.width()), 0, NULL);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
gRand.setSeed(fNow);
SkBitmap bm, bm2;
canvas->drawBitmap(bm2, SkIntToScalar(10), SkIntToScalar(10), NULL);
}
- bool onAnimate(const SkAnimTimer&) SK_OVERRIDE {
+ bool onAnimate(const SkAnimTimer&) override {
if (fDoAA) {
fProcIndex = cycle_hairproc_index(fProcIndex);
// todo: signal that we want to rebuild our TITLE
return true;
}
- SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) SK_OVERRIDE {
+ SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) override {
fDoAA = !fDoAA;
this->inval(NULL);
return this->INHERITED::onFindClickHandler(x, y, modi);
SkBitmap fBM;
// overrides from SkEventSink
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "IdentityScale");
return true;
return this->INHERITED::onQuery(evt);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
SkPaint paint;
class RedFilter : public SkDrawFilter {
public:
- bool filter(SkPaint* p, SkDrawFilter::Type) SK_OVERRIDE {
+ bool filter(SkPaint* p, SkDrawFilter::Type) override {
fColor = p->getColor();
if (fColor == SK_ColorRED) {
p->setColor(SK_ColorGREEN);
}
virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y,
- unsigned modi) SK_OVERRIDE {
+ unsigned modi) override {
this->inval(NULL);
return this->INHERITED::onFindClickHandler(x, y, modi);
canvas->drawLine(x, y, x + SkIntToScalar(90), y + SkIntToScalar(90), paint);
}
- SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned) SK_OVERRIDE {
+ SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned) override {
fAlpha = SkScalarRoundToInt(y);
this->inval(NULL);
return NULL;
}
protected:
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "Lua");
return true;
return this->INHERITED::onQuery(evt);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
lua_State* L = this->ensureLua();
lua_getglobal(L, gDrawName);
}
virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y,
- unsigned modi) SK_OVERRIDE {
+ unsigned modi) override {
lua_State* L = this->ensureLua();
lua_getglobal(L, gClickName);
if (lua_isfunction(L, -1)) {
return this->INHERITED::onFindClickHandler(x, y, modi);
}
- bool onClick(Click* click) SK_OVERRIDE {
+ bool onClick(Click* click) override {
if (click->getType() != gLuaClickHandlerName) {
return this->INHERITED::onClick(click);
}
ManyRectsView() {}
protected:
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "ManyRects");
return true;
drawpatches(canvas, paint, nu, nv, &patch);
}
- bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ bool onAnimate(const SkAnimTimer& timer) override {
fAngle = timer.scaled(60, 360);
return true;
}
}
virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y,
- unsigned modi) SK_OVERRIDE {
+ unsigned modi) override {
x -= DX;
y -= DY;
for (size_t i = 0; i < SK_ARRAY_COUNT(fPts); i++) {
}
}
- bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ bool onAnimate(const SkAnimTimer& timer) override {
SkScalar currSecs = timer.scaled(100);
SkScalar delta = currSecs - fPrevSecs;
fPrevSecs = currSecs;
return true;
}
- SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) SK_OVERRIDE {
+ SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) override {
fShowHairline = !fShowHairline;
this->inval(NULL);
return this->INHERITED::onFindClickHandler(x, y, modi);
protected:
// overrides from SkEventSink
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "ArcTo");
return true;
}
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
canvas->drawPoints(SkCanvas::kPoints_PointMode, N, fPts, fPtsPaint);
SkPath path;
canvas->drawPath(path, fSkeletonPaint);
}
- bool onClick(Click* click) SK_OVERRIDE {
+ bool onClick(Click* click) override {
int32_t index;
if (click->fMeta.findS32("index", &index)) {
SkASSERT((unsigned)index < N);
return false;
}
- SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) SK_OVERRIDE {
+ SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) override {
const SkScalar tol = 4;
const SkRect r = SkRect::MakeXYWH(x - tol, y - tol, tol * 2, tol * 2);
for (int i = 0; i < N; ++i) {
canvas->drawOval(oval, p);
}
- SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned) SK_OVERRIDE {
+ SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned) override {
return new Click(this);
}
}
protected:
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
SkRandom rand;
int steps = 20;
SkScalar dist = SkIntToScalar(400);
this->setBGColor(0xFFDDDDDD);
}
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "PathEffects");
return true;
return this->INHERITED::onQuery(evt);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
SkPaint paint;
canvas->translate(0, 50);
canvas->drawPath(fPath, paint);
}
- bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ bool onAnimate(const SkAnimTimer& timer) override {
fPhase = timer.scaled(40);
return true;
}
return this->INHERITED::onQuery(evt);
}
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
fIndex = 0;
SkImageInfo info(SkImageInfo::MakeN32Premul(SkScalarRoundToInt(width()),
SkScalarRoundToInt(height())));
}
}
- void onTileSizeChanged(const SkSize &tileSize) SK_OVERRIDE {
+ void onTileSizeChanged(const SkSize &tileSize) override {
if (tileSize != fTileSize) {
fTileSize = tileSize;
}
protected:
// overrides from SkEventSink
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SkString name("P:");
const char* basename = strrchr(fFilename.c_str(), SkPATH_SEPARATOR);
return this->INHERITED::onQuery(evt);
}
- bool onEvent(const SkEvent& evt) SK_OVERRIDE {
+ bool onEvent(const SkEvent& evt) override {
if (evt.isType("PictFileView::toggleBBox")) {
fBBox = (BBoxType)((fBBox + 1) % kBBoxTypeCount);
return true;
return this->INHERITED::onEvent(evt);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
SkASSERT(static_cast<int>(fBBox) < kBBoxTypeCount);
SkPicture** picture = fPictures + fBBox;
protected:
// overrides from SkEventSink
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "Picture");
return true;
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
this->drawSomething(canvas);
SkPictureRecorder recorder;
(new SkEvent(INVAL_ALL_TYPE, this->getSinkID()))->postDelay(delay);
}
- bool onEvent(const SkEvent& evt) SK_OVERRIDE {
+ bool onEvent(const SkEvent& evt) override {
if (evt.isType(INVAL_ALL_TYPE)) {
this->inval(NULL);
return true;
}
protected:
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "QuadStroker");
return true;
return this->INHERITED::onQuery(evt);
}
- void onSizeChange() SK_OVERRIDE {
+ void onSizeChange() override {
fWeightControl.setXYWH(this->width() - 150, 30, 30, 400);
fErrorControl.setXYWH(this->width() - 100, 30, 30, 400);
fWidthControl.setXYWH(this->width() - 50, 30, 30, 400);
}
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
SkPath path;
SkScalar width = fWidth;
};
virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y,
- unsigned modi) SK_OVERRIDE {
+ unsigned modi) override {
for (size_t i = 0; i < SK_ARRAY_COUNT(fPts); ++i) {
if (hittest(fPts[i], x, y)) {
return new MyClick(this, (int)i);
return (SkIntToScalar(y) - control.fTop) / control.height() * (max - min) + min;
}
- bool onClick(Click* click) SK_OVERRIDE {
+ bool onClick(Click* click) override {
int index = ((MyClick*)click)->fIndex;
if (index < (int) SK_ARRAY_COUNT(fPts)) {
fPts[index].offset(SkIntToScalar(click->fICurr.fX - click->fIPrev.fX),
}
protected:
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "Rectanizer");
return true;
return this->INHERITED::onQuery(evt);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
if (fCurRandRect < kNumRandRects) {
if (fCurRectanizer->addRect((*fCurRects)[fCurRandRect].fWidth,
(*fCurRects)[fCurRandRect].fHeight,
protected:
// overrides from SkEventSink
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "Regions");
return true;
canvas->drawPath(path, paint);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
if (false) { // avoid bit rot, suppress warning
test_strokerect(canvas);
return;
}
virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y,
- unsigned modi) SK_OVERRIDE {
+ unsigned modi) override {
return fRect.contains(SkScalarRoundToInt(x),
SkScalarRoundToInt(y)) ? new Click(this) : NULL;
}
- bool onClick(Click* click) SK_OVERRIDE {
+ bool onClick(Click* click) override {
fRect.offset(click->fICurr.fX - click->fIPrev.fX,
click->fICurr.fY - click->fIPrev.fY);
this->inval(NULL);
protected:
// overrides from SkEventSink
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "RepeatTile");
return true;
return this->INHERITED::onQuery(evt);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
SkPaint paint;
make_paint(&paint, SkShader::kRepeat_TileMode);
canvas->drawPaint(paint);
}
- SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) SK_OVERRIDE {
+ SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) override {
this->inval(NULL);
return this->INHERITED::onFindClickHandler(x, y, modi);
}
- bool onClick(Click* click) SK_OVERRIDE {
+ bool onClick(Click* click) override {
return this->INHERITED::onClick(click);
}
protected:
// overrides from SkEventSink
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "Shaders");
return true;
return this->INHERITED::onQuery(evt);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
canvas->drawBitmap(fBitmap, 0, 0);
canvas->translate(SkIntToScalar(20), SkIntToScalar(120));
}
virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y,
- unsigned modi) SK_OVERRIDE {
+ unsigned modi) override {
this->inval(NULL);
return this->INHERITED::onFindClickHandler(x, y, modi);
}
- bool onClick(Click* click) SK_OVERRIDE {
+ bool onClick(Click* click) override {
return this->INHERITED::onClick(click);
}
protected:
// overrides from SkEventSink
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "Slides");
return true;
return this->INHERITED::onQuery(evt);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
this->init();
gProc[fIndex](canvas);
}
- SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned) SK_OVERRIDE {
+ SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned) override {
this->init();
fIndex = (fIndex + 1) % SK_ARRAY_COUNT(gProc);
this->inval(NULL);
protected:
// overrides from SkEventSink
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "StringArt");
return true;
return this->INHERITED::onQuery(evt);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
SkScalar angle = fAngle*SK_ScalarPI + SkScalarHalf(SK_ScalarPI);
SkPoint center = SkPoint::Make(SkScalarHalf(this->width()), SkScalarHalf(this->height()));
canvas->drawPath(path, paint);
}
- SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned) SK_OVERRIDE {
+ SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned) override {
fAngle = x/width();
this->inval(NULL);
return NULL;
SkScalar fWidth;
SkPath fPath;
protected:
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
// test_blur();
fWidth = SkIntToScalar(120);
}
// overrides from SkEventSink
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "StrokePath");
return true;
}
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
test_huge_stroke(canvas); return;
canvas->translate(SkIntToScalar(10), SkIntToScalar(10));
}
virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y,
- unsigned modi) SK_OVERRIDE {
+ unsigned modi) override {
this->inval(NULL);
return this->INHERITED::onFindClickHandler(x, y, modi);
}
SkPoint fCurPos;
// overrides from SkEventSink
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "SubpixelTranslate");
return true;
return this->INHERITED::onQuery(evt);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
static const SkFilterQuality gQualitys[] = {
kNone_SkFilterQuality,
protected:
// overrides from SkEventSink
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "Text");
return true;
pts[i].set(rand->nextUScalar1() * 640, rand->nextUScalar1() * 480);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
SkAutoCanvasRestore restore(canvas, false);
{
SkRect r;
}
virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y,
- unsigned modi) SK_OVERRIDE {
+ unsigned modi) override {
fClickX = x;
this->inval(NULL);
return this->INHERITED::onFindClickHandler(x, y, modi);
}
- bool onClick(Click* click) SK_OVERRIDE {
+ bool onClick(Click* click) override {
return this->INHERITED::onClick(click);
}
protected:
// overrides from SkEventSink
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "TextAlpha");
return true;
return this->INHERITED::onQuery(evt);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
const char* str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
SkPaint paint;
SkScalar x = SkIntToScalar(10);
}
}
- SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned) SK_OVERRIDE {
+ SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned) override {
return new Click(this);
}
- bool onClick(Click* click) SK_OVERRIDE {
+ bool onClick(Click* click) override {
int y = click->fICurr.fY;
if (y < 0) {
y = 0;
SkScalar fHOffset;
protected:
- void onOnceBeforeDraw() SK_OVERRIDE {
+ void onOnceBeforeDraw() override {
SkRect r;
r.set(SkIntToScalar(100), SkIntToScalar(100),
SkIntToScalar(300), SkIntToScalar(300));
}
// overrides from SkEventSink
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "Text On Path");
return true;
return this->INHERITED::onQuery(evt);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
paint.setTextSize(SkIntToScalar(48));
this->inval(NULL);
}
- SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) SK_OVERRIDE {
+ SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) override {
fHints += 1;
this->inval(NULL);
return this->INHERITED::onFindClickHandler(x, y, modi);
}
- bool onClick(Click* click) SK_OVERRIDE {
+ bool onClick(Click* click) override {
return this->INHERITED::onClick(click);
}
protected:
// overrides from SkEventSink
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "unpremul");
return true;
return this->INHERITED::onQuery(evt);
}
- void onDrawBackground(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawBackground(SkCanvas* canvas) override {
sk_tool_utils::draw_checkerboard(canvas, 0xFFCCCCCC, 0xFFFFFFFF, 12);
}
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
paint.setTextSize(SkIntToScalar(24));
protected:
// overrides from SkEventSink
- bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ bool onQuery(SkEvent* evt) override {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "Vertices");
return true;
SkScalar fScale;
- void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
+ void onDrawContent(SkCanvas* canvas) override {
SkPaint paint;
paint.setDither(true);
paint.setFilterQuality(kLow_SkFilterQuality);
}
}
- SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned) SK_OVERRIDE {
+ SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned) override {
return new Click(this);
}
- bool onClick(Click* click) SK_OVERRIDE {
+ bool onClick(Click* click) override {
// fCurrX = click->fICurr.fX;
// fCurrY = click->fICurr.fY;
this->inval(NULL);
<!--?prettify?-->
~~~~
-virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE {
+virtual void flatten(SkFlattenableWriteBuffer& buffer) const override {
this->INHERITED::flatten(buffer);
// Write any private data that needs to be stored to recreate this object
}
};
~~~~
-Virtual functions that are overridden in derived classes should use SK_OVERRIDE
+Virtual functions that are overridden in derived classes should use override
(and not the override keyword). The virtual keyword can be omitted.
<!--?prettify?-->
~~~~
-void myVirtual() SK_OVERRIDE {
+void myVirtual() override {
}
~~~~
<!--?prettify?-->
~~~~
-void myVirtual() SK_OVERRIDE {
+void myVirtual() override {
...
this->INHERITED::myVirtual();
...
~~~~
As in the above example, derived classes that redefine virtual functions should
-use SK_OVERRIDE to note that explicitly.
+use override to note that explicitly.
Constructor initializers should be one per line, indented, with punctuation
placed before the initializer. This is a fairly new rule so much of the existing
}
protected:
- void draw(SkCanvas* canvas) SK_OVERRIDE {
+ void draw(SkCanvas* canvas) override {
// Clear background
canvas->drawColor(SK_ColorWHITE);
DECLARE_MEMBER_INFO(Animate);
SkAnimate();
virtual ~SkAnimate();
- int components() SK_OVERRIDE;
+ int components() override;
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
- void onEndElement(SkAnimateMaker& maker) SK_OVERRIDE;
+ void onEndElement(SkAnimateMaker& maker) override;
protected:
bool resolveCommon(SkAnimateMaker& );
int fComponents;
SkAnimateBase();
virtual ~SkAnimateBase();
virtual int components();
- SkDisplayable* deepCopy(SkAnimateMaker* ) SK_OVERRIDE;
- void dirty() SK_OVERRIDE;
+ SkDisplayable* deepCopy(SkAnimateMaker* ) override;
+ void dirty() override;
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
int entries() { return fValues.count() / components(); }
virtual bool hasExecute() const;
bool isDynamic() const { return SkToBool(fDynamic); }
- SkDisplayable* getParent() const SK_OVERRIDE;
- bool getProperty(int index, SkScriptValue* value) const SK_OVERRIDE;
+ SkDisplayable* getParent() const override;
+ bool getProperty(int index, SkScriptValue* value) const override;
SkMSec getStart() const { return fStart; }
SkOperand* getValues() { return fValues.begin(); }
SkDisplayTypes getValuesType() { return fValues.getType(); }
- void onEndElement(SkAnimateMaker& ) SK_OVERRIDE;
+ void onEndElement(SkAnimateMaker& ) override;
void packARGB(SkScalar [], int count, SkTDOperandArray* );
virtual void refresh(SkAnimateMaker& );
void setChanged(bool changed) { fChanged = changed; }
void setHasEndEvent() { fHasEndEvent = true; }
- bool setParent(SkDisplayable* ) SK_OVERRIDE;
- bool setProperty(int index, SkScriptValue& value) SK_OVERRIDE;
+ bool setParent(SkDisplayable* ) override;
+ bool setProperty(int index, SkScriptValue& value) override;
void setTarget(SkAnimateMaker& );
virtual bool targetNeedsInitialization() const;
protected:
DECLARE_MEMBER_INFO(Set);
SkSet();
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
- void onEndElement(SkAnimateMaker& ) SK_OVERRIDE;
- void refresh(SkAnimateMaker& ) SK_OVERRIDE;
+ void onEndElement(SkAnimateMaker& ) override;
+ void refresh(SkAnimateMaker& ) override;
private:
typedef SkAnimate INHERITED;
};
kMode_immediate
};
- SkDisplayable* deepCopy(SkAnimateMaker* ) SK_OVERRIDE;
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ SkDisplayable* deepCopy(SkAnimateMaker* ) override;
+ bool draw(SkAnimateMaker& ) override;
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
- bool enable(SkAnimateMaker& ) SK_OVERRIDE;
- bool hasEnable() const SK_OVERRIDE;
- void initialize() SK_OVERRIDE;
- bool isDrawable() const SK_OVERRIDE;
+ bool enable(SkAnimateMaker& ) override;
+ bool hasEnable() const override;
+ void initialize() override;
+ bool isDrawable() const override;
protected:
// struct _A {
Mode mode;
void appendActive(SkActive* );
void applyValues(int animatorIndex, SkOperand* values, int count,
SkDisplayTypes , SkMSec time);
- bool contains(SkDisplayable*) SK_OVERRIDE;
+ bool contains(SkDisplayable*) override;
// void createActive(SkAnimateMaker& );
- SkDisplayable* deepCopy(SkAnimateMaker* ) SK_OVERRIDE;
+ SkDisplayable* deepCopy(SkAnimateMaker* ) override;
void disable();
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ bool draw(SkAnimateMaker& ) override;
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
- bool enable(SkAnimateMaker& ) SK_OVERRIDE;
+ bool enable(SkAnimateMaker& ) override;
void enableCreate(SkAnimateMaker& );
void enableDynamic(SkAnimateMaker& );
void endSave(int index);
Mode getMode() { return mode; }
- bool getProperty(int index, SkScriptValue* value) const SK_OVERRIDE;
+ bool getProperty(int index, SkScriptValue* value) const override;
SkADrawable* getScope() { return scope; }
void getStep(SkScriptValue* );
SkADrawable* getTarget(SkAnimateBase* );
bool hasDelayedAnimator() const;
- bool hasEnable() const SK_OVERRIDE;
+ bool hasEnable() const override;
bool inactivate(SkAnimateMaker& maker);
- void initialize() SK_OVERRIDE;
+ void initialize() override;
bool interpolate(SkAnimateMaker& , SkMSec time);
- void onEndElement(SkAnimateMaker& ) SK_OVERRIDE;
- const SkMemberInfo* preferredChild(SkDisplayTypes type) SK_OVERRIDE;
+ void onEndElement(SkAnimateMaker& ) override;
+ const SkMemberInfo* preferredChild(SkDisplayTypes type) override;
void refresh(SkAnimateMaker& );
void reset();
- bool resolveIDs(SkAnimateMaker& maker, SkDisplayable* original, SkApply* ) SK_OVERRIDE;
+ bool resolveIDs(SkAnimateMaker& maker, SkDisplayable* original, SkApply* ) override;
bool resolveField(SkAnimateMaker& , SkDisplayable* parent, SkString* str);
void save(int index);
void setEmbedded() { fEmbedded = true; }
- bool setProperty(int index, SkScriptValue& ) SK_OVERRIDE;
- void setSteps(int _steps) SK_OVERRIDE;
+ bool setProperty(int index, SkScriptValue& ) override;
+ void setSteps(int _steps) override;
// virtual void setTime(SkMSec time);
#ifdef SK_DEBUG
- void validate() SK_OVERRIDE;
+ void validate() override;
#endif
private:
SkMSec begin;
class SkDisplayBounds : public SkDrawRect {
DECLARE_DISPLAY_MEMBER_INFO(Bounds);
SkDisplayBounds();
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ bool draw(SkAnimateMaker& ) override;
private:
SkBool inval;
typedef SkDrawRect INHERITED;
};
SkDisplayEvent();
virtual ~SkDisplayEvent();
- bool addChild(SkAnimateMaker& , SkDisplayable* child) SK_OVERRIDE;
- bool contains(SkDisplayable*) SK_OVERRIDE;
- SkDisplayable* contains(const SkString& ) SK_OVERRIDE;
+ bool addChild(SkAnimateMaker& , SkDisplayable* child) override;
+ bool contains(SkDisplayable*) override;
+ SkDisplayable* contains(const SkString& ) override;
#ifdef SK_DEBUG
void dumpEvent(SkAnimateMaker* );
#endif
bool enableEvent(SkAnimateMaker& );
- bool getProperty(int index, SkScriptValue* ) const SK_OVERRIDE;
- void onEndElement(SkAnimateMaker& maker) SK_OVERRIDE;
+ bool getProperty(int index, SkScriptValue* ) const override;
+ void onEndElement(SkAnimateMaker& maker) override;
void populateInput(SkAnimateMaker& , const SkEvent& fEvent);
- bool setProperty(int index, SkScriptValue& ) SK_OVERRIDE;
+ bool setProperty(int index, SkScriptValue& ) override;
protected:
SkKey code;
SkBool disable;
class SkInclude : public SkDisplayable {
DECLARE_MEMBER_INFO(Include);
- void onEndElement(SkAnimateMaker & ) SK_OVERRIDE;
- bool enable(SkAnimateMaker & ) SK_OVERRIDE;
- bool hasEnable() const SK_OVERRIDE;
+ void onEndElement(SkAnimateMaker & ) override;
+ bool enable(SkAnimateMaker & ) override;
+ bool hasEnable() const override;
protected:
SkString src;
};
class SkInput : public SkDisplayable {
DECLARE_MEMBER_INFO(Input);
SkInput();
- SkDisplayable* contains(const SkString& ) SK_OVERRIDE;
- bool getProperty(int index, SkScriptValue* value) const SK_OVERRIDE;
- bool enable(SkAnimateMaker & ) SK_OVERRIDE;
- bool hasEnable() const SK_OVERRIDE;
+ SkDisplayable* contains(const SkString& ) override;
+ bool getProperty(int index, SkScriptValue* value) const override;
+ bool enable(SkAnimateMaker & ) override;
+ bool hasEnable() const override;
protected:
SkString name;
int32_t fInt;
DECLARE_DISPLAY_MEMBER_INFO(Math);
virtual void executeFunction(SkDisplayable* , int index,
SkTDArray<SkScriptValue>& parameters, SkDisplayTypes type,
- SkScriptValue* ) SK_OVERRIDE;
- const SkFunctionParamType* getFunctionsParameters() SK_OVERRIDE;
- bool getProperty(int index, SkScriptValue* value) const SK_OVERRIDE;
+ SkScriptValue* ) override;
+ const SkFunctionParamType* getFunctionsParameters() override;
+ bool getProperty(int index, SkScriptValue* value) const override;
private:
mutable SkRandom fRandom;
static const SkScalar gConstants[];
SkDisplayMovie();
virtual ~SkDisplayMovie();
void buildMovie();
- SkDisplayable* deepCopy(SkAnimateMaker* ) SK_OVERRIDE;
- void dirty() SK_OVERRIDE;
+ SkDisplayable* deepCopy(SkAnimateMaker* ) override;
+ void dirty() override;
bool doEvent(const SkEvent& evt) {
return fLoaded && fMovie.doEvent(evt);
}
- bool doEvent(SkDisplayEvent::Kind , SkEventState* state ) SK_OVERRIDE;
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ bool doEvent(SkDisplayEvent::Kind , SkEventState* state ) override;
+ bool draw(SkAnimateMaker& ) override;
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
- void dumpEvents() SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
+ void dumpEvents() override;
#endif
- bool enable(SkAnimateMaker& ) SK_OVERRIDE;
+ bool enable(SkAnimateMaker& ) override;
const SkAnimator* getAnimator() const { return &fMovie; }
- bool hasEnable() const SK_OVERRIDE;
- void onEndElement(SkAnimateMaker& ) SK_OVERRIDE;
+ bool hasEnable() const override;
+ void onEndElement(SkAnimateMaker& ) override;
protected:
SkString src;
SkAnimator fMovie;
class SkDisplayNumber : public SkDisplayable {
DECLARE_DISPLAY_MEMBER_INFO(Number);
- bool getProperty(int index, SkScriptValue* value) const SK_OVERRIDE;
+ bool getProperty(int index, SkScriptValue* value) const override;
private:
};
};
SkPost();
virtual ~SkPost();
- bool addChild(SkAnimateMaker& , SkDisplayable* child) SK_OVERRIDE;
- bool childrenNeedDisposing() const SK_OVERRIDE;
- void dirty() SK_OVERRIDE;
+ bool addChild(SkAnimateMaker& , SkDisplayable* child) override;
+ bool childrenNeedDisposing() const override;
+ void dirty() override;
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
- bool enable(SkAnimateMaker& ) SK_OVERRIDE;
- bool hasEnable() const SK_OVERRIDE;
- void onEndElement(SkAnimateMaker& ) SK_OVERRIDE;
- void setChildHasID() SK_OVERRIDE;
- bool setProperty(int index, SkScriptValue& ) SK_OVERRIDE;
+ bool enable(SkAnimateMaker& ) override;
+ bool hasEnable() const override;
+ void onEndElement(SkAnimateMaker& ) override;
+ void setChildHasID() override;
+ bool setProperty(int index, SkScriptValue& ) override;
protected:
SkMSec delay;
SkString sink;
DECLARE_DISPLAY_MEMBER_INFO(Random);
SkDisplayRandom();
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
- bool getProperty(int index, SkScriptValue* value) const SK_OVERRIDE;
- bool setProperty(int index, SkScriptValue& ) SK_OVERRIDE;
+ bool getProperty(int index, SkScriptValue* value) const override;
+ bool setProperty(int index, SkScriptValue& ) override;
private:
SkScalar blend;
SkScalar min;
DECLARE_DISPLAY_MEMBER_INFO(Boolean);
SkDisplayBoolean();
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
SkBool value;
friend class SkAnimatorScript;
DECLARE_DISPLAY_MEMBER_INFO(Int);
SkDisplayInt();
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
private:
int32_t value;
DECLARE_DISPLAY_MEMBER_INFO(Float);
SkDisplayFloat();
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
private:
SkScalar value;
SkDisplayString(SkString& );
virtual void executeFunction(SkDisplayable* , int index,
SkTDArray<SkScriptValue>& parameters, SkDisplayTypes type,
- SkScriptValue* ) SK_OVERRIDE;
- const SkFunctionParamType* getFunctionsParameters() SK_OVERRIDE;
- bool getProperty(int index, SkScriptValue* ) const SK_OVERRIDE;
+ SkScriptValue* ) override;
+ const SkFunctionParamType* getFunctionsParameters() override;
+ bool getProperty(int index, SkScriptValue* ) const override;
SkString value;
private:
static const SkFunctionParamType fFunctionParameters[];
SkDisplayArray(SkTypedArray& );
SkDisplayArray(SkOpArray& ); // compiled script experiment
virtual ~SkDisplayArray();
- bool getProperty(int index, SkScriptValue* ) const SK_OVERRIDE;
+ bool getProperty(int index, SkScriptValue* ) const override;
private:
SkTypedArray values;
friend class SkAnimator;
DECLARE_MEMBER_INFO(3D_Camera);
Sk3D_Camera();
virtual ~Sk3D_Camera();
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ bool draw(SkAnimateMaker& ) override;
private:
SkScalar hackWidth;
SkScalar hackHeight;
private:
virtual void executeFunction(SkDisplayable* , int index,
SkTDArray<SkScriptValue>& parameters, SkDisplayTypes type,
- SkScriptValue* ) SK_OVERRIDE;
- const SkFunctionParamType* getFunctionsParameters() SK_OVERRIDE;
+ SkScriptValue* ) override;
+ const SkFunctionParamType* getFunctionsParameters() override;
SkPatch3D fPatch;
static const SkFunctionParamType fFunctionParameters[];
friend class Sk3D_Camera;
DECLARE_MEMBER_INFO(BaseBitmap);
SkBaseBitmap();
virtual ~SkBaseBitmap();
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ bool draw(SkAnimateMaker& ) override;
protected:
SkBitmap fBitmap;
SkScalar x;
SkDrawBitmap();
virtual ~SkDrawBitmap();
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
- void onEndElement(SkAnimateMaker& ) SK_OVERRIDE;
- bool setProperty(int index, SkScriptValue& value) SK_OVERRIDE;
+ void onEndElement(SkAnimateMaker& ) override;
+ bool setProperty(int index, SkScriptValue& value) override;
protected:
int /*SkBitmap::Config*/ format;
int32_t height;
DECLARE_MEMBER_INFO(ImageBaseBitmap);
SkImageBaseBitmap();
virtual ~SkImageBaseBitmap();
- SkDisplayable* deepCopy(SkAnimateMaker* ) SK_OVERRIDE;
- void dirty() SK_OVERRIDE;
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
- bool getProperty(int index, SkScriptValue* value) const SK_OVERRIDE;
- void onEndElement(SkAnimateMaker& maker) SK_OVERRIDE;
+ SkDisplayable* deepCopy(SkAnimateMaker* ) override;
+ void dirty() override;
+ bool draw(SkAnimateMaker& ) override;
+ bool getProperty(int index, SkScriptValue* value) const override;
+ void onEndElement(SkAnimateMaker& maker) override;
private:
void resolve() const { (const_cast<SkImageBaseBitmap*>(this))->resolve(); }
void resolve();
class SkDrawBlur : public SkDrawMaskFilter {
DECLARE_DRAW_MEMBER_INFO(Blur);
SkDrawBlur();
- SkMaskFilter* getMaskFilter() SK_OVERRIDE;
+ SkMaskFilter* getMaskFilter() override;
protected:
SkScalar fSigma;
int /*SkBlurStyle*/ fBlurStyle;
class SkDrawClip : public SkADrawable {
DECLARE_DRAW_MEMBER_INFO(Clip);
SkDrawClip();
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ bool draw(SkAnimateMaker& ) override;
private:
SkDrawRect* rect;
SkDrawPath* path;
class SkDrawColor : public SkPaintPart {
DECLARE_DRAW_MEMBER_INFO(Color);
SkDrawColor();
- bool add() SK_OVERRIDE;
- void dirty() SK_OVERRIDE;
+ bool add() override;
+ void dirty() override;
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
SkColor getColor();
- SkDisplayable* deepCopy(SkAnimateMaker* ) SK_OVERRIDE;
- SkDisplayable* getParent() const SK_OVERRIDE;
- bool getProperty(int index, SkScriptValue* value) const SK_OVERRIDE;
- void onEndElement(SkAnimateMaker& ) SK_OVERRIDE;
- bool setParent(SkDisplayable* parent) SK_OVERRIDE;
- bool setProperty(int index, SkScriptValue&) SK_OVERRIDE;
+ SkDisplayable* deepCopy(SkAnimateMaker* ) override;
+ SkDisplayable* getParent() const override;
+ bool getProperty(int index, SkScriptValue* value) const override;
+ void onEndElement(SkAnimateMaker& ) override;
+ bool setParent(SkDisplayable* parent) override;
+ bool setProperty(int index, SkScriptValue&) override;
protected:
SkColor color;
SkScalar fHue;
DECLARE_MEMBER_INFO(Dash);
SkDash();
virtual ~SkDash();
- SkPathEffect* getPathEffect() SK_OVERRIDE;
+ SkPathEffect* getPathEffect() override;
private:
SkTDScalarArray intervals;
SkScalar phase;
class SkDiscrete : public SkDrawPathEffect {
DECLARE_MEMBER_INFO(Discrete);
SkDiscrete();
- SkPathEffect* getPathEffect() SK_OVERRIDE;
+ SkPathEffect* getPathEffect() override;
private:
SkScalar deviation;
SkScalar segLength;
class SkDrawEmboss : public SkDrawMaskFilter {
DECLARE_DRAW_MEMBER_INFO(Emboss);
SkDrawEmboss();
- SkMaskFilter* getMaskFilter() SK_OVERRIDE;
+ SkMaskFilter* getMaskFilter() override;
protected:
SkTDScalarArray fDirection;
SkScalar fSigma;
DECLARE_PRIVATE_MEMBER_INFO(DrawShapePathEffect);
SkDrawShapePathEffect();
virtual ~SkDrawShapePathEffect();
- bool addChild(SkAnimateMaker& , SkDisplayable* ) SK_OVERRIDE;
- SkPathEffect* getPathEffect() SK_OVERRIDE;
+ bool addChild(SkAnimateMaker& , SkDisplayable* ) override;
+ SkPathEffect* getPathEffect() override;
protected:
SkADrawable* addPath;
SkADrawable* addMatrix;
DECLARE_EXTRAS_MEMBER_INFO(SkDrawShape1DPathEffect);
SkDrawShape1DPathEffect(SkDisplayTypes );
virtual ~SkDrawShape1DPathEffect();
- void onEndElement(SkAnimateMaker& ) SK_OVERRIDE;
+ void onEndElement(SkAnimateMaker& ) override;
private:
SkString phase;
SkString spacing;
DECLARE_EXTRAS_MEMBER_INFO(SkDrawShape2DPathEffect);
SkDrawShape2DPathEffect(SkDisplayTypes );
virtual ~SkDrawShape2DPathEffect();
- void onEndElement(SkAnimateMaker& ) SK_OVERRIDE;
+ void onEndElement(SkAnimateMaker& ) override;
private:
SkDrawMatrix* matrix;
friend class SkShape2DPathEffect;
DECLARE_EXTRAS_MEMBER_INFO(SkDrawComposePathEffect);
SkDrawComposePathEffect(SkDisplayTypes );
virtual ~SkDrawComposePathEffect();
- bool addChild(SkAnimateMaker& , SkDisplayable* ) SK_OVERRIDE;
- SkPathEffect* getPathEffect() SK_OVERRIDE;
- bool isPaint() const SK_OVERRIDE;
+ bool addChild(SkAnimateMaker& , SkDisplayable* ) override;
+ SkPathEffect* getPathEffect() override;
+ bool isPaint() const override;
private:
SkDrawPathEffect* effect1;
SkDrawPathEffect* effect2;
DECLARE_EXTRAS_MEMBER_INFO(SkDrawCornerPathEffect);
SkDrawCornerPathEffect(SkDisplayTypes );
virtual ~SkDrawCornerPathEffect();
- SkPathEffect* getPathEffect() SK_OVERRIDE;
+ SkPathEffect* getPathEffect() override;
private:
SkScalar radius;
};
}
// For serialization. This will never be called.
- Factory getFactory() const SK_OVERRIDE { sk_throw(); return NULL; }
+ Factory getFactory() const override { sk_throw(); return NULL; }
protected:
- SkScalar begin(SkScalar contourLength) const SK_OVERRIDE {
+ SkScalar begin(SkScalar contourLength) const override {
SkScriptValue value;
SkAnimatorScript engine(*fMaker, NULL, SkType_Float);
engine.propertyCallBack(GetContourLength, &contourLength);
return value.fOperand.fScalar;
}
- SkScalar next(SkPath* dst, SkScalar distance, SkPathMeasure&) const SK_OVERRIDE {
+ SkScalar next(SkPath* dst, SkScalar distance, SkPathMeasure&) const override {
fMaker->setExtraPropertyCallBack(fDraw->fType, GetDistance, &distance);
SkDrawPath* drawPath = NULL;
if (fDraw->addPath->isPath()) {
}
#ifndef SK_IGNORE_TO_STRING
- void toString(SkString* str) const SK_OVERRIDE {
+ void toString(SkString* str) const override {
str->appendf("SkShape1DPathEffect: (");
// TODO: fill in
str->appendf(")");
}
// For serialization. This will never be called.
- Factory getFactory() const SK_OVERRIDE { sk_throw(); return NULL; }
+ Factory getFactory() const override { sk_throw(); return NULL; }
protected:
- void begin(const SkIRect& uvBounds, SkPath*) const SK_OVERRIDE {
+ void begin(const SkIRect& uvBounds, SkPath*) const override {
const_cast<SkShape2DPathEffect*>(this)->setUVBounds(uvBounds);
}
- void next(const SkPoint& loc, int u, int v, SkPath* dst) const SK_OVERRIDE {
+ void next(const SkPoint& loc, int u, int v, SkPath* dst) const override {
const_cast<SkShape2DPathEffect*>(this)->addPath(loc, u, v, dst);
}
class SkFull : public SkBoundable {
DECLARE_EMPTY_MEMBER_INFO(Full);
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ bool draw(SkAnimateMaker& ) override;
private:
typedef SkBoundable INHERITED;
};
DECLARE_PRIVATE_MEMBER_INFO(DrawGradient);
SkDrawGradient();
virtual ~SkDrawGradient();
- bool addChild(SkAnimateMaker& , SkDisplayable* child) SK_OVERRIDE;
+ bool addChild(SkAnimateMaker& , SkDisplayable* child) override;
#ifdef SK_DUMP_ENABLED
virtual void dumpRest(SkAnimateMaker*);
#endif
- void onEndElement(SkAnimateMaker& ) SK_OVERRIDE;
+ void onEndElement(SkAnimateMaker& ) override;
protected:
SkTDScalarArray offsets;
SkString unitMapper;
class SkDrawLinearGradient : public SkDrawGradient {
DECLARE_MEMBER_INFO(DrawLinearGradient);
SkDrawLinearGradient();
- void onEndElement(SkAnimateMaker& ) SK_OVERRIDE;
+ void onEndElement(SkAnimateMaker& ) override;
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker*) SK_OVERRIDE;
+ void dump(SkAnimateMaker*) override;
#endif
- SkShader* getShader() SK_OVERRIDE;
+ SkShader* getShader() override;
protected:
SkTDScalarArray points;
private:
DECLARE_MEMBER_INFO(DrawRadialGradient);
SkDrawRadialGradient();
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker*) SK_OVERRIDE;
+ void dump(SkAnimateMaker*) override;
#endif
- SkShader* getShader() SK_OVERRIDE;
+ SkShader* getShader() override;
protected:
SkPoint center;
SkScalar radius;
DECLARE_MEMBER_INFO(Group);
SkGroup();
virtual ~SkGroup();
- bool addChild(SkAnimateMaker& , SkDisplayable* child) SK_OVERRIDE;
- bool contains(SkDisplayable* ) SK_OVERRIDE;
+ bool addChild(SkAnimateMaker& , SkDisplayable* child) override;
+ bool contains(SkDisplayable* ) override;
SkGroup* copy();
SkBool copySet(int index);
- SkDisplayable* deepCopy(SkAnimateMaker* ) SK_OVERRIDE;
- bool doEvent(SkDisplayEvent::Kind , SkEventState* state ) SK_OVERRIDE;
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ SkDisplayable* deepCopy(SkAnimateMaker* ) override;
+ bool doEvent(SkDisplayEvent::Kind , SkEventState* state ) override;
+ bool draw(SkAnimateMaker& ) override;
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
virtual void dumpDrawables(SkAnimateMaker* );
- void dumpEvents() SK_OVERRIDE;
+ void dumpEvents() override;
#endif
int findGroup(SkADrawable* drawable, SkTDDrawableArray** list,
SkGroup** parent, SkGroup** found, SkTDDrawableArray** grandList);
- bool enable(SkAnimateMaker& ) SK_OVERRIDE;
+ bool enable(SkAnimateMaker& ) override;
SkTDDrawableArray* getChildren() { return &fChildren; }
SkGroup* getOriginal() { return fOriginal; }
- bool hasEnable() const SK_OVERRIDE;
- void initialize() SK_OVERRIDE;
+ bool hasEnable() const override;
+ void initialize() override;
SkBool isACopy() { return fOriginal != NULL; }
void markCopyClear(int index);
void markCopySet(int index);
void markCopySize(int index);
bool markedForDelete(int index) const { return (fCopies[index >> 5] & 1 << (index & 0x1f)) == 0; }
void reset();
- bool resolveIDs(SkAnimateMaker& maker, SkDisplayable* original, SkApply* ) SK_OVERRIDE;
- void setSteps(int steps) SK_OVERRIDE;
+ bool resolveIDs(SkAnimateMaker& maker, SkDisplayable* original, SkApply* ) override;
+ void setSteps(int steps) override;
#ifdef SK_DEBUG
- void validate() SK_OVERRIDE;
+ void validate() override;
#endif
protected:
bool ifCondition(SkAnimateMaker& maker, SkADrawable* drawable,
class SkSave: public SkGroup {
DECLARE_MEMBER_INFO(Save);
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ bool draw(SkAnimateMaker& ) override;
private:
typedef SkGroup INHERITED;
};
class SkLine : public SkBoundable {
DECLARE_MEMBER_INFO(Line);
SkLine();
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ bool draw(SkAnimateMaker& ) override;
private:
SkScalar x1;
SkScalar x2;
DECLARE_DRAW_MEMBER_INFO(Matrix);
SkDrawMatrix();
virtual ~SkDrawMatrix();
- bool addChild(SkAnimateMaker& , SkDisplayable* child) SK_OVERRIDE;
- bool childrenNeedDisposing() const SK_OVERRIDE;
- void dirty() SK_OVERRIDE;
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ bool addChild(SkAnimateMaker& , SkDisplayable* child) override;
+ bool childrenNeedDisposing() const override;
+ void dirty() override;
+ bool draw(SkAnimateMaker& ) override;
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
SkMatrix& getMatrix();
- bool getProperty(int index, SkScriptValue* value) const SK_OVERRIDE;
- void initialize() SK_OVERRIDE;
- void onEndElement(SkAnimateMaker& ) SK_OVERRIDE;
- void setChildHasID() SK_OVERRIDE;
- bool setProperty(int index, SkScriptValue& ) SK_OVERRIDE;
+ bool getProperty(int index, SkScriptValue* value) const override;
+ void initialize() override;
+ void onEndElement(SkAnimateMaker& ) override;
+ void setChildHasID() override;
+ bool setProperty(int index, SkScriptValue& ) override;
void concat(SkMatrix& inMatrix) {
fConcat.preConcat(inMatrix);
}
- SkDisplayable* deepCopy(SkAnimateMaker* ) SK_OVERRIDE;
+ SkDisplayable* deepCopy(SkAnimateMaker* ) override;
void rotate(SkScalar degrees, SkPoint& center) {
class SkOval : public SkDrawRect {
DECLARE_MEMBER_INFO(Oval);
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ bool draw(SkAnimateMaker& ) override;
private:
typedef SkDrawRect INHERITED;
};
SkDrawPaint();
virtual ~SkDrawPaint();
virtual bool add(SkAnimateMaker* , SkDisplayable* child);
- SkDisplayable* deepCopy(SkAnimateMaker* ) SK_OVERRIDE;
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ SkDisplayable* deepCopy(SkAnimateMaker* ) override;
+ bool draw(SkAnimateMaker& ) override;
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
virtual void executeFunction(SkDisplayable* target, int index,
SkTDArray<SkScriptValue>& parameters, SkDisplayTypes type,
- SkScriptValue* ) SK_OVERRIDE;
- const SkFunctionParamType* getFunctionsParameters() SK_OVERRIDE;
- bool getProperty(int index, SkScriptValue* value) const SK_OVERRIDE;
- bool resolveIDs(SkAnimateMaker& maker, SkDisplayable* original, SkApply* apply) SK_OVERRIDE;
+ SkScriptValue* ) override;
+ const SkFunctionParamType* getFunctionsParameters() override;
+ bool getProperty(int index, SkScriptValue* value) const override;
+ bool resolveIDs(SkAnimateMaker& maker, SkDisplayable* original, SkApply* apply) override;
protected:
static const SkFunctionParamType fFunctionParameters[];
void setupPaint(SkPaint* paint) const;
DECLARE_DRAW_MEMBER_INFO(Path);
SkDrawPath();
virtual ~SkDrawPath();
- bool addChild(SkAnimateMaker& , SkDisplayable* child) SK_OVERRIDE;
+ bool addChild(SkAnimateMaker& , SkDisplayable* child) override;
bool childHasID() { return SkToBool(fChildHasID); }
- bool childrenNeedDisposing() const SK_OVERRIDE;
- void dirty() SK_OVERRIDE;
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
- SkDisplayable* getParent() const SK_OVERRIDE;
+ bool childrenNeedDisposing() const override;
+ void dirty() override;
+ bool draw(SkAnimateMaker& ) override;
+ SkDisplayable* getParent() const override;
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
SkPath& getPath();
- bool getProperty(int index, SkScriptValue* value) const SK_OVERRIDE;
- bool setProperty(int index, SkScriptValue& value) SK_OVERRIDE;
- void onEndElement(SkAnimateMaker& ) SK_OVERRIDE;
- void setChildHasID() SK_OVERRIDE;
- bool setParent(SkDisplayable* parent) SK_OVERRIDE;
- bool isPath() const SK_OVERRIDE { return true; }
+ bool getProperty(int index, SkScriptValue* value) const override;
+ bool setProperty(int index, SkScriptValue& value) override;
+ void onEndElement(SkAnimateMaker& ) override;
+ void setChildHasID() override;
+ bool setParent(SkDisplayable* parent) override;
+ bool isPath() const override { return true; }
public:
SkPath fPath;
protected:
class SkPolyline : public SkDrawPath {
DECLARE_MEMBER_INFO(Polyline);
- bool addChild(SkAnimateMaker& , SkDisplayable*) SK_OVERRIDE;
- void onEndElement(SkAnimateMaker& ) SK_OVERRIDE;
+ bool addChild(SkAnimateMaker& , SkDisplayable*) override;
+ void onEndElement(SkAnimateMaker& ) override;
protected:
SkTDScalarArray points;
private:
class SkPolygon : public SkPolyline {
DECLARE_MEMBER_INFO(Polygon);
- void onEndElement(SkAnimateMaker& ) SK_OVERRIDE;
+ void onEndElement(SkAnimateMaker& ) override;
private:
typedef SkPolyline INHERITED;
};
class SkDrawPoint : public SkDisplayable {
DECLARE_MEMBER_INFO(DrawPoint);
SkDrawPoint();
- void getBounds(SkRect* ) SK_OVERRIDE;
+ void getBounds(SkRect* ) override;
private:
SkPoint fPoint;
typedef SkDisplayable INHERITED;
class SkDrawRect : public SkBoundable {
DECLARE_DRAW_MEMBER_INFO(Rect);
SkDrawRect();
- void dirty() SK_OVERRIDE;
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ void dirty() override;
+ bool draw(SkAnimateMaker& ) override;
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
- SkDisplayable* getParent() const SK_OVERRIDE;
- bool getProperty(int index, SkScriptValue* value) const SK_OVERRIDE;
- bool setParent(SkDisplayable* parent) SK_OVERRIDE;
- bool setProperty(int index, SkScriptValue& ) SK_OVERRIDE;
+ SkDisplayable* getParent() const override;
+ bool getProperty(int index, SkScriptValue* value) const override;
+ bool setParent(SkDisplayable* parent) override;
+ bool setProperty(int index, SkScriptValue& ) override;
protected:
SkRect fRect;
SkDisplayable* fParent;
class SkRoundRect : public SkDrawRect {
DECLARE_MEMBER_INFO(RoundRect);
SkRoundRect();
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ bool draw(SkAnimateMaker& ) override;
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
protected:
SkScalar rx;
DECLARE_MEMBER_INFO(SaveLayer);
SkSaveLayer();
virtual ~SkSaveLayer();
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ bool draw(SkAnimateMaker& ) override;
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
- void onEndElement(SkAnimateMaker& ) SK_OVERRIDE;
+ void onEndElement(SkAnimateMaker& ) override;
protected:
SkDrawPaint* paint;
SkDrawRect* bounds;
class SkDrawBitmapShader : public SkDrawShader {
DECLARE_DRAW_MEMBER_INFO(BitmapShader);
SkDrawBitmapShader();
- bool add() SK_OVERRIDE;
- SkShader* getShader() SK_OVERRIDE;
+ bool add() override;
+ SkShader* getShader() override;
protected:
SkBool filterBitmap;
SkBaseBitmap* image;
DECLARE_MEMBER_INFO(Text);
SkText();
virtual ~SkText();
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ bool draw(SkAnimateMaker& ) override;
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
- bool getProperty(int index, SkScriptValue* value) const SK_OVERRIDE;
+ bool getProperty(int index, SkScriptValue* value) const override;
const char* getText() { return text.c_str(); }
size_t getSize() { return text.size(); }
protected:
SkDrawTextBox();
// overrides
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ bool draw(SkAnimateMaker& ) override;
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
- bool getProperty(int index, SkScriptValue* value) const SK_OVERRIDE;
- bool setProperty(int index, SkScriptValue& ) SK_OVERRIDE;
+ bool getProperty(int index, SkScriptValue* value) const override;
+ bool setProperty(int index, SkScriptValue& ) override;
private:
SkString fText;
DECLARE_MEMBER_INFO(DrawTo);
SkDrawTo();
// virtual ~SkDrawTo();
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ bool draw(SkAnimateMaker& ) override;
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
protected:
SkBool drawOnce;
class SkDrawTransparentShader : public SkDrawShader {
DECLARE_EMPTY_MEMBER_INFO(TransparentShader);
- SkShader* getShader() SK_OVERRIDE;
+ SkShader* getShader() override;
};
#endif // SkDrawTransparentShader_DEFINED
DECLARE_MEMBER_INFO(Dump);
#ifdef SK_DUMP_ENABLED
SkDump();
- bool enable(SkAnimateMaker & ) SK_OVERRIDE;
+ bool enable(SkAnimateMaker & ) override;
bool evaluate(SkAnimateMaker &);
- bool hasEnable() const SK_OVERRIDE;
+ bool hasEnable() const override;
static void GetEnumString(SkDisplayTypes , int index, SkString* result);
SkBool displayList;
SkBool eventList;
class SkHitClear : public SkDisplayable {
DECLARE_MEMBER_INFO(HitClear);
- bool enable(SkAnimateMaker& ) SK_OVERRIDE;
- bool hasEnable() const SK_OVERRIDE;
+ bool enable(SkAnimateMaker& ) override;
+ bool hasEnable() const override;
private:
SkTDDisplayableArray targets;
};
class SkHitTest : public SkADrawable {
DECLARE_MEMBER_INFO(HitTest);
SkHitTest();
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
- bool enable(SkAnimateMaker& ) SK_OVERRIDE;
- bool hasEnable() const SK_OVERRIDE;
- const SkMemberInfo* preferredChild(SkDisplayTypes type) SK_OVERRIDE;
+ bool draw(SkAnimateMaker& ) override;
+ bool enable(SkAnimateMaker& ) override;
+ bool hasEnable() const override;
+ const SkMemberInfo* preferredChild(SkDisplayTypes type) override;
private:
SkTDDisplayableArray bullets;
SkTDIntArray hits;
DECLARE_MEMBER_INFO(Rotate);
SkRotate();
protected:
- bool add() SK_OVERRIDE;
+ bool add() override;
SkScalar degrees;
SkPoint center;
};
DECLARE_MEMBER_INFO(Scale);
SkScale();
protected:
- bool add() SK_OVERRIDE;
+ bool add() override;
SkScalar x;
SkScalar y;
SkPoint center;
DECLARE_MEMBER_INFO(Skew);
SkSkew();
protected:
- bool add() SK_OVERRIDE;
+ bool add() override;
SkScalar x;
SkScalar y;
SkPoint center;
DECLARE_MEMBER_INFO(Translate);
SkTranslate();
protected:
- bool add() SK_OVERRIDE;
+ bool add() override;
SkScalar x;
SkScalar y;
};
SkFromPath();
virtual ~SkFromPath();
protected:
- bool add() SK_OVERRIDE;
+ bool add() override;
int32_t mode;
SkScalar offset;
SkDrawPath* path;
SkRectToRect();
virtual ~SkRectToRect();
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
- const SkMemberInfo* preferredChild(SkDisplayTypes type) SK_OVERRIDE;
+ const SkMemberInfo* preferredChild(SkDisplayTypes type) override;
protected:
- bool add() SK_OVERRIDE;
+ bool add() override;
SkDrawRect* source;
SkDrawRect* destination;
};
SkPolyToPoly();
virtual ~SkPolyToPoly();
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker* ) SK_OVERRIDE;
+ void dump(SkAnimateMaker* ) override;
#endif
- void onEndElement(SkAnimateMaker& ) SK_OVERRIDE;
- const SkMemberInfo* preferredChild(SkDisplayTypes type) SK_OVERRIDE;
+ void onEndElement(SkAnimateMaker& ) override;
+ const SkMemberInfo* preferredChild(SkDisplayTypes type) override;
protected:
- bool add() SK_OVERRIDE;
+ bool add() override;
SkPolygon* source;
SkPolygon* destination;
};
public: \
static const SkMemberInfo fInfo[]; \
static const int fInfoCount; \
- const SkMemberInfo* getMember(int index) SK_OVERRIDE; \
- const SkMemberInfo* getMember(const char name[]) SK_OVERRIDE; \
+ const SkMemberInfo* getMember(int index) override; \
+ const SkMemberInfo* getMember(const char name[]) override; \
typedef Sk##_type BASE_CLASS
#define DECLARE_MEMBER_INFO(_type) \
public: \
static const SkMemberInfo fInfo[]; \
static const int fInfoCount; \
- const SkMemberInfo* getMember(int index) SK_OVERRIDE; \
- const SkMemberInfo* getMember(const char name[]) SK_OVERRIDE; \
- SkDisplayTypes getType() const SK_OVERRIDE { return SkType_##_type; } \
+ const SkMemberInfo* getMember(int index) override; \
+ const SkMemberInfo* getMember(const char name[]) override; \
+ SkDisplayTypes getType() const override { return SkType_##_type; } \
typedef Sk##_type BASE_CLASS
#define DECLARE_DRAW_MEMBER_INFO(_type) \
public: \
static const SkMemberInfo fInfo[]; \
static const int fInfoCount; \
- const SkMemberInfo* getMember(int index) SK_OVERRIDE; \
- const SkMemberInfo* getMember(const char name[]) SK_OVERRIDE; \
- SkDisplayTypes getType() const SK_OVERRIDE { return SkType_##_type; } \
+ const SkMemberInfo* getMember(int index) override; \
+ const SkMemberInfo* getMember(const char name[]) override; \
+ SkDisplayTypes getType() const override { return SkType_##_type; } \
typedef SkDraw##_type BASE_CLASS
#define DECLARE_DISPLAY_MEMBER_INFO(_type) \
public: \
static const SkMemberInfo fInfo[]; \
static const int fInfoCount; \
- const SkMemberInfo* getMember(int index) SK_OVERRIDE; \
- const SkMemberInfo* getMember(const char name[]) SK_OVERRIDE; \
- SkDisplayTypes getType() const SK_OVERRIDE { return SkType_##_type; } \
+ const SkMemberInfo* getMember(int index) override; \
+ const SkMemberInfo* getMember(const char name[]) override; \
+ SkDisplayTypes getType() const override { return SkType_##_type; } \
typedef SkDisplay##_type BASE_CLASS
#define DECLARE_EMPTY_MEMBER_INFO(_type) \
public: \
- SkDisplayTypes getType() const SK_OVERRIDE { return SkType_##_type; }
+ SkDisplayTypes getType() const override { return SkType_##_type; }
#define DECLARE_EXTRAS_MEMBER_INFO(_type) \
public: \
static const SkMemberInfo fInfo[]; \
static const int fInfoCount; \
- const SkMemberInfo* getMember(int index) SK_OVERRIDE; \
- const SkMemberInfo* getMember(const char name[]) SK_OVERRIDE; \
+ const SkMemberInfo* getMember(int index) override; \
+ const SkMemberInfo* getMember(const char name[]) override; \
SkDisplayTypes fType; \
- SkDisplayTypes getType() const SK_OVERRIDE { return fType; } \
+ SkDisplayTypes getType() const override { return fType; } \
typedef _type BASE_CLASS
#define DECLARE_NO_VIRTUALS_MEMBER_INFO(_type) \
DECLARE_EMPTY_MEMBER_INFO(MaskFilter);
virtual SkMaskFilter* getMaskFilter();
protected:
- bool add() SK_OVERRIDE;
+ bool add() override;
};
class SkDrawPathEffect : public SkPaintPart {
DECLARE_EMPTY_MEMBER_INFO(PathEffect);
virtual SkPathEffect* getPathEffect();
protected:
- bool add() SK_OVERRIDE;
+ bool add() override;
};
class SkDrawShader : public SkPaintPart {
SkDrawShader();
virtual SkShader* getShader();
protected:
- bool add() SK_OVERRIDE;
+ bool add() override;
SkMatrix* getMatrix(); // returns NULL if matrix is NULL
SkDrawMatrix* matrix;
int /*SkShader::TileMode*/ tileMode;
DECLARE_DRAW_MEMBER_INFO(Typeface);
SkDrawTypeface();
#ifdef SK_DUMP_ENABLED
- void dump(SkAnimateMaker *) SK_OVERRIDE;
+ void dump(SkAnimateMaker *) override;
#endif
SkTypeface* getTypeface() {
return SkTypeface::CreateFromName(fontName.c_str(), style); }
protected:
- bool add() SK_OVERRIDE;
+ bool add() override;
SkString fontName;
SkTypeface::Style style;
};
class SkMoveTo : public SkPathPart {
DECLARE_MEMBER_INFO(MoveTo);
SkMoveTo();
- bool add() SK_OVERRIDE;
+ bool add() override;
protected:
SkScalar x;
SkScalar y;
class SkRMoveTo : public SkMoveTo {
DECLARE_MEMBER_INFO(RMoveTo);
- bool add() SK_OVERRIDE;
+ bool add() override;
private:
typedef SkMoveTo INHERITED;
};
class SkLineTo : public SkPathPart {
DECLARE_MEMBER_INFO(LineTo);
SkLineTo();
- bool add() SK_OVERRIDE;
+ bool add() override;
protected:
SkScalar x;
SkScalar y;
class SkRLineTo : public SkLineTo {
DECLARE_MEMBER_INFO(RLineTo);
- bool add() SK_OVERRIDE;
+ bool add() override;
private:
typedef SkLineTo INHERITED;
};
class SkQuadTo : public SkPathPart {
DECLARE_MEMBER_INFO(QuadTo);
SkQuadTo();
- bool add() SK_OVERRIDE;
+ bool add() override;
protected:
SkScalar x1;
SkScalar y1;
class SkRQuadTo : public SkQuadTo {
DECLARE_MEMBER_INFO(RQuadTo);
- bool add() SK_OVERRIDE;
+ bool add() override;
private:
typedef SkQuadTo INHERITED;
};
class SkCubicTo : public SkPathPart {
DECLARE_MEMBER_INFO(CubicTo);
SkCubicTo();
- bool add() SK_OVERRIDE;
+ bool add() override;
protected:
SkScalar x1;
SkScalar y1;
class SkRCubicTo : public SkCubicTo {
DECLARE_MEMBER_INFO(RCubicTo);
- bool add() SK_OVERRIDE;
+ bool add() override;
private:
typedef SkCubicTo INHERITED;
};
class SkClose : public SkPathPart {
DECLARE_EMPTY_MEMBER_INFO(Close);
- bool add() SK_OVERRIDE;
+ bool add() override;
};
class SkAddGeom : public SkPathPart {
class SkAddRect : public SkAddGeom {
DECLARE_MEMBER_INFO(AddRect);
SkAddRect();
- bool add() SK_OVERRIDE;
+ bool add() override;
protected:
SkRect fRect;
private:
class SkAddOval : public SkAddRect {
DECLARE_MEMBER_INFO(AddOval);
- bool add() SK_OVERRIDE;
+ bool add() override;
private:
typedef SkAddRect INHERITED;
};
class SkAddCircle : public SkAddGeom {
DECLARE_MEMBER_INFO(AddCircle);
SkAddCircle();
- bool add() SK_OVERRIDE;
+ bool add() override;
private:
SkScalar radius;
SkScalar x;
class SkAddRoundRect : public SkAddRect {
DECLARE_MEMBER_INFO(AddRoundRect);
SkAddRoundRect();
- bool add() SK_OVERRIDE;
+ bool add() override;
private:
SkScalar rx;
SkScalar ry;
class SkAddPath : public SkPathPart {
DECLARE_MEMBER_INFO(AddPath);
SkAddPath();
- bool add() SK_OVERRIDE;
+ bool add() override;
private:
typedef SkPathPart INHERITED;
SkDrawMatrix* matrix;
DECLARE_MEMBER_INFO(DataInput);
SkDataInput();
bool add();
- void dirty() SK_OVERRIDE;
- SkDisplayable* getParent() const SK_OVERRIDE;
- void onEndElement(SkAnimateMaker& ) SK_OVERRIDE;
- bool setParent(SkDisplayable* ) SK_OVERRIDE;
+ void dirty() override;
+ SkDisplayable* getParent() const override;
+ void onEndElement(SkAnimateMaker& ) override;
+ bool setParent(SkDisplayable* ) override;
protected:
SkPost* fParent;
typedef SkInput INHERITED;
class SkSnapshot: public SkADrawable {
DECLARE_MEMBER_INFO(Snapshot);
SkSnapshot();
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ bool draw(SkAnimateMaker& ) override;
private:
SkString filename;
SkScalar quality;
class SkTextOnPath : public SkBoundable {
DECLARE_MEMBER_INFO(TextOnPath);
SkTextOnPath();
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
+ bool draw(SkAnimateMaker& ) override;
private:
SkScalar offset;
SkDrawPath* path;
class SkTextToPath : public SkADrawable {
DECLARE_MEMBER_INFO(TextToPath);
SkTextToPath();
- bool draw(SkAnimateMaker& ) SK_OVERRIDE;
- void onEndElement(SkAnimateMaker& ) SK_OVERRIDE;
+ bool draw(SkAnimateMaker& ) override;
+ void onEndElement(SkAnimateMaker& ) override;
private:
SkDrawPaint* paint;
SkDrawPath* path;
SkDEBUGCODE(static void UnitTest(class SkCanvas* canvas);)
protected:
- void onAddAttributeLen(const char name[], const char value[], size_t length) SK_OVERRIDE;
- void onEndElement() SK_OVERRIDE;
- void onStartElementLen(const char elem[], size_t length) SK_OVERRIDE;
- void onAddText(const char text[], size_t length) SK_OVERRIDE;
+ void onAddAttributeLen(const char name[], const char value[], size_t length) override;
+ void onEndElement() override;
+ void onStartElementLen(const char elem[], size_t length) override;
+ void onAddText(const char text[], size_t length) override;
private:
SkAnimator* fAnimator;
*/
virtual Result onGetPixels(const SkImageInfo& dstInfo, void* dst,
size_t dstRowBytes, const Options&, SkPMColor*,
- int*) SK_OVERRIDE;
+ int*) override;
- SkEncodedFormat onGetEncodedFormat() const SK_OVERRIDE { return kBMP_SkEncodedFormat; }
+ SkEncodedFormat onGetEncodedFormat() const override { return kBMP_SkEncodedFormat; }
private:
/*
* Chooses the best dimensions given the desired scale
*/
- SkISize onGetScaledDimensions(float desiredScale) const SK_OVERRIDE;
+ SkISize onGetScaledDimensions(float desiredScale) const override;
/*
* Initiates the Ico decode
*/
Result onGetPixels(const SkImageInfo& dstInfo, void* dst,
size_t dstRowBytes, const Options&, SkPMColor*, int*)
- SK_OVERRIDE;
+ override;
- SkEncodedFormat onGetEncodedFormat() const SK_OVERRIDE {
+ SkEncodedFormat onGetEncodedFormat() const override {
return kICO_SkEncodedFormat;
}
fSrcRow = static_cast<uint8_t*>(fStorage.get());
}
- SkImageGenerator::Result onGetScanlines(void* dst, int count, size_t rowBytes) SK_OVERRIDE {
+ SkImageGenerator::Result onGetScanlines(void* dst, int count, size_t rowBytes) override {
if (setjmp(png_jmpbuf(fCodec->fPng_ptr))) {
SkDebugf("setjmp long jump!\n");
return SkImageGenerator::kInvalidInput;
return SkImageGenerator::kSuccess;
}
- SkImageGenerator::Result onSkipScanlines(int count) SK_OVERRIDE {
+ SkImageGenerator::Result onSkipScanlines(int count) override {
// FIXME: Could we use the return value of setjmp to specify the type of
// error?
if (setjmp(png_jmpbuf(fCodec->fPng_ptr))) {
return SkImageGenerator::kSuccess;
}
- void onFinish() SK_OVERRIDE {
+ void onFinish() override {
fCodec->finish();
}
- bool onReallyHasAlpha() const SK_OVERRIDE { return fHasAlpha; }
+ bool onReallyHasAlpha() const override { return fHasAlpha; }
private:
SkPngCodec* fCodec; // Unowned.
static bool IsPng(SkStream*);
protected:
Result onGetPixels(const SkImageInfo&, void*, size_t, const Options&, SkPMColor*, int*)
- SK_OVERRIDE;
- SkEncodedFormat onGetEncodedFormat() const SK_OVERRIDE { return kPNG_SkEncodedFormat; }
- SkScanlineDecoder* onGetScanlineDecoder(const SkImageInfo& dstInfo) SK_OVERRIDE;
- bool onReallyHasAlpha() const SK_OVERRIDE { return fReallyHasAlpha; }
+ override;
+ SkEncodedFormat onGetEncodedFormat() const override { return kPNG_SkEncodedFormat; }
+ SkScanlineDecoder* onGetScanlineDecoder(const SkImageInfo& dstInfo) override;
+ bool onReallyHasAlpha() const override { return fReallyHasAlpha; }
private:
png_structp fPng_ptr;
png_infop fInfo_ptr;
Instead we'll rely on the runtime asserts to guarantee Y monotonicity;
any failure cases that misses may have minor artifacts.
*/
- void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE {
+ void blitV(int x, int y, int height, SkAlpha alpha) override {
this->recordMinY(y);
fBuilder->addColumn(x, y, alpha, height);
fLastY = y + height - 1;
}
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE {
+ void blitRect(int x, int y, int width, int height) override {
this->recordMinY(y);
this->checkForYGap(y);
fBuilder->addRectRun(x, y, width, height);
}
virtual void blitAntiRect(int x, int y, int width, int height,
- SkAlpha leftAlpha, SkAlpha rightAlpha) SK_OVERRIDE {
+ SkAlpha leftAlpha, SkAlpha rightAlpha) override {
this->recordMinY(y);
this->checkForYGap(y);
fBuilder->addAntiRectRun(x, y, width, height, leftAlpha, rightAlpha);
fLastY = y + height - 1;
}
- void blitMask(const SkMask&, const SkIRect& clip) SK_OVERRIDE
+ void blitMask(const SkMask&, const SkIRect& clip) override
{ unexpected(); }
- const SkBitmap* justAnOpaqueColor(uint32_t*) SK_OVERRIDE {
+ const SkBitmap* justAnOpaqueColor(uint32_t*) override {
return NULL;
}
- void blitH(int x, int y, int width) SK_OVERRIDE {
+ void blitH(int x, int y, int width) override {
this->recordMinY(y);
this->checkForYGap(y);
fBuilder->addRun(x, y, 0xFF, width);
}
virtual void blitAntiH(int x, int y, const SkAlpha alpha[],
- const int16_t runs[]) SK_OVERRIDE {
+ const int16_t runs[]) override {
this->recordMinY(y);
this->checkForYGap(y);
for (;;) {
fAAClipBounds = aaclip->getBounds();
}
- void blitH(int x, int y, int width) SK_OVERRIDE;
+ void blitH(int x, int y, int width) override;
virtual void blitAntiH(int x, int y, const SkAlpha[],
- const int16_t runs[]) SK_OVERRIDE;
- void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE;
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE;
- void blitMask(const SkMask&, const SkIRect& clip) SK_OVERRIDE;
- const SkBitmap* justAnOpaqueColor(uint32_t* value) SK_OVERRIDE;
+ const int16_t runs[]) override;
+ void blitV(int x, int y, int height, SkAlpha alpha) override;
+ void blitRect(int x, int y, int width, int height) override;
+ void blitMask(const SkMask&, const SkIRect& clip) override;
+ const SkBitmap* justAnOpaqueColor(uint32_t* value) override;
private:
SkBlitter* fBlitter;
, fBitmap(result)
{}
- const Key& getKey() const SK_OVERRIDE { return fKey; }
- size_t bytesUsed() const SK_OVERRIDE { return sizeof(fKey) + fBitmap.getSize(); }
+ const Key& getKey() const override { return fKey; }
+ size_t bytesUsed() const override { return sizeof(fKey) + fBitmap.getSize(); }
static bool Finder(const SkResourceCache::Rec& baseRec, void* contextBitmap) {
const BitmapRec& rec = static_cast<const BitmapRec&>(baseRec);
fMipMap->detachFromCacheAndUnref();
}
- const Key& getKey() const SK_OVERRIDE { return fKey; }
- size_t bytesUsed() const SK_OVERRIDE { return sizeof(fKey) + fMipMap->size(); }
+ const Key& getKey() const override { return fKey; }
+ size_t bytesUsed() const override { return sizeof(fKey) + fMipMap->size(); }
static bool Finder(const SkResourceCache::Rec& baseRec, void* contextMip) {
const MipMapRec& rec = static_cast<const MipMapRec&>(baseRec);
: SkBitmapFilter(width), B(b), C(c) {
}
- float evaluate(float x) const SK_OVERRIDE {
+ float evaluate(float x) const override {
x = fabsf(x);
if (x > 2.f) {
return 0;
: SkBitmapFilter(width), alpha(a), expWidth(expf(-alpha * width * width)) {
}
- float evaluate(float x) const SK_OVERRIDE {
+ float evaluate(float x) const override {
return SkTMax(0.f, float(expf(-alpha*x*x) - expWidth));
}
protected:
: SkBitmapFilter(width) {
}
- float evaluate(float x) const SK_OVERRIDE {
+ float evaluate(float x) const override {
return SkTMax(0.f, fWidth - fabsf(x));
}
protected:
: SkBitmapFilter(width) {
}
- float evaluate(float x) const SK_OVERRIDE {
+ float evaluate(float x) const override {
return (x >= -fWidth && x < fWidth) ? 1.0f : 0.0f;
}
protected:
SkHammingFilter(float width=1.f)
: SkBitmapFilter(width) {
}
- float evaluate(float x) const SK_OVERRIDE {
+ float evaluate(float x) const override {
if (x <= -fWidth || x >= fWidth) {
return 0.0f; // Outside of the window.
}
: SkBitmapFilter(width) {
}
- float evaluate(float x) const SK_OVERRIDE {
+ float evaluate(float x) const override {
if (x <= -fWidth || x >= fWidth) {
return 0.0f; // Outside of the window.
}
*
* @return The bitmap located at that slot or NULL if external storage is being used.
*/
- SkBitmap* getBitmap(int32_t slot) const SK_OVERRIDE {
+ SkBitmap* getBitmap(int32_t slot) const override {
SkASSERT(fExternalStorage == NULL);
SkBitmapHeapEntry* entry = getEntry(slot);
if (entry) {
*
* @return The bitmap located at that slot or NULL if external storage is being used.
*/
- void releaseRef(int32_t slot) SK_OVERRIDE {
+ void releaseRef(int32_t slot) override {
SkASSERT(fExternalStorage == NULL);
if (fOwnerCount != IGNORE_OWNERS) {
SkBitmapHeapEntry* entry = getEntry(slot);
const SkMatrix* localMatrix = NULL);
// overrides from SkShader
- bool isOpaque() const SK_OVERRIDE;
- BitmapType asABitmap(SkBitmap*, SkMatrix*, TileMode*) const SK_OVERRIDE;
+ bool isOpaque() const override;
+ BitmapType asABitmap(SkBitmap*, SkMatrix*, TileMode*) const override;
- size_t contextSize() const SK_OVERRIDE;
+ size_t contextSize() const override;
static bool CanDo(const SkBitmap&, TileMode tx, TileMode ty);
bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix& viewM, const SkMatrix*,
- GrColor*, GrFragmentProcessor**) const SK_OVERRIDE;
+ GrColor*, GrFragmentProcessor**) const override;
class BitmapProcShaderContext : public SkShader::Context {
public:
BitmapProcShaderContext(const SkBitmapProcShader&, const ContextRec&, SkBitmapProcState*);
virtual ~BitmapProcShaderContext();
- void shadeSpan(int x, int y, SkPMColor dstC[], int count) SK_OVERRIDE;
- ShadeProc asAShadeProc(void** ctx) SK_OVERRIDE;
- void shadeSpan16(int x, int y, uint16_t dstC[], int count) SK_OVERRIDE;
+ void shadeSpan(int x, int y, SkPMColor dstC[], int count) override;
+ ShadeProc asAShadeProc(void** ctx) override;
+ void shadeSpan16(int x, int y, uint16_t dstC[], int count) override;
- uint32_t getFlags() const SK_OVERRIDE { return fFlags; }
+ uint32_t getFlags() const override { return fFlags; }
private:
SkBitmapProcState* fState;
};
protected:
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
- Context* onCreateContext(const ContextRec&, void* storage) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
+ Context* onCreateContext(const ContextRec&, void* storage) const override;
SkBitmap fRawBitmap; // experimental for RLE encoding
uint8_t fTileModeX, fTileModeY;
SkSafeUnref(fProxy);
}
- size_t contextSize() const SK_OVERRIDE {
+ size_t contextSize() const override {
size_t size = sizeof(Sk3DShaderContext);
if (fProxy) {
size += fProxy->contextSize();
return size;
}
- Context* onCreateContext(const ContextRec& rec, void* storage) const SK_OVERRIDE {
+ Context* onCreateContext(const ContextRec& rec, void* storage) const override {
SkShader::Context* proxyContext = NULL;
if (fProxy) {
char* proxyContextStorage = (char*) storage + sizeof(Sk3DShaderContext);
}
}
- void set3DMask(const SkMask* mask) SK_OVERRIDE { fMask = mask; }
+ void set3DMask(const SkMask* mask) override { fMask = mask; }
- void shadeSpan(int x, int y, SkPMColor span[], int count) SK_OVERRIDE {
+ void shadeSpan(int x, int y, SkPMColor span[], int count) override {
if (fProxyContext) {
fProxyContext->shadeSpan(x, y, span, count);
}
};
#ifndef SK_IGNORE_TO_STRING
- void toString(SkString* str) const SK_OVERRIDE {
+ void toString(SkString* str) const override {
str->append("Sk3DShader: (");
if (fProxy) {
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(Sk3DShader)
protected:
- void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
+ void flatten(SkWriteBuffer& buffer) const override {
buffer.writeFlattenable(fProxy);
}
, fShaderContext(shaderContext)
{}
- void blitH(int x, int y, int width) SK_OVERRIDE {
+ void blitH(int x, int y, int width) override {
fProxy->blitH(x, y, width);
}
virtual void blitAntiH(int x, int y, const SkAlpha antialias[],
- const int16_t runs[]) SK_OVERRIDE {
+ const int16_t runs[]) override {
fProxy->blitAntiH(x, y, antialias, runs);
}
- void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE {
+ void blitV(int x, int y, int height, SkAlpha alpha) override {
fProxy->blitV(x, y, height, alpha);
}
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE {
+ void blitRect(int x, int y, int width, int height) override {
fProxy->blitRect(x, y, width, height);
}
- void blitMask(const SkMask& mask, const SkIRect& clip) SK_OVERRIDE {
+ void blitMask(const SkMask& mask, const SkIRect& clip) override {
if (mask.fFormat == SkMask::k3D_Format) {
fShaderContext->set3DMask(&mask);
// Override rec with the identity matrix, so it is guaranteed to be invertible.
: INHERITED(shader, SkShader::ContextRec(*rec.fDevice, *rec.fPaint, SkMatrix::I())) {}
- void shadeSpan(int x, int y, SkPMColor colors[], int count) SK_OVERRIDE {
+ void shadeSpan(int x, int y, SkPMColor colors[], int count) override {
sk_bzero(colors, count * sizeof(SkPMColor));
}
*/
class SkNullBlitter : public SkBlitter {
public:
- void blitH(int x, int y, int width) SK_OVERRIDE;
+ void blitH(int x, int y, int width) override;
virtual void blitAntiH(int x, int y, const SkAlpha[],
- const int16_t runs[]) SK_OVERRIDE;
- void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE;
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE;
- void blitMask(const SkMask&, const SkIRect& clip) SK_OVERRIDE;
- const SkBitmap* justAnOpaqueColor(uint32_t* value) SK_OVERRIDE;
- bool isNullBlitter() const SK_OVERRIDE;
+ const int16_t runs[]) override;
+ void blitV(int x, int y, int height, SkAlpha alpha) override;
+ void blitRect(int x, int y, int width, int height) override;
+ void blitMask(const SkMask&, const SkIRect& clip) override;
+ const SkBitmap* justAnOpaqueColor(uint32_t* value) override;
+ bool isNullBlitter() const override;
};
/** Wraps another (real) blitter, and ensures that the real blitter is only
fClipRect = clipRect;
}
- void blitH(int x, int y, int width) SK_OVERRIDE;
+ void blitH(int x, int y, int width) override;
virtual void blitAntiH(int x, int y, const SkAlpha[],
- const int16_t runs[]) SK_OVERRIDE;
- void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE;
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE;
+ const int16_t runs[]) override;
+ void blitV(int x, int y, int height, SkAlpha alpha) override;
+ void blitRect(int x, int y, int width, int height) override;
virtual void blitAntiRect(int x, int y, int width, int height,
- SkAlpha leftAlpha, SkAlpha rightAlpha) SK_OVERRIDE;
- void blitMask(const SkMask&, const SkIRect& clip) SK_OVERRIDE;
- const SkBitmap* justAnOpaqueColor(uint32_t* value) SK_OVERRIDE;
+ SkAlpha leftAlpha, SkAlpha rightAlpha) override;
+ void blitMask(const SkMask&, const SkIRect& clip) override;
+ const SkBitmap* justAnOpaqueColor(uint32_t* value) override;
- int requestRowsPreserved() const SK_OVERRIDE {
+ int requestRowsPreserved() const override {
return fBlitter->requestRowsPreserved();
}
- void* allocBlitMemory(size_t sz) SK_OVERRIDE {
+ void* allocBlitMemory(size_t sz) override {
return fBlitter->allocBlitMemory(sz);
}
fRgn = clipRgn;
}
- void blitH(int x, int y, int width) SK_OVERRIDE;
+ void blitH(int x, int y, int width) override;
virtual void blitAntiH(int x, int y, const SkAlpha[],
- const int16_t runs[]) SK_OVERRIDE;
- void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE;
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE;
+ const int16_t runs[]) override;
+ void blitV(int x, int y, int height, SkAlpha alpha) override;
+ void blitRect(int x, int y, int width, int height) override;
virtual void blitAntiRect(int x, int y, int width, int height,
- SkAlpha leftAlpha, SkAlpha rightAlpha) SK_OVERRIDE;
- void blitMask(const SkMask&, const SkIRect& clip) SK_OVERRIDE;
- const SkBitmap* justAnOpaqueColor(uint32_t* value) SK_OVERRIDE;
+ SkAlpha leftAlpha, SkAlpha rightAlpha) override;
+ void blitMask(const SkMask&, const SkIRect& clip) override;
+ const SkBitmap* justAnOpaqueColor(uint32_t* value) override;
- int requestRowsPreserved() const SK_OVERRIDE {
+ int requestRowsPreserved() const override {
return fBlitter->requestRowsPreserved();
}
- void* allocBlitMemory(size_t sz) SK_OVERRIDE {
+ void* allocBlitMemory(size_t sz) override {
return fBlitter->allocBlitMemory(sz);
}
class SkRGB16_Blitter : public SkRasterBlitter {
public:
SkRGB16_Blitter(const SkBitmap& device, const SkPaint& paint);
- void blitH(int x, int y, int width) SK_OVERRIDE;
+ void blitH(int x, int y, int width) override;
virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
- const int16_t* runs) SK_OVERRIDE;
- void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE;
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE;
+ const int16_t* runs) override;
+ void blitV(int x, int y, int height, SkAlpha alpha) override;
+ void blitRect(int x, int y, int width, int height) override;
virtual void blitMask(const SkMask&,
- const SkIRect&) SK_OVERRIDE;
- const SkBitmap* justAnOpaqueColor(uint32_t*) SK_OVERRIDE;
+ const SkIRect&) override;
+ const SkBitmap* justAnOpaqueColor(uint32_t*) override;
protected:
SkPMColor fSrcColor32;
class SkRGB16_Opaque_Blitter : public SkRGB16_Blitter {
public:
SkRGB16_Opaque_Blitter(const SkBitmap& device, const SkPaint& paint);
- void blitH(int x, int y, int width) SK_OVERRIDE;
+ void blitH(int x, int y, int width) override;
virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
- const int16_t* runs) SK_OVERRIDE;
- void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE;
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE;
+ const int16_t* runs) override;
+ void blitV(int x, int y, int height, SkAlpha alpha) override;
+ void blitRect(int x, int y, int width, int height) override;
virtual void blitMask(const SkMask&,
- const SkIRect&) SK_OVERRIDE;
+ const SkIRect&) override;
private:
typedef SkRGB16_Blitter INHERITED;
class SkRGB16_Black_Blitter : public SkRGB16_Opaque_Blitter {
public:
SkRGB16_Black_Blitter(const SkBitmap& device, const SkPaint& paint);
- void blitMask(const SkMask&, const SkIRect&) SK_OVERRIDE;
+ void blitMask(const SkMask&, const SkIRect&) override;
virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
- const int16_t* runs) SK_OVERRIDE;
+ const int16_t* runs) override;
private:
typedef SkRGB16_Opaque_Blitter INHERITED;
SkRGB16_Shader_Blitter(const SkBitmap& device, const SkPaint& paint,
SkShader::Context* shaderContext);
virtual ~SkRGB16_Shader_Blitter();
- void blitH(int x, int y, int width) SK_OVERRIDE;
+ void blitH(int x, int y, int width) override;
virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
- const int16_t* runs) SK_OVERRIDE;
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE;
+ const int16_t* runs) override;
+ void blitRect(int x, int y, int width, int height) override;
protected:
SkPMColor* fBuffer;
public:
SkRGB16_Shader16_Blitter(const SkBitmap& device, const SkPaint& paint,
SkShader::Context* shaderContext);
- void blitH(int x, int y, int width) SK_OVERRIDE;
+ void blitH(int x, int y, int width) override;
virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
- const int16_t* runs) SK_OVERRIDE;
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE;
+ const int16_t* runs) override;
+ void blitRect(int x, int y, int width, int height) override;
private:
typedef SkRGB16_Shader_Blitter INHERITED;
SkRGB16_Shader_Xfermode_Blitter(const SkBitmap& device, const SkPaint& paint,
SkShader::Context* shaderContext);
virtual ~SkRGB16_Shader_Xfermode_Blitter();
- void blitH(int x, int y, int width) SK_OVERRIDE;
+ void blitH(int x, int y, int width) override;
virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
- const int16_t* runs) SK_OVERRIDE;
+ const int16_t* runs) override;
private:
SkXfermode* fXfermode;
null and the number of bytes to read does not overflow this object's data,
copy those bytes into buffer.
*/
- bool read(void* buffer, size_t size) SK_OVERRIDE;
+ bool read(void* buffer, size_t size) override;
/** Returns whether or not a read operation attempted to read past the end of the data.
*/
class SkComposeColorFilter : public SkColorFilter {
public:
- uint32_t getFlags() const SK_OVERRIDE {
+ uint32_t getFlags() const override {
// Can only claim alphaunchanged and 16bit support if both our proxys do.
return fOuter->getFlags() & fInner->getFlags();
}
- void filterSpan(const SkPMColor shader[], int count, SkPMColor result[]) const SK_OVERRIDE {
+ void filterSpan(const SkPMColor shader[], int count, SkPMColor result[]) const override {
fInner->filterSpan(shader, count, result);
fOuter->filterSpan(result, count, result);
}
#ifndef SK_IGNORE_TO_STRING
- void toString(SkString* str) const SK_OVERRIDE {
+ void toString(SkString* str) const override {
SkString outerS, innerS;
fOuter->toString(&outerS);
fInner->toString(&innerS);
#if SK_SUPPORT_GPU
bool asFragmentProcessors(GrContext* context,
- SkTDArray<GrFragmentProcessor*>* array) const SK_OVERRIDE {
+ SkTDArray<GrFragmentProcessor*>* array) const override {
bool hasFrags = fInner->asFragmentProcessors(context, array);
hasFrags |= fOuter->asFragmentProcessors(context, array);
return hasFrags;
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkComposeColorFilter)
protected:
- void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
+ void flatten(SkWriteBuffer& buffer) const override {
buffer.writeFlattenable(fOuter);
buffer.writeFlattenable(fInner);
}
SkASSERT(composedFilterCount <= SK_MAX_COMPOSE_COLORFILTER_COUNT);
}
- int privateComposedFilterCount() const SK_OVERRIDE {
+ int privateComposedFilterCount() const override {
return fComposedFilterCount;
}
*/
explicit SkColorShader(SkColor c);
- bool isOpaque() const SK_OVERRIDE;
+ bool isOpaque() const override;
- size_t contextSize() const SK_OVERRIDE {
+ size_t contextSize() const override {
return sizeof(ColorShaderContext);
}
public:
ColorShaderContext(const SkColorShader& shader, const ContextRec&);
- uint32_t getFlags() const SK_OVERRIDE;
- uint8_t getSpan16Alpha() const SK_OVERRIDE;
- void shadeSpan(int x, int y, SkPMColor span[], int count) SK_OVERRIDE;
- void shadeSpan16(int x, int y, uint16_t span[], int count) SK_OVERRIDE;
- void shadeSpanAlpha(int x, int y, uint8_t alpha[], int count) SK_OVERRIDE;
+ uint32_t getFlags() const override;
+ uint8_t getSpan16Alpha() const override;
+ void shadeSpan(int x, int y, SkPMColor span[], int count) override;
+ void shadeSpan16(int x, int y, uint16_t span[], int count) override;
+ void shadeSpanAlpha(int x, int y, uint8_t alpha[], int count) override;
private:
SkPMColor fPMColor;
// we return false for this, use asAGradient
virtual BitmapType asABitmap(SkBitmap* outTexture,
SkMatrix* outMatrix,
- TileMode xy[2]) const SK_OVERRIDE;
+ TileMode xy[2]) const override;
- GradientType asAGradient(GradientInfo* info) const SK_OVERRIDE;
+ GradientType asAGradient(GradientInfo* info) const override;
virtual bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix& viewM,
const SkMatrix*, GrColor*,
- GrFragmentProcessor**) const SK_OVERRIDE;
+ GrFragmentProcessor**) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkColorShader)
protected:
SkColorShader(SkReadBuffer&);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
- Context* onCreateContext(const ContextRec&, void* storage) const SK_OVERRIDE;
- bool onAsLuminanceColor(SkColor* lum) const SK_OVERRIDE {
+ void flatten(SkWriteBuffer&) const override;
+ Context* onCreateContext(const ContextRec&, void* storage) const override;
+ bool onAsLuminanceColor(SkColor* lum) const override {
*lum = fColor;
return true;
}
* Will create the context at the same location as the old one (this is safe
* because the shader itself is unchanged).
*/
- bool resetShaderContext(const SkShader::ContextRec&) SK_OVERRIDE;
+ bool resetShaderContext(const SkShader::ContextRec&) override;
- SkShader::Context* getShaderContext() const SK_OVERRIDE { return fShaderContext; }
+ SkShader::Context* getShaderContext() const override { return fShaderContext; }
protected:
uint32_t fShaderFlags;
class SkA8_Coverage_Blitter : public SkRasterBlitter {
public:
SkA8_Coverage_Blitter(const SkBitmap& device, const SkPaint& paint);
- void blitH(int x, int y, int width) SK_OVERRIDE;
- void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]) SK_OVERRIDE;
- void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE;
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE;
- void blitMask(const SkMask&, const SkIRect&) SK_OVERRIDE;
- const SkBitmap* justAnOpaqueColor(uint32_t*) SK_OVERRIDE;
+ void blitH(int x, int y, int width) override;
+ void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]) override;
+ void blitV(int x, int y, int height, SkAlpha alpha) override;
+ void blitRect(int x, int y, int width, int height) override;
+ void blitMask(const SkMask&, const SkIRect&) override;
+ const SkBitmap* justAnOpaqueColor(uint32_t*) override;
};
class SkA8_Blitter : public SkRasterBlitter {
SkARGB32_Shader_Blitter(const SkBitmap& device, const SkPaint& paint,
SkShader::Context* shaderContext);
virtual ~SkARGB32_Shader_Blitter();
- void blitH(int x, int y, int width) SK_OVERRIDE;
- void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE;
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE;
- void blitAntiH(int x, int y, const SkAlpha[], const int16_t[]) SK_OVERRIDE;
- void blitMask(const SkMask&, const SkIRect&) SK_OVERRIDE;
+ void blitH(int x, int y, int width) override;
+ void blitV(int x, int y, int height, SkAlpha alpha) override;
+ void blitRect(int x, int y, int width, int height) override;
+ void blitAntiH(int x, int y, const SkAlpha[], const int16_t[]) override;
+ void blitMask(const SkMask&, const SkIRect&) override;
private:
SkXfermode* fXfermode;
, fProps(props.flags(), kUnknown_SkPixelGeometry)
{}
- SkBaseDevice* createDevice(int w, int h) SK_OVERRIDE {
+ SkBaseDevice* createDevice(int w, int h) override {
SkBaseDevice::CreateInfo cinfo(SkImageInfo::MakeN32Premul(w, h),
SkBaseDevice::kPossible_TileUsage,
kUnknown_SkPixelGeometry);
return fDevice->onCreateDevice(cinfo, NULL);
}
- bool canHandleImageFilter(const SkImageFilter* filter) SK_OVERRIDE {
+ bool canHandleImageFilter(const SkImageFilter* filter) override {
return fDevice->canHandleImageFilter(filter);
}
virtual bool filterImage(const SkImageFilter* filter, const SkBitmap& src,
const SkImageFilter::Context& ctx,
- SkBitmap* result, SkIPoint* offset) SK_OVERRIDE {
+ SkBitmap* result, SkIPoint* offset) override {
return fDevice->filterImage(filter, src, ctx, result, offset);
}
- const SkSurfaceProps* surfaceProps() const SK_OVERRIDE {
+ const SkSurfaceProps* surfaceProps() const override {
return &fProps;
}
public:
SkTriColorShader() {}
- size_t contextSize() const SK_OVERRIDE;
+ size_t contextSize() const override;
class TriColorShaderContext : public SkShader::Context {
public:
bool setup(const SkPoint pts[], const SkColor colors[], int, int, int);
- void shadeSpan(int x, int y, SkPMColor dstC[], int count) SK_OVERRIDE;
+ void shadeSpan(int x, int y, SkPMColor dstC[], int count) override;
private:
SkMatrix fDstToUnit;
SK_TO_STRING_OVERRIDE()
// For serialization. This will never be called.
- Factory getFactory() const SK_OVERRIDE { sk_throw(); return NULL; }
+ Factory getFactory() const override { sk_throw(); return NULL; }
protected:
- Context* onCreateContext(const ContextRec& rec, void* storage) const SK_OVERRIDE {
+ Context* onCreateContext(const ContextRec& rec, void* storage) const override {
return SkNEW_PLACEMENT_ARGS(storage, TriColorShaderContext, (*this, rec));
}
public:
SkEmptyShader() {}
- size_t contextSize() const SK_OVERRIDE {
+ size_t contextSize() const override {
// Even though createContext returns NULL we have to return a value of at least
// sizeof(SkShader::Context) to satisfy SkSmallAllocator.
return sizeof(SkShader::Context);
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkEmptyShader)
protected:
- SkShader::Context* onCreateContext(const ContextRec&, void*) const SK_OVERRIDE {
+ SkShader::Context* onCreateContext(const ContextRec&, void*) const override {
return NULL;
}
SkFilterShader(SkShader* shader, SkColorFilter* filter);
virtual ~SkFilterShader();
- size_t contextSize() const SK_OVERRIDE;
+ size_t contextSize() const override;
class FilterShaderContext : public SkShader::Context {
public:
FilterShaderContext(const SkFilterShader&, SkShader::Context*, const ContextRec&);
virtual ~FilterShaderContext();
- uint32_t getFlags() const SK_OVERRIDE;
+ uint32_t getFlags() const override;
- void shadeSpan(int x, int y, SkPMColor[], int count) SK_OVERRIDE;
+ void shadeSpan(int x, int y, SkPMColor[], int count) override;
- void set3DMask(const SkMask* mask) SK_OVERRIDE {
+ void set3DMask(const SkMask* mask) override {
// forward to our proxy
fShaderContext->set3DMask(mask);
}
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkFilterShader)
protected:
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
- Context* onCreateContext(const ContextRec&, void* storage) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
+ Context* onCreateContext(const ContextRec&, void* storage) const override;
private:
void finalize();
// The SkWStream interface:
- bool write(const void*, size_t) SK_OVERRIDE;
- size_t bytesWritten() const SK_OVERRIDE;
+ bool write(const void*, size_t) override;
+ size_t bytesWritten() const override;
private:
struct Impl;
class SkEmptyFontStyleSet : public SkFontStyleSet {
public:
- int count() SK_OVERRIDE { return 0; }
- void getStyle(int, SkFontStyle*, SkString*) SK_OVERRIDE {
+ int count() override { return 0; }
+ void getStyle(int, SkFontStyle*, SkString*) override {
SkDEBUGFAIL("SkFontStyleSet::getStyle called on empty set");
}
- SkTypeface* createTypeface(int index) SK_OVERRIDE {
+ SkTypeface* createTypeface(int index) override {
SkDEBUGFAIL("SkFontStyleSet::createTypeface called on empty set");
return NULL;
}
- SkTypeface* matchStyle(const SkFontStyle&) SK_OVERRIDE {
+ SkTypeface* matchStyle(const SkFontStyle&) override {
return NULL;
}
};
class SkEmptyFontMgr : public SkFontMgr {
protected:
- int onCountFamilies() const SK_OVERRIDE {
+ int onCountFamilies() const override {
return 0;
}
- void onGetFamilyName(int index, SkString* familyName) const SK_OVERRIDE {
+ void onGetFamilyName(int index, SkString* familyName) const override {
SkDEBUGFAIL("onGetFamilyName called with bad index");
}
- SkFontStyleSet* onCreateStyleSet(int index) const SK_OVERRIDE {
+ SkFontStyleSet* onCreateStyleSet(int index) const override {
SkDEBUGFAIL("onCreateStyleSet called with bad index");
return NULL;
}
- SkFontStyleSet* onMatchFamily(const char[]) const SK_OVERRIDE {
+ SkFontStyleSet* onMatchFamily(const char[]) const override {
return SkFontStyleSet::CreateEmpty();
}
virtual SkTypeface* onMatchFamilyStyle(const char[],
- const SkFontStyle&) const SK_OVERRIDE {
+ const SkFontStyle&) const override {
return NULL;
}
virtual SkTypeface* onMatchFamilyStyleCharacter(const char familyName[],
const SkFontStyle& style,
const char* bcp47[],
int bcp47Count,
- SkUnichar character) const SK_OVERRIDE {
+ SkUnichar character) const override {
return NULL;
}
virtual SkTypeface* onMatchFaceStyle(const SkTypeface*,
- const SkFontStyle&) const SK_OVERRIDE {
+ const SkFontStyle&) const override {
return NULL;
}
- SkTypeface* onCreateFromData(SkData*, int) const SK_OVERRIDE {
+ SkTypeface* onCreateFromData(SkData*, int) const override {
return NULL;
}
- SkTypeface* onCreateFromStream(SkStreamAsset* stream, int) const SK_OVERRIDE {
+ SkTypeface* onCreateFromStream(SkStreamAsset* stream, int) const override {
SkDELETE(stream);
return NULL;
}
- SkTypeface* onCreateFromFile(const char[], int) const SK_OVERRIDE {
+ SkTypeface* onCreateFromFile(const char[], int) const override {
return NULL;
}
- SkTypeface* onLegacyCreateTypeface(const char [], unsigned) const SK_OVERRIDE {
+ SkTypeface* onLegacyCreateTypeface(const char [], unsigned) const override {
return NULL;
}
};
}
SK_DECLARE_INTERNAL_LLIST_INTERFACE(Value);
};
- bool get(const Key& key, SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE {
+ bool get(const Key& key, SkBitmap* result, SkIPoint* offset) const override {
SkAutoMutexAcquire mutex(fMutex);
if (Value* v = fLookup.find(key)) {
*result = v->fBitmap;
}
return false;
}
- void set(const Key& key, const SkBitmap& result, const SkIPoint& offset) SK_OVERRIDE {
+ void set(const Key& key, const SkBitmap& result, const SkIPoint& offset) override {
SkAutoMutexAcquire mutex(fMutex);
if (Value* v = fLookup.find(key)) {
removeInternal(v);
, fProxyShader(SkRef(proxy))
{}
- size_t contextSize() const SK_OVERRIDE {
+ size_t contextSize() const override {
return fProxyShader->contextSize();
}
virtual BitmapType asABitmap(SkBitmap* bitmap, SkMatrix* matrix,
- TileMode* mode) const SK_OVERRIDE {
+ TileMode* mode) const override {
return fProxyShader->asABitmap(bitmap, matrix, mode);
}
- GradientType asAGradient(GradientInfo* info) const SK_OVERRIDE {
+ GradientType asAGradient(GradientInfo* info) const override {
return fProxyShader->asAGradient(info);
}
virtual bool asFragmentProcessor(GrContext* context, const SkPaint& paint,
const SkMatrix& viewM, const SkMatrix* localMatrix,
- GrColor* grColor, GrFragmentProcessor** fp) const SK_OVERRIDE {
+ GrColor* grColor, GrFragmentProcessor** fp) const override {
SkMatrix tmp = this->getLocalMatrix();
if (localMatrix) {
tmp.preConcat(*localMatrix);
virtual bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&,
const SkMatrix*, GrColor*,
- GrFragmentProcessor**) const SK_OVERRIDE {
+ GrFragmentProcessor**) const override {
SkDEBUGFAIL("Should not call in GPU-less build");
return false;
}
#endif
- SkShader* refAsALocalMatrixShader(SkMatrix* localMatrix) const SK_OVERRIDE {
+ SkShader* refAsALocalMatrixShader(SkMatrix* localMatrix) const override {
if (localMatrix) {
*localMatrix = this->getLocalMatrix();
}
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLocalMatrixShader)
protected:
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
- Context* onCreateContext(const ContextRec&, void*) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
+ Context* onCreateContext(const ContextRec&, void*) const override;
private:
SkAutoTUnref<SkShader> fProxyShader;
RRectBlurKey fKey;
MaskValue fValue;
- const Key& getKey() const SK_OVERRIDE { return fKey; }
- size_t bytesUsed() const SK_OVERRIDE { return sizeof(*this) + fValue.fData->size(); }
+ const Key& getKey() const override { return fKey; }
+ size_t bytesUsed() const override { return sizeof(*this) + fValue.fData->size(); }
static bool Visitor(const SkResourceCache::Rec& baseRec, void* contextData) {
const RRectBlurRec& rec = static_cast<const RRectBlurRec&>(baseRec);
RectsBlurKey fKey;
MaskValue fValue;
- const Key& getKey() const SK_OVERRIDE { return fKey; }
- size_t bytesUsed() const SK_OVERRIDE { return sizeof(*this) + fValue.fData->size(); }
+ const Key& getKey() const override { return fKey; }
+ size_t bytesUsed() const override { return sizeof(*this) + fValue.fData->size(); }
static bool Visitor(const SkResourceCache::Rec& baseRec, void* contextData) {
const RectsBlurRec& rec = static_cast<const RectsBlurRec&>(baseRec);
#include "SkMaskGamma.h"
class SkLinearColorSpaceLuminance : public SkColorSpaceLuminance {
- SkScalar toLuma(SkScalar SkDEBUGCODE(gamma), SkScalar luminance) const SK_OVERRIDE {
+ SkScalar toLuma(SkScalar SkDEBUGCODE(gamma), SkScalar luminance) const override {
SkASSERT(SK_Scalar1 == gamma);
return luminance;
}
- SkScalar fromLuma(SkScalar SkDEBUGCODE(gamma), SkScalar luma) const SK_OVERRIDE {
+ SkScalar fromLuma(SkScalar SkDEBUGCODE(gamma), SkScalar luma) const override {
SkASSERT(SK_Scalar1 == gamma);
return luma;
}
};
class SkGammaColorSpaceLuminance : public SkColorSpaceLuminance {
- SkScalar toLuma(SkScalar gamma, SkScalar luminance) const SK_OVERRIDE {
+ SkScalar toLuma(SkScalar gamma, SkScalar luminance) const override {
return SkScalarPow(luminance, gamma);
}
- SkScalar fromLuma(SkScalar gamma, SkScalar luma) const SK_OVERRIDE {
+ SkScalar fromLuma(SkScalar gamma, SkScalar luma) const override {
return SkScalarPow(luma, SkScalarInvert(gamma));
}
};
class SkSRGBColorSpaceLuminance : public SkColorSpaceLuminance {
- SkScalar toLuma(SkScalar SkDEBUGCODE(gamma), SkScalar luminance) const SK_OVERRIDE {
+ SkScalar toLuma(SkScalar SkDEBUGCODE(gamma), SkScalar luminance) const override {
SkASSERT(0 == gamma);
//The magic numbers are derived from the sRGB specification.
//See http://www.color.org/chardata/rgb/srgb.xalter .
return SkScalarPow((luminance + 0.055f) / 1.055f,
2.4f);
}
- SkScalar fromLuma(SkScalar SkDEBUGCODE(gamma), SkScalar luma) const SK_OVERRIDE {
+ SkScalar fromLuma(SkScalar SkDEBUGCODE(gamma), SkScalar luma) const override {
SkASSERT(0 == gamma);
//The magic numbers are derived from the sRGB specification.
//See http://www.color.org/chardata/rgb/srgb.xalter .
#endif
virtual ~SkMatrixImageFilter();
- void computeFastBounds(const SkRect&, SkRect*) const SK_OVERRIDE;
+ void computeFastBounds(const SkRect&, SkRect*) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkMatrixImageFilter)
SkMatrixImageFilter(const SkMatrix& transform,
SkFilterQuality,
SkImageFilter* input);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* loc) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* loc) const override;
virtual bool onFilterBounds(const SkIRect& src, const SkMatrix&,
- SkIRect* dst) const SK_OVERRIDE;
+ SkIRect* dst) const override;
private:
SkMatrix fTransform;
bool extractLevel(SkScalar scale, Level*) const;
protected:
- void onDataChange(void* oldData, void* newData) SK_OVERRIDE {
+ void onDataChange(void* oldData, void* newData) override {
fLevels = (Level*)newData; // could be NULL
}
SkPictureRecord(const SkISize& dimensions, uint32_t recordFlags);
virtual ~SkPictureRecord();
- void beginCommentGroup(const char* description) SK_OVERRIDE;
- void addComment(const char* kywd, const char* value) SK_OVERRIDE;
- void endCommentGroup() SK_OVERRIDE;
+ void beginCommentGroup(const char* description) override;
+ void addComment(const char* kywd, const char* value) override;
+ void endCommentGroup() override;
const SkTDArray<const SkPicture* >& getPictureRefs() const {
return fPictureRefs;
SkASSERT(fWriter.bytesWritten() == initialOffset + size);
}
- SkSurface* onNewSurface(const SkImageInfo&, const SkSurfaceProps&) SK_OVERRIDE;
- const void* onPeekPixels(SkImageInfo*, size_t*) SK_OVERRIDE {
+ SkSurface* onNewSurface(const SkImageInfo&, const SkSurfaceProps&) override;
+ const void* onPeekPixels(SkImageInfo*, size_t*) override {
return NULL;
}
- void willSave() SK_OVERRIDE;
- SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) SK_OVERRIDE;
- void willRestore() SK_OVERRIDE;
+ void willSave() override;
+ SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) override;
+ void willRestore() override;
- void didConcat(const SkMatrix&) SK_OVERRIDE;
- void didSetMatrix(const SkMatrix&) SK_OVERRIDE;
+ void didConcat(const SkMatrix&) override;
+ void didSetMatrix(const SkMatrix&) override;
- void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) SK_OVERRIDE;
+ void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) override;
virtual void onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
virtual void onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
virtual void onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
- SkScalar constY, const SkPaint&) SK_OVERRIDE;
+ SkScalar constY, const SkPaint&) override;
virtual void onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
- const SkMatrix* matrix, const SkPaint&) SK_OVERRIDE;
+ const SkMatrix* matrix, const SkPaint&) override;
virtual void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
virtual void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
const SkPoint texCoords[4], SkXfermode* xmode,
- const SkPaint& paint) SK_OVERRIDE;
-
- void onDrawPaint(const SkPaint&) SK_OVERRIDE;
- void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) SK_OVERRIDE;
- void onDrawRect(const SkRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawOval(const SkRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawRRect(const SkRRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawPath(const SkPath&, const SkPaint&) SK_OVERRIDE;
- void onDrawBitmap(const SkBitmap&, SkScalar left, SkScalar top, const SkPaint*) SK_OVERRIDE;
+ const SkPaint& paint) override;
+
+ void onDrawPaint(const SkPaint&) override;
+ void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) override;
+ void onDrawRect(const SkRect&, const SkPaint&) override;
+ void onDrawOval(const SkRect&, const SkPaint&) override;
+ void onDrawRRect(const SkRRect&, const SkPaint&) override;
+ void onDrawPath(const SkPath&, const SkPaint&) override;
+ void onDrawBitmap(const SkBitmap&, SkScalar left, SkScalar top, const SkPaint*) override;
void onDrawBitmapRect(const SkBitmap&, const SkRect* src, const SkRect& dst, const SkPaint*,
- DrawBitmapRectFlags flags) SK_OVERRIDE;
+ DrawBitmapRectFlags flags) override;
#if 0
// rely on conversion to bitmap (for now)
- void onDrawImage(const SkImage*, SkScalar left, SkScalar top, const SkPaint*) SK_OVERRIDE;
+ void onDrawImage(const SkImage*, SkScalar left, SkScalar top, const SkPaint*) override;
void onDrawImageRect(const SkImage*, const SkRect* src, const SkRect& dst,
- const SkPaint*) SK_OVERRIDE;
+ const SkPaint*) override;
#endif
void onDrawBitmapNine(const SkBitmap&, const SkIRect& center, const SkRect& dst,
- const SkPaint*) SK_OVERRIDE;
- void onDrawSprite(const SkBitmap&, int left, int top, const SkPaint*) SK_OVERRIDE;
+ const SkPaint*) override;
+ void onDrawSprite(const SkBitmap&, int left, int top, const SkPaint*) override;
void onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
const SkColor colors[], SkXfermode* xmode,
const uint16_t indices[], int indexCount,
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
- void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipRegion(const SkRegion&, SkRegion::Op) SK_OVERRIDE;
+ void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipRegion(const SkRegion&, SkRegion::Op) override;
- void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) SK_OVERRIDE;
+ void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;
int addPathToHeap(const SkPath& path); // does not write to ops stream
{}
protected:
- SkRect onGetBounds() SK_OVERRIDE { return fBounds; }
+ SkRect onGetBounds() override { return fBounds; }
- void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ void onDraw(SkCanvas* canvas) override {
SkDrawable* const* drawables = NULL;
int drawableCount = 0;
if (fDrawableList) {
SkRecordDraw(*fRecord, canvas, NULL, drawables, drawableCount, fBBH, NULL/*callback*/);
}
- SkPicture* onNewPictureSnapshot() SK_OVERRIDE {
+ SkPicture* onNewPictureSnapshot() override {
SkPicture::SnapshotArray* pictList = NULL;
if (fDrawableList) {
// TODO: should we plumb-down the BBHFactory and recordFlags from our host
SkAutoTUnref<SkShader> fShader;
size_t fBitmapBytes;
- const Key& getKey() const SK_OVERRIDE { return fKey; }
- size_t bytesUsed() const SK_OVERRIDE {
+ const Key& getKey() const override { return fKey; }
+ size_t bytesUsed() const override {
return sizeof(fKey) + sizeof(SkShader) + fBitmapBytes;
}
const SkRect*);
virtual ~SkPictureShader();
- size_t contextSize() const SK_OVERRIDE;
+ size_t contextSize() const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPictureShader)
bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix& viewM, const SkMatrix*,
- GrColor*, GrFragmentProcessor**) const SK_OVERRIDE;
+ GrColor*, GrFragmentProcessor**) const override;
protected:
SkPictureShader(SkReadBuffer&);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
- Context* onCreateContext(const ContextRec&, void* storage) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
+ Context* onCreateContext(const ContextRec&, void* storage) const override;
private:
SkPictureShader(const SkPicture*, TileMode, TileMode, const SkMatrix*, const SkRect*);
virtual ~PictureShaderContext();
- uint32_t getFlags() const SK_OVERRIDE;
+ uint32_t getFlags() const override;
- ShadeProc asAShadeProc(void** ctx) SK_OVERRIDE;
- void shadeSpan(int x, int y, SkPMColor dstC[], int count) SK_OVERRIDE;
- void shadeSpan16(int x, int y, uint16_t dstC[], int count) SK_OVERRIDE;
+ ShadeProc asAShadeProc(void** ctx) override;
+ void shadeSpan(int x, int y, SkPMColor dstC[], int count) override;
+ void shadeSpan16(int x, int y, uint16_t dstC[], int count) override;
private:
PictureShaderContext(const SkPictureShader&, const ContextRec&, SkShader* bitmapShader);
explicit SkRTree(SkScalar aspectRatio = 1);
virtual ~SkRTree() {}
- void insert(const SkRect[], int N) SK_OVERRIDE;
- void search(const SkRect& query, SkTDArray<unsigned>* results) const SK_OVERRIDE;
- size_t bytesUsed() const SK_OVERRIDE;
+ void insert(const SkRect[], int N) override;
+ void search(const SkRect& query, SkTDArray<unsigned>* results) const override;
+ size_t bytesUsed() const override;
// Methods and constants below here are only public for tests.
int getCount() const { return fCount; }
// Get the root bound.
- SkRect getRootBound() const SK_OVERRIDE;
+ SkRect getRootBound() const override;
// These values were empirically determined to produce reasonable performance in most cases.
static const int kMinChildren = 6,
// Make SkRecorder forget entirely about its SkRecord*; all calls to SkRecorder will fail.
void forgetRecord();
- void willSave() SK_OVERRIDE;
- SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SkCanvas::SaveFlags) SK_OVERRIDE;
- void willRestore() SK_OVERRIDE {}
- void didRestore() SK_OVERRIDE;
+ void willSave() override;
+ SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SkCanvas::SaveFlags) override;
+ void willRestore() override {}
+ void didRestore() override;
- void didConcat(const SkMatrix&) SK_OVERRIDE;
- void didSetMatrix(const SkMatrix&) SK_OVERRIDE;
+ void didConcat(const SkMatrix&) override;
+ void didSetMatrix(const SkMatrix&) override;
- void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawDrawable(SkDrawable*) SK_OVERRIDE;
+ void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) override;
+ void onDrawDrawable(SkDrawable*) override;
void onDrawText(const void* text,
size_t byteLength,
SkScalar x,
SkScalar y,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
void onDrawPosText(const void* text,
size_t byteLength,
const SkPoint pos[],
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
void onDrawPosTextH(const void* text,
size_t byteLength,
const SkScalar xpos[],
SkScalar constY,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
void onDrawTextOnPath(const void* text,
size_t byteLength,
const SkPath& path,
const SkMatrix* matrix,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
void onDrawTextBlob(const SkTextBlob* blob,
SkScalar x,
SkScalar y,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
const SkPoint texCoords[4], SkXfermode* xmode,
- const SkPaint& paint) SK_OVERRIDE;
-
- void onDrawPaint(const SkPaint&) SK_OVERRIDE;
- void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) SK_OVERRIDE;
- void onDrawRect(const SkRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawOval(const SkRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawRRect(const SkRRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawPath(const SkPath&, const SkPaint&) SK_OVERRIDE;
- void onDrawBitmap(const SkBitmap&, SkScalar left, SkScalar top, const SkPaint*) SK_OVERRIDE;
+ const SkPaint& paint) override;
+
+ void onDrawPaint(const SkPaint&) override;
+ void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) override;
+ void onDrawRect(const SkRect&, const SkPaint&) override;
+ void onDrawOval(const SkRect&, const SkPaint&) override;
+ void onDrawRRect(const SkRRect&, const SkPaint&) override;
+ void onDrawPath(const SkPath&, const SkPaint&) override;
+ void onDrawBitmap(const SkBitmap&, SkScalar left, SkScalar top, const SkPaint*) override;
void onDrawBitmapRect(const SkBitmap&, const SkRect* src, const SkRect& dst, const SkPaint*,
- DrawBitmapRectFlags flags) SK_OVERRIDE;
- void onDrawImage(const SkImage*, SkScalar left, SkScalar top, const SkPaint*) SK_OVERRIDE;
+ DrawBitmapRectFlags flags) override;
+ void onDrawImage(const SkImage*, SkScalar left, SkScalar top, const SkPaint*) override;
void onDrawImageRect(const SkImage*, const SkRect* src, const SkRect& dst,
- const SkPaint*) SK_OVERRIDE;
+ const SkPaint*) override;
void onDrawBitmapNine(const SkBitmap&, const SkIRect& center, const SkRect& dst,
- const SkPaint*) SK_OVERRIDE;
- void onDrawSprite(const SkBitmap&, int left, int top, const SkPaint*) SK_OVERRIDE;
+ const SkPaint*) override;
+ void onDrawSprite(const SkBitmap&, int left, int top, const SkPaint*) override;
void onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
const SkColor colors[], SkXfermode* xmode,
const uint16_t indices[], int indexCount,
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
- void onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) SK_OVERRIDE;
- void onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) SK_OVERRIDE;
- void onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) SK_OVERRIDE;
- void onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) SK_OVERRIDE;
+ void onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) override;
+ void onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) override;
+ void onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) override;
+ void onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) override;
- void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) SK_OVERRIDE;
+ void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;
- void beginCommentGroup(const char*) SK_OVERRIDE;
- void addComment(const char*, const char*) SK_OVERRIDE;
- void endCommentGroup() SK_OVERRIDE;
+ void beginCommentGroup(const char*) override;
+ void addComment(const char*, const char*) override;
+ void endCommentGroup() override;
- SkSurface* onNewSurface(const SkImageInfo&, const SkSurfaceProps&) SK_OVERRIDE { return NULL; }
+ SkSurface* onNewSurface(const SkImageInfo&, const SkSurfaceProps&) override { return NULL; }
private:
template <typename T>
void copyToRect(SkIRect*) const;
void copyToRgn(SkRegion::RunType runs[]) const;
- void blitH(int x, int y, int width) SK_OVERRIDE;
+ void blitH(int x, int y, int width) override;
#ifdef SK_DEBUG
void dump() const {
~SkOneShotDiscardablePixelRef();
protected:
- bool onNewLockPixels(LockRec*) SK_OVERRIDE;
- void onUnlockPixels() SK_OVERRIDE;
- size_t getAllocatedSizeInBytes() const SK_OVERRIDE;
+ bool onNewLockPixels(LockRec*) override;
+ void onUnlockPixels() override;
+ size_t getAllocatedSizeInBytes() const override;
private:
SkDiscardableMemory* fDM;
fFactory = factory;
}
- bool allocPixelRef(SkBitmap*, SkColorTable*) SK_OVERRIDE;
+ bool allocPixelRef(SkBitmap*, SkColorTable*) override;
private:
SkResourceCache::DiscardableFactory fFactory;
: SkScalerContext(face, desc) {}
protected:
- unsigned generateGlyphCount() SK_OVERRIDE {
+ unsigned generateGlyphCount() override {
return 0;
}
- uint16_t generateCharToGlyph(SkUnichar uni) SK_OVERRIDE {
+ uint16_t generateCharToGlyph(SkUnichar uni) override {
return 0;
}
- void generateAdvance(SkGlyph* glyph) SK_OVERRIDE {
+ void generateAdvance(SkGlyph* glyph) override {
glyph->zeroMetrics();
}
- void generateMetrics(SkGlyph* glyph) SK_OVERRIDE {
+ void generateMetrics(SkGlyph* glyph) override {
glyph->zeroMetrics();
}
- void generateImage(const SkGlyph& glyph) SK_OVERRIDE {}
- void generatePath(const SkGlyph& glyph, SkPath* path) SK_OVERRIDE {}
- void generateFontMetrics(SkPaint::FontMetrics* metrics) SK_OVERRIDE {
+ void generateImage(const SkGlyph& glyph) override {}
+ void generatePath(const SkGlyph& glyph, SkPath* path) override {}
+ void generateFontMetrics(SkPaint::FontMetrics* metrics) override {
if (metrics) {
sk_bzero(metrics, sizeof(*metrics));
}
/// Must be explicitly defined on subclasses.
virtual void blitAntiH(int x, int y, const SkAlpha antialias[],
- const int16_t runs[]) SK_OVERRIDE {
+ const int16_t runs[]) override {
SkDEBUGFAIL("How did I get here?");
}
/// May not be called on BaseSuperBlitter because it blits out of order.
- void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE {
+ void blitV(int x, int y, int height, SkAlpha alpha) override {
SkDEBUGFAIL("How did I get here?");
}
/// Blits a row of pixels, with location and width specified
/// in supersampled coordinates.
- void blitH(int x, int y, int width) SK_OVERRIDE;
+ void blitH(int x, int y, int width) override;
/// Blits a rectangle of pixels, with location and size specified
/// in supersampled coordinates.
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE;
+ void blitRect(int x, int y, int width, int height) override;
private:
// The next three variables are used to track a circular buffer that
fRealBlitter->blitMask(fMask, fClipRect);
}
- void blitH(int x, int y, int width) SK_OVERRIDE;
+ void blitH(int x, int y, int width) override;
static bool CanHandleRect(const SkIRect& bounds) {
#ifdef FORCE_RLE
class HLine_SkAntiHairBlitter : public SkAntiHairBlitter {
public:
- SkFixed drawCap(int x, SkFixed fy, SkFixed slope, int mod64) SK_OVERRIDE {
+ SkFixed drawCap(int x, SkFixed fy, SkFixed slope, int mod64) override {
fy += SK_Fixed1/2;
int y = fy >> 16;
}
virtual SkFixed drawLine(int x, int stopx, SkFixed fy,
- SkFixed slope) SK_OVERRIDE {
+ SkFixed slope) override {
SkASSERT(x < stopx);
int count = stopx - x;
fy += SK_Fixed1/2;
class Horish_SkAntiHairBlitter : public SkAntiHairBlitter {
public:
- SkFixed drawCap(int x, SkFixed fy, SkFixed dy, int mod64) SK_OVERRIDE {
+ SkFixed drawCap(int x, SkFixed fy, SkFixed dy, int mod64) override {
int16_t runs[2];
uint8_t aa[1];
return fy - SK_Fixed1/2;
}
- SkFixed drawLine(int x, int stopx, SkFixed fy, SkFixed dy) SK_OVERRIDE {
+ SkFixed drawLine(int x, int stopx, SkFixed fy, SkFixed dy) override {
SkASSERT(x < stopx);
int16_t runs[2];
class VLine_SkAntiHairBlitter : public SkAntiHairBlitter {
public:
- SkFixed drawCap(int y, SkFixed fx, SkFixed dx, int mod64) SK_OVERRIDE {
+ SkFixed drawCap(int y, SkFixed fx, SkFixed dx, int mod64) override {
SkASSERT(0 == dx);
fx += SK_Fixed1/2;
return fx - SK_Fixed1/2;
}
- SkFixed drawLine(int y, int stopy, SkFixed fx, SkFixed dx) SK_OVERRIDE {
+ SkFixed drawLine(int y, int stopy, SkFixed fx, SkFixed dx) override {
SkASSERT(y < stopy);
SkASSERT(0 == dx);
fx += SK_Fixed1/2;
class Vertish_SkAntiHairBlitter : public SkAntiHairBlitter {
public:
- SkFixed drawCap(int y, SkFixed fx, SkFixed dx, int mod64) SK_OVERRIDE {
+ SkFixed drawCap(int y, SkFixed fx, SkFixed dx, int mod64) override {
int16_t runs[3];
uint8_t aa[2];
return fx - SK_Fixed1/2;
}
- SkFixed drawLine(int y, int stopy, SkFixed fx, SkFixed dx) SK_OVERRIDE {
+ SkFixed drawLine(int y, int stopy, SkFixed fx, SkFixed dx) override {
SkASSERT(y < stopy);
int16_t runs[3];
uint8_t aa[2];
}
// overrides
- void blitH(int x, int y, int width) SK_OVERRIDE {
+ void blitH(int x, int y, int width) override {
int invWidth = x - fPrevX;
if (invWidth > 0) {
fBlitter->blitH(fPrevX, y, invWidth);
}
// we do not expect to get called with these entrypoints
- void blitAntiH(int, int, const SkAlpha[], const int16_t runs[]) SK_OVERRIDE {
+ void blitAntiH(int, int, const SkAlpha[], const int16_t runs[]) override {
SkDEBUGFAIL("blitAntiH unexpected");
}
- void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE {
+ void blitV(int x, int y, int height, SkAlpha alpha) override {
SkDEBUGFAIL("blitV unexpected");
}
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE {
+ void blitRect(int x, int y, int width, int height) override {
SkDEBUGFAIL("blitRect unexpected");
}
- void blitMask(const SkMask&, const SkIRect& clip) SK_OVERRIDE {
+ void blitMask(const SkMask&, const SkIRect& clip) override {
SkDEBUGFAIL("blitMask unexpected");
}
- const SkBitmap* justAnOpaqueColor(uint32_t* value) SK_OVERRIDE {
+ const SkBitmap* justAnOpaqueColor(uint32_t* value) override {
SkDEBUGFAIL("justAnOpaqueColor unexpected");
return NULL;
}
fAlpha = alpha;
}
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE {
+ void blitRect(int x, int y, int width, int height) override {
SkASSERT(width > 0 && height > 0);
uint32_t* SK_RESTRICT dst = fDevice->getAddr32(x, y);
const uint32_t* SK_RESTRICT src = fSource->getAddr32(x - fLeft,
}
virtual void setup(const SkBitmap& device, int left, int top,
- const SkPaint& paint) SK_OVERRIDE {
+ const SkPaint& paint) override {
this->INHERITED::setup(device, left, top, paint);
int width = device.width();
Sprite_D32_S32A_XferFilter(const SkBitmap& source, const SkPaint& paint)
: Sprite_D32_XferFilter(source, paint) {}
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE {
+ void blitRect(int x, int y, int width, int height) override {
SkASSERT(width > 0 && height > 0);
uint32_t* SK_RESTRICT dst = fDevice->getAddr32(x, y);
const uint32_t* SK_RESTRICT src = fSource->getAddr32(x - fLeft,
Sprite_D32_S4444_XferFilter(const SkBitmap& source, const SkPaint& paint)
: Sprite_D32_XferFilter(source, paint) {}
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE {
+ void blitRect(int x, int y, int width, int height) override {
SkASSERT(width > 0 && height > 0);
SkPMColor* SK_RESTRICT dst = fDevice->getAddr32(x, y);
const SkPMColor16* SK_RESTRICT src = fSource->getAddr16(x - fLeft,
public:
Sprite_D32_S4444_Opaque(const SkBitmap& source) : SkSpriteBlitter(source) {}
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE {
+ void blitRect(int x, int y, int width, int height) override {
SkASSERT(width > 0 && height > 0);
SkPMColor* SK_RESTRICT dst = fDevice->getAddr32(x, y);
const SkPMColor16* SK_RESTRICT src = fSource->getAddr16(x - fLeft,
public:
Sprite_D32_S4444(const SkBitmap& source) : SkSpriteBlitter(source) {}
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE {
+ void blitRect(int x, int y, int width, int height) override {
SkASSERT(width > 0 && height > 0);
SkPMColor* SK_RESTRICT dst = fDevice->getAddr32(x, y);
const SkPMColor16* SK_RESTRICT src = fSource->getAddr16(x - fLeft,
: SkSpriteBlitter(source) {}
// overrides
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE {
+ void blitRect(int x, int y, int width, int height) override {
uint16_t* SK_RESTRICT dst = fDevice->getAddr16(x, y);
const uint16_t* SK_RESTRICT src = fSource->getAddr16(x - fLeft,
y - fTop);
// overrides
virtual void setup(const SkBitmap& device, int left, int top,
- const SkPaint& paint) SK_OVERRIDE {
+ const SkPaint& paint) override {
this->INHERITED::setup(device, left, top, paint);
unsigned flags = 0;
fProc = SkBlitRow::Factory16(flags);
}
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE {
+ void blitRect(int x, int y, int width, int height) override {
uint16_t* SK_RESTRICT dst = fDevice->getAddr16(x, y);
const SkPMColor* SK_RESTRICT src = fSource->getAddr32(x - fLeft,
y - fTop);
: fBlockMemory(SkRef(headRef)), fCurrent(fBlockMemory->fHead)
, fSize(size) , fOffset(0), fCurrentOffset(0) { }
- size_t read(void* buffer, size_t rawCount) SK_OVERRIDE {
+ size_t read(void* buffer, size_t rawCount) override {
size_t count = rawCount;
if (fOffset + count > fSize) {
count = fSize - fOffset;
return 0;
}
- bool isAtEnd() const SK_OVERRIDE {
+ bool isAtEnd() const override {
return fOffset == fSize;
}
- bool rewind() SK_OVERRIDE {
+ bool rewind() override {
fCurrent = fBlockMemory->fHead;
fOffset = 0;
fCurrentOffset = 0;
return true;
}
- SkBlockMemoryStream* duplicate() const SK_OVERRIDE {
+ SkBlockMemoryStream* duplicate() const override {
return SkNEW_ARGS(SkBlockMemoryStream, (fBlockMemory.get(), fSize));
}
- size_t getPosition() const SK_OVERRIDE {
+ size_t getPosition() const override {
return fOffset;
}
- bool seek(size_t position) SK_OVERRIDE {
+ bool seek(size_t position) override {
// If possible, skip forward.
if (position >= fOffset) {
size_t skipAmount = position - fOffset;
return this->rewind() && this->skip(position) == position;
}
- bool move(long offset) SK_OVERRIDE {
+ bool move(long offset) override {
return seek(fOffset + offset);
}
- SkBlockMemoryStream* fork() const SK_OVERRIDE {
+ SkBlockMemoryStream* fork() const override {
SkAutoTDelete<SkBlockMemoryStream> that(this->duplicate());
that->fCurrent = this->fCurrent;
that->fOffset = this->fOffset;
return that.detach();
}
- size_t getLength() const SK_OVERRIDE {
+ size_t getLength() const override {
return fSize;
}
- const void* getMemoryBase() SK_OVERRIDE {
+ const void* getMemoryBase() override {
if (NULL == fBlockMemory->fHead->fNext) {
return fBlockMemory->fHead->start();
}
protected:
SkEmptyTypeface() : SkTypeface(SkFontStyle(), 0, true) { }
- SkStreamAsset* onOpenStream(int* ttcIndex) const SK_OVERRIDE { return NULL; }
- SkScalerContext* onCreateScalerContext(const SkDescriptor*) const SK_OVERRIDE {
+ SkStreamAsset* onOpenStream(int* ttcIndex) const override { return NULL; }
+ SkScalerContext* onCreateScalerContext(const SkDescriptor*) const override {
return NULL;
}
- void onFilterRec(SkScalerContextRec*) const SK_OVERRIDE { }
+ void onFilterRec(SkScalerContextRec*) const override { }
virtual SkAdvancedTypefaceMetrics* onGetAdvancedTypefaceMetrics(
SkAdvancedTypefaceMetrics::PerGlyphInfo,
- const uint32_t*, uint32_t) const SK_OVERRIDE { return NULL; }
- void onGetFontDescriptor(SkFontDescriptor*, bool*) const SK_OVERRIDE { }
+ const uint32_t*, uint32_t) const override { return NULL; }
+ void onGetFontDescriptor(SkFontDescriptor*, bool*) const override { }
virtual int onCharsToGlyphs(const void* chars, Encoding encoding,
- uint16_t glyphs[], int glyphCount) const SK_OVERRIDE {
+ uint16_t glyphs[], int glyphCount) const override {
if (glyphs && glyphCount > 0) {
sk_bzero(glyphs, glyphCount * sizeof(glyphs[0]));
}
return 0;
}
- int onCountGlyphs() const SK_OVERRIDE { return 0; };
- int onGetUPEM() const SK_OVERRIDE { return 0; };
+ int onCountGlyphs() const override { return 0; };
+ int onGetUPEM() const override { return 0; };
class EmptyLocalizedStrings : public SkTypeface::LocalizedStrings {
public:
- bool next(SkTypeface::LocalizedString*) SK_OVERRIDE { return false; }
+ bool next(SkTypeface::LocalizedString*) override { return false; }
};
- void onGetFamilyName(SkString* familyName) const SK_OVERRIDE {
+ void onGetFamilyName(SkString* familyName) const override {
familyName->reset();
}
- SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const SK_OVERRIDE {
+ SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const override {
return SkNEW(EmptyLocalizedStrings);
};
- int onGetTableTags(SkFontTableTag tags[]) const SK_OVERRIDE { return 0; }
- size_t onGetTableData(SkFontTableTag, size_t, size_t, void*) const SK_OVERRIDE {
+ int onGetTableTags(SkFontTableTag tags[]) const override { return 0; }
+ size_t onGetTableData(SkFontTableTag, size_t, size_t, void*) const override {
return 0;
}
};
SkValidatingReadBuffer(const void* data, size_t size);
virtual ~SkValidatingReadBuffer();
- const void* skip(size_t size) SK_OVERRIDE;
+ const void* skip(size_t size) override;
// primitives
- bool readBool() SK_OVERRIDE;
- SkColor readColor() SK_OVERRIDE;
- SkFixed readFixed() SK_OVERRIDE;
- int32_t readInt() SK_OVERRIDE;
- SkScalar readScalar() SK_OVERRIDE;
- uint32_t readUInt() SK_OVERRIDE;
- int32_t read32() SK_OVERRIDE;
+ bool readBool() override;
+ SkColor readColor() override;
+ SkFixed readFixed() override;
+ int32_t readInt() override;
+ SkScalar readScalar() override;
+ uint32_t readUInt() override;
+ int32_t read32() override;
// strings -- the caller is responsible for freeing the string contents
- void readString(SkString* string) SK_OVERRIDE;
- void* readEncodedString(size_t* length, SkPaint::TextEncoding encoding) SK_OVERRIDE;
+ void readString(SkString* string) override;
+ void* readEncodedString(size_t* length, SkPaint::TextEncoding encoding) override;
// common data structures
- SkFlattenable* readFlattenable(SkFlattenable::Type type) SK_OVERRIDE;
- void skipFlattenable() SK_OVERRIDE;
- void readPoint(SkPoint* point) SK_OVERRIDE;
- void readMatrix(SkMatrix* matrix) SK_OVERRIDE;
- void readIRect(SkIRect* rect) SK_OVERRIDE;
- void readRect(SkRect* rect) SK_OVERRIDE;
- void readRegion(SkRegion* region) SK_OVERRIDE;
- void readPath(SkPath* path) SK_OVERRIDE;
+ SkFlattenable* readFlattenable(SkFlattenable::Type type) override;
+ void skipFlattenable() override;
+ void readPoint(SkPoint* point) override;
+ void readMatrix(SkMatrix* matrix) override;
+ void readIRect(SkIRect* rect) override;
+ void readRect(SkRect* rect) override;
+ void readRegion(SkRegion* region) override;
+ void readPath(SkPath* path) override;
// binary data and arrays
- bool readByteArray(void* value, size_t size) SK_OVERRIDE;
- bool readColorArray(SkColor* colors, size_t size) SK_OVERRIDE;
- bool readIntArray(int32_t* values, size_t size) SK_OVERRIDE;
- bool readPointArray(SkPoint* points, size_t size) SK_OVERRIDE;
- bool readScalarArray(SkScalar* values, size_t size) SK_OVERRIDE;
+ bool readByteArray(void* value, size_t size) override;
+ bool readColorArray(SkColor* colors, size_t size) override;
+ bool readIntArray(int32_t* values, size_t size) override;
+ bool readPointArray(SkPoint* points, size_t size) override;
+ bool readScalarArray(SkScalar* values, size_t size) override;
// helpers to get info about arrays and binary data
- uint32_t getArrayCount() SK_OVERRIDE;
+ uint32_t getArrayCount() override;
// TODO: Implement this (securely) when needed
- SkTypeface* readTypeface() SK_OVERRIDE;
+ SkTypeface* readTypeface() override;
- bool validate(bool isValid) SK_OVERRIDE;
- bool isValid() const SK_OVERRIDE;
+ bool validate(bool isValid) override;
+ bool isValid() const override;
- bool validateAvailable(size_t size) SK_OVERRIDE;
+ bool validateAvailable(size_t size) override;
private:
bool readArray(void* value, size_t size, size_t elementSize);
return SkNEW_ARGS(SkClearXfermode, (rec));
}
- void xfer32(SkPMColor*, const SkPMColor*, int, const SkAlpha*) const SK_OVERRIDE;
- void xferA8(SkAlpha*, const SkPMColor*, int, const SkAlpha*) const SK_OVERRIDE;
+ void xfer32(SkPMColor*, const SkPMColor*, int, const SkAlpha*) const override;
+ void xferA8(SkAlpha*, const SkPMColor*, int, const SkAlpha*) const override;
SK_TO_STRING_OVERRIDE()
return SkNEW_ARGS(SkSrcXfermode, (rec));
}
- void xfer32(SkPMColor*, const SkPMColor*, int, const SkAlpha*) const SK_OVERRIDE;
- void xferA8(SkAlpha*, const SkPMColor*, int, const SkAlpha*) const SK_OVERRIDE;
+ void xfer32(SkPMColor*, const SkPMColor*, int, const SkAlpha*) const override;
+ void xferA8(SkAlpha*, const SkPMColor*, int, const SkAlpha*) const override;
SK_TO_STRING_OVERRIDE()
return SkNEW_ARGS(SkDstInXfermode, (rec));
}
- void xfer32(SkPMColor*, const SkPMColor*, int, const SkAlpha*) const SK_OVERRIDE;
+ void xfer32(SkPMColor*, const SkPMColor*, int, const SkAlpha*) const override;
SK_TO_STRING_OVERRIDE()
return SkNEW_ARGS(SkDstOutXfermode, (rec));
}
- void xfer32(SkPMColor*, const SkPMColor*, int, const SkAlpha*) const SK_OVERRIDE;
+ void xfer32(SkPMColor*, const SkPMColor*, int, const SkAlpha*) const override;
SK_TO_STRING_OVERRIDE()
}
virtual void xfer32(SkPMColor dst[], const SkPMColor src[], int count,
- const SkAlpha aa[]) const SK_OVERRIDE;
+ const SkAlpha aa[]) const override;
virtual void xfer16(uint16_t dst[], const SkPMColor src[], int count,
- const SkAlpha aa[]) const SK_OVERRIDE;
+ const SkAlpha aa[]) const override;
virtual void xferA8(SkAlpha dst[], const SkPMColor src[], int count,
- const SkAlpha aa[]) const SK_OVERRIDE;
+ const SkAlpha aa[]) const override;
- bool asMode(Mode* mode) const SK_OVERRIDE;
+ bool asMode(Mode* mode) const override;
- bool supportsCoverageAsAlpha() const SK_OVERRIDE;
+ bool supportsCoverageAsAlpha() const override;
- bool isOpaque(SkXfermode::SrcColorOpacity opacityType) const SK_OVERRIDE;
+ bool isOpaque(SkXfermode::SrcColorOpacity opacityType) const override;
#if SK_SUPPORT_GPU
virtual bool asFragmentProcessor(GrFragmentProcessor**,
- GrTexture* background) const SK_OVERRIDE;
+ GrTexture* background) const override;
- virtual bool asXPFactory(GrXPFactory**) const SK_OVERRIDE;
+ virtual bool asXPFactory(GrXPFactory**) const override;
#endif
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkProcCoeffXfermode)
protected:
- void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer& buffer) const override;
Mode getMode() const { return fMode; }
YUVPlanesKey fKey;
YUVValue fValue;
- const Key& getKey() const SK_OVERRIDE { return fKey; }
- size_t bytesUsed() const SK_OVERRIDE { return sizeof(*this) + fValue.fData->size(); }
+ const Key& getKey() const override { return fKey; }
+ size_t bytesUsed() const override { return sizeof(*this) + fValue.fData->size(); }
static bool Visitor(const SkResourceCache::Rec& baseRec, void* contextData) {
const YUVPlanesRec& rec = static_cast<const YUVPlanesRec&>(baseRec);
protected:
virtual SkCanvas* onBeginPage(SkScalar width, SkScalar height,
- const SkRect& trimBox) SK_OVERRIDE {
+ const SkRect& trimBox) override {
SkASSERT(!fCanvas.get());
SkISize pageSize = SkISize::Make(
return fCanvas.get();
}
- void onEndPage() SK_OVERRIDE {
+ void onEndPage() override {
SkASSERT(fCanvas.get());
fCanvas->flush();
fCanvas.reset(NULL);
}
- bool onClose(SkWStream* stream) SK_OVERRIDE {
+ bool onClose(SkWStream* stream) override {
SkASSERT(!fCanvas.get());
bool success = emit_pdf_document(fPageDevices, stream);
return success;
}
- void onAbort() SK_OVERRIDE {
+ void onAbort() override {
fPageDevices.unrefAll();
fCanon.reset();
}
protected:
virtual SkCanvas* onBeginPage(SkScalar width,
SkScalar height,
- const SkRect& trimBox) SK_OVERRIDE {
+ const SkRect& trimBox) override {
fDevice.beginSheet(fUnitsPerMeter, fPixelsPerMeter,
SkSize::Make(width, height));
fCanvas.reset(SkNEW_ARGS(SkCanvas, (&fDevice)));
return fCanvas.get();
}
- void onEndPage() SK_OVERRIDE {
+ void onEndPage() override {
SkASSERT(fCanvas.get());
fCanvas->flush();
fCanvas.reset(NULL);
fDevice.endSheet();
}
- bool onClose(SkWStream*) SK_OVERRIDE {
+ bool onClose(SkWStream*) override {
SkASSERT(!fCanvas.get());
return fDevice.endPortfolio();
}
- void onAbort() SK_OVERRIDE {}
+ void onAbort() override {}
private:
SkXPSDevice fDevice;
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkAlphaThresholdFilterImpl)
protected:
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* offset) const override;
#if SK_SUPPORT_GPU
virtual bool asFragmentProcessor(GrFragmentProcessor**, GrTexture*, const SkMatrix&,
- const SkIRect& bounds) const SK_OVERRIDE;
+ const SkIRect& bounds) const override;
#endif
private:
virtual ~AlphaThresholdEffect() {};
- const char* name() const SK_OVERRIDE { return "Alpha Threshold"; }
+ const char* name() const override { return "Alpha Threshold"; }
float innerThreshold() const { return fInnerThreshold; }
float outerThreshold() const { return fOuterThreshold; }
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
private:
AlphaThresholdEffect(GrTexture* texture,
this->addTextureAccess(&fMaskTextureAccess);
}
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor&) const override;
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
}
virtual void xfer32(SkPMColor dst[], const SkPMColor src[], int count,
- const SkAlpha aa[]) const SK_OVERRIDE;
+ const SkAlpha aa[]) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkArithmeticMode_scalar)
#if SK_SUPPORT_GPU
- bool asFragmentProcessor(GrFragmentProcessor**, GrTexture* background) const SK_OVERRIDE;
+ bool asFragmentProcessor(GrFragmentProcessor**, GrTexture* background) const override;
- bool asXPFactory(GrXPFactory**) const SK_OVERRIDE;
+ bool asXPFactory(GrXPFactory**) const override;
#endif
private:
fEnforcePMColor = enforcePMColor;
}
- void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
+ void flatten(SkWriteBuffer& buffer) const override {
buffer.writeScalar(fK[0]);
buffer.writeScalar(fK[1]);
buffer.writeScalar(fK[2]);
: fEnforcePMColor(true) {
}
- ~GLArithmeticFP() SK_OVERRIDE {}
+ ~GLArithmeticFP() override {}
void emitCode(GrGLFPBuilder* builder,
const GrFragmentProcessor& fp,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray& coords,
- const TextureSamplerArray& samplers) SK_OVERRIDE {
+ const TextureSamplerArray& samplers) override {
GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
fsBuilder->codeAppend("vec4 bgColor = ");
fsBuilder->appendTextureLookup(samplers[0], coords[0].c_str(), coords[0].getType());
add_arithmetic_code(fsBuilder, inputColor, dstColor, outputColor, kUni, fEnforcePMColor);
}
- void setData(const GrGLProgramDataManager& pdman, const GrProcessor& proc) SK_OVERRIDE {
+ void setData(const GrGLProgramDataManager& pdman, const GrProcessor& proc) override {
const GrArithmeticFP& arith = proc.cast<GrArithmeticFP>();
pdman.set4f(fKUni, arith.k1(), arith.k2(), arith.k3(), arith.k4());
fEnforcePMColor = arith.enforcePMColor();
willReadDstColor));
}
- ~ArithmeticXP() SK_OVERRIDE {};
+ ~ArithmeticXP() override {};
- const char* name() const SK_OVERRIDE { return "Arithmetic"; }
+ const char* name() const override { return "Arithmetic"; }
- GrGLXferProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLXferProcessor* createGLInstance() const override;
- bool hasSecondaryOutput() const SK_OVERRIDE { return false; }
+ bool hasSecondaryOutput() const override { return false; }
GrXferProcessor::OptFlags getOptimizations(const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
bool doesStencilWrite,
GrColor* overrideColor,
- const GrDrawTargetCaps& caps) SK_OVERRIDE;
+ const GrDrawTargetCaps& caps) override;
- void getBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const SK_OVERRIDE {
+ void getBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const override {
blendInfo->fSrcBlend = kOne_GrBlendCoeff;
blendInfo->fDstBlend = kZero_GrBlendCoeff;
blendInfo->fBlendConstant = 0;
ArithmeticXP(float k1, float k2, float k3, float k4, bool enforcePMColor,
const GrDeviceCoordTexture* dstCopy, bool willReadDstColor);
- void onGetGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+ void onGetGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const override;
- bool onIsEqual(const GrXferProcessor& xpBase) const SK_OVERRIDE {
+ bool onIsEqual(const GrXferProcessor& xpBase) const override {
const ArithmeticXP& xp = xpBase.cast<ArithmeticXP>();
if (fK1 != xp.fK1 ||
fK2 != xp.fK2 ||
: fEnforcePMColor(true) {
}
- ~GLArithmeticXP() SK_OVERRIDE {}
+ ~GLArithmeticXP() override {}
static void GenKey(const GrProcessor& processor, const GrGLCaps& caps,
GrProcessorKeyBuilder* b) {
}
private:
- void onEmitCode(const EmitArgs& args) SK_OVERRIDE {
+ void onEmitCode(const EmitArgs& args) override {
GrGLFPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
const char* dstColor = fsBuilder->dstColor();
}
void onSetData(const GrGLProgramDataManager& pdman,
- const GrXferProcessor& processor) SK_OVERRIDE {
+ const GrXferProcessor& processor) override {
const ArithmeticXP& arith = processor.cast<ArithmeticXP>();
pdman.set4f(fKUni, arith.k1(), arith.k2(), arith.k3(), arith.k4());
fEnforcePMColor = arith.enforcePMColor();
return SkNEW_ARGS(GrArithmeticFP, (k1, k2, k3, k4, enforcePMColor, background));
}
- ~GrArithmeticFP() SK_OVERRIDE {};
+ ~GrArithmeticFP() override {};
- const char* name() const SK_OVERRIDE { return "Arithmetic"; }
+ const char* name() const override { return "Arithmetic"; }
- void getGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
float k1() const { return fK1; }
float k2() const { return fK2; }
bool enforcePMColor() const { return fEnforcePMColor; }
private:
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor&) const override;
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
GrArithmeticFP(float k1, float k2, float k3, float k4, bool enforcePMColor,
GrTexture* background);
return SkNEW_ARGS(GrArithmeticXPFactory, (k1, k2, k3, k4, enforcePMColor));
}
- bool supportsRGBCoverage(GrColor knownColor, uint32_t knownColorFlags) const SK_OVERRIDE {
+ bool supportsRGBCoverage(GrColor knownColor, uint32_t knownColorFlags) const override {
return true;
}
- bool canTweakAlphaForCoverage() const SK_OVERRIDE {
+ bool canTweakAlphaForCoverage() const override {
return false;
}
void getInvariantOutput(const GrProcOptInfo& colorPOI, const GrProcOptInfo& coveragePOI,
- GrXPFactory::InvariantOutput*) const SK_OVERRIDE;
+ GrXPFactory::InvariantOutput*) const override;
private:
GrArithmeticXPFactory(float k1, float k2, float k3, float k4, bool enforcePMColor);
GrXferProcessor* onCreateXferProcessor(const GrDrawTargetCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
- const GrDeviceCoordTexture* dstCopy) const SK_OVERRIDE;
+ const GrDeviceCoordTexture* dstCopy) const override;
bool willReadDstColor(const GrDrawTargetCaps& caps,
const GrProcOptInfo& colorPOI,
- const GrProcOptInfo& coveragePOI) const SK_OVERRIDE {
+ const GrProcOptInfo& coveragePOI) const override {
return true;
}
- bool onIsEqual(const GrXPFactory& xpfBase) const SK_OVERRIDE {
+ bool onIsEqual(const GrXPFactory& xpfBase) const override {
const GrArithmeticXPFactory& xpf = xpfBase.cast<GrArithmeticXPFactory>();
if (fK1 != xpf.fK1 ||
fK2 != xpf.fK2 ||
SkBlurMaskFilterImpl(SkScalar sigma, SkBlurStyle, uint32_t flags);
// overrides from SkMaskFilter
- SkMask::Format getFormat() const SK_OVERRIDE;
+ SkMask::Format getFormat() const override;
virtual bool filterMask(SkMask* dst, const SkMask& src, const SkMatrix&,
- SkIPoint* margin) const SK_OVERRIDE;
+ SkIPoint* margin) const override;
#if SK_SUPPORT_GPU
virtual bool canFilterMaskGPU(const SkRect& devBounds,
const SkIRect& clipBounds,
const SkMatrix& ctm,
- SkRect* maskRect) const SK_OVERRIDE;
+ SkRect* maskRect) const override;
virtual bool directFilterMaskGPU(GrContext* context,
GrRenderTarget* rt,
GrPaint* grp,
const GrClip&,
const SkMatrix& viewMatrix,
const SkStrokeRec& strokeRec,
- const SkPath& path) const SK_OVERRIDE;
+ const SkPath& path) const override;
virtual bool directFilterRRectMaskGPU(GrContext* context,
GrRenderTarget* rt,
GrPaint* grp,
const GrClip&,
const SkMatrix& viewMatrix,
const SkStrokeRec& strokeRec,
- const SkRRect& rrect) const SK_OVERRIDE;
+ const SkRRect& rrect) const override;
virtual bool filterMaskGPU(GrTexture* src,
const SkMatrix& ctm,
const SkRect& maskRect,
GrTexture** result,
- bool canOverwriteSrc) const SK_OVERRIDE;
+ bool canOverwriteSrc) const override;
#endif
- void computeFastBounds(const SkRect&, SkRect*) const SK_OVERRIDE;
- bool asABlur(BlurRec*) const SK_OVERRIDE;
+ void computeFastBounds(const SkRect&, SkRect*) const override;
+ bool asABlur(BlurRec*) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBlurMaskFilterImpl)
protected:
virtual FilterReturn filterRectsToNine(const SkRect[], int count, const SkMatrix&,
const SkIRect& clipBounds,
- NinePatch*) const SK_OVERRIDE;
+ NinePatch*) const override;
virtual FilterReturn filterRRectToNine(const SkRRect&, const SkMatrix&,
const SkIRect& clipBounds,
- NinePatch*) const SK_OVERRIDE;
+ NinePatch*) const override;
bool filterRectMask(SkMask* dstM, const SkRect& r, const SkMatrix& matrix,
SkIPoint* margin, SkMask::CreateMode createMode) const;
}
SkBlurMaskFilterImpl(SkReadBuffer&);
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
SkScalar computeXformedSigma(const SkMatrix& ctm) const {
bool ignoreTransform = SkToBool(fBlurFlags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag);
public:
virtual ~GrRectBlurEffect();
- const char* name() const SK_OVERRIDE { return "RectBlur"; }
+ const char* name() const override { return "RectBlur"; }
virtual void getGLProcessorKey(const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+ GrProcessorKeyBuilder* b) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
/**
* Create a simple filter effect with custom bicubic coefficients.
private:
GrRectBlurEffect(const SkRect& rect, float sigma, GrTexture *blur_profile);
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor&) const override;
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
static bool CreateBlurProfileTexture(GrContext *context, float sigma,
GrTexture **blurProfileTexture);
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
typedef GrGLProgramDataManager::UniformHandle UniformHandle;
static GrFragmentProcessor* Create(GrContext* context, float sigma, const SkRRect&);
virtual ~GrRRectBlurEffect() {};
- const char* name() const SK_OVERRIDE { return "GrRRectBlur"; }
+ const char* name() const override { return "GrRRectBlur"; }
const SkRRect& getRRect() const { return fRRect; }
float getSigma() const { return fSigma; }
virtual void getGLProcessorKey(const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+ GrProcessorKeyBuilder* b) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
private:
GrRRectBlurEffect(float sigma, const SkRRect&, GrTexture* profileTexture);
- bool onIsEqual(const GrFragmentProcessor& other) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor& other) const override;
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
SkRRect fRRect;
float fSigma;
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
GrGLProgramDataManager::UniformHandle fProxyRectUniform;
virtual ~GrColorCubeEffect();
- const char* name() const SK_OVERRIDE { return "ColorCube"; }
+ const char* name() const override { return "ColorCube"; }
virtual void getGLProcessorKey(const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+ GrProcessorKeyBuilder* b) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
int colorCubeSize() const { return fColorCubeAccess.getTexture()->width(); }
- void onComputeInvariantOutput(GrInvariantOutput*) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput*) const override;
class GLProcessor : public GrGLFragmentProcessor {
public:
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder*);
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
GrGLProgramDataManager::UniformHandle fColorCubeSizeUni;
};
private:
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE { return true; }
+ bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
GrColorCubeEffect(GrTexture* colorCube);
}
virtual void getGLProcessorKey(const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrProcessorKeyBuilder* b) const override {
GLProcessor::GenKey(*this, caps, b);
}
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ GrGLFragmentProcessor* createGLInstance() const override {
return SkNEW_ARGS(GLProcessor, (*this));
}
- const char* name() const SK_OVERRIDE { return "ModeColorFilterEffect"; }
+ const char* name() const override { return "ModeColorFilterEffect"; }
SkXfermode::Mode mode() const { return fMode; }
GrColor color() const { return fColor; }
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE {
+ const TextureSamplerArray&) override {
SkXfermode::Mode mode = fp.cast<ModeColorFilterEffect>().mode();
SkASSERT(SkXfermode::kDst_Mode != mode);
}
virtual void setData(const GrGLProgramDataManager& pdman,
- const GrProcessor& fp) SK_OVERRIDE {
+ const GrProcessor& fp) override {
if (fFilterColorUni.isValid()) {
const ModeColorFilterEffect& colorModeFilter = fp.cast<ModeColorFilterEffect>();
GrGLfloat c[4];
this->initClassID<ModeColorFilterEffect>();
}
- bool onIsEqual(const GrFragmentProcessor& other) const SK_OVERRIDE {
+ bool onIsEqual(const GrFragmentProcessor& other) const override {
const ModeColorFilterEffect& s = other.cast<ModeColorFilterEffect>();
return fMode == s.fMode && fColor == s.fColor;
}
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
SkXfermode::Mode fMode;
GrColor fColor;
public:
Src_SkModeColorFilter(SkColor color) : INHERITED(color, SkXfermode::kSrc_Mode) {}
- void filterSpan(const SkPMColor shader[], int count, SkPMColor result[]) const SK_OVERRIDE {
+ void filterSpan(const SkPMColor shader[], int count, SkPMColor result[]) const override {
sk_memset32(result, this->getPMColor(), count);
}
fColor32Proc = SkBlitRow::ColorProcFactory();
}
- void filterSpan(const SkPMColor shader[], int count, SkPMColor result[]) const SK_OVERRIDE {
+ void filterSpan(const SkPMColor shader[], int count, SkPMColor result[]) const override {
fColor32Proc(result, shader, count, this->getPMColor());
}
return SkNEW_ARGS(ColorMatrixEffect, (matrix));
}
- const char* name() const SK_OVERRIDE { return "Color Matrix"; }
+ const char* name() const override { return "Color Matrix"; }
virtual void getGLProcessorKey(const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrProcessorKeyBuilder* b) const override {
GLProcessor::GenKey(*this, caps, b);
}
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ GrGLFragmentProcessor* createGLInstance() const override {
return SkNEW_ARGS(GLProcessor, (*this));
}
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE {
+ const TextureSamplerArray&) override {
fMatrixHandle = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kMat44f_GrSLType, kDefault_GrSLPrecision,
"ColorMatrix");
}
virtual void setData(const GrGLProgramDataManager& uniManager,
- const GrProcessor& proc) SK_OVERRIDE {
+ const GrProcessor& proc) override {
const ColorMatrixEffect& cme = proc.cast<ColorMatrixEffect>();
const float* m = cme.fMatrix.fMat;
// The GL matrix is transposed from SkColorMatrix.
this->initClassID<ColorMatrixEffect>();
}
- bool onIsEqual(const GrFragmentProcessor& s) const SK_OVERRIDE {
+ bool onIsEqual(const GrFragmentProcessor& s) const override {
const ColorMatrixEffect& cme = s.cast<ColorMatrixEffect>();
return cme.fMatrix == fMatrix;
}
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE {
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
// We only bother to check whether the alpha channel will be constant. If SkColorMatrix had
// type flags it might be worth checking the other components.
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder*);
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
SkDisplacementMapEffect::ChannelSelectorType fXChannelSelector;
virtual ~GrDisplacementMapEffect();
virtual void getGLProcessorKey(const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrProcessorKeyBuilder* b) const override {
GrGLDisplacementMapEffect::GenKey(*this, caps, b);
}
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ GrGLFragmentProcessor* createGLInstance() const override {
return SkNEW_ARGS(GrGLDisplacementMapEffect, (*this));
}
{ return fYChannelSelector; }
const SkVector& scale() const { return fScale; }
- const char* name() const SK_OVERRIDE { return "DisplacementMap"; }
+ const char* name() const override { return "DisplacementMap"; }
private:
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor&) const override;
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
GrDisplacementMapEffect(SkDisplacementMapEffect::ChannelSelectorType xChannelSelector,
SkDisplacementMapEffect::ChannelSelectorType yChannelSelector,
protected:
SkDiffuseLightingImageFilter(SkLight* light, SkScalar surfaceScale,
SkScalar kd, SkImageFilter* input, const CropRect* cropRect);
- void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer& buffer) const override;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* offset) const override;
#if SK_SUPPORT_GPU
virtual bool asFragmentProcessor(GrFragmentProcessor**, GrTexture*, const SkMatrix&,
- const SkIRect& bounds) const SK_OVERRIDE;
+ const SkIRect& bounds) const override;
#endif
private:
protected:
SkSpecularLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar ks,
SkScalar shininess, SkImageFilter* input, const CropRect*);
- void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer& buffer) const override;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
+ SkBitmap* result, SkIPoint* offset) const override;
#if SK_SUPPORT_GPU
virtual bool asFragmentProcessor(GrFragmentProcessor**, GrTexture*, const SkMatrix&,
- const SkIRect& bounds) const SK_OVERRIDE;
+ const SkIRect& bounds) const override;
#endif
private:
const SkMatrix& filterMatrix() const { return fFilterMatrix; }
protected:
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor&) const override;
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE {
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
// lighting shaders are complicated. We just throw up our hands.
inout->mulByUnknownFourComponents();
}
kd));
}
- const char* name() const SK_OVERRIDE { return "DiffuseLighting"; }
+ const char* name() const override { return "DiffuseLighting"; }
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
SkScalar kd() const { return fKD; }
private:
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor&) const override;
GrDiffuseLightingEffect(GrTexture* texture,
const SkLight* light,
shininess));
}
- const char* name() const SK_OVERRIDE { return "SpecularLighting"; }
+ const char* name() const override { return "SpecularLighting"; }
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
SkScalar ks() const { return fKS; }
SkScalar shininess() const { return fShininess; }
private:
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor&) const override;
GrSpecularLightingEffect(GrTexture* texture,
const SkLight* light,
public:
virtual ~GrGLDistantLight() {}
virtual void setData(const GrGLProgramDataManager&,
- const SkLight* light) const SK_OVERRIDE;
- void emitSurfaceToLight(GrGLFPBuilder*, const char* z) SK_OVERRIDE;
+ const SkLight* light) const override;
+ void emitSurfaceToLight(GrGLFPBuilder*, const char* z) override;
private:
typedef GrGLLight INHERITED;
public:
virtual ~GrGLPointLight() {}
virtual void setData(const GrGLProgramDataManager&,
- const SkLight* light) const SK_OVERRIDE;
- void emitSurfaceToLight(GrGLFPBuilder*, const char* z) SK_OVERRIDE;
+ const SkLight* light) const override;
+ void emitSurfaceToLight(GrGLFPBuilder*, const char* z) override;
private:
typedef GrGLLight INHERITED;
public:
virtual ~GrGLSpotLight() {}
virtual void setData(const GrGLProgramDataManager&,
- const SkLight* light) const SK_OVERRIDE;
- void emitSurfaceToLight(GrGLFPBuilder*, const char* z) SK_OVERRIDE;
- void emitLightColor(GrGLFPBuilder*, const char *surfaceToLight) SK_OVERRIDE;
+ const SkLight* light) const override;
+ void emitSurfaceToLight(GrGLFPBuilder*, const char* z) override;
+ void emitLightColor(GrGLFPBuilder*, const char *surfaceToLight) override;
private:
typedef GrGLLight INHERITED;
return fDirection;
};
SkPoint3 lightColor(const SkPoint3&) const { return color(); }
- LightType type() const SK_OVERRIDE { return kDistant_LightType; }
+ LightType type() const override { return kDistant_LightType; }
const SkPoint3& direction() const { return fDirection; }
- GrGLLight* createGLLight() const SK_OVERRIDE {
+ GrGLLight* createGLLight() const override {
#if SK_SUPPORT_GPU
return SkNEW(GrGLDistantLight);
#else
return NULL;
#endif
}
- bool requiresFragmentPosition() const SK_OVERRIDE { return false; }
+ bool requiresFragmentPosition() const override { return false; }
- bool isEqual(const SkLight& other) const SK_OVERRIDE {
+ bool isEqual(const SkLight& other) const override {
if (other.type() != kDistant_LightType) {
return false;
}
SkDistantLight(const SkPoint3& direction, const SkPoint3& color)
: INHERITED(color), fDirection(direction) {
}
- SkLight* transform(const SkMatrix& matrix) const SK_OVERRIDE {
+ SkLight* transform(const SkMatrix& matrix) const override {
return new SkDistantLight(direction(), color());
}
- void onFlattenLight(SkWriteBuffer& buffer) const SK_OVERRIDE {
+ void onFlattenLight(SkWriteBuffer& buffer) const override {
writePoint3(fDirection, buffer);
}
return direction;
};
SkPoint3 lightColor(const SkPoint3&) const { return color(); }
- LightType type() const SK_OVERRIDE { return kPoint_LightType; }
+ LightType type() const override { return kPoint_LightType; }
const SkPoint3& location() const { return fLocation; }
- GrGLLight* createGLLight() const SK_OVERRIDE {
+ GrGLLight* createGLLight() const override {
#if SK_SUPPORT_GPU
return SkNEW(GrGLPointLight);
#else
return NULL;
#endif
}
- bool requiresFragmentPosition() const SK_OVERRIDE { return true; }
- bool isEqual(const SkLight& other) const SK_OVERRIDE {
+ bool requiresFragmentPosition() const override { return true; }
+ bool isEqual(const SkLight& other) const override {
if (other.type() != kPoint_LightType) {
return false;
}
return INHERITED::isEqual(other) &&
fLocation == o.fLocation;
}
- SkLight* transform(const SkMatrix& matrix) const SK_OVERRIDE {
+ SkLight* transform(const SkMatrix& matrix) const override {
SkPoint location2 = SkPoint::Make(fLocation.fX, fLocation.fY);
matrix.mapPoints(&location2, 1);
// Use X scale and Y scale on Z and average the result
protected:
SkPointLight(const SkPoint3& location, const SkPoint3& color)
: INHERITED(color), fLocation(location) {}
- void onFlattenLight(SkWriteBuffer& buffer) const SK_OVERRIDE {
+ void onFlattenLight(SkWriteBuffer& buffer) const override {
writePoint3(fLocation, buffer);
}
fConeScale = SkScalarInvert(antiAliasThreshold);
}
- SkLight* transform(const SkMatrix& matrix) const SK_OVERRIDE {
+ SkLight* transform(const SkMatrix& matrix) const override {
SkPoint location2 = SkPoint::Make(fLocation.fX, fLocation.fY);
matrix.mapPoints(&location2, 1);
// Use X scale and Y scale on Z and average the result
}
return color() * scale;
}
- GrGLLight* createGLLight() const SK_OVERRIDE {
+ GrGLLight* createGLLight() const override {
#if SK_SUPPORT_GPU
return SkNEW(GrGLSpotLight);
#else
return NULL;
#endif
}
- bool requiresFragmentPosition() const SK_OVERRIDE { return true; }
- LightType type() const SK_OVERRIDE { return kSpot_LightType; }
+ bool requiresFragmentPosition() const override { return true; }
+ LightType type() const override { return kSpot_LightType; }
const SkPoint3& location() const { return fLocation; }
const SkPoint3& target() const { return fTarget; }
SkScalar specularExponent() const { return fSpecularExponent; }
fS(s)
{
}
- void onFlattenLight(SkWriteBuffer& buffer) const SK_OVERRIDE {
+ void onFlattenLight(SkWriteBuffer& buffer) const override {
writePoint3(fLocation, buffer);
writePoint3(fTarget, buffer);
buffer.writeScalar(fSpecularExponent);
writePoint3(fS, buffer);
}
- bool isEqual(const SkLight& other) const SK_OVERRIDE {
+ bool isEqual(const SkLight& other) const override {
if (other.type() != kSpot_LightType) {
return false;
}
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder* b);
/**
* Subclasses of GrGLLightingEffect must call INHERITED::setData();
*/
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
protected:
virtual void emitLightFunc(GrGLFPBuilder*, SkString* funcName) = 0;
class GrGLDiffuseLightingEffect : public GrGLLightingEffect {
public:
GrGLDiffuseLightingEffect(const GrProcessor&);
- void emitLightFunc(GrGLFPBuilder*, SkString* funcName) SK_OVERRIDE;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void emitLightFunc(GrGLFPBuilder*, SkString* funcName) override;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
typedef GrGLLightingEffect INHERITED;
class GrGLSpecularLightingEffect : public GrGLLightingEffect {
public:
GrGLSpecularLightingEffect(const GrProcessor&);
- void emitLightFunc(GrGLFPBuilder*, SkString* funcName) SK_OVERRIDE;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void emitLightFunc(GrGLFPBuilder*, SkString* funcName) override;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
typedef GrGLLightingEffect INHERITED;
return SkRef(gLumaEffect);
}
- const char* name() const SK_OVERRIDE { return "Luminance-to-Alpha"; }
+ const char* name() const override { return "Luminance-to-Alpha"; }
virtual void getGLProcessorKey(const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrProcessorKeyBuilder* b) const override {
GLProcessor::GenKey(*this, caps, b);
}
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ GrGLFragmentProcessor* createGLInstance() const override {
return SkNEW_ARGS(GLProcessor, (*this));
}
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE {
+ const TextureSamplerArray&) override {
if (NULL == inputColor) {
inputColor = "vec4(1)";
}
this->initClassID<LumaColorFilterEffect>();
}
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE { return true; }
+ bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE {
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
// The output is always black. The alpha value for the color passed in is arbitrary.
inout->setToOther(kRGB_GrColorComponentFlags, GrColorPackRGBA(0, 0, 0, 0),
GrInvariantOutput::kWill_ReadInput);
virtual ~GrMagnifierEffect() {};
- const char* name() const SK_OVERRIDE { return "Magnifier"; }
+ const char* name() const override { return "Magnifier"; }
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
float x_offset() const { return fXOffset; }
float y_offset() const { return fYOffset; }
this->initClassID<GrMagnifierEffect>();
}
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor&) const override;
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
UniformHandle fOffsetVar;
bool useRange() const { return fUseRange; }
const float* range() const { return fRange; }
- const char* name() const SK_OVERRIDE { return "Morphology"; }
+ const char* name() const override { return "Morphology"; }
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
protected:
float fRange[2];
private:
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor&) const override;
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
GrMorphologyEffect(GrTexture*, Direction, int radius, MorphologyType);
GrMorphologyEffect(GrTexture*, Direction, int radius, MorphologyType, float bounds[2]);
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder* b);
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
int width() const { return GrMorphologyEffect::WidthFromRadius(fRadius); }
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder* b);
SkDELETE(fPaintingData);
}
- const char* name() const SK_OVERRIDE { return "PerlinNoise"; }
+ const char* name() const override { return "PerlinNoise"; }
virtual void getGLProcessorKey(const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrProcessorKeyBuilder* b) const override {
GrGLPerlinNoise::GenKey(*this, caps, b);
}
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ GrGLFragmentProcessor* createGLInstance() const override {
return SkNEW_ARGS(GrGLPerlinNoise, (*this));
}
uint8_t alpha() const { return fAlpha; }
private:
- bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
+ bool onIsEqual(const GrFragmentProcessor& sBase) const override {
const GrPerlinNoiseEffect& s = sBase.cast<GrPerlinNoiseEffect>();
return fType == s.fType &&
fPaintingData->fBaseFrequency == s.fPaintingData->fBaseFrequency &&
fPaintingData->fStitchDataInit == s.fPaintingData->fStitchDataInit;
}
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE {
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
inout->setToUnknown(GrInvariantOutput::kWillNot_ReadInput);
}
SkDELETE(fBitmap);
}
- bool asComponentTable(SkBitmap* table) const SK_OVERRIDE;
- SkColorFilter* newComposed(const SkColorFilter* inner) const SK_OVERRIDE;
+ bool asComponentTable(SkBitmap* table) const override;
+ SkColorFilter* newComposed(const SkColorFilter* inner) const override;
#if SK_SUPPORT_GPU
- bool asFragmentProcessors(GrContext*, SkTDArray<GrFragmentProcessor*>*) const SK_OVERRIDE;
+ bool asFragmentProcessors(GrContext*, SkTDArray<GrFragmentProcessor*>*) const override;
#endif
- void filterSpan(const SkPMColor src[], int count, SkPMColor dst[]) const SK_OVERRIDE;
+ void filterSpan(const SkPMColor src[], int count, SkPMColor dst[]) const override;
SK_TO_STRING_OVERRIDE()
};
protected:
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
private:
mutable const SkBitmap* fBitmap; // lazily allocated
virtual ~ColorTableEffect();
- const char* name() const SK_OVERRIDE { return "ColorTable"; }
+ const char* name() const override { return "ColorTable"; }
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
const GrTextureStripAtlas* atlas() const { return fAtlas; }
int atlasRow() const { return fRow; }
private:
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor&) const override;
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
ColorTableEffect(GrTexture* texture, GrTextureStripAtlas* atlas, int row, unsigned flags);
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
static void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder* b) {}
public:
GradientShaderBaseContext(const SkGradientShaderBase& shader, const ContextRec&);
- uint32_t getFlags() const SK_OVERRIDE { return fFlags; }
+ uint32_t getFlags() const override { return fFlags; }
protected:
SkMatrix fDstToIndex;
typedef SkShader::Context INHERITED;
};
- bool isOpaque() const SK_OVERRIDE;
+ bool isOpaque() const override;
void getGradientTableBitmap(SkBitmap*) const;
protected:
SkGradientShaderBase(SkReadBuffer& );
- void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer&) const override;
SK_TO_STRING_OVERRIDE()
const SkMatrix fPtsToUnit;
void commonAsAGradient(GradientInfo*, bool flipGrad = false) const;
- bool onAsLuminanceColor(SkColor*) const SK_OVERRIDE;
+ bool onAsLuminanceColor(SkColor*) const override;
/*
* Takes in pointers to gradient color and Rec info as colorSrc and recSrc respectively.
SkScalar** stops,
SkShader::TileMode* tm);
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor&) const override;
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
const GrCoordTransform& getCoordTransform() const { return fCoordTransform; }
GrGLGradientEffect();
virtual ~GrGLGradientEffect();
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
protected:
/**
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
static void GenKey(const GrProcessor& processor, const GrGLCaps&, GrProcessorKeyBuilder* b) {
b->add32(GenBaseGradientKey(processor));
virtual ~GrLinearGradient() { }
- const char* name() const SK_OVERRIDE { return "Linear Gradient"; }
+ const char* name() const override { return "Linear Gradient"; }
virtual void getGLProcessorKey(const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrProcessorKeyBuilder* b) const override {
GrGLLinearGradient::GenKey(*this, caps, b);
}
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ GrGLFragmentProcessor* createGLInstance() const override {
return SkNEW_ARGS(GrGLLinearGradient, (*this));
}
public:
SkLinearGradient(const SkPoint pts[2], const Descriptor&);
- size_t contextSize() const SK_OVERRIDE;
+ size_t contextSize() const override;
class LinearGradientContext : public SkGradientShaderBase::GradientShaderBaseContext {
public:
LinearGradientContext(const SkLinearGradient&, const ContextRec&);
~LinearGradientContext() {}
- void shadeSpan(int x, int y, SkPMColor dstC[], int count) SK_OVERRIDE;
- void shadeSpan16(int x, int y, uint16_t dstC[], int count) SK_OVERRIDE;
+ void shadeSpan(int x, int y, SkPMColor dstC[], int count) override;
+ void shadeSpan16(int x, int y, uint16_t dstC[], int count) override;
private:
typedef SkGradientShaderBase::GradientShaderBaseContext INHERITED;
};
- BitmapType asABitmap(SkBitmap*, SkMatrix*, TileMode*) const SK_OVERRIDE;
- GradientType asAGradient(GradientInfo* info) const SK_OVERRIDE;
+ BitmapType asABitmap(SkBitmap*, SkMatrix*, TileMode*) const override;
+ GradientType asAGradient(GradientInfo* info) const override;
virtual bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix& viewM,
const SkMatrix*,
- GrColor*, GrFragmentProcessor**) const SK_OVERRIDE;
+ GrColor*, GrFragmentProcessor**) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLinearGradient)
protected:
SkLinearGradient(SkReadBuffer& buffer);
- void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
- Context* onCreateContext(const ContextRec&, void* storage) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer& buffer) const override;
+ Context* onCreateContext(const ContextRec&, void* storage) const override;
private:
friend class SkGradientShader;
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
static void GenKey(const GrProcessor& processor, const GrGLCaps&, GrProcessorKeyBuilder* b) {
b->add32(GenBaseGradientKey(processor));
virtual ~GrRadialGradient() { }
- const char* name() const SK_OVERRIDE { return "Radial Gradient"; }
+ const char* name() const override { return "Radial Gradient"; }
virtual void getGLProcessorKey(const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrProcessorKeyBuilder* b) const override {
GrGLRadialGradient::GenKey(*this, caps, b);
}
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ GrGLFragmentProcessor* createGLInstance() const override {
return SkNEW_ARGS(GrGLRadialGradient, (*this));
}
public:
SkRadialGradient(const SkPoint& center, SkScalar radius, const Descriptor&);
- size_t contextSize() const SK_OVERRIDE;
+ size_t contextSize() const override;
class RadialGradientContext : public SkGradientShaderBase::GradientShaderBaseContext {
public:
RadialGradientContext(const SkRadialGradient&, const ContextRec&);
- void shadeSpan(int x, int y, SkPMColor dstC[], int count) SK_OVERRIDE;
- void shadeSpan16(int x, int y, uint16_t dstC[], int count) SK_OVERRIDE;
+ void shadeSpan(int x, int y, SkPMColor dstC[], int count) override;
+ void shadeSpan16(int x, int y, uint16_t dstC[], int count) override;
private:
typedef SkGradientShaderBase::GradientShaderBaseContext INHERITED;
virtual BitmapType asABitmap(SkBitmap* bitmap,
SkMatrix* matrix,
- TileMode* xy) const SK_OVERRIDE;
- GradientType asAGradient(GradientInfo* info) const SK_OVERRIDE;
+ TileMode* xy) const override;
+ GradientType asAGradient(GradientInfo* info) const override;
virtual bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix& viewM,
const SkMatrix*, GrColor*,
- GrFragmentProcessor**) const SK_OVERRIDE;
+ GrFragmentProcessor**) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkRadialGradient)
protected:
SkRadialGradient(SkReadBuffer& buffer);
- void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
- Context* onCreateContext(const ContextRec&, void* storage) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer& buffer) const override;
+ Context* onCreateContext(const ContextRec&, void* storage) const override;
private:
friend class SkGradientShader;
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
static void GenKey(const GrProcessor& processor, const GrGLCaps&, GrProcessorKeyBuilder* b) {
b->add32(GenBaseGradientKey(processor));
}
virtual ~GrSweepGradient() { }
- const char* name() const SK_OVERRIDE { return "Sweep Gradient"; }
+ const char* name() const override { return "Sweep Gradient"; }
virtual void getGLProcessorKey(const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrProcessorKeyBuilder* b) const override {
GrGLSweepGradient::GenKey(*this, caps, b);
}
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ GrGLFragmentProcessor* createGLInstance() const override {
return SkNEW_ARGS(GrGLSweepGradient, (*this));
}
public:
SkSweepGradient(SkScalar cx, SkScalar cy, const Descriptor&);
- size_t contextSize() const SK_OVERRIDE;
+ size_t contextSize() const override;
class SweepGradientContext : public SkGradientShaderBase::GradientShaderBaseContext {
public:
SweepGradientContext(const SkSweepGradient& shader, const ContextRec&);
- void shadeSpan(int x, int y, SkPMColor dstC[], int count) SK_OVERRIDE;
- void shadeSpan16(int x, int y, uint16_t dstC[], int count) SK_OVERRIDE;
+ void shadeSpan(int x, int y, SkPMColor dstC[], int count) override;
+ void shadeSpan16(int x, int y, uint16_t dstC[], int count) override;
private:
typedef SkGradientShaderBase::GradientShaderBaseContext INHERITED;
virtual BitmapType asABitmap(SkBitmap* bitmap,
SkMatrix* matrix,
- TileMode* xy) const SK_OVERRIDE;
+ TileMode* xy) const override;
- GradientType asAGradient(GradientInfo* info) const SK_OVERRIDE;
+ GradientType asAGradient(GradientInfo* info) const override;
virtual bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix& viewM,
const SkMatrix*, GrColor*,
- GrFragmentProcessor**) const SK_OVERRIDE;
+ GrFragmentProcessor**) const override;
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSweepGradient)
protected:
- void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
- Context* onCreateContext(const ContextRec&, void* storage) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer& buffer) const override;
+ Context* onCreateContext(const ContextRec&, void* storage) const override;
private:
const SkPoint fCenter;
bool flippedGrad, const Descriptor&);
- size_t contextSize() const SK_OVERRIDE;
+ size_t contextSize() const override;
class TwoPointConicalGradientContext : public SkGradientShaderBase::GradientShaderBaseContext {
public:
TwoPointConicalGradientContext(const SkTwoPointConicalGradient&, const ContextRec&);
~TwoPointConicalGradientContext() {}
- void shadeSpan(int x, int y, SkPMColor dstC[], int count) SK_OVERRIDE;
+ void shadeSpan(int x, int y, SkPMColor dstC[], int count) override;
private:
typedef SkGradientShaderBase::GradientShaderBaseContext INHERITED;
virtual BitmapType asABitmap(SkBitmap* bitmap,
SkMatrix* matrix,
- TileMode* xy) const SK_OVERRIDE;
- SkShader::GradientType asAGradient(GradientInfo* info) const SK_OVERRIDE;
+ TileMode* xy) const override;
+ SkShader::GradientType asAGradient(GradientInfo* info) const override;
virtual bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&, const SkMatrix*,
- GrColor*, GrFragmentProcessor**) const SK_OVERRIDE;
- bool isOpaque() const SK_OVERRIDE;
+ GrColor*, GrFragmentProcessor**) const override;
+ bool isOpaque() const override;
SkScalar getCenterX1() const { return SkPoint::Distance(fCenter1, fCenter2); }
SkScalar getStartRadius() const { return fRadius1; }
protected:
SkTwoPointConicalGradient(SkReadBuffer& buffer);
- void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
- Context* onCreateContext(const ContextRec&, void* storage) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer& buffer) const override;
+ Context* onCreateContext(const ContextRec&, void* storage) const override;
private:
SkPoint fCenter1;
virtual ~Edge2PtConicalEffect() {}
- const char* name() const SK_OVERRIDE {
+ const char* name() const override {
return "Two-Point Conical Gradient Edge Touching";
}
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
// The radial gradient parameters can collapse to a linear (instead of quadratic) equation.
SkScalar center() const { return fCenterX1; }
SkScalar radius() const { return fRadius0; }
private:
- bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
+ bool onIsEqual(const GrFragmentProcessor& sBase) const override {
const Edge2PtConicalEffect& s = sBase.cast<Edge2PtConicalEffect>();
return (INHERITED::onIsEqual(sBase) &&
this->fCenterX1 == s.fCenterX1 &&
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);
virtual ~FocalOutside2PtConicalEffect() { }
- const char* name() const SK_OVERRIDE {
+ const char* name() const override {
return "Two-Point Conical Gradient Focal Outside";
}
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
bool isFlipped() const { return fIsFlipped; }
SkScalar focal() const { return fFocalX; }
private:
- bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
+ bool onIsEqual(const GrFragmentProcessor& sBase) const override {
const FocalOutside2PtConicalEffect& s = sBase.cast<FocalOutside2PtConicalEffect>();
return (INHERITED::onIsEqual(sBase) &&
this->fFocalX == s.fFocalX &&
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);
virtual ~FocalInside2PtConicalEffect() {}
- const char* name() const SK_OVERRIDE {
+ const char* name() const override {
return "Two-Point Conical Gradient Focal Inside";
}
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
SkScalar focal() const { return fFocalX; }
typedef GLFocalInside2PtConicalEffect GLProcessor;
private:
- bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
+ bool onIsEqual(const GrFragmentProcessor& sBase) const override {
const FocalInside2PtConicalEffect& s = sBase.cast<FocalInside2PtConicalEffect>();
return (INHERITED::onIsEqual(sBase) &&
this->fFocalX == s.fFocalX);
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);
virtual ~CircleInside2PtConicalEffect() {}
- const char* name() const SK_OVERRIDE { return "Two-Point Conical Gradient Inside"; }
+ const char* name() const override { return "Two-Point Conical Gradient Inside"; }
virtual void getGLProcessorKey(const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+ GrProcessorKeyBuilder* b) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
SkScalar centerX() const { return fInfo.fCenterEnd.fX; }
SkScalar centerY() const { return fInfo.fCenterEnd.fY; }
SkScalar C() const { return fInfo.fC; }
private:
- bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
+ bool onIsEqual(const GrFragmentProcessor& sBase) const override {
const CircleInside2PtConicalEffect& s = sBase.cast<CircleInside2PtConicalEffect>();
return (INHERITED::onIsEqual(sBase) &&
this->fInfo.fCenterEnd == s.fInfo.fCenterEnd &&
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);
virtual ~CircleOutside2PtConicalEffect() {}
- const char* name() const SK_OVERRIDE { return "Two-Point Conical Gradient Outside"; }
+ const char* name() const override { return "Two-Point Conical Gradient Outside"; }
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
SkScalar centerX() const { return fInfo.fCenterEnd.fX; }
SkScalar centerY() const { return fInfo.fCenterEnd.fY; }
bool isFlipped() const { return fIsFlipped; }
private:
- bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
+ bool onIsEqual(const GrFragmentProcessor& sBase) const override {
const CircleOutside2PtConicalEffect& s = sBase.cast<CircleOutside2PtConicalEffect>();
return (INHERITED::onIsEqual(sBase) &&
this->fInfo.fCenterEnd == s.fInfo.fCenterEnd &&
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);
virtual ~GrRadial2Gradient() { }
- const char* name() const SK_OVERRIDE { return "Two-Point Radial Gradient"; }
+ const char* name() const override { return "Two-Point Radial Gradient"; }
virtual void getGLProcessorKey(const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrProcessorKeyBuilder* b) const override {
GrGLRadial2Gradient::GenKey(*this, caps, b);
}
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ GrGLFragmentProcessor* createGLInstance() const override {
return SkNEW_ARGS(GrGLRadial2Gradient, (*this));
}
bool isPosRoot() const { return SkToBool(fPosRoot); }
private:
- bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
+ bool onIsEqual(const GrFragmentProcessor& sBase) const override {
const GrRadial2Gradient& s = sBase.cast<GrRadial2Gradient>();
return (INHERITED::onIsEqual(sBase) &&
this->fCenterX1 == s.fCenterX1 &&
virtual BitmapType asABitmap(SkBitmap* bitmap,
SkMatrix* matrix,
- TileMode* xy) const SK_OVERRIDE;
- GradientType asAGradient(GradientInfo* info) const SK_OVERRIDE;
+ TileMode* xy) const override;
+ GradientType asAGradient(GradientInfo* info) const override;
virtual bool asFragmentProcessor(GrContext* context, const SkPaint&, const SkMatrix& viewM,
const SkMatrix*, GrColor*,
- GrFragmentProcessor**) const SK_OVERRIDE;
+ GrFragmentProcessor**) const override;
- size_t contextSize() const SK_OVERRIDE;
+ size_t contextSize() const override;
class TwoPointRadialGradientContext : public SkGradientShaderBase::GradientShaderBaseContext {
public:
TwoPointRadialGradientContext(const SkTwoPointRadialGradient&, const ContextRec&);
- void shadeSpan(int x, int y, SkPMColor dstC[], int count) SK_OVERRIDE;
+ void shadeSpan(int x, int y, SkPMColor dstC[], int count) override;
private:
typedef SkGradientShaderBase::GradientShaderBaseContext INHERITED;
protected:
SkTwoPointRadialGradient(SkReadBuffer& buffer);
- void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
- Context* onCreateContext(const ContextRec&, void* storage) const SK_OVERRIDE;
+ void flatten(SkWriteBuffer& buffer) const override;
+ Context* onCreateContext(const ContextRec&, void* storage) const override;
private:
const SkPoint fCenter1;
SkFontStyleSet_FC(FcPattern** matches, int count);
virtual ~SkFontStyleSet_FC();
- int count() SK_OVERRIDE { return fRecCount; }
- void getStyle(int index, SkFontStyle*, SkString* style) SK_OVERRIDE;
- SkTypeface* createTypeface(int index) SK_OVERRIDE;
- SkTypeface* matchStyle(const SkFontStyle& pattern) SK_OVERRIDE;
+ int count() override { return fRecCount; }
+ void getStyle(int index, SkFontStyle*, SkString* style) override;
+ SkTypeface* createTypeface(int index) override;
+ SkTypeface* matchStyle(const SkFontStyle& pattern) override;
private:
struct Rec {
}
protected:
- int onCountFamilies() const SK_OVERRIDE {
+ int onCountFamilies() const override {
return fFamilyNames->count();
}
- void onGetFamilyName(int index, SkString* familyName) const SK_OVERRIDE {
+ void onGetFamilyName(int index, SkString* familyName) const override {
familyName->set(fFamilyNames->atStr(index));
}
- SkFontStyleSet* onCreateStyleSet(int index) const SK_OVERRIDE {
+ SkFontStyleSet* onCreateStyleSet(int index) const override {
return this->onMatchFamily(fFamilyNames->atStr(index));
}
- SkFontStyleSet* onMatchFamily(const char familyName[]) const SK_OVERRIDE {
+ SkFontStyleSet* onMatchFamily(const char familyName[]) const override {
FCLocker lock;
FcPattern* pattern = FcPatternCreate();
}
virtual SkTypeface* onMatchFamilyStyle(const char familyName[],
- const SkFontStyle&) const SK_OVERRIDE { return NULL; }
+ const SkFontStyle&) const override { return NULL; }
virtual SkTypeface* onMatchFamilyStyleCharacter(const char familyName[], const SkFontStyle&,
const char* bcp47[], int bcp47Count,
- SkUnichar character) const SK_OVERRIDE {
+ SkUnichar character) const override {
return NULL;
}
virtual SkTypeface* onMatchFaceStyle(const SkTypeface*,
- const SkFontStyle&) const SK_OVERRIDE { return NULL; }
+ const SkFontStyle&) const override { return NULL; }
- SkTypeface* onCreateFromData(SkData*, int ttcIndex) const SK_OVERRIDE { return NULL; }
+ SkTypeface* onCreateFromData(SkData*, int ttcIndex) const override { return NULL; }
- SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const SK_OVERRIDE {
+ SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const override {
SkAutoTDelete<SkStreamAsset> stream(bareStream);
const size_t length = stream->getLength();
if (!length) {
return face;
}
- SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const SK_OVERRIDE {
+ SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override {
SkAutoTDelete<SkStreamAsset> stream(SkStream::NewFromFile(path));
return stream.get() ? this->createFromStream(stream.detach(), ttcIndex) : NULL;
}
virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
- unsigned styleBits) const SK_OVERRIDE {
+ unsigned styleBits) const override {
FCLocker lock;
return FontConfigTypeface::LegacyCreateTypeface(familyName, (SkTypeface::Style)styleBits);
}
: fOwner(SkRef(owner)), fFamilyIndex(familyIndex), fData(data)
{ }
- int count() SK_OVERRIDE { return fData->count(); }
+ int count() override { return fData->count(); }
- void getStyle(int index, SkFontStyle* fs, SkString* style) SK_OVERRIDE {
+ void getStyle(int index, SkFontStyle* fs, SkString* style) override {
if (fs) {
*fs = fData->at(index).fFontStyle;
}
}
}
- SkTypeface* createTypeface(int index) SK_OVERRIDE {
+ SkTypeface* createTypeface(int index) override {
return fOwner->createTypefaceFromFontId(fData->at(index));
}
- SkTypeface* matchStyle(const SkFontStyle& pattern) SK_OVERRIDE {
+ SkTypeface* matchStyle(const SkFontStyle& pattern) override {
if (fFamilyIndex >= 0) {
SkFontIdentity id = fOwner->fProxy->matchIndexStyle(fFamilyIndex, pattern);
return fOwner->createTypefaceFromFontId(id);
virtual ~SkGScalerContext();
protected:
- unsigned generateGlyphCount() SK_OVERRIDE;
- uint16_t generateCharToGlyph(SkUnichar) SK_OVERRIDE;
- void generateAdvance(SkGlyph*) SK_OVERRIDE;
- void generateMetrics(SkGlyph*) SK_OVERRIDE;
- void generateImage(const SkGlyph&) SK_OVERRIDE;
- void generatePath(const SkGlyph&, SkPath*) SK_OVERRIDE;
- void generateFontMetrics(SkPaint::FontMetrics*) SK_OVERRIDE;
+ unsigned generateGlyphCount() override;
+ uint16_t generateCharToGlyph(SkUnichar) override;
+ void generateAdvance(SkGlyph*) override;
+ void generateMetrics(SkGlyph*) override;
+ void generateImage(const SkGlyph&) override;
+ void generatePath(const SkGlyph&, SkPath*) override;
+ void generateFontMetrics(SkPaint::FontMetrics*) override;
private:
SkGTypeface* fFace;
const SkPaint& paint() const { return fPaint; }
protected:
- SkScalerContext* onCreateScalerContext(const SkDescriptor*) const SK_OVERRIDE;
- void onFilterRec(SkScalerContextRec*) const SK_OVERRIDE;
+ SkScalerContext* onCreateScalerContext(const SkDescriptor*) const override;
+ void onFilterRec(SkScalerContextRec*) const override;
virtual SkAdvancedTypefaceMetrics* onGetAdvancedTypefaceMetrics(
SkAdvancedTypefaceMetrics::PerGlyphInfo,
const uint32_t* glyphIDs,
- uint32_t glyphIDsCount) const SK_OVERRIDE;
- SkStreamAsset* onOpenStream(int* ttcIndex) const SK_OVERRIDE;
- void onGetFontDescriptor(SkFontDescriptor*, bool* isLocal) const SK_OVERRIDE;
+ uint32_t glyphIDsCount) const override;
+ SkStreamAsset* onOpenStream(int* ttcIndex) const override;
+ void onGetFontDescriptor(SkFontDescriptor*, bool* isLocal) const override;
virtual int onCharsToGlyphs(const void* chars, Encoding encoding,
- uint16_t glyphs[], int glyphCount) const SK_OVERRIDE;
- int onCountGlyphs() const SK_OVERRIDE;
- int onGetUPEM() const SK_OVERRIDE;
+ uint16_t glyphs[], int glyphCount) const override;
+ int onCountGlyphs() const override;
+ int onGetUPEM() const override;
- void onGetFamilyName(SkString* familyName) const SK_OVERRIDE;
- SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const SK_OVERRIDE;
+ void onGetFamilyName(SkString* familyName) const override;
+ SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const override;
- int onGetTableTags(SkFontTableTag tags[]) const SK_OVERRIDE;
+ int onGetTableTags(SkFontTableTag tags[]) const override;
virtual size_t onGetTableData(SkFontTableTag, size_t offset,
- size_t length, void* data) const SK_OVERRIDE;
+ size_t length, void* data) const override;
private:
SkTypeface* fProxy;
}
protected:
- unsigned generateGlyphCount() SK_OVERRIDE {
+ unsigned generateGlyphCount() override {
return fFace->onCountGlyphs();
}
- uint16_t generateCharToGlyph(SkUnichar uni) SK_OVERRIDE {
+ uint16_t generateCharToGlyph(SkUnichar uni) override {
uint16_t glyph;
(void) fFace->onCharsToGlyphs((const void *) &uni, SkTypeface::kUTF16_Encoding, &glyph, 1);
return glyph;
}
- void generateAdvance(SkGlyph* glyph) SK_OVERRIDE {
+ void generateAdvance(SkGlyph* glyph) override {
fFace->getAdvance(glyph);
const SkVector advance = fMatrix.mapXY(SkFixedToScalar(glyph->fAdvanceX),
glyph->fAdvanceY = SkScalarToFixed(advance.fY);
}
- void generateMetrics(SkGlyph* glyph) SK_OVERRIDE {
+ void generateMetrics(SkGlyph* glyph) override {
fFace->getMetrics(glyph);
const SkVector advance = fMatrix.mapXY(SkFixedToScalar(glyph->fAdvanceX),
glyph->fMaskFormat = SkMask::kARGB32_Format;
}
- void generateImage(const SkGlyph& glyph) SK_OVERRIDE {
+ void generateImage(const SkGlyph& glyph) override {
SkPath path;
fFace->getPath(glyph, &path);
canvas.drawPath(path, paint);
}
- void generatePath(const SkGlyph& glyph, SkPath* path) SK_OVERRIDE {
+ void generatePath(const SkGlyph& glyph, SkPath* path) override {
fFace->getPath(glyph, path);
path->transform(fMatrix);
}
- void generateFontMetrics(SkPaint::FontMetrics* metrics) SK_OVERRIDE {
+ void generateFontMetrics(SkPaint::FontMetrics* metrics) override {
fFace->getFontMetrics(metrics);
if (metrics) {
SkScalar scale = fMatrix.getScaleY();
void getMetrics(SkGlyph* glyph);
void getPath(const SkGlyph& glyph, SkPath* path);
protected:
- SkScalerContext* onCreateScalerContext(const SkDescriptor* desc) const SK_OVERRIDE;
- void onFilterRec(SkScalerContextRec* rec) const SK_OVERRIDE;
+ SkScalerContext* onCreateScalerContext(const SkDescriptor* desc) const override;
+ void onFilterRec(SkScalerContextRec* rec) const override;
virtual SkAdvancedTypefaceMetrics* onGetAdvancedTypefaceMetrics(
SkAdvancedTypefaceMetrics::PerGlyphInfo ,
const uint32_t* glyphIDs,
- uint32_t glyphIDsCount) const SK_OVERRIDE;
+ uint32_t glyphIDsCount) const override;
- SkStreamAsset* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
+ SkStreamAsset* onOpenStream(int* ttcIndex) const override {
SkASSERT(0); // don't expect to get here
return NULL;
}
- void onGetFontDescriptor(SkFontDescriptor* desc, bool* isLocal) const SK_OVERRIDE;
+ void onGetFontDescriptor(SkFontDescriptor* desc, bool* isLocal) const override;
virtual int onCharsToGlyphs(const void* chars, Encoding encoding,
- uint16_t glyphs[], int glyphCount) const SK_OVERRIDE;
+ uint16_t glyphs[], int glyphCount) const override;
- int onCountGlyphs() const SK_OVERRIDE {
+ int onCountGlyphs() const override {
return (int) fTestFont->fCharCodesCount;
}
- int onGetUPEM() const SK_OVERRIDE {
+ int onGetUPEM() const override {
SkASSERT(0); // don't expect to get here
return 1;
}
- void onGetFamilyName(SkString* familyName) const SK_OVERRIDE;
- SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const SK_OVERRIDE;
+ void onGetFamilyName(SkString* familyName) const override;
+ SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const override;
- int onGetTableTags(SkFontTableTag tags[]) const SK_OVERRIDE {
+ int onGetTableTags(SkFontTableTag tags[]) const override {
return 0;
}
virtual size_t onGetTableData(SkFontTableTag tag, size_t offset,
- size_t length, void* data) const SK_OVERRIDE {
+ size_t length, void* data) const override {
return 0;
}
private:
virtual ~QuadEdgeEffect() {}
- const char* name() const SK_OVERRIDE { return "QuadEdge"; }
+ const char* name() const override { return "QuadEdge"; }
const Attribute* inPosition() const { return fInPosition; }
const Attribute* inQuadEdge() const { return fInQuadEdge; }
const GrBatchTracker&)
: fColor(GrColor_ILLEGAL) {}
- void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) SK_OVERRIDE {
+ void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
const QuadEdgeEffect& qe = args.fGP.cast<QuadEdgeEffect>();
GrGLGPBuilder* pb = args.fPB;
GrGLVertexBuilder* vsBuilder = pb->getVertexShaderBuilder();
virtual void setData(const GrGLProgramDataManager& pdman,
const GrPrimitiveProcessor& gp,
- const GrBatchTracker& bt) SK_OVERRIDE {
+ const GrBatchTracker& bt) override {
this->setUniformViewMatrix(pdman, gp.viewMatrix());
const BatchTracker& local = bt.cast<BatchTracker>();
virtual void getGLProcessorKey(const GrBatchTracker& bt,
const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrProcessorKeyBuilder* b) const override {
GLProcessor::GenKey(*this, bt, caps, b);
}
virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
- const GrGLCaps&) const SK_OVERRIDE {
+ const GrGLCaps&) const override {
return SkNEW_ARGS(GLProcessor, (*this, bt));
}
- void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const SK_OVERRIDE {
+ void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override {
BatchTracker* local = bt->cast<BatchTracker>();
local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false);
local->fUsesLocalCoords = init.fUsesLocalCoords;
bool onCanMakeEqual(const GrBatchTracker& m,
const GrGeometryProcessor& that,
- const GrBatchTracker& t) const SK_OVERRIDE {
+ const GrBatchTracker& t) const override {
const BatchTracker& mine = m.cast<BatchTracker>();
const BatchTracker& theirs = t.cast<BatchTracker>();
return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
fInQuadEdge = &this->addVertexAttrib(Attribute("inQuadEdge", kVec4f_GrVertexAttribType));
}
- bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE {
+ bool onIsEqual(const GrGeometryProcessor& other) const override {
return true;
}
- void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setUnknownSingleComponent();
}
return SkNEW_ARGS(AAConvexPathBatch, (geometry));
}
- const char* name() const SK_OVERRIDE { return "AAConvexBatch"; }
+ const char* name() const override { return "AAConvexBatch"; }
- void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
// When this is called on a batch, there is only one geometry bundle
out->setKnownFourComponents(fGeoData[0].fColor);
}
- void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setUnknownSingleComponent();
}
- void initBatchTracker(const GrPipelineInfo& init) SK_OVERRIDE {
+ void initBatchTracker(const GrPipelineInfo& init) override {
// Handle any color overrides
if (init.fColorIgnored) {
fGeoData[0].fColor = GrColor_ILLEGAL;
fBatch.fCoverageIgnored = init.fCoverageIgnored;
}
- void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE {
+ void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
int instanceCount = fGeoData.count();
SkMatrix invert;
fGeoData.push_back(geometry);
}
- bool onCombineIfPossible(GrBatch* t) SK_OVERRIDE {
+ bool onCombineIfPossible(GrBatch* t) override {
AAConvexPathBatch* that = t->cast<AAConvexPathBatch>();
if (this->color() != that->color()) {
const SkMatrix& viewMatrix,
const SkPath&,
const SkStrokeRec&,
- bool antiAlias) const SK_OVERRIDE;
+ bool antiAlias) const override;
protected:
virtual bool onDrawPath(GrDrawTarget*,
const SkMatrix& viewMatrix,
const SkPath&,
const SkStrokeRec&,
- bool antiAlias) SK_OVERRIDE;
+ bool antiAlias) override;
};
#endif
atlas, pathCache, pathList));
}
- const char* name() const SK_OVERRIDE { return "AADistanceFieldPathBatch"; }
+ const char* name() const override { return "AADistanceFieldPathBatch"; }
- void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
out->setKnownFourComponents(fBatch.fColor);
}
- void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setUnknownSingleComponent();
}
- void initBatchTracker(const GrPipelineInfo& init) SK_OVERRIDE {
+ void initBatchTracker(const GrPipelineInfo& init) override {
// Handle any color overrides
if (init.fColorIgnored) {
fBatch.fColor = GrColor_ILLEGAL;
fBatch.fCoverageIgnored = init.fCoverageIgnored;
}
- void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE {
+ void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
int instanceCount = fGeoData.count();
SkMatrix invert;
const SkMatrix& viewMatrix() const { return fBatch.fViewMatrix; }
bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
- bool onCombineIfPossible(GrBatch* t) SK_OVERRIDE {
+ bool onCombineIfPossible(GrBatch* t) override {
AADistanceFieldPathBatch* that = t->cast<AADistanceFieldPathBatch>();
// TODO we could actually probably do a bunch of this work on the CPU, ie map viewMatrix,
const SkMatrix& viewMatrix,
const SkPath&,
const SkStrokeRec&,
- bool antiAlias) const SK_OVERRIDE;
+ bool antiAlias) const override;
protected:
virtual StencilSupport onGetStencilSupport(const GrDrawTarget*,
const GrPipelineBuilder*,
const SkPath&,
- const SkStrokeRec&) const SK_OVERRIDE;
+ const SkStrokeRec&) const override;
virtual bool onDrawPath(GrDrawTarget*,
GrPipelineBuilder*,
const SkMatrix& viewMatrix,
const SkPath&,
const SkStrokeRec&,
- bool antiAlias) SK_OVERRIDE;
+ bool antiAlias) override;
private:
struct PathData {
return SkNEW_ARGS(AAHairlineBatch, (geometry, linesIndexBuffer, quadsIndexBuffer));
}
- const char* name() const SK_OVERRIDE { return "AAHairlineBatch"; }
+ const char* name() const override { return "AAHairlineBatch"; }
- void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
// When this is called on a batch, there is only one geometry bundle
out->setKnownFourComponents(fGeoData[0].fColor);
}
- void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setUnknownSingleComponent();
}
- void initBatchTracker(const GrPipelineInfo& init) SK_OVERRIDE {
+ void initBatchTracker(const GrPipelineInfo& init) override {
// Handle any color overrides
if (init.fColorIgnored) {
fGeoData[0].fColor = GrColor_ILLEGAL;
SkDEBUGCODE(fBatch.fDevBounds = fGeoData[0].fDevBounds;)
}
- void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE;
+ void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override;
SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
fGeoData.push_back(geometry);
}
- bool onCombineIfPossible(GrBatch* t) SK_OVERRIDE {
+ bool onCombineIfPossible(GrBatch* t) override {
AAHairlineBatch* that = t->cast<AAHairlineBatch>();
if (this->viewMatrix().hasPerspective() != that->viewMatrix().hasPerspective()) {
const SkMatrix& viewMatrix,
const SkPath&,
const SkStrokeRec&,
- bool antiAlias) const SK_OVERRIDE;
+ bool antiAlias) const override;
typedef SkTArray<SkPoint, true> PtArray;
typedef SkTArray<int, true> IntArray;
const SkMatrix& viewMatrix,
const SkPath&,
const SkStrokeRec&,
- bool antiAlias) SK_OVERRIDE;
+ bool antiAlias) override;
private:
GrAAHairLinePathRenderer(const GrContext* context,
return SkNEW_ARGS(AAFillRectBatch, (geometry, indexBuffer));
}
- const char* name() const SK_OVERRIDE { return "AAFillRectBatch"; }
+ const char* name() const override { return "AAFillRectBatch"; }
- void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
// When this is called on a batch, there is only one geometry bundle
out->setKnownFourComponents(fGeoData[0].fColor);
}
- void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setUnknownSingleComponent();
}
- void initBatchTracker(const GrPipelineInfo& init) SK_OVERRIDE {
+ void initBatchTracker(const GrPipelineInfo& init) override {
// Handle any color overrides
if (init.fColorIgnored) {
fGeoData[0].fColor = GrColor_ILLEGAL;
fBatch.fCanTweakAlphaForCoverage = init.fCanTweakAlphaForCoverage;
}
- void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE {
+ void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
bool canTweakAlphaForCoverage = this->canTweakAlphaForCoverage();
SkMatrix localMatrix;
bool colorIgnored() const { return fBatch.fColorIgnored; }
const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
- bool onCombineIfPossible(GrBatch* t) SK_OVERRIDE {
+ bool onCombineIfPossible(GrBatch* t) override {
AAFillRectBatch* that = t->cast<AAFillRectBatch>();
SkASSERT(this->usesLocalCoords() == that->usesLocalCoords());
return SkNEW_ARGS(AAStrokeRectBatch, (geometry, viewMatrix, indexBuffer));
}
- const char* name() const SK_OVERRIDE { return "AAStrokeRect"; }
+ const char* name() const override { return "AAStrokeRect"; }
- void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
// When this is called on a batch, there is only one geometry bundle
out->setKnownFourComponents(fGeoData[0].fColor);
}
- void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setUnknownSingleComponent();
}
- void initBatchTracker(const GrPipelineInfo& init) SK_OVERRIDE {
+ void initBatchTracker(const GrPipelineInfo& init) override {
// Handle any color overrides
if (init.fColorIgnored) {
fGeoData[0].fColor = GrColor_ILLEGAL;
fBatch.fCanTweakAlphaForCoverage = init.fCanTweakAlphaForCoverage;
}
- void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE {
+ void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
bool canTweakAlphaForCoverage = this->canTweakAlphaForCoverage();
// Local matrix is ignored if we don't have local coords. If we have localcoords we only
const SkMatrix& viewMatrix() const { return fBatch.fViewMatrix; }
bool miterStroke() const { return fBatch.fMiterStroke; }
- bool onCombineIfPossible(GrBatch* t) SK_OVERRIDE {
+ bool onCombineIfPossible(GrBatch* t) override {
AAStrokeRectBatch* that = t->cast<AAStrokeRectBatch>();
// TODO batch across miterstroke changes
SkASSERT(plot);
}
- void upload(GrBatchTarget::TextureUploader uploader) SK_OVERRIDE {
+ void upload(GrBatchTarget::TextureUploader uploader) override {
fPlot->uploadToTexture(uploader);
}
GrBitmapTextContext(GrContext*, SkGpuDevice*, const SkDeviceProperties&);
bool canDraw(const GrRenderTarget*, const GrClip&, const GrPaint&,
- const SkPaint&, const SkMatrix& viewMatrix) SK_OVERRIDE;
+ const SkPaint&, const SkMatrix& viewMatrix) override;
void onDrawText(GrRenderTarget*, const GrClip&, const GrPaint&, const SkPaint&,
const SkMatrix& viewMatrix, const char text[], size_t byteLength,
- SkScalar x, SkScalar y, const SkIRect& regionClipBounds) SK_OVERRIDE;
+ SkScalar x, SkScalar y, const SkIRect& regionClipBounds) override;
void onDrawPosText(GrRenderTarget*, const GrClip&, const GrPaint&, const SkPaint&,
const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
const SkScalar pos[], int scalarsPerPosition,
- const SkPoint& offset, const SkIRect& regionClipBounds) SK_OVERRIDE;
+ const SkPoint& offset, const SkIRect& regionClipBounds) override;
void init(GrRenderTarget*, const GrClip&, const GrPaint&, const SkPaint&,
const SkIRect& regionClipBounds);
return SkNEW_ARGS(StrokeRectBatch, (geometry));
}
- const char* name() const SK_OVERRIDE { return "StrokeRectBatch"; }
+ const char* name() const override { return "StrokeRectBatch"; }
- void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
// When this is called on a batch, there is only one geometry bundle
out->setKnownFourComponents(fGeoData[0].fColor);
}
- void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setKnownSingleComponent(0xff);
}
- void initBatchTracker(const GrPipelineInfo& init) SK_OVERRIDE {
+ void initBatchTracker(const GrPipelineInfo& init) override {
// Handle any color overrides
if (init.fColorIgnored) {
fGeoData[0].fColor = GrColor_ILLEGAL;
fBatch.fCoverageIgnored = init.fCoverageIgnored;
}
- void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE {
+ void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
SkAutoTUnref<const GrGeometryProcessor> gp(
GrDefaultGeoProcFactory::Create(GrDefaultGeoProcFactory::kPosition_GPType,
this->color(),
const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
bool hairline() const { return fBatch.fHairline; }
- bool onCombineIfPossible(GrBatch* t) SK_OVERRIDE {
+ bool onCombineIfPossible(GrBatch* t) override {
// StrokeRectBatch* that = t->cast<StrokeRectBatch>();
// NonAA stroke rects cannot batch right now
localCoords));
}
- const char* name() const SK_OVERRIDE { return "DrawVerticesBatch"; }
+ const char* name() const override { return "DrawVerticesBatch"; }
- void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
// When this is called on a batch, there is only one geometry bundle
if (this->hasColors()) {
out->setUnknownFourComponents();
}
}
- void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setKnownSingleComponent(0xff);
}
- void initBatchTracker(const GrPipelineInfo& init) SK_OVERRIDE {
+ void initBatchTracker(const GrPipelineInfo& init) override {
// Handle any color overrides
if (init.fColorIgnored) {
fGeoData[0].fColor = GrColor_ILLEGAL;
fBatch.fCoverageIgnored = init.fCoverageIgnored;
}
- void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE {
+ void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
int colorOffset = -1, texOffset = -1;
SkAutoTUnref<const GrGeometryProcessor> gp(
set_vertex_attributes(this->hasLocalCoords(), this->hasColors(), &colorOffset,
int vertexCount() const { return fBatch.fVertexCount; }
int indexCount() const { return fBatch.fIndexCount; }
- bool onCombineIfPossible(GrBatch* t) SK_OVERRIDE {
+ bool onCombineIfPossible(GrBatch* t) override {
DrawVerticesBatch* that = t->cast<DrawVerticesBatch>();
if (!this->batchablePrimitiveType() || this->primitiveType() != that->primitiveType()) {
coverage));
}
- const char* name() const SK_OVERRIDE { return "DefaultGeometryProcessor"; }
+ const char* name() const override { return "DefaultGeometryProcessor"; }
const Attribute* inPosition() const { return fInPosition; }
const Attribute* inColor() const { return fInColor; }
const Attribute* inCoverage() const { return fInCoverage; }
uint8_t coverage() const { return fCoverage; }
- void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const SK_OVERRIDE {
+ void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override {
BatchTracker* local = bt->cast<BatchTracker>();
local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init,
SkToBool(fInColor));
bool onCanMakeEqual(const GrBatchTracker& m,
const GrGeometryProcessor& that,
- const GrBatchTracker& t) const SK_OVERRIDE {
+ const GrBatchTracker& t) const override {
const BatchTracker& mine = m.cast<BatchTracker>();
const BatchTracker& theirs = t.cast<BatchTracker>();
return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
GLProcessor(const GrGeometryProcessor& gp, const GrBatchTracker&)
: fColor(GrColor_ILLEGAL), fCoverage(0xff) {}
- void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) SK_OVERRIDE {
+ void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
const DefaultGeoProc& gp = args.fGP.cast<DefaultGeoProc>();
GrGLGPBuilder* pb = args.fPB;
GrGLVertexBuilder* vsBuilder = pb->getVertexShaderBuilder();
virtual void setData(const GrGLProgramDataManager& pdman,
const GrPrimitiveProcessor& gp,
- const GrBatchTracker& bt) SK_OVERRIDE {
+ const GrBatchTracker& bt) override {
this->setUniformViewMatrix(pdman, gp.viewMatrix());
const BatchTracker& local = bt.cast<BatchTracker>();
virtual void getGLProcessorKey(const GrBatchTracker& bt,
const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrProcessorKeyBuilder* b) const override {
GLProcessor::GenKey(*this, bt, caps, b);
}
virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
- const GrGLCaps&) const SK_OVERRIDE {
+ const GrGLCaps&) const override {
return SkNEW_ARGS(GLProcessor, (*this, bt));
}
}
}
- bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE {
+ bool onIsEqual(const GrGeometryProcessor& other) const override {
const DefaultGeoProc& gp = other.cast<DefaultGeoProc>();
return gp.fFlags == this->fFlags;
}
- void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
if (fInCoverage) {
out->setUnknownSingleComponent();
} else {
return SkNEW_ARGS(DefaultPathBatch, (geometry, coverage, viewMatrix, isHairline));
}
- const char* name() const SK_OVERRIDE { return "DefaultPathBatch"; }
+ const char* name() const override { return "DefaultPathBatch"; }
- void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
// When this is called on a batch, there is only one geometry bundle
out->setKnownFourComponents(fGeoData[0].fColor);
}
- void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setKnownSingleComponent(this->coverage());
}
- void initBatchTracker(const GrPipelineInfo& init) SK_OVERRIDE {
+ void initBatchTracker(const GrPipelineInfo& init) override {
// Handle any color overrides
if (init.fColorIgnored) {
fGeoData[0].fColor = GrColor_ILLEGAL;
fBatch.fCoverageIgnored = init.fCoverageIgnored;
}
- void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE {
+ void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
SkAutoTUnref<const GrGeometryProcessor> gp(
GrDefaultGeoProcFactory::Create(GrDefaultGeoProcFactory::kPosition_GPType,
this->color(),
fGeoData.push_back(geometry);
}
- bool onCombineIfPossible(GrBatch* t) SK_OVERRIDE {
+ bool onCombineIfPossible(GrBatch* t) override {
DefaultPathBatch* that = t->cast<DefaultPathBatch>();
if (this->color() != that->color()) {
const SkMatrix& viewMatrix,
const SkPath&,
const SkStrokeRec&,
- bool antiAlias) const SK_OVERRIDE;
+ bool antiAlias) const override;
private:
virtual StencilSupport onGetStencilSupport(const GrDrawTarget*,
const GrPipelineBuilder*,
const SkPath&,
- const SkStrokeRec&) const SK_OVERRIDE;
+ const SkStrokeRec&) const override;
virtual bool onDrawPath(GrDrawTarget*,
GrPipelineBuilder*,
const SkMatrix& viewMatrix,
const SkPath&,
const SkStrokeRec&,
- bool antiAlias) SK_OVERRIDE;
+ bool antiAlias) override;
virtual void onStencilPath(GrDrawTarget*,
GrPipelineBuilder*,
const SkMatrix& viewMatrix,
const SkPath&,
- const SkStrokeRec&) SK_OVERRIDE;
+ const SkStrokeRec&) override;
bool internalDrawPath(GrDrawTarget*,
GrPipelineBuilder*,
GrDistanceFieldTextContext(GrContext*, SkGpuDevice*, const SkDeviceProperties&, bool enable);
bool canDraw(const GrRenderTarget*, const GrClip&, const GrPaint&,
- const SkPaint&, const SkMatrix& viewMatrix) SK_OVERRIDE;
+ const SkPaint&, const SkMatrix& viewMatrix) override;
void onDrawText(GrRenderTarget*, const GrClip&, const GrPaint&, const SkPaint&,
const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
- SkScalar x, SkScalar y, const SkIRect& regionClipBounds) SK_OVERRIDE;
+ SkScalar x, SkScalar y, const SkIRect& regionClipBounds) override;
void onDrawPosText(GrRenderTarget*, const GrClip&, const GrPaint&, const SkPaint&,
const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
const SkScalar pos[], int scalarsPerPosition,
- const SkPoint& offset, const SkIRect& regionClipBounds) SK_OVERRIDE;
+ const SkPoint& offset, const SkIRect& regionClipBounds) override;
void init(GrRenderTarget*, const GrClip&, const GrPaint&, const SkPaint&,
const SkIRect& regionClipBounds);
* Release any resources that are cached but not currently in use. This
* is intended to give an application some recourse when resources are low.
*/
- void purgeResources() SK_OVERRIDE {
+ void purgeResources() override {
// The clip mask manager can rebuild all its clip masks so just
// get rid of them all.
fClipMaskManager.purgeResources();
GrClipMaskManager fClipMaskManager;
private:
- GrClipMaskManager* clipMaskManager() SK_OVERRIDE { return &fClipMaskManager; }
+ GrClipMaskManager* clipMaskManager() override { return &fClipMaskManager; }
virtual bool setupClip(GrPipelineBuilder*,
GrPipelineBuilder::AutoRestoreFragmentProcessors*,
GrPipelineBuilder::AutoRestoreStencil*,
GrScissorState* scissorState,
- const SkRect* devBounds) SK_OVERRIDE;
+ const SkRect* devBounds) override;
typedef GrDrawTarget INHERITED;
};
public:
GrFlushToGpuDrawTarget(GrGpu*, GrVertexBufferAllocPool*,GrIndexBufferAllocPool*);
- ~GrFlushToGpuDrawTarget() SK_OVERRIDE;
+ ~GrFlushToGpuDrawTarget() override;
/**
* Empties the draw buffer of any queued up draws. This must not be called while inside an
*/
void flush();
- bool geometryHints(size_t vertexStride, int* vertexCount, int* indexCount) const SK_OVERRIDE;
+ bool geometryHints(size_t vertexStride, int* vertexCount, int* indexCount) const override;
protected:
GrGpu* getGpu() { return fGpu; }
void willReserveVertexAndIndexSpace(int vertexCount,
size_t vertexStride,
- int indexCount) SK_OVERRIDE;
+ int indexCount) override;
private:
virtual void onReset() = 0;
virtual void onFlush() = 0;
- void setDrawBuffers(DrawInfo*, size_t stride) SK_OVERRIDE;
- bool onReserveVertexSpace(size_t vertexSize, int vertexCount, void** vertices) SK_OVERRIDE;
- bool onReserveIndexSpace(int indexCount, void** indices) SK_OVERRIDE;
- void releaseReservedVertexSpace() SK_OVERRIDE;
- void releaseReservedIndexSpace() SK_OVERRIDE;
- void geometrySourceWillPush() SK_OVERRIDE;
- void geometrySourceWillPop(const GeometrySrcState& restoredState) SK_OVERRIDE;
+ void setDrawBuffers(DrawInfo*, size_t stride) override;
+ bool onReserveVertexSpace(size_t vertexSize, int vertexCount, void** vertices) override;
+ bool onReserveIndexSpace(int indexCount, void** indices) override;
+ void releaseReservedVertexSpace() override;
+ void releaseReservedIndexSpace() override;
+ void geometrySourceWillPush() override;
+ void geometrySourceWillPop(const GeometrySrcState& restoredState) override;
bool onCanCopySurface(const GrSurface* dst,
const GrSurface* src,
const SkIRect& srcRect,
- const SkIPoint& dstPoint) SK_OVERRIDE;
- bool onInitCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) SK_OVERRIDE;
+ const SkIPoint& dstPoint) override;
+ bool onInitCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) override;
GeoPoolStateStack fGeoPoolStateStack;
SkAutoTUnref<GrGpu> fGpu;
*/
bool canMakeEqual(const GrBatchTracker& mine,
const GrPrimitiveProcessor& that,
- const GrBatchTracker& theirs) const SK_OVERRIDE {
+ const GrBatchTracker& theirs) const override {
if (this->classID() != that.classID() || !this->hasSameTextureAccesses(that)) {
return false;
}
// TODO this is a total hack until the gp can do deferred geometry
bool hasVertexColor() const { return fHasVertexColor; }
- void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE;
- void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE;
+ void getInvariantOutputColor(GrInitInvariantOutput* out) const override;
+ void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override;
protected:
/*
// TODO delete this when we have more advanced equality testing via bundles and the BT
virtual bool onIsEqual(const GrGeometryProcessor&) const = 0;
- bool hasExplicitLocalCoords() const SK_OVERRIDE { return fHasLocalCoords; }
+ bool hasExplicitLocalCoords() const override { return fHasLocalCoords; }
GrColor fColor;
bool fOpaqueVertexColors;
////////////////////////////////////////////////////////////////////////////
GrGpu(GrContext* context);
- ~GrGpu() SK_OVERRIDE;
+ ~GrGpu() override;
GrContext* getContext() { return fContext; }
const GrContext* getContext() const { return fContext; }
return SkNEW_ARGS(RectBatch, (geometry));
}
- const char* name() const SK_OVERRIDE { return "RectBatch"; }
+ const char* name() const override { return "RectBatch"; }
- void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
// When this is called on a batch, there is only one geometry bundle
out->setKnownFourComponents(fGeoData[0].fColor);
}
- void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setKnownSingleComponent(0xff);
}
- void initBatchTracker(const GrPipelineInfo& init) SK_OVERRIDE {
+ void initBatchTracker(const GrPipelineInfo& init) override {
// Handle any color overrides
if (init.fColorIgnored) {
fGeoData[0].fColor = GrColor_ILLEGAL;
fBatch.fCoverageIgnored = init.fCoverageIgnored;
}
- void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE {
+ void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
// Go to device coords to allow batching across matrix changes
SkMatrix invert = SkMatrix::I();
bool hasLocalRect() const { return fGeoData[0].fHasLocalRect; }
bool hasLocalMatrix() const { return fGeoData[0].fHasLocalMatrix; }
- bool onCombineIfPossible(GrBatch* t) SK_OVERRIDE {
+ bool onCombineIfPossible(GrBatch* t) override {
RectBatch* that = t->cast<RectBatch>();
if (this->hasLocalRect() != that->hasLocalRect()) {
GrVertexBufferAllocPool* vertexPool,
GrIndexBufferAllocPool* indexPool);
- ~GrInOrderDrawBuffer() SK_OVERRIDE;
+ ~GrInOrderDrawBuffer() override;
// tracking for draws
- DrawToken getCurrentDrawToken() SK_OVERRIDE { return DrawToken(this, fDrawID); }
+ DrawToken getCurrentDrawToken() override { return DrawToken(this, fDrawID); }
void clearStencilClip(const SkIRect& rect,
bool insideClip,
- GrRenderTarget* renderTarget) SK_OVERRIDE;
+ GrRenderTarget* renderTarget) override;
- void discard(GrRenderTarget*) SK_OVERRIDE;
+ void discard(GrRenderTarget*) override;
protected:
void willReserveVertexAndIndexSpace(int vertexCount,
size_t vertexStride,
- int indexCount) SK_OVERRIDE;
+ int indexCount) override;
void appendIndicesAndTransforms(const void* indexValues, PathIndexType indexType,
const float* transformValues, PathTransformType transformType,
private:
friend class GrTargetCommands;
- void onReset() SK_OVERRIDE;
- void onFlush() SK_OVERRIDE;
+ void onReset() override;
+ void onFlush() override;
// overrides from GrDrawTarget
- void onDraw(const GrGeometryProcessor*, const DrawInfo&, const PipelineInfo&) SK_OVERRIDE;
- void onDrawBatch(GrBatch*, const PipelineInfo&) SK_OVERRIDE;
+ void onDraw(const GrGeometryProcessor*, const DrawInfo&, const PipelineInfo&) override;
+ void onDrawBatch(GrBatch*, const PipelineInfo&) override;
void onDrawRect(GrPipelineBuilder*,
GrColor,
const SkMatrix& viewMatrix,
const SkRect& rect,
const SkRect* localRect,
- const SkMatrix* localMatrix) SK_OVERRIDE;
+ const SkMatrix* localMatrix) override;
void onStencilPath(const GrPipelineBuilder&,
const GrPathProcessor*,
const GrPath*,
const GrScissorState&,
- const GrStencilSettings&) SK_OVERRIDE;
+ const GrStencilSettings&) override;
void onDrawPath(const GrPathProcessor*,
const GrPath*,
const GrStencilSettings&,
- const PipelineInfo&) SK_OVERRIDE;
+ const PipelineInfo&) override;
void onDrawPaths(const GrPathProcessor*,
const GrPathRange*,
const void* indices,
PathTransformType,
int count,
const GrStencilSettings&,
- const PipelineInfo&) SK_OVERRIDE;
+ const PipelineInfo&) override;
void onClear(const SkIRect* rect,
GrColor color,
bool canIgnoreRect,
- GrRenderTarget* renderTarget) SK_OVERRIDE;
+ GrRenderTarget* renderTarget) override;
bool onCopySurface(GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
- const SkIPoint& dstPoint) SK_OVERRIDE;
+ const SkIPoint& dstPoint) override;
// Attempts to concat instances from info onto the previous draw. info must represent an
// instanced draw. The caller must have already recorded a new draw state and clip if necessary.
SkASSERT(index < fGpuCmdMarkers.count());
return fGpuCmdMarkers[index].toString();
}
- bool isIssued(uint32_t drawID) SK_OVERRIDE { return drawID != fDrawID; }
+ bool isIssued(uint32_t drawID) override { return drawID != fDrawID; }
// TODO: Use a single allocator for commands and records
enum {
const Attribute* inCircleEdge() const { return fInCircleEdge; }
virtual ~CircleEdgeEffect() {}
- const char* name() const SK_OVERRIDE { return "CircleEdge"; }
+ const char* name() const override { return "CircleEdge"; }
inline bool isStroked() const { return fStroke; }
const GrBatchTracker&)
: fColor(GrColor_ILLEGAL) {}
- void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) SK_OVERRIDE{
+ void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override{
const CircleEdgeEffect& ce = args.fGP.cast<CircleEdgeEffect>();
GrGLGPBuilder* pb = args.fPB;
const BatchTracker& local = args.fBT.cast<BatchTracker>();
virtual void setData(const GrGLProgramDataManager& pdman,
const GrPrimitiveProcessor& gp,
- const GrBatchTracker& bt) SK_OVERRIDE {
+ const GrBatchTracker& bt) override {
this->setUniformViewMatrix(pdman, gp.viewMatrix());
const BatchTracker& local = bt.cast<BatchTracker>();
virtual void getGLProcessorKey(const GrBatchTracker& bt,
const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrProcessorKeyBuilder* b) const override {
GLProcessor::GenKey(*this, bt, caps, b);
}
virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
- const GrGLCaps&) const SK_OVERRIDE {
+ const GrGLCaps&) const override {
return SkNEW_ARGS(GLProcessor, (*this, bt));
}
- void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const SK_OVERRIDE {
+ void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override {
BatchTracker* local = bt->cast<BatchTracker>();
local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false);
local->fUsesLocalCoords = init.fUsesLocalCoords;
bool onCanMakeEqual(const GrBatchTracker& m,
const GrGeometryProcessor& that,
- const GrBatchTracker& t) const SK_OVERRIDE {
+ const GrBatchTracker& t) const override {
const BatchTracker& mine = m.cast<BatchTracker>();
const BatchTracker& theirs = t.cast<BatchTracker>();
return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
fStroke = stroke;
}
- bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE {
+ bool onIsEqual(const GrGeometryProcessor& other) const override {
const CircleEdgeEffect& cee = other.cast<CircleEdgeEffect>();
return cee.fStroke == fStroke;
}
- void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setUnknownSingleComponent();
}
virtual ~EllipseEdgeEffect() {}
- const char* name() const SK_OVERRIDE { return "EllipseEdge"; }
+ const char* name() const override { return "EllipseEdge"; }
const Attribute* inPosition() const { return fInPosition; }
const Attribute* inEllipseOffset() const { return fInEllipseOffset; }
const GrBatchTracker&)
: fColor(GrColor_ILLEGAL) {}
- void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) SK_OVERRIDE{
+ void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override{
const EllipseEdgeEffect& ee = args.fGP.cast<EllipseEdgeEffect>();
GrGLGPBuilder* pb = args.fPB;
const BatchTracker& local = args.fBT.cast<BatchTracker>();
virtual void setData(const GrGLProgramDataManager& pdman,
const GrPrimitiveProcessor& gp,
- const GrBatchTracker& bt) SK_OVERRIDE {
+ const GrBatchTracker& bt) override {
this->setUniformViewMatrix(pdman, gp.viewMatrix());
const BatchTracker& local = bt.cast<BatchTracker>();
virtual void getGLProcessorKey(const GrBatchTracker& bt,
const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrProcessorKeyBuilder* b) const override {
GLProcessor::GenKey(*this, bt, caps, b);
}
virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
- const GrGLCaps&) const SK_OVERRIDE {
+ const GrGLCaps&) const override {
return SkNEW_ARGS(GLProcessor, (*this, bt));
}
- void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const SK_OVERRIDE {
+ void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override {
BatchTracker* local = bt->cast<BatchTracker>();
local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false);
local->fUsesLocalCoords = init.fUsesLocalCoords;
bool onCanMakeEqual(const GrBatchTracker& m,
const GrGeometryProcessor& that,
- const GrBatchTracker& t) const SK_OVERRIDE {
+ const GrBatchTracker& t) const override {
const BatchTracker& mine = m.cast<BatchTracker>();
const BatchTracker& theirs = t.cast<BatchTracker>();
return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
fStroke = stroke;
}
- bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE {
+ bool onIsEqual(const GrGeometryProcessor& other) const override {
const EllipseEdgeEffect& eee = other.cast<EllipseEdgeEffect>();
return eee.fStroke == fStroke;
}
- void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setUnknownSingleComponent();
}
virtual ~DIEllipseEdgeEffect() {}
- const char* name() const SK_OVERRIDE { return "DIEllipseEdge"; }
+ const char* name() const override { return "DIEllipseEdge"; }
const Attribute* inPosition() const { return fInPosition; }
const Attribute* inEllipseOffsets0() const { return fInEllipseOffsets0; }
const GrBatchTracker&)
: fColor(GrColor_ILLEGAL) {}
- void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) SK_OVERRIDE{
+ void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override{
const DIEllipseEdgeEffect& ee = args.fGP.cast<DIEllipseEdgeEffect>();
GrGLGPBuilder* pb = args.fPB;
const BatchTracker& local = args.fBT.cast<BatchTracker>();
virtual void setData(const GrGLProgramDataManager& pdman,
const GrPrimitiveProcessor& gp,
- const GrBatchTracker& bt) SK_OVERRIDE {
+ const GrBatchTracker& bt) override {
this->setUniformViewMatrix(pdman, gp.viewMatrix());
const BatchTracker& local = bt.cast<BatchTracker>();
virtual void getGLProcessorKey(const GrBatchTracker& bt,
const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrProcessorKeyBuilder* b) const override {
GLProcessor::GenKey(*this, bt, caps, b);
}
virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
- const GrGLCaps&) const SK_OVERRIDE {
+ const GrGLCaps&) const override {
return SkNEW_ARGS(GLProcessor, (*this, bt));
}
- void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const SK_OVERRIDE {
+ void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override {
BatchTracker* local = bt->cast<BatchTracker>();
local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false);
local->fUsesLocalCoords = init.fUsesLocalCoords;
bool onCanMakeEqual(const GrBatchTracker& m,
const GrGeometryProcessor& that,
- const GrBatchTracker& t) const SK_OVERRIDE {
+ const GrBatchTracker& t) const override {
const BatchTracker& mine = m.cast<BatchTracker>();
const BatchTracker& theirs = t.cast<BatchTracker>();
return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
fMode = mode;
}
- bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE {
+ bool onIsEqual(const GrGeometryProcessor& other) const override {
const DIEllipseEdgeEffect& eee = other.cast<DIEllipseEdgeEffect>();
return eee.fMode == fMode;
}
- void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setUnknownSingleComponent();
}
return SkNEW_ARGS(CircleBatch, (geometry));
}
- const char* name() const SK_OVERRIDE { return "CircleBatch"; }
+ const char* name() const override { return "CircleBatch"; }
- void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
// When this is called on a batch, there is only one geometry bundle
out->setKnownFourComponents(fGeoData[0].fColor);
}
- void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setUnknownSingleComponent();
}
- void initBatchTracker(const GrPipelineInfo& init) SK_OVERRIDE {
+ void initBatchTracker(const GrPipelineInfo& init) override {
// Handle any color overrides
if (init.fColorIgnored) {
fGeoData[0].fColor = GrColor_ILLEGAL;
fBatch.fCoverageIgnored = init.fCoverageIgnored;
}
- void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE {
+ void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
SkMatrix invert;
if (!this->viewMatrix().invert(&invert)) {
return;
fGeoData.push_back(geometry);
}
- bool onCombineIfPossible(GrBatch* t) SK_OVERRIDE {
+ bool onCombineIfPossible(GrBatch* t) override {
CircleBatch* that = t->cast<CircleBatch>();
// TODO use vertex color to avoid breaking batches
return SkNEW_ARGS(EllipseBatch, (geometry));
}
- const char* name() const SK_OVERRIDE { return "EllipseBatch"; }
+ const char* name() const override { return "EllipseBatch"; }
- void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
// When this is called on a batch, there is only one geometry bundle
out->setKnownFourComponents(fGeoData[0].fColor);
}
- void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setUnknownSingleComponent();
}
- void initBatchTracker(const GrPipelineInfo& init) SK_OVERRIDE {
+ void initBatchTracker(const GrPipelineInfo& init) override {
// Handle any color overrides
if (init.fColorIgnored) {
fGeoData[0].fColor = GrColor_ILLEGAL;
fBatch.fCoverageIgnored = init.fCoverageIgnored;
}
- void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE {
+ void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
SkMatrix invert;
if (!this->viewMatrix().invert(&invert)) {
return;
fGeoData.push_back(geometry);
}
- bool onCombineIfPossible(GrBatch* t) SK_OVERRIDE {
+ bool onCombineIfPossible(GrBatch* t) override {
EllipseBatch* that = t->cast<EllipseBatch>();
// TODO use vertex color to avoid breaking batches
return SkNEW_ARGS(DIEllipseBatch, (geometry));
}
- const char* name() const SK_OVERRIDE { return "DIEllipseBatch"; }
+ const char* name() const override { return "DIEllipseBatch"; }
- void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
// When this is called on a batch, there is only one geometry bundle
out->setKnownFourComponents(fGeoData[0].fColor);
}
- void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setUnknownSingleComponent();
}
- void initBatchTracker(const GrPipelineInfo& init) SK_OVERRIDE {
+ void initBatchTracker(const GrPipelineInfo& init) override {
// Handle any color overrides
if (init.fColorIgnored) {
fGeoData[0].fColor = GrColor_ILLEGAL;
fBatch.fCoverageIgnored = init.fCoverageIgnored;
}
- void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE {
+ void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
// Setup geometry processor
SkAutoTUnref<GrGeometryProcessor> gp(DIEllipseEdgeEffect::Create(this->color(),
this->viewMatrix(),
fGeoData.push_back(geometry);
}
- bool onCombineIfPossible(GrBatch* t) SK_OVERRIDE {
+ bool onCombineIfPossible(GrBatch* t) override {
DIEllipseBatch* that = t->cast<DIEllipseBatch>();
// TODO use vertex color to avoid breaking batches
return SkNEW_ARGS(RRectCircleRendererBatch, (geometry, indexBuffer));
}
- const char* name() const SK_OVERRIDE { return "RRectCircleBatch"; }
+ const char* name() const override { return "RRectCircleBatch"; }
- void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
// When this is called on a batch, there is only one geometry bundle
out->setKnownFourComponents(fGeoData[0].fColor);
}
- void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setUnknownSingleComponent();
}
- void initBatchTracker(const GrPipelineInfo& init) SK_OVERRIDE {
+ void initBatchTracker(const GrPipelineInfo& init) override {
// Handle any color overrides
if (init.fColorIgnored) {
fGeoData[0].fColor = GrColor_ILLEGAL;
fBatch.fCoverageIgnored = init.fCoverageIgnored;
}
- void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE {
+ void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
// reset to device coordinates
SkMatrix invert;
if (!this->viewMatrix().invert(&invert)) {
fGeoData.push_back(geometry);
}
- bool onCombineIfPossible(GrBatch* t) SK_OVERRIDE {
+ bool onCombineIfPossible(GrBatch* t) override {
RRectCircleRendererBatch* that = t->cast<RRectCircleRendererBatch>();
// TODO use vertex color to avoid breaking batches
return SkNEW_ARGS(RRectEllipseRendererBatch, (geometry, indexBuffer));
}
- const char* name() const SK_OVERRIDE { return "RRectEllipseRendererBatch"; }
+ const char* name() const override { return "RRectEllipseRendererBatch"; }
- void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
// When this is called on a batch, there is only one geometry bundle
out->setKnownFourComponents(fGeoData[0].fColor);
}
- void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setUnknownSingleComponent();
}
- void initBatchTracker(const GrPipelineInfo& init) SK_OVERRIDE {
+ void initBatchTracker(const GrPipelineInfo& init) override {
// Handle any color overrides
if (init.fColorIgnored) {
fGeoData[0].fColor = GrColor_ILLEGAL;
fBatch.fCoverageIgnored = init.fCoverageIgnored;
}
- void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE {
+ void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
// reset to device coordinates
SkMatrix invert;
if (!this->viewMatrix().invert(&invert)) {
fGeoData.push_back(geometry);
}
- bool onCombineIfPossible(GrBatch* t) SK_OVERRIDE {
+ bool onCombineIfPossible(GrBatch* t) override {
RRectEllipseRendererBatch* that = t->cast<RRectEllipseRendererBatch>();
// TODO use vertex color to avoid breaking batches
return SkNEW_ARGS(GrPathProcessor, (color, viewMatrix, localMatrix));
}
- void initBatchTracker(GrBatchTracker*, const GrPipelineInfo&) const SK_OVERRIDE;
+ void initBatchTracker(GrBatchTracker*, const GrPipelineInfo&) const override;
bool canMakeEqual(const GrBatchTracker& mine,
const GrPrimitiveProcessor& that,
- const GrBatchTracker& theirs) const SK_OVERRIDE;
+ const GrBatchTracker& theirs) const override;
- const char* name() const SK_OVERRIDE { return "PathProcessor"; }
+ const char* name() const override { return "PathProcessor"; }
GrColor color() const { return fColor; }
- void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE;
- void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE;
+ void getInvariantOutputColor(GrInitInvariantOutput* out) const override;
+ void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override;
- bool willUseGeoShader() const SK_OVERRIDE { return false; }
+ bool willUseGeoShader() const override { return false; }
virtual void getGLProcessorKey(const GrBatchTracker& bt,
const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+ GrProcessorKeyBuilder* b) const override;
virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
- const GrGLCaps& caps) const SK_OVERRIDE;
+ const GrGLCaps& caps) const override;
protected:
GrPathProcessor(GrColor color, const SkMatrix& viewMatrix, const SkMatrix& localMatrix);
private:
- bool hasExplicitLocalCoords() const SK_OVERRIDE { return false; }
+ bool hasExplicitLocalCoords() const override { return false; }
GrColor fColor;
SkDescriptor::Free(fDesc);
}
- int getNumPaths() SK_OVERRIDE {
+ int getNumPaths() override {
return fScalerContext->getGlyphCount();
}
- void generatePath(int glyphID, SkPath* out) SK_OVERRIDE {
+ void generatePath(int glyphID, SkPath* out) override {
SkGlyph skGlyph;
skGlyph.initWithGlyphID(glyphID);
fScalerContext->getMetrics(&skGlyph);
out->transform(fFlipMatrix); // Load glyphs with the inverted y-direction.
}
- bool isEqualTo(const SkDescriptor& desc) const SK_OVERRIDE {
+ bool isEqualTo(const SkDescriptor& desc) const override {
return fDesc->equals(desc);
}
virtual ~GrRectanizerPow2() { }
- void reset() SK_OVERRIDE {
+ void reset() override {
fNextStripY = 0;
fAreaSoFar = 0;
sk_bzero(fRows, sizeof(fRows));
}
- bool addRect(int w, int h, SkIPoint16* loc) SK_OVERRIDE;
+ bool addRect(int w, int h, SkIPoint16* loc) override;
- float percentFull() const SK_OVERRIDE {
+ float percentFull() const override {
return fAreaSoFar / ((float)this->width() * this->height());
}
virtual ~GrRectanizerSkyline() { }
- void reset() SK_OVERRIDE{
+ void reset() override{
fAreaSoFar = 0;
fSkyline.reset();
SkylineSegment* seg = fSkyline.append(1);
seg->fWidth = this->width();
}
- bool addRect(int w, int h, SkIPoint16* loc) SK_OVERRIDE;
+ bool addRect(int w, int h, SkIPoint16* loc) override;
- float percentFull() const SK_OVERRIDE {
+ float percentFull() const override {
return fAreaSoFar / ((float)this->width() * this->height());
}
const SkMatrix& viewMatrix,
const SkPath&,
const SkStrokeRec&,
- bool antiAlias) const SK_OVERRIDE;
+ bool antiAlias) const override;
protected:
virtual StencilSupport onGetStencilSupport(const GrDrawTarget*,
const GrPipelineBuilder*,
const SkPath&,
- const SkStrokeRec&) const SK_OVERRIDE;
+ const SkStrokeRec&) const override;
virtual bool onDrawPath(GrDrawTarget*,
GrPipelineBuilder*,
const SkMatrix& viewMatrix,
const SkPath&,
const SkStrokeRec&,
- bool antiAlias) SK_OVERRIDE;
+ bool antiAlias) override;
private:
GrContext* fContext;
const SkMatrix& viewMatrix,
const SkPath&,
const SkStrokeRec&,
- bool antiAlias) const SK_OVERRIDE;
+ bool antiAlias) const override;
protected:
virtual StencilSupport onGetStencilSupport(const GrDrawTarget*,
const GrPipelineBuilder*,
const SkPath&,
- const SkStrokeRec&) const SK_OVERRIDE;
+ const SkStrokeRec&) const override;
virtual bool onDrawPath(GrDrawTarget*,
GrPipelineBuilder*,
const SkMatrix& viewMatrix,
const SkPath&,
const SkStrokeRec&,
- bool antiAlias) SK_OVERRIDE;
+ bool antiAlias) override;
virtual void onStencilPath(GrDrawTarget*,
GrPipelineBuilder*,
const SkMatrix& viewMatrix,
const SkPath&,
- const SkStrokeRec&) SK_OVERRIDE;
+ const SkStrokeRec&) override;
private:
GrStencilAndCoverPathRenderer(GrGpu*);
GrStencilAndCoverTextContext(GrContext*, SkGpuDevice*, const SkDeviceProperties&);
bool canDraw(const GrRenderTarget*, const GrClip&, const GrPaint&,
- const SkPaint&, const SkMatrix& viewMatrix) SK_OVERRIDE;
+ const SkPaint&, const SkMatrix& viewMatrix) override;
void onDrawText(GrRenderTarget*, const GrClip&, const GrPaint&, const SkPaint&,
const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
- SkScalar x, SkScalar y, const SkIRect& regionClipBounds) SK_OVERRIDE;
+ SkScalar x, SkScalar y, const SkIRect& regionClipBounds) override;
void onDrawPosText(GrRenderTarget*, const GrClip&, const GrPaint&, const SkPaint&,
const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
const SkScalar pos[], int scalarsPerPosition,
- const SkPoint& offset, const SkIRect& regionClipBounds) SK_OVERRIDE;
+ const SkPoint& offset, const SkIRect& regionClipBounds) override;
void init(GrRenderTarget*, const GrClip&, const GrPaint&, const SkPaint&,
size_t textByteLength, RenderMode, const SkMatrix& viewMatrix,
struct Draw : public Cmd {
Draw(const GrDrawTarget::DrawInfo& info) : Cmd(kDraw_CmdType), fInfo(info) {}
- void execute(GrGpu*, const SetState*) SK_OVERRIDE;
+ void execute(GrGpu*, const SetState*) override;
GrDrawTarget::DrawInfo fInfo;
};
const GrPath* path() const { return fPath.get(); }
- void execute(GrGpu*, const SetState*) SK_OVERRIDE;
+ void execute(GrGpu*, const SetState*) override;
SkMatrix fViewMatrix;
bool fUseHWAA;
const GrPath* path() const { return fPath.get(); }
- void execute(GrGpu*, const SetState*) SK_OVERRIDE;
+ void execute(GrGpu*, const SetState*) override;
GrStencilSettings fStencilSettings;
const GrPathRange* pathRange() const { return fPathRange.get(); }
- void execute(GrGpu*, const SetState*) SK_OVERRIDE;
+ void execute(GrGpu*, const SetState*) override;
char* fIndices;
GrDrawTarget::PathIndexType fIndexType;
GrRenderTarget* renderTarget() const { return fRenderTarget.get(); }
- void execute(GrGpu*, const SetState*) SK_OVERRIDE;
+ void execute(GrGpu*, const SetState*) override;
SkIRect fRect;
GrColor fColor;
GrRenderTarget* renderTarget() const { return fRenderTarget.get(); }
- void execute(GrGpu*, const SetState*) SK_OVERRIDE;
+ void execute(GrGpu*, const SetState*) override;
SkIRect fRect;
bool fInsideClip;
GrSurface* dst() const { return fDst.get(); }
GrSurface* src() const { return fSrc.get(); }
- void execute(GrGpu*, const SetState*) SK_OVERRIDE;
+ void execute(GrGpu*, const SetState*) override;
SkIPoint fDstPoint;
SkIRect fSrcRect;
return reinterpret_cast<const GrPipeline*>(fPipeline.get());
}
- void execute(GrGpu*, const SetState*) SK_OVERRIDE;
+ void execute(GrGpu*, const SetState*) override;
typedef GrPendingProgramElement<const GrPrimitiveProcessor> ProgramPrimitiveProcessor;
ProgramPrimitiveProcessor fPrimitiveProcessor;
SkASSERT(!batch->isUsed());
}
- void execute(GrGpu*, const SetState*) SK_OVERRIDE;
+ void execute(GrGpu*, const SetState*) override;
// TODO it wouldn't be too hard to let batches allocate in the cmd buffer
SkAutoTUnref<GrBatch> fBatch;
return SkNEW_ARGS(TessellatingPathBatch, (color, path, viewMatrix, clipBounds));
}
- const char* name() const SK_OVERRIDE { return "TessellatingPathBatch"; }
+ const char* name() const override { return "TessellatingPathBatch"; }
- void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
out->setKnownFourComponents(fColor);
}
- void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setUnknownSingleComponent();
}
- void initBatchTracker(const GrPipelineInfo& init) SK_OVERRIDE {
+ void initBatchTracker(const GrPipelineInfo& init) override {
// Handle any color overrides
if (init.fColorIgnored) {
fColor = GrColor_ILLEGAL;
fPipelineInfo = init;
}
- void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE {
+ void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
SkScalar tol = GrPathUtils::scaleToleranceToSrc(SK_Scalar1, fViewMatrix, fPath.getBounds());
int contourCnt;
int maxPts = GrPathUtils::worstCasePointCount(fPath, &contourCnt, tol);
return;
}
- bool onCombineIfPossible(GrBatch*) SK_OVERRIDE {
+ bool onCombineIfPossible(GrBatch*) override {
return false;
}
const SkMatrix&,
const SkPath&,
const SkStrokeRec&,
- bool antiAlias) const SK_OVERRIDE;
+ bool antiAlias) const override;
protected:
StencilSupport onGetStencilSupport(const GrDrawTarget*,
const GrPipelineBuilder*,
const SkPath&,
- const SkStrokeRec&) const SK_OVERRIDE;
+ const SkStrokeRec&) const override;
bool onDrawPath(GrDrawTarget*,
GrPipelineBuilder*,
const SkMatrix& viewMatrix,
const SkPath&,
const SkStrokeRec&,
- bool antiAlias) SK_OVERRIDE;
+ bool antiAlias) override;
typedef GrPathRenderer INHERITED;
};
class MockGpu : public GrGpu {
public:
MockGpu(GrContext* context) : INHERITED(context) { fCaps.reset(SkNEW(GrDrawTargetCaps)); }
- ~MockGpu() SK_OVERRIDE {}
- bool canWriteTexturePixels(const GrTexture*, GrPixelConfig srcConfig) const SK_OVERRIDE {
+ ~MockGpu() override {}
+ bool canWriteTexturePixels(const GrTexture*, GrPixelConfig srcConfig) const override {
return true;
}
int left, int top,
int width, int height,
GrPixelConfig config,
- size_t rowBytes) const SK_OVERRIDE { return false; }
+ size_t rowBytes) const override { return false; }
void buildProgramDesc(GrProgramDesc*,const GrPrimitiveProcessor&,
const GrPipeline&,
- const GrBatchTracker&) const SK_OVERRIDE {}
+ const GrBatchTracker&) const override {}
- void discard(GrRenderTarget*) SK_OVERRIDE {}
+ void discard(GrRenderTarget*) override {}
bool canCopySurface(const GrSurface* dst,
const GrSurface* src,
const SkIRect& srcRect,
- const SkIPoint& dstPoint) SK_OVERRIDE { return false; };
+ const SkIPoint& dstPoint) override { return false; };
bool copySurface(GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
- const SkIPoint& dstPoint) SK_OVERRIDE { return false; };
+ const SkIPoint& dstPoint) override { return false; };
- bool initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) SK_OVERRIDE {
+ bool initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) override {
return false;
}
private:
- void onResetContext(uint32_t resetBits) SK_OVERRIDE {}
+ void onResetContext(uint32_t resetBits) override {}
GrTexture* onCreateTexture(const GrSurfaceDesc& desc, bool budgeted, const void* srcData,
- size_t rowBytes) SK_OVERRIDE {
+ size_t rowBytes) override {
return NULL;
}
GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc, bool budgeted,
- const void* srcData) SK_OVERRIDE {
+ const void* srcData) override {
return NULL;
}
- GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&) SK_OVERRIDE { return NULL; }
+ GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&) override { return NULL; }
- GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) SK_OVERRIDE {
+ GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) override {
return NULL;
}
- GrVertexBuffer* onCreateVertexBuffer(size_t size, bool dynamic) SK_OVERRIDE { return NULL; }
+ GrVertexBuffer* onCreateVertexBuffer(size_t size, bool dynamic) override { return NULL; }
- GrIndexBuffer* onCreateIndexBuffer(size_t size, bool dynamic) SK_OVERRIDE { return NULL; }
+ GrIndexBuffer* onCreateIndexBuffer(size_t size, bool dynamic) override { return NULL; }
void onClear(GrRenderTarget*, const SkIRect* rect, GrColor color,
- bool canIgnoreRect) SK_OVERRIDE {}
+ bool canIgnoreRect) override {}
- void onClearStencilClip(GrRenderTarget*, const SkIRect& rect, bool insideClip) SK_OVERRIDE {}
+ void onClearStencilClip(GrRenderTarget*, const SkIRect& rect, bool insideClip) override {}
- void onDraw(const DrawArgs&, const GrDrawTarget::DrawInfo&) SK_OVERRIDE {}
+ void onDraw(const DrawArgs&, const GrDrawTarget::DrawInfo&) override {}
- void onStencilPath(const GrPath* path, const StencilPathState& state) SK_OVERRIDE {}
+ void onStencilPath(const GrPath* path, const StencilPathState& state) override {}
- void onDrawPath(const DrawArgs&, const GrPath*, const GrStencilSettings&) SK_OVERRIDE {}
+ void onDrawPath(const DrawArgs&, const GrPath*, const GrStencilSettings&) override {}
void onDrawPaths(const DrawArgs&,
const GrPathRange*,
const float transformValues[],
GrDrawTarget::PathTransformType,
int count,
- const GrStencilSettings&) SK_OVERRIDE {}
+ const GrStencilSettings&) override {}
bool onReadPixels(GrRenderTarget* target,
int left, int top, int width, int height,
GrPixelConfig,
void* buffer,
- size_t rowBytes) SK_OVERRIDE {
+ size_t rowBytes) override {
return false;
}
bool onWriteTexturePixels(GrTexture* texture,
int left, int top, int width, int height,
GrPixelConfig config, const void* buffer,
- size_t rowBytes) SK_OVERRIDE {
+ size_t rowBytes) override {
return false;
}
- void onResolveRenderTarget(GrRenderTarget* target) SK_OVERRIDE { return; }
+ void onResolveRenderTarget(GrRenderTarget* target) override { return; }
- bool createStencilBufferForRenderTarget(GrRenderTarget*, int width, int height) SK_OVERRIDE {
+ bool createStencilBufferForRenderTarget(GrRenderTarget*, int width, int height) override {
return false;
}
- bool attachStencilBufferToRenderTarget(GrStencilBuffer*, GrRenderTarget*) SK_OVERRIDE {
+ bool attachStencilBufferToRenderTarget(GrStencilBuffer*, GrRenderTarget*) override {
return false;
}
- void clearStencil(GrRenderTarget* target) SK_OVERRIDE {}
+ void clearStencil(GrRenderTarget* target) override {}
- void didAddGpuTraceMarker() SK_OVERRIDE {}
+ void didAddGpuTraceMarker() override {}
- void didRemoveGpuTraceMarker() SK_OVERRIDE {}
+ void didRemoveGpuTraceMarker() override {}
typedef GrGpu INHERITED;
};
GrColor fColor;
};
- virtual const char* name() const SK_OVERRIDE = 0;
+ virtual const char* name() const override = 0;
- void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
// When this is called on a batch, there is only one geometry bundle
if (fGeometryProcessor->hasVertexColor()) {
out->setUnknownFourComponents();
}
}
- void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setUnknownSingleComponent();
}
- void initBatchTracker(const GrPipelineInfo& init) SK_OVERRIDE {
+ void initBatchTracker(const GrPipelineInfo& init) override {
// Handle any color overrides
if (init.fColorIgnored) {
this->geoData(0)->fColor = GrColor_ILLEGAL;
fBatch.fCoverageIgnored = init.fCoverageIgnored;
}
- void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE {
+ void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
batchTarget->initDraw(fGeometryProcessor, pipeline);
// TODO this is hacky, but the only way we have to initialize the GP is to use the
private:
virtual Geometry* geoData(int index) = 0;
- bool onCombineIfPossible(GrBatch* t) SK_OVERRIDE {
+ bool onCombineIfPossible(GrBatch* t) override {
return false;
}
void replaceRenderTarget(bool shouldRetainContent);
- GrRenderTarget* accessRenderTarget() SK_OVERRIDE;
+ GrRenderTarget* accessRenderTarget() override;
- SkImageInfo imageInfo() const SK_OVERRIDE {
+ SkImageInfo imageInfo() const override {
return fRenderTarget ? fRenderTarget->surfacePriv().info() : SkImageInfo::MakeUnknown();
}
const SkSurfaceProps& surfaceProps() const { return fSurfaceProps; }
- void drawPaint(const SkDraw&, const SkPaint& paint) SK_OVERRIDE;
+ void drawPaint(const SkDraw&, const SkPaint& paint) override;
virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count,
- const SkPoint[], const SkPaint& paint) SK_OVERRIDE;
+ const SkPoint[], const SkPaint& paint) override;
virtual void drawRect(const SkDraw&, const SkRect& r,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
virtual void drawRRect(const SkDraw&, const SkRRect& r,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
virtual void drawDRRect(const SkDraw& draw, const SkRRect& outer,
- const SkRRect& inner, const SkPaint& paint) SK_OVERRIDE;
+ const SkRRect& inner, const SkPaint& paint) override;
virtual void drawOval(const SkDraw&, const SkRect& oval,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
virtual void drawPath(const SkDraw&, const SkPath& path,
const SkPaint& paint, const SkMatrix* prePathMatrix,
- bool pathIsMutable) SK_OVERRIDE;
+ bool pathIsMutable) override;
virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
- const SkMatrix&, const SkPaint&) SK_OVERRIDE;
+ const SkMatrix&, const SkPaint&) override;
virtual void drawBitmapRect(const SkDraw&, const SkBitmap&,
const SkRect* srcOrNull, const SkRect& dst,
const SkPaint& paint,
- SkCanvas::DrawBitmapRectFlags flags) SK_OVERRIDE;
+ SkCanvas::DrawBitmapRectFlags flags) override;
virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap,
- int x, int y, const SkPaint& paint) SK_OVERRIDE;
+ int x, int y, const SkPaint& paint) override;
virtual void drawText(const SkDraw&, const void* text, size_t len,
- SkScalar x, SkScalar y, const SkPaint&) SK_OVERRIDE;
+ SkScalar x, SkScalar y, const SkPaint&) override;
virtual void drawPosText(const SkDraw&, const void* text, size_t len,
const SkScalar pos[], int scalarsPerPos,
- const SkPoint& offset, const SkPaint&) SK_OVERRIDE;
+ const SkPoint& offset, const SkPaint&) override;
virtual void drawTextBlob(const SkDraw&, const SkTextBlob*, SkScalar x, SkScalar y,
- const SkPaint& paint, SkDrawFilter* drawFilter) SK_OVERRIDE;
+ const SkPaint& paint, SkDrawFilter* drawFilter) override;
virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount,
const SkPoint verts[], const SkPoint texs[],
const SkColor colors[], SkXfermode* xmode,
const uint16_t indices[], int indexCount,
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
- void flush() SK_OVERRIDE;
+ void flush() override;
- void onAttachToCanvas(SkCanvas* canvas) SK_OVERRIDE;
- void onDetachFromCanvas() SK_OVERRIDE;
+ void onAttachToCanvas(SkCanvas* canvas) override;
+ void onDetachFromCanvas() override;
- const SkBitmap& onAccessBitmap() SK_OVERRIDE;
+ const SkBitmap& onAccessBitmap() override;
- bool canHandleImageFilter(const SkImageFilter*) SK_OVERRIDE;
+ bool canHandleImageFilter(const SkImageFilter*) override;
virtual bool filterImage(const SkImageFilter*, const SkBitmap&,
const SkImageFilter::Context&,
- SkBitmap*, SkIPoint*) SK_OVERRIDE;
+ SkBitmap*, SkIPoint*) override;
bool filterTexture(GrContext*, GrTexture*, const SkImageFilter*,
const SkImageFilter::Context&,
SkBitmap* result, SkIPoint* offset);
protected:
- bool onReadPixels(const SkImageInfo&, void*, size_t, int, int) SK_OVERRIDE;
- bool onWritePixels(const SkImageInfo&, const void*, size_t, int, int) SK_OVERRIDE;
- bool onShouldDisableLCD(const SkPaint&) const SK_OVERRIDE;
+ bool onReadPixels(const SkImageInfo&, void*, size_t, int, int) override;
+ bool onWritePixels(const SkImageInfo&, const void*, size_t, int, int) override;
+ bool onShouldDisableLCD(const SkPaint&) const override;
/** PRIVATE / EXPERIMENTAL -- do not call */
virtual bool EXPERIMENTAL_drawPicture(SkCanvas* canvas, const SkPicture* picture,
- const SkMatrix*, const SkPaint*) SK_OVERRIDE;
+ const SkMatrix*, const SkPaint*) override;
private:
GrContext* fContext;
SkGpuDevice(GrRenderTarget*, const SkSurfaceProps*, unsigned flags);
- SkBaseDevice* onCreateDevice(const CreateInfo&, const SkPaint*) SK_OVERRIDE;
+ SkBaseDevice* onCreateDevice(const CreateInfo&, const SkPaint*) override;
- SkSurface* newSurface(const SkImageInfo&, const SkSurfaceProps&) SK_OVERRIDE;
+ SkSurface* newSurface(const SkImageInfo&, const SkSurfaceProps&) override;
- SkImageFilter::Cache* getImageFilterCache() SK_OVERRIDE;
+ SkImageFilter::Cache* getImageFilterCache() override;
- bool forceConservativeRasterClip() const SK_OVERRIDE { return true; }
+ bool forceConservativeRasterClip() const override { return true; }
// sets the render target and clip on context
void prepareDraw(const SkDraw&);
private:
GrUniqueKeyInvalidatedMessage fMsg;
- void onChange() SK_OVERRIDE {
+ void onChange() override {
SkMessageBus<GrUniqueKeyInvalidatedMessage>::Post(fMsg);
}
};
GrGLConicEffect(const GrGeometryProcessor&,
const GrBatchTracker&);
- void onEmitCode(EmitArgs&, GrGPArgs*) SK_OVERRIDE;
+ void onEmitCode(EmitArgs&, GrGPArgs*) override;
static inline void GenKey(const GrGeometryProcessor&,
const GrBatchTracker&,
virtual void setData(const GrGLProgramDataManager& pdman,
const GrPrimitiveProcessor& primProc,
- const GrBatchTracker& bt) SK_OVERRIDE {
+ const GrBatchTracker& bt) override {
this->setUniformViewMatrix(pdman, primProc.viewMatrix());
const ConicBatchTracker& local = bt.cast<ConicBatchTracker>();
GrGLQuadEffect(const GrGeometryProcessor&,
const GrBatchTracker&);
- void onEmitCode(EmitArgs&, GrGPArgs*) SK_OVERRIDE;
+ void onEmitCode(EmitArgs&, GrGPArgs*) override;
static inline void GenKey(const GrGeometryProcessor&,
const GrBatchTracker&,
virtual void setData(const GrGLProgramDataManager& pdman,
const GrPrimitiveProcessor& primProc,
- const GrBatchTracker& bt) SK_OVERRIDE {
+ const GrBatchTracker& bt) override {
this->setUniformViewMatrix(pdman, primProc.viewMatrix());
const QuadBatchTracker& local = bt.cast<QuadBatchTracker>();
GrGLCubicEffect(const GrGeometryProcessor&,
const GrBatchTracker&);
- void onEmitCode(EmitArgs&, GrGPArgs*) SK_OVERRIDE;
+ void onEmitCode(EmitArgs&, GrGPArgs*) override;
static inline void GenKey(const GrGeometryProcessor&,
const GrBatchTracker&,
virtual void setData(const GrGLProgramDataManager& pdman,
const GrPrimitiveProcessor& primProc,
- const GrBatchTracker& bt) SK_OVERRIDE {
+ const GrBatchTracker& bt) override {
this->setUniformViewMatrix(pdman, primProc.viewMatrix());
const CubicBatchTracker& local = bt.cast<CubicBatchTracker>();
virtual ~GrConicEffect();
- const char* name() const SK_OVERRIDE { return "Conic"; }
+ const char* name() const override { return "Conic"; }
inline const Attribute* inPosition() const { return fInPosition; }
inline const Attribute* inConicCoeffs() const { return fInConicCoeffs; }
virtual void getGLProcessorKey(const GrBatchTracker& bt,
const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+ GrProcessorKeyBuilder* b) const override;
virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
- const GrGLCaps&) const SK_OVERRIDE;
+ const GrGLCaps&) const override;
- void initBatchTracker(GrBatchTracker*, const GrPipelineInfo&) const SK_OVERRIDE;
+ void initBatchTracker(GrBatchTracker*, const GrPipelineInfo&) const override;
bool onCanMakeEqual(const GrBatchTracker&,
const GrGeometryProcessor&,
- const GrBatchTracker&) const SK_OVERRIDE;
+ const GrBatchTracker&) const override;
private:
GrConicEffect(GrColor, const SkMatrix& viewMatrix, uint8_t coverage, GrPrimitiveEdgeType,
const SkMatrix& localMatrix);
- bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE;
+ bool onIsEqual(const GrGeometryProcessor& other) const override;
- void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setUnknownSingleComponent();
}
virtual ~GrQuadEffect();
- const char* name() const SK_OVERRIDE { return "Quad"; }
+ const char* name() const override { return "Quad"; }
inline const Attribute* inPosition() const { return fInPosition; }
inline const Attribute* inHairQuadEdge() const { return fInHairQuadEdge; }
virtual void getGLProcessorKey(const GrBatchTracker& bt,
const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+ GrProcessorKeyBuilder* b) const override;
virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
- const GrGLCaps&) const SK_OVERRIDE;
+ const GrGLCaps&) const override;
- void initBatchTracker(GrBatchTracker*, const GrPipelineInfo&) const SK_OVERRIDE;
+ void initBatchTracker(GrBatchTracker*, const GrPipelineInfo&) const override;
bool onCanMakeEqual(const GrBatchTracker&,
const GrGeometryProcessor&,
- const GrBatchTracker&) const SK_OVERRIDE;
+ const GrBatchTracker&) const override;
private:
GrQuadEffect(GrColor, const SkMatrix& viewMatrix, uint8_t coverage, GrPrimitiveEdgeType,
const SkMatrix& localMatrix);
- bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE;
+ bool onIsEqual(const GrGeometryProcessor& other) const override;
- void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setUnknownSingleComponent();
}
virtual ~GrCubicEffect();
- const char* name() const SK_OVERRIDE { return "Cubic"; }
+ const char* name() const override { return "Cubic"; }
inline const Attribute* inPosition() const { return fInPosition; }
inline const Attribute* inCubicCoeffs() const { return fInCubicCoeffs; }
virtual void getGLProcessorKey(const GrBatchTracker& bt,
const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+ GrProcessorKeyBuilder* b) const override;
virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
- const GrGLCaps&) const SK_OVERRIDE;
+ const GrGLCaps&) const override;
- void initBatchTracker(GrBatchTracker*, const GrPipelineInfo&) const SK_OVERRIDE;
+ void initBatchTracker(GrBatchTracker*, const GrPipelineInfo&) const override;
bool onCanMakeEqual(const GrBatchTracker&,
const GrGeometryProcessor&,
- const GrBatchTracker&) const SK_OVERRIDE;
+ const GrBatchTracker&) const override;
private:
GrCubicEffect(GrColor, const SkMatrix& viewMatrix, GrPrimitiveEdgeType);
- bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE;
+ bool onIsEqual(const GrGeometryProcessor& other) const override;
- void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setUnknownSingleComponent();
}
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
static inline void GenKey(const GrProcessor& effect, const GrGLCaps&,
GrProcessorKeyBuilder* b) {
const float* coefficients() const { return fCoefficients; }
- const char* name() const SK_OVERRIDE { return "Bicubic"; }
+ const char* name() const override { return "Bicubic"; }
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
const GrTextureDomain& domain() const { return fDomain; }
const SkMatrix &matrix, const SkShader::TileMode tileModes[2]);
GrBicubicEffect(GrTexture*, const SkScalar coefficients[16],
const SkMatrix &matrix, const SkRect& domain);
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor&) const override;
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
float fCoefficients[16];
GrTextureDomain fDomain;
GrGLBitmapTextGeoProc(const GrGeometryProcessor&, const GrBatchTracker&)
: fColor(GrColor_ILLEGAL) {}
- void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) SK_OVERRIDE{
+ void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override{
const GrBitmapTextGeoProc& cte = args.fGP.cast<GrBitmapTextGeoProc>();
const BitmapTextBatchTracker& local = args.fBT.cast<BitmapTextBatchTracker>();
virtual void setData(const GrGLProgramDataManager& pdman,
const GrPrimitiveProcessor& gp,
- const GrBatchTracker& bt) SK_OVERRIDE {
+ const GrBatchTracker& bt) override {
this->setUniformViewMatrix(pdman, gp.viewMatrix());
const BitmapTextBatchTracker& local = bt.cast<BitmapTextBatchTracker>();
virtual ~GrBitmapTextGeoProc() {}
- const char* name() const SK_OVERRIDE { return "Texture"; }
+ const char* name() const override { return "Texture"; }
const Attribute* inPosition() const { return fInPosition; }
const Attribute* inColor() const { return fInColor; }
virtual void getGLProcessorKey(const GrBatchTracker& bt,
const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+ GrProcessorKeyBuilder* b) const override;
virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
- const GrGLCaps& caps) const SK_OVERRIDE;
+ const GrGLCaps& caps) const override;
- void initBatchTracker(GrBatchTracker*, const GrPipelineInfo&) const SK_OVERRIDE;
+ void initBatchTracker(GrBatchTracker*, const GrPipelineInfo&) const override;
bool onCanMakeEqual(const GrBatchTracker&,
const GrGeometryProcessor&,
- const GrBatchTracker&) const SK_OVERRIDE;
+ const GrBatchTracker&) const override;
private:
GrBitmapTextGeoProc(GrColor, GrTexture* texture, const GrTextureParams& params,
GrMaskFormat format, bool opaqueVertexColors, const SkMatrix& localMatrix);
- bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE;
+ bool onIsEqual(const GrGeometryProcessor& other) const override;
- void onGetInvariantOutputColor(GrInitInvariantOutput*) const SK_OVERRIDE;
+ void onGetInvariantOutputColor(GrInitInvariantOutput*) const override;
- void onGetInvariantOutputCoverage(GrInitInvariantOutput*) const SK_OVERRIDE;
+ void onGetInvariantOutputCoverage(GrInitInvariantOutput*) const override;
GrTextureAccess fTextureAccess;
const Attribute* fInPosition;
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray& coords,
- const TextureSamplerArray& samplers) SK_OVERRIDE {
+ const TextureSamplerArray& samplers) override {
// Using highp for GLES here in order to avoid some precision issues on specific GPUs.
GrGLShaderVar tmpVar("tmpColor", kVec4f_GrSLType, 0, kHigh_GrSLPrecision);
SkString tmpDecl;
static const GrFragmentProcessor* Create(GrTexture*, bool swapRedAndBlue, PMConversion,
const SkMatrix&);
- const char* name() const SK_OVERRIDE { return "Config Conversion"; }
+ const char* name() const override { return "Config Conversion"; }
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
bool swapsRedAndBlue() const { return fSwapRedAndBlue; }
PMConversion pmConversion() const { return fPMConversion; }
PMConversion pmConversion,
const SkMatrix& matrix);
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor&) const override;
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
bool fSwapRedAndBlue;
PMConversion fPMConversion;
GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
- const char* name() const SK_OVERRIDE { return "AARect"; }
+ const char* name() const override { return "AARect"; }
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
private:
AARectEffect(GrPrimitiveEdgeType edgeType, const SkRect& rect)
this->setWillReadFragmentPosition();
}
- bool onIsEqual(const GrFragmentProcessor& other) const SK_OVERRIDE {
+ bool onIsEqual(const GrFragmentProcessor& other) const override {
const AARectEffect& aare = other.cast<AARectEffect>();
return fRect == aare.fRect;
}
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE {
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
if (fRect.isEmpty()) {
// An empty rect will have no coverage anywhere.
inout->mulByKnownSingleComponent(0);
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder*);
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
GrGLProgramDataManager::UniformHandle fRectUniform;
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder*);
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
GrGLProgramDataManager::UniformHandle fEdgeUniform;
virtual ~GrConvexPolyEffect();
- const char* name() const SK_OVERRIDE { return "ConvexPoly"; }
+ const char* name() const override { return "ConvexPoly"; }
GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
const SkScalar* getEdges() const { return fEdges; }
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
private:
GrConvexPolyEffect(GrPrimitiveEdgeType edgeType, int n, const SkScalar edges[]);
- bool onIsEqual(const GrFragmentProcessor& other) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor& other) const override;
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
GrPrimitiveEdgeType fEdgeType;
int fEdgeCount;
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
- void setData(const GrGLProgramDataManager& pdman, const GrProcessor&) SK_OVERRIDE;
+ void setData(const GrGLProgramDataManager& pdman, const GrProcessor&) override;
static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder*);
const float* bounds() const { return fBounds; }
bool useBounds() const { return fUseBounds; }
- const char* name() const SK_OVERRIDE { return "Convolution"; }
+ const char* name() const override { return "Convolution"; }
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
enum {
// This was decided based on the min allowed value for the max texture
bool useBounds,
float bounds[2]);
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor&) const override;
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE {
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
// If the texture was opaque we could know that the output color if we knew the sum of the
// kernel values.
inout->mulByUnknownFourComponents();
return SkNEW_ARGS(CoverageSetOpXP, (regionOp, invertCoverage));
}
- ~CoverageSetOpXP() SK_OVERRIDE;
+ ~CoverageSetOpXP() override;
- const char* name() const SK_OVERRIDE { return "Coverage Set Op"; }
+ const char* name() const override { return "Coverage Set Op"; }
- GrGLXferProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLXferProcessor* createGLInstance() const override;
- bool hasSecondaryOutput() const SK_OVERRIDE { return false; }
+ bool hasSecondaryOutput() const override { return false; }
GrXferProcessor::OptFlags getOptimizations(const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
bool doesStencilWrite,
GrColor* color,
- const GrDrawTargetCaps& caps) SK_OVERRIDE;
+ const GrDrawTargetCaps& caps) override;
- void getBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const SK_OVERRIDE;
+ void getBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const override;
bool invertCoverage() const { return fInvertCoverage; }
private:
CoverageSetOpXP(SkRegion::Op regionOp, bool fInvertCoverage);
- void onGetGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+ void onGetGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const override;
- bool onIsEqual(const GrXferProcessor& xpBase) const SK_OVERRIDE {
+ bool onIsEqual(const GrXferProcessor& xpBase) const override {
const CoverageSetOpXP& xp = xpBase.cast<CoverageSetOpXP>();
return (fRegionOp == xp.fRegionOp &&
fInvertCoverage == xp.fInvertCoverage);
public:
GLCoverageSetOpXP(const GrProcessor&) {}
- ~GLCoverageSetOpXP() SK_OVERRIDE {}
+ ~GLCoverageSetOpXP() override {}
static void GenKey(const GrProcessor& processor, const GrGLCaps& caps,
GrProcessorKeyBuilder* b) {
};
private:
- void onEmitCode(const EmitArgs& args) SK_OVERRIDE {
+ void onEmitCode(const EmitArgs& args) override {
const CoverageSetOpXP& xp = args.fXP.cast<CoverageSetOpXP>();
GrGLFPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
}
}
- void onSetData(const GrGLProgramDataManager&, const GrXferProcessor&) SK_OVERRIDE {};
+ void onSetData(const GrGLProgramDataManager&, const GrXferProcessor&) override {};
typedef GrGLXferProcessor INHERITED;
};
class GLCustomXferFP : public GrGLFragmentProcessor {
public:
GLCustomXferFP(const GrFragmentProcessor&) {}
- ~GLCustomXferFP() SK_OVERRIDE {};
+ ~GLCustomXferFP() override {};
void emitCode(GrGLFPBuilder* builder,
const GrFragmentProcessor& fp,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray& coords,
- const TextureSamplerArray& samplers) SK_OVERRIDE {
+ const TextureSamplerArray& samplers) override {
SkXfermode::Mode mode = fp.cast<GrCustomXferFP>().mode();
GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
const char* dstColor = "bgColor";
emit_custom_xfermode_code(mode, fsBuilder, outputColor, inputColor, dstColor);
}
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE {}
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override {}
static void GenKey(const GrFragmentProcessor& proc, const GrGLCaps&, GrProcessorKeyBuilder* b) {
// The background may come from the dst or from a texture.
}
}
- ~CustomXP() SK_OVERRIDE {};
+ ~CustomXP() override {};
- const char* name() const SK_OVERRIDE { return "Custom Xfermode"; }
+ const char* name() const override { return "Custom Xfermode"; }
- GrGLXferProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLXferProcessor* createGLInstance() const override;
- bool hasSecondaryOutput() const SK_OVERRIDE { return false; }
+ bool hasSecondaryOutput() const override { return false; }
GrXferProcessor::OptFlags getOptimizations(const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
bool doesStencilWrite,
GrColor* overrideColor,
- const GrDrawTargetCaps& caps) SK_OVERRIDE;
+ const GrDrawTargetCaps& caps) override;
- void getBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const SK_OVERRIDE {
+ void getBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const override {
blendInfo->fSrcBlend = kOne_GrBlendCoeff;
blendInfo->fDstBlend = kZero_GrBlendCoeff;
blendInfo->fBlendConstant = 0;
private:
CustomXP(SkXfermode::Mode mode, const GrDeviceCoordTexture* dstCopy, bool willReadDstColor);
- void onGetGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+ void onGetGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const override;
- bool onIsEqual(const GrXferProcessor& xpBase) const SK_OVERRIDE;
+ bool onIsEqual(const GrXferProcessor& xpBase) const override;
SkXfermode::Mode fMode;
class GLCustomXP : public GrGLXferProcessor {
public:
GLCustomXP(const GrXferProcessor&) {}
- ~GLCustomXP() SK_OVERRIDE {}
+ ~GLCustomXP() override {}
static void GenKey(const GrXferProcessor& proc, const GrGLCaps&, GrProcessorKeyBuilder* b) {
uint32_t key = proc.numTextures();
}
private:
- void onEmitCode(const EmitArgs& args) SK_OVERRIDE {
+ void onEmitCode(const EmitArgs& args) override {
SkXfermode::Mode mode = args.fXP.cast<CustomXP>().mode();
GrGLFPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
const char* dstColor = fsBuilder->dstColor();
args.fInputCoverage, dstColor);
}
- void onSetData(const GrGLProgramDataManager&, const GrXferProcessor&) SK_OVERRIDE {}
+ void onSetData(const GrGLProgramDataManager&, const GrXferProcessor&) override {}
typedef GrGLFragmentProcessor INHERITED;
};
public:
GrCustomXferFP(SkXfermode::Mode mode, GrTexture* background);
- void getGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
- const char* name() const SK_OVERRIDE { return "Custom Xfermode"; }
+ const char* name() const override { return "Custom Xfermode"; }
SkXfermode::Mode mode() const { return fMode; }
const GrTextureAccess& backgroundAccess() const { return fBackgroundAccess; }
private:
- bool onIsEqual(const GrFragmentProcessor& other) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor& other) const override;
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
public:
GrCustomXPFactory(SkXfermode::Mode mode);
- bool supportsRGBCoverage(GrColor knownColor, uint32_t knownColorFlags) const SK_OVERRIDE {
+ bool supportsRGBCoverage(GrColor knownColor, uint32_t knownColorFlags) const override {
return true;
}
- bool canTweakAlphaForCoverage() const SK_OVERRIDE {
+ bool canTweakAlphaForCoverage() const override {
return false;
}
void getInvariantOutput(const GrProcOptInfo& colorPOI, const GrProcOptInfo& coveragePOI,
- GrXPFactory::InvariantOutput*) const SK_OVERRIDE;
+ GrXPFactory::InvariantOutput*) const override;
private:
GrXferProcessor* onCreateXferProcessor(const GrDrawTargetCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
- const GrDeviceCoordTexture* dstCopy) const SK_OVERRIDE;
+ const GrDeviceCoordTexture* dstCopy) const override;
bool willReadDstColor(const GrDrawTargetCaps& caps,
const GrProcOptInfo& colorPOI,
- const GrProcOptInfo& coveragePOI) const SK_OVERRIDE {
+ const GrProcOptInfo& coveragePOI) const override {
return true;
}
- bool onIsEqual(const GrXPFactory& xpfBase) const SK_OVERRIDE {
+ bool onIsEqual(const GrXPFactory& xpfBase) const override {
const GrCustomXPFactory& xpf = xpfBase.cast<GrCustomXPFactory>();
return fMode == xpf.fMode;
}
return SkNEW_ARGS(DashBatch, (geometry, cap, useAA, fullDash));
}
- const char* name() const SK_OVERRIDE { return "DashBatch"; }
+ const char* name() const override { return "DashBatch"; }
- void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
// When this is called on a batch, there is only one geometry bundle
out->setKnownFourComponents(fGeoData[0].fColor);
}
- void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+ void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
out->setUnknownSingleComponent();
}
- void initBatchTracker(const GrPipelineInfo& init) SK_OVERRIDE {
+ void initBatchTracker(const GrPipelineInfo& init) override {
// Handle any color overrides
if (init.fColorIgnored) {
fGeoData[0].fColor = GrColor_ILLEGAL;
bool fHasEndRect;
};
- void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) SK_OVERRIDE {
+ void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
int instanceCount = fGeoData.count();
SkMatrix invert;
fBatch.fFullDash = fullDash;
}
- bool onCombineIfPossible(GrBatch* t) SK_OVERRIDE {
+ bool onCombineIfPossible(GrBatch* t) override {
DashBatch* that = t->cast<DashBatch>();
if (this->useAA() != that->useAA()) {
virtual ~DashingCircleEffect();
- const char* name() const SK_OVERRIDE { return "DashingCircleEffect"; }
+ const char* name() const override { return "DashingCircleEffect"; }
const Attribute* inPosition() const { return fInPosition; }
virtual void getGLProcessorKey(const GrBatchTracker&,
const GrGLCaps&,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+ GrProcessorKeyBuilder* b) const override;
virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker&,
- const GrGLCaps&) const SK_OVERRIDE;
+ const GrGLCaps&) const override;
- void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const SK_OVERRIDE;
+ void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override;
bool onCanMakeEqual(const GrBatchTracker&,
const GrGeometryProcessor&,
- const GrBatchTracker&) const SK_OVERRIDE;
+ const GrBatchTracker&) const override;
private:
DashingCircleEffect(GrColor, GrPrimitiveEdgeType edgeType, const SkMatrix& localMatrix);
- bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE;
+ bool onIsEqual(const GrGeometryProcessor& other) const override;
- void onGetInvariantOutputCoverage(GrInitInvariantOutput*) const SK_OVERRIDE;
+ void onGetInvariantOutputCoverage(GrInitInvariantOutput*) const override;
GrPrimitiveEdgeType fEdgeType;
const Attribute* fInPosition;
public:
GLDashingCircleEffect(const GrGeometryProcessor&, const GrBatchTracker&);
- void onEmitCode(EmitArgs&, GrGPArgs*) SK_OVERRIDE;
+ void onEmitCode(EmitArgs&, GrGPArgs*) override;
static inline void GenKey(const GrGeometryProcessor&,
const GrBatchTracker&,
virtual void setData(const GrGLProgramDataManager&,
const GrPrimitiveProcessor&,
- const GrBatchTracker&) SK_OVERRIDE;
+ const GrBatchTracker&) override;
private:
UniformHandle fParamUniform;
virtual ~DashingLineEffect();
- const char* name() const SK_OVERRIDE { return "DashingEffect"; }
+ const char* name() const override { return "DashingEffect"; }
const Attribute* inPosition() const { return fInPosition; }
virtual void getGLProcessorKey(const GrBatchTracker& bt,
const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+ GrProcessorKeyBuilder* b) const override;
virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
- const GrGLCaps&) const SK_OVERRIDE;
+ const GrGLCaps&) const override;
- void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const SK_OVERRIDE;
+ void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override;
bool onCanMakeEqual(const GrBatchTracker&,
const GrGeometryProcessor&,
- const GrBatchTracker&) const SK_OVERRIDE;
+ const GrBatchTracker&) const override;
private:
DashingLineEffect(GrColor, GrPrimitiveEdgeType edgeType, const SkMatrix& localMatrix);
- bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE;
+ bool onIsEqual(const GrGeometryProcessor& other) const override;
- void onGetInvariantOutputCoverage(GrInitInvariantOutput*) const SK_OVERRIDE;
+ void onGetInvariantOutputCoverage(GrInitInvariantOutput*) const override;
GrPrimitiveEdgeType fEdgeType;
const Attribute* fInPosition;
public:
GLDashingLineEffect(const GrGeometryProcessor&, const GrBatchTracker&);
- void onEmitCode(EmitArgs&, GrGPArgs*) SK_OVERRIDE;
+ void onEmitCode(EmitArgs&, GrGPArgs*) override;
static inline void GenKey(const GrGeometryProcessor&,
const GrBatchTracker&,
virtual void setData(const GrGLProgramDataManager&,
const GrPrimitiveProcessor&,
- const GrBatchTracker&) SK_OVERRIDE;
+ const GrBatchTracker&) override;
private:
GrColor fColor;
return SkNEW(DisableColorXP);
}
- ~DisableColorXP() SK_OVERRIDE {};
+ ~DisableColorXP() override {};
- const char* name() const SK_OVERRIDE { return "Disable Color"; }
+ const char* name() const override { return "Disable Color"; }
- GrGLXferProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLXferProcessor* createGLInstance() const override;
- bool hasSecondaryOutput() const SK_OVERRIDE { return false; }
+ bool hasSecondaryOutput() const override { return false; }
GrXferProcessor::OptFlags getOptimizations(const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
bool doesStencilWrite,
GrColor* color,
- const GrDrawTargetCaps& caps) SK_OVERRIDE {
+ const GrDrawTargetCaps& caps) override {
return GrXferProcessor::kIgnoreColor_OptFlag | GrXferProcessor::kIgnoreCoverage_OptFlag;
}
- void getBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const SK_OVERRIDE;
+ void getBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const override;
private:
DisableColorXP();
- void onGetGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+ void onGetGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const override;
- bool onIsEqual(const GrXferProcessor& xpBase) const SK_OVERRIDE {
+ bool onIsEqual(const GrXferProcessor& xpBase) const override {
return true;
}
public:
GLDisableColorXP(const GrProcessor&) {}
- ~GLDisableColorXP() SK_OVERRIDE {}
+ ~GLDisableColorXP() override {}
static void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder*) {}
private:
- void onEmitCode(const EmitArgs& args) SK_OVERRIDE {
+ void onEmitCode(const EmitArgs& args) override {
// This emit code should be empty. However, on the nexus 6 there is a driver bug where if
// you do not give gl_FragColor a value, the gl context is lost and we end up drawing
// nothing. So this fix just sets the gl_FragColor arbitrarily to 0.
fsBuilder->codeAppendf("%s = vec4(0);", args.fOutputPrimary);
}
- void onSetData(const GrGLProgramDataManager&, const GrXferProcessor&) SK_OVERRIDE {}
+ void onSetData(const GrGLProgramDataManager&, const GrXferProcessor&) override {}
typedef GrGLXferProcessor INHERITED;
};
return SkNEW(GrDisableColorXPFactory);
}
- bool supportsRGBCoverage(GrColor knownColor, uint32_t knownColorFlags) const SK_OVERRIDE {
+ bool supportsRGBCoverage(GrColor knownColor, uint32_t knownColorFlags) const override {
return true;
}
- bool canTweakAlphaForCoverage() const SK_OVERRIDE { return true; }
+ bool canTweakAlphaForCoverage() const override { return true; }
void getInvariantOutput(const GrProcOptInfo& colorPOI, const GrProcOptInfo& coveragePOI,
- GrXPFactory::InvariantOutput* output) const SK_OVERRIDE {
+ GrXPFactory::InvariantOutput* output) const override {
output->fBlendedColorFlags = 0;
output->fWillBlendWithDst = 0;
}
GrXferProcessor* onCreateXferProcessor(const GrDrawTargetCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
- const GrDeviceCoordTexture* dstCopy) const SK_OVERRIDE;
+ const GrDeviceCoordTexture* dstCopy) const override;
bool willReadDstColor(const GrDrawTargetCaps& caps,
const GrProcOptInfo& colorPOI,
- const GrProcOptInfo& coveragePOI) const SK_OVERRIDE {
+ const GrProcOptInfo& coveragePOI) const override {
return false;
}
- bool onIsEqual(const GrXPFactory& xpfBase) const SK_OVERRIDE {
+ bool onIsEqual(const GrXPFactory& xpfBase) const override {
return true;
}
#endif
{}
- void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) SK_OVERRIDE{
+ void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override{
const GrDistanceFieldTextureEffect& dfTexEffect =
args.fGP.cast<GrDistanceFieldTextureEffect>();
const DistanceFieldBatchTracker& local = args.fBT.cast<DistanceFieldBatchTracker>();
virtual void setData(const GrGLProgramDataManager& pdman,
const GrPrimitiveProcessor& proc,
- const GrBatchTracker& bt) SK_OVERRIDE {
+ const GrBatchTracker& bt) override {
#ifdef SK_GAMMA_APPLY_TO_A8
const GrDistanceFieldTextureEffect& dfTexEffect =
proc.cast<GrDistanceFieldTextureEffect>();
const GrBatchTracker&)
: fColor(GrColor_ILLEGAL), fTextureSize(SkISize::Make(-1, -1)) {}
- void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) SK_OVERRIDE{
+ void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override{
const GrDistanceFieldNoGammaTextureEffect& dfTexEffect =
args.fGP.cast<GrDistanceFieldNoGammaTextureEffect>();
virtual void setData(const GrGLProgramDataManager& pdman,
const GrPrimitiveProcessor& proc,
- const GrBatchTracker& bt) SK_OVERRIDE {
+ const GrBatchTracker& bt) override {
SkASSERT(fTextureSizeUni.isValid());
GrTexture* texture = proc.texture(0);
: fColor(GrColor_ILLEGAL)
, fTextColor(GrColor_ILLEGAL) {}
- void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) SK_OVERRIDE{
+ void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override{
const GrDistanceFieldLCDTextureEffect& dfTexEffect =
args.fGP.cast<GrDistanceFieldLCDTextureEffect>();
const DistanceFieldLCDBatchTracker& local = args.fBT.cast<DistanceFieldLCDBatchTracker>();
virtual void setData(const GrGLProgramDataManager& pdman,
const GrPrimitiveProcessor& processor,
- const GrBatchTracker& bt) SK_OVERRIDE {
+ const GrBatchTracker& bt) override {
SkASSERT(fTextColorUni.isValid());
const GrDistanceFieldLCDTextureEffect& dfTexEffect =
virtual ~GrDistanceFieldTextureEffect() {}
- const char* name() const SK_OVERRIDE { return "DistanceFieldTexture"; }
+ const char* name() const override { return "DistanceFieldTexture"; }
const Attribute* inPosition() const { return fInPosition; }
const Attribute* inColor() const { return fInColor; }
virtual void getGLProcessorKey(const GrBatchTracker& bt,
const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+ GrProcessorKeyBuilder* b) const override;
virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
- const GrGLCaps&) const SK_OVERRIDE;
+ const GrGLCaps&) const override;
- void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const SK_OVERRIDE;
+ void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override;
bool onCanMakeEqual(const GrBatchTracker&,
const GrGeometryProcessor&,
- const GrBatchTracker&) const SK_OVERRIDE;
+ const GrBatchTracker&) const override;
private:
GrDistanceFieldTextureEffect(GrColor, const SkMatrix& viewMatrix, GrTexture* texture,
#endif
uint32_t flags, bool opaqueVertexColors);
- bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE;
+ bool onIsEqual(const GrGeometryProcessor& other) const override;
- void onGetInvariantOutputCoverage(GrInitInvariantOutput*) const SK_OVERRIDE;
+ void onGetInvariantOutputCoverage(GrInitInvariantOutput*) const override;
GrTextureAccess fTextureAccess;
#ifdef SK_GAMMA_APPLY_TO_A8
virtual ~GrDistanceFieldNoGammaTextureEffect() {}
- const char* name() const SK_OVERRIDE { return "DistanceFieldTexture"; }
+ const char* name() const override { return "DistanceFieldTexture"; }
const Attribute* inPosition() const { return fInPosition; }
const Attribute* inColor() const { return fInColor; }
virtual void getGLProcessorKey(const GrBatchTracker& bt,
const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+ GrProcessorKeyBuilder* b) const override;
virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
- const GrGLCaps&) const SK_OVERRIDE;
+ const GrGLCaps&) const override;
- void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const SK_OVERRIDE;
+ void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override;
bool onCanMakeEqual(const GrBatchTracker&,
const GrGeometryProcessor&,
- const GrBatchTracker&) const SK_OVERRIDE;
+ const GrBatchTracker&) const override;
private:
GrDistanceFieldNoGammaTextureEffect(GrColor, const SkMatrix& viewMatrix, GrTexture* texture,
const GrTextureParams& params, uint32_t flags,
bool opaqueVertexColors);
- bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE;
+ bool onIsEqual(const GrGeometryProcessor& other) const override;
- void onGetInvariantOutputCoverage(GrInitInvariantOutput*) const SK_OVERRIDE;
+ void onGetInvariantOutputCoverage(GrInitInvariantOutput*) const override;
GrTextureAccess fTextureAccess;
uint32_t fFlags;
virtual ~GrDistanceFieldLCDTextureEffect() {}
- const char* name() const SK_OVERRIDE { return "DistanceFieldLCDTexture"; }
+ const char* name() const override { return "DistanceFieldLCDTexture"; }
const Attribute* inPosition() const { return fInPosition; }
const Attribute* inTextureCoords() const { return fInTextureCoords; }
virtual void getGLProcessorKey(const GrBatchTracker& bt,
const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+ GrProcessorKeyBuilder* b) const override;
virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
- const GrGLCaps&) const SK_OVERRIDE;
+ const GrGLCaps&) const override;
- void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const SK_OVERRIDE;
+ void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override;
bool onCanMakeEqual(const GrBatchTracker&,
const GrGeometryProcessor&,
- const GrBatchTracker&) const SK_OVERRIDE;
+ const GrBatchTracker&) const override;
private:
GrDistanceFieldLCDTextureEffect(GrColor, const SkMatrix& viewMatrix, GrTexture* texture,
GrTexture* gamma, const GrTextureParams& gammaParams,
SkColor textColor, uint32_t flags);
- bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE;
+ bool onIsEqual(const GrGeometryProcessor& other) const override;
- void onGetInvariantOutputCoverage(GrInitInvariantOutput*) const SK_OVERRIDE;
+ void onGetInvariantOutputCoverage(GrInitInvariantOutput*) const override;
GrTextureAccess fTextureAccess;
GrTextureAccess fGammaTextureAccess;
virtual ~DitherEffect() {};
- const char* name() const SK_OVERRIDE { return "Dither"; }
+ const char* name() const override { return "Dither"; }
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
private:
DitherEffect() {
}
// All dither effects are equal
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE { return true; }
+ bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
private:
typedef GrGLFragmentProcessor INHERITED;
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder*);
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
typedef GrGLProgramDataManager::UniformHandle UniformHandle;
bool convolveAlpha() const { return fConvolveAlpha; }
const GrTextureDomain& domain() const { return fDomain; }
- const char* name() const SK_OVERRIDE { return "MatrixConvolution"; }
+ const char* name() const override { return "MatrixConvolution"; }
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
private:
GrMatrixConvolutionEffect(GrTexture*,
GrTextureDomain::Mode tileMode,
bool convolveAlpha);
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor&) const override;
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE {
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
// TODO: Try to do better?
inout->mulByUnknownFourComponents();
}
virtual ~CircleEffect() {};
- const char* name() const SK_OVERRIDE { return "Circle"; }
+ const char* name() const override { return "Circle"; }
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
const SkPoint& getCenter() const { return fCenter; }
SkScalar getRadius() const { return fRadius; }
private:
CircleEffect(GrPrimitiveEdgeType, const SkPoint& center, SkScalar radius);
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor&) const override;
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
SkPoint fCenter;
SkScalar fRadius;
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder*);
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
GrGLProgramDataManager::UniformHandle fCircleUniform;
virtual ~EllipseEffect() {};
- const char* name() const SK_OVERRIDE { return "Ellipse"; }
+ const char* name() const override { return "Ellipse"; }
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
const SkPoint& getCenter() const { return fCenter; }
SkVector getRadii() const { return fRadii; }
private:
EllipseEffect(GrPrimitiveEdgeType, const SkPoint& center, SkScalar rx, SkScalar ry);
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor&) const override;
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
SkPoint fCenter;
SkVector fRadii;
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder*);
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
GrGLProgramDataManager::UniformHandle fEllipseUniform;
willReadDstColor));
}
- ~PorterDuffXferProcessor() SK_OVERRIDE;
+ ~PorterDuffXferProcessor() override;
- const char* name() const SK_OVERRIDE { return "Porter Duff"; }
+ const char* name() const override { return "Porter Duff"; }
- GrGLXferProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLXferProcessor* createGLInstance() const override;
- bool hasSecondaryOutput() const SK_OVERRIDE;
+ bool hasSecondaryOutput() const override;
///////////////////////////////////////////////////////////////////////////
/// @name Stage Output Types
const GrProcOptInfo& coveragePOI,
bool doesStencilWrite,
GrColor* overrideColor,
- const GrDrawTargetCaps& caps) SK_OVERRIDE;
+ const GrDrawTargetCaps& caps) override;
- void getBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const SK_OVERRIDE {
+ void getBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const override {
if (!this->willReadDstColor()) {
blendInfo->fSrcBlend = fSrcBlend;
blendInfo->fDstBlend = fDstBlend;
PorterDuffXferProcessor(GrBlendCoeff srcBlend, GrBlendCoeff dstBlend, GrColor constant,
const GrDeviceCoordTexture* dstCopy, bool willReadDstColor);
- void onGetGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+ void onGetGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const override;
- bool onIsEqual(const GrXferProcessor& xpBase) const SK_OVERRIDE {
+ bool onIsEqual(const GrXferProcessor& xpBase) const override {
const PorterDuffXferProcessor& xp = xpBase.cast<PorterDuffXferProcessor>();
if (fSrcBlend != xp.fSrcBlend ||
fDstBlend != xp.fDstBlend ||
};
private:
- void onEmitCode(const EmitArgs& args) SK_OVERRIDE {
+ void onEmitCode(const EmitArgs& args) override {
const PorterDuffXferProcessor& xp = args.fXP.cast<PorterDuffXferProcessor>();
GrGLFPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
if (PorterDuffXferProcessor::kCustom_PrimaryOutputType != xp.primaryOutputType()) {
}
}
- void onSetData(const GrGLProgramDataManager&, const GrXferProcessor&) SK_OVERRIDE {};
+ void onSetData(const GrGLProgramDataManager&, const GrXferProcessor&) override {};
typedef GrGLXferProcessor INHERITED;
};
virtual ~CircularRRectEffect() {};
- const char* name() const SK_OVERRIDE { return "CircularRRect"; }
+ const char* name() const override { return "CircularRRect"; }
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
const SkRRect& getRRect() const { return fRRect; }
private:
CircularRRectEffect(GrPrimitiveEdgeType, uint32_t circularCornerFlags, const SkRRect&);
- bool onIsEqual(const GrFragmentProcessor& other) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor& other) const override;
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
SkRRect fRRect;
GrPrimitiveEdgeType fEdgeType;
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder*);
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
GrGLProgramDataManager::UniformHandle fInnerRectUniform;
virtual ~EllipticalRRectEffect() {};
- const char* name() const SK_OVERRIDE { return "EllipticalRRect"; }
+ const char* name() const override { return "EllipticalRRect"; }
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
const SkRRect& getRRect() const { return fRRect; }
private:
EllipticalRRectEffect(GrPrimitiveEdgeType, const SkRRect&);
- bool onIsEqual(const GrFragmentProcessor& other) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor& other) const override;
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
SkRRect fRRect;
GrPrimitiveEdgeType fEdgeType;
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder*);
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
GrGLProgramDataManager::UniformHandle fInnerRectUniform;
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray& coords,
- const TextureSamplerArray& samplers) SK_OVERRIDE {
+ const TextureSamplerArray& samplers) override {
GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
fsBuilder->codeAppendf("\t%s = ", outputColor);
fsBuilder->appendTextureLookupAndModulate(inputColor,
virtual ~GrSimpleTextureEffect() {}
- const char* name() const SK_OVERRIDE { return "SimpleTexture"; }
+ const char* name() const override { return "SimpleTexture"; }
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
private:
GrSimpleTextureEffect(GrTexture* texture,
this->initClassID<GrSimpleTextureEffect>();
}
- bool onIsEqual(const GrFragmentProcessor& other) const SK_OVERRIDE { return true; }
+ bool onIsEqual(const GrFragmentProcessor& other) const override { return true; }
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
- const TextureSamplerArray&) SK_OVERRIDE;
+ const TextureSamplerArray&) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
+ void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder*);
virtual ~GrTextureDomainEffect();
- const char* name() const SK_OVERRIDE { return "TextureDomain"; }
+ const char* name() const override { return "TextureDomain"; }
- void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+ void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+ GrGLFragmentProcessor* createGLInstance() const override;
const GrTextureDomain& textureDomain() const { return fTextureDomain; }
GrTextureParams::FilterMode,
GrCoordSet);
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
+ bool onIsEqual(const GrFragmentProcessor&) const override;
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
uvFilterMode, colorSpace));
}
- const char* name() const SK_OVERRIDE { return "YUV to RGB"; }
+ const char* name() const override { return "YUV to RGB"; }
SkYUVColorSpace getColorSpace() const {
return fColorSpace;
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray& coords,
- const TextureSamplerArray& samplers) SK_OVERRIDE {
+ const TextureSamplerArray& samplers) override {
GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
const char* yuvMatrix = NULL;
}
virtual void setData(const GrGLProgramDataManager& pdman,
- const GrProcessor& processor) SK_OVERRIDE {
+ const GrProcessor& processor) override {
const YUVtoRGBEffect& yuvEffect = processor.cast<YUVtoRGBEffect>();
switch (yuvEffect.getColorSpace()) {
case kJPEG_SkYUVColorSpace:
};
virtual void getGLProcessorKey(const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrProcessorKeyBuilder* b) const override {
GLProcessor::GenKey(*this, caps, b);
}
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ GrGLFragmentProcessor* createGLInstance() const override {
return SkNEW_ARGS(GLProcessor, (*this));
}
this->addTextureAccess(&fVAccess);
}
- bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
+ bool onIsEqual(const GrFragmentProcessor& sBase) const override {
const YUVtoRGBEffect& s = sBase.cast<YUVtoRGBEffect>();
return fColorSpace == s.getColorSpace();
}
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE {
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
// YUV is opaque
inout->setToOther(kA_GrColorComponentFlag, 0xFF << GrColor_SHIFT_A,
GrInvariantOutput::kWillNot_ReadInput);
/**
* Resets the caps such that nothing is supported.
*/
- void reset() SK_OVERRIDE;
+ void reset() override;
/**
* Initializes the GrGLCaps to the set of features supported in the current
/**
* Returns a string containing the caps info.
*/
- SkString dump() const SK_OVERRIDE;
+ SkString dump() const override;
/**
* LATC can appear under one of three possible names. In order to know
class GrGLGeometryProcessor : public GrGLPrimitiveProcessor {
public:
/* Any general emit code goes in the base class emitCode. Subclasses override onEmitCode */
- void emitCode(EmitArgs&) SK_OVERRIDE;
+ void emitCode(EmitArgs&) override;
void setTransformData(const GrPrimitiveProcessor&,
const GrGLProgramDataManager&,
class GrGLGpu : public GrGpu {
public:
GrGLGpu(const GrGLContext& ctx, GrContext* context);
- ~GrGLGpu() SK_OVERRIDE;
+ ~GrGLGpu() override;
- void contextAbandoned() SK_OVERRIDE;
+ void contextAbandoned() override;
const GrGLContext& glContext() const { return fGLContext; }
return static_cast<GrGLPathRendering*>(pathRendering());
}
- void discard(GrRenderTarget*) SK_OVERRIDE;
+ void discard(GrRenderTarget*) override;
// Used by GrGLProgram and GrGLPathTexGenProgramEffects to configure OpenGL
// state.
// GrGpu overrides
GrPixelConfig preferredReadPixelsConfig(GrPixelConfig readConfig,
- GrPixelConfig surfaceConfig) const SK_OVERRIDE;
+ GrPixelConfig surfaceConfig) const override;
GrPixelConfig preferredWritePixelsConfig(GrPixelConfig writeConfig,
- GrPixelConfig surfaceConfig) const SK_OVERRIDE;
- bool canWriteTexturePixels(const GrTexture*, GrPixelConfig srcConfig) const SK_OVERRIDE;
+ GrPixelConfig surfaceConfig) const override;
+ bool canWriteTexturePixels(const GrTexture*, GrPixelConfig srcConfig) const override;
bool readPixelsWillPayForYFlip(GrRenderTarget* renderTarget,
int left, int top,
int width, int height,
GrPixelConfig config,
- size_t rowBytes) const SK_OVERRIDE;
- bool fullReadPixelsIsFasterThanPartial() const SK_OVERRIDE;
+ size_t rowBytes) const override;
+ bool fullReadPixelsIsFasterThanPartial() const override;
- bool initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) SK_OVERRIDE;
+ bool initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) override;
// These functions should be used to bind GL objects. They track the GL state and skip redundant
// bindings. Making the equivalent glBind calls directly will confuse the state tracking.
bool copySurface(GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
- const SkIPoint& dstPoint) SK_OVERRIDE;
+ const SkIPoint& dstPoint) override;
bool canCopySurface(const GrSurface* dst,
const GrSurface* src,
const SkIRect& srcRect,
- const SkIPoint& dstPoint) SK_OVERRIDE;
+ const SkIPoint& dstPoint) override;
void buildProgramDesc(GrProgramDesc*,
const GrPrimitiveProcessor&,
const GrPipeline&,
- const GrBatchTracker&) const SK_OVERRIDE;
+ const GrBatchTracker&) const override;
private:
// GrGpu overrides
- void onResetContext(uint32_t resetBits) SK_OVERRIDE;
+ void onResetContext(uint32_t resetBits) override;
GrTexture* onCreateTexture(const GrSurfaceDesc& desc, bool budgeted, const void* srcData,
- size_t rowBytes) SK_OVERRIDE;
+ size_t rowBytes) override;
GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc, bool budgeted,
- const void* srcData) SK_OVERRIDE;
- GrVertexBuffer* onCreateVertexBuffer(size_t size, bool dynamic) SK_OVERRIDE;
- GrIndexBuffer* onCreateIndexBuffer(size_t size, bool dynamic) SK_OVERRIDE;
- GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&) SK_OVERRIDE;
- GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) SK_OVERRIDE;
- bool createStencilBufferForRenderTarget(GrRenderTarget* rt, int width, int height) SK_OVERRIDE;
- bool attachStencilBufferToRenderTarget(GrStencilBuffer* sb, GrRenderTarget* rt) SK_OVERRIDE;
+ const void* srcData) override;
+ GrVertexBuffer* onCreateVertexBuffer(size_t size, bool dynamic) override;
+ GrIndexBuffer* onCreateIndexBuffer(size_t size, bool dynamic) override;
+ GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&) override;
+ GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) override;
+ bool createStencilBufferForRenderTarget(GrRenderTarget* rt, int width, int height) override;
+ bool attachStencilBufferToRenderTarget(GrStencilBuffer* sb, GrRenderTarget* rt) override;
void onClear(GrRenderTarget*, const SkIRect* rect, GrColor color,
- bool canIgnoreRect) SK_OVERRIDE;
+ bool canIgnoreRect) override;
- void onClearStencilClip(GrRenderTarget*, const SkIRect& rect, bool insideClip) SK_OVERRIDE;
+ void onClearStencilClip(GrRenderTarget*, const SkIRect& rect, bool insideClip) override;
bool onReadPixels(GrRenderTarget* target,
int left, int top,
int width, int height,
GrPixelConfig,
void* buffer,
- size_t rowBytes) SK_OVERRIDE;
+ size_t rowBytes) override;
bool onWriteTexturePixels(GrTexture* texture,
int left, int top, int width, int height,
GrPixelConfig config, const void* buffer,
- size_t rowBytes) SK_OVERRIDE;
+ size_t rowBytes) override;
- void onResolveRenderTarget(GrRenderTarget* target) SK_OVERRIDE;
+ void onResolveRenderTarget(GrRenderTarget* target) override;
- void onDraw(const DrawArgs&, const GrDrawTarget::DrawInfo&) SK_OVERRIDE;
- void onStencilPath(const GrPath*, const StencilPathState&) SK_OVERRIDE;
- void onDrawPath(const DrawArgs&, const GrPath*, const GrStencilSettings&) SK_OVERRIDE;
+ void onDraw(const DrawArgs&, const GrDrawTarget::DrawInfo&) override;
+ void onStencilPath(const GrPath*, const StencilPathState&) override;
+ void onDrawPath(const DrawArgs&, const GrPath*, const GrStencilSettings&) override;
void onDrawPaths(const DrawArgs&,
const GrPathRange*,
const void* indices,
const float transformValues[],
GrDrawTarget::PathTransformType,
int count,
- const GrStencilSettings&) SK_OVERRIDE;
+ const GrStencilSettings&) override;
- void clearStencil(GrRenderTarget*) SK_OVERRIDE;
+ void clearStencil(GrRenderTarget*) override;
// GrDrawTarget overrides
- void didAddGpuTraceMarker() SK_OVERRIDE;
- void didRemoveGpuTraceMarker() SK_OVERRIDE;
+ void didAddGpuTraceMarker() override;
+ void didRemoveGpuTraceMarker() override;
// binds texture unit in GL
void setTextureUnit(int unitIdx);
}
protected:
- void onAbandon() SK_OVERRIDE;
- void onRelease() SK_OVERRIDE;
+ void onAbandon() override;
+ void onRelease() override;
private:
- void* onMap() SK_OVERRIDE;
- void onUnmap() SK_OVERRIDE;
- bool onUpdateData(const void* src, size_t srcSizeInBytes) SK_OVERRIDE;
+ void* onMap() override;
+ void onUnmap() override;
+ bool onUpdateData(const void* src, size_t srcSizeInBytes) override;
GrGLGpu* getGpuGL() const {
SkASSERT(!this->wasDestroyed());
this->updateStats();
}
- SparseNameRange* SK_WARN_UNUSED_RESULT internalAllocate(GrGLuint* outName) SK_OVERRIDE {
+ SparseNameRange* SK_WARN_UNUSED_RESULT internalAllocate(GrGLuint* outName) override {
// Try allocating the range inside fLeft's internal gaps.
fLeft.reset(fLeft->internalAllocate(outName));
if (0 != *outName) {
return this->takeRef();
}
- SparseNameRange* SK_WARN_UNUSED_RESULT removeLeftmostContiguousRange(GrGLuint* removedCount) SK_OVERRIDE {
+ SparseNameRange* SK_WARN_UNUSED_RESULT removeLeftmostContiguousRange(GrGLuint* removedCount) override {
fLeft.reset(fLeft->removeLeftmostContiguousRange(removedCount));
if (NULL == fLeft) {
return fRight.detach();
return this->rebalance();
}
- GrGLuint appendNames(GrGLuint count) SK_OVERRIDE {
+ GrGLuint appendNames(GrGLuint count) override {
SkASSERT(fEnd + count > fEnd); // Check for integer wrap.
GrGLuint name = fRight->appendNames(count);
SkASSERT(fRight->end() == fEnd + count);
return name;
}
- GrGLuint prependNames(GrGLuint count) SK_OVERRIDE {
+ GrGLuint prependNames(GrGLuint count) override {
SkASSERT(fFirst > count); // We can't allocate at or below 0.
GrGLuint name = fLeft->prependNames(count);
SkASSERT(fLeft->first() == fFirst - count);
return name;
}
- SparseNameRange* SK_WARN_UNUSED_RESULT free(GrGLuint name) SK_OVERRIDE {
+ SparseNameRange* SK_WARN_UNUSED_RESULT free(GrGLuint name) override {
if (name < fLeft->end()) {
fLeft.reset(fLeft->free(name));
if (NULL == fLeft) {
fHeight = 0;
}
- SparseNameRange* SK_WARN_UNUSED_RESULT internalAllocate(GrGLuint* outName) SK_OVERRIDE {
+ SparseNameRange* SK_WARN_UNUSED_RESULT internalAllocate(GrGLuint* outName) override {
*outName = 0; // No internal gaps, we are contiguous.
return this->takeRef();
}
- SparseNameRange* SK_WARN_UNUSED_RESULT removeLeftmostContiguousRange(GrGLuint* removedCount) SK_OVERRIDE {
+ SparseNameRange* SK_WARN_UNUSED_RESULT removeLeftmostContiguousRange(GrGLuint* removedCount) override {
*removedCount = fEnd - fFirst;
return NULL;
}
- GrGLuint appendNames(GrGLuint count) SK_OVERRIDE {
+ GrGLuint appendNames(GrGLuint count) override {
SkASSERT(fEnd + count > fEnd); // Check for integer wrap.
GrGLuint name = fEnd;
fEnd += count;
return name;
}
- GrGLuint prependNames(GrGLuint count) SK_OVERRIDE {
+ GrGLuint prependNames(GrGLuint count) override {
SkASSERT(fFirst > count); // We can't allocate at or below 0.
fFirst -= count;
return fFirst;
}
- SparseNameRange* SK_WARN_UNUSED_RESULT free(GrGLuint name) SK_OVERRIDE {
+ SparseNameRange* SK_WARN_UNUSED_RESULT free(GrGLuint name) override {
if (name < fFirst || name >= fEnd) {
// Not-allocated names are silently ignored.
return this->takeRef();
GrGLuint pathID() const { return fPathID; }
protected:
- void onRelease() SK_OVERRIDE;
- void onAbandon() SK_OVERRIDE;
+ void onRelease() override;
+ void onAbandon() override;
private:
// TODO: Figure out how to get an approximate size of the path in Gpu memory.
- size_t onGpuMemorySize() const SK_OVERRIDE { return 100; }
+ size_t onGpuMemorySize() const override { return 100; }
GrGLuint fPathID;
const GrGLCaps&,
GrProcessorKeyBuilder* b);
- void emitCode(EmitArgs&) SK_OVERRIDE;
+ void emitCode(EmitArgs&) override;
virtual void emitTransforms(GrGLGPBuilder*, const TransformsIn&, TransformsOut*) = 0;
void setData(const GrGLProgramDataManager&,
const GrPrimitiveProcessor&,
- const GrBatchTracker&) SK_OVERRIDE;
+ const GrBatchTracker&) override;
virtual void setTransformData(const GrPrimitiveProcessor&,
int index,
return firstFreeCoordSet;
}
- void emitTransforms(GrGLGPBuilder*, const TransformsIn& tin, TransformsOut* tout) SK_OVERRIDE;
+ void emitTransforms(GrGLGPBuilder*, const TransformsIn& tin, TransformsOut* tout) override;
void setTransformData(const GrPrimitiveProcessor& primProc,
int index,
const SkTArray<const GrCoordTransform*, true>& transforms,
GrGLPathRendering* glpr,
- GrGLuint) SK_OVERRIDE;
+ GrGLuint) override;
- void didSetData(GrGLPathRendering* glpr) SK_OVERRIDE;
+ void didSetData(GrGLPathRendering* glpr) override;
private:
SkDEBUGCODE(int fMaxTexCoords;)
GrGLNormalPathProcessor(const GrPathProcessor& pathProc, const GrBatchTracker& bt)
: INHERITED(pathProc, bt) {}
- void emitTransforms(GrGLGPBuilder* pb, const TransformsIn& tin,TransformsOut* tout) SK_OVERRIDE;
+ void emitTransforms(GrGLGPBuilder* pb, const TransformsIn& tin,TransformsOut* tout) override;
void resolveSeparableVaryings(GrGLGpu* gpu, GrGLuint programId);
int index,
const SkTArray<const GrCoordTransform*, true>& coordTransforms,
GrGLPathRendering* glpr,
- GrGLuint programID) SK_OVERRIDE;
+ GrGLuint programID) override;
private:
struct SeparableVaryingInfo {
GrGLuint basePathID() const { return fBasePathID; }
protected:
- void onInitPath(int index, const SkPath&) const SK_OVERRIDE;
+ void onInitPath(int index, const SkPath&) const override;
- void onRelease() SK_OVERRIDE;
- void onAbandon() SK_OVERRIDE;
+ void onRelease() override;
+ void onAbandon() override;
private:
- size_t onGpuMemorySize() const SK_OVERRIDE { return fGpuMemorySize; }
+ size_t onGpuMemorySize() const override { return fGpuMemorySize; }
GrGLuint fBasePathID;
mutable size_t fGpuMemorySize;
virtual ~GrGLPathRendering();
// GrPathRendering implementations.
- GrPath* createPath(const SkPath&, const SkStrokeRec&) SK_OVERRIDE;
+ GrPath* createPath(const SkPath&, const SkStrokeRec&) override;
virtual GrPathRange* createPathRange(GrPathRange::PathGenerator*,
- const SkStrokeRec&) SK_OVERRIDE;
+ const SkStrokeRec&) override;
virtual GrPathRange* createGlyphs(const SkTypeface*,
const SkDescriptor*,
- const SkStrokeRec&) SK_OVERRIDE;
- void stencilPath(const GrPath*, const GrStencilSettings&) SK_OVERRIDE;
- void drawPath(const GrPath*, const GrStencilSettings&) SK_OVERRIDE;
+ const SkStrokeRec&) override;
+ void stencilPath(const GrPath*, const GrStencilSettings&) override;
+ void drawPath(const GrPath*, const GrStencilSettings&) override;
virtual void drawPaths(const GrPathRange*, const void* indices, PathIndexType,
const float transformValues[], PathTransformType, int count,
- const GrStencilSettings&) SK_OVERRIDE;
+ const GrStencilSettings&) override;
/* Called when the 3D context state is unknown. */
void resetContext();
GrGLInstalledFragProcs* fragmentProcessors);
private:
- void didSetData() SK_OVERRIDE;
+ void didSetData() override;
virtual void setTransformData(const GrPrimitiveProcessor&,
const GrPendingFragmentStage&,
int index,
- GrGLInstalledFragProc*) SK_OVERRIDE;
+ GrGLInstalledFragProc*) override;
virtual void onSetRenderTargetState(const GrPrimitiveProcessor&, const GrPipeline&);
friend class GrGLNvprProgramBuilder;
GrGLuint textureFBOID() const { return fTexFBOID; }
// override of GrRenderTarget
- ResolveType getResolveType() const SK_OVERRIDE {
+ ResolveType getResolveType() const override {
if (!this->isMultisampled() ||
fRTFBOID == fTexFBOID) {
// catches FBO 0 and non MSAA case
}
/** When we don't own the FBO ID we don't attempt to modify its attachments. */
- bool canAttemptStencilAttachment() const SK_OVERRIDE { return !fIsWrapped; }
+ bool canAttemptStencilAttachment() const override { return !fIsWrapped; }
protected:
// The public constructor registers this object with the cache. However, only the most derived
void init(const GrSurfaceDesc&, const IDDesc&);
- void onAbandon() SK_OVERRIDE;
- void onRelease() SK_OVERRIDE;
+ void onAbandon() override;
+ void onRelease() override;
// In protected because subclass GrGLTextureRenderTarget calls this version.
- size_t onGpuMemorySize() const SK_OVERRIDE;
+ size_t onGpuMemorySize() const override;
private:
GrGLuint fRTFBOID;
protected:
// overrides of GrResource
- void onRelease() SK_OVERRIDE;
- void onAbandon() SK_OVERRIDE;
+ void onRelease() override;
+ void onAbandon() override;
private:
- size_t onGpuMemorySize() const SK_OVERRIDE;
+ size_t onGpuMemorySize() const override;
Format fFormat;
// may be zero for external SBs associated with external RTs
GrGLTexture(GrGLGpu*, const GrSurfaceDesc&, const IDDesc&);
- GrBackendObject getTextureHandle() const SK_OVERRIDE;
+ GrBackendObject getTextureHandle() const override;
- void textureParamsModified() SK_OVERRIDE { fTexParams.invalidate(); }
+ void textureParamsModified() override { fTexParams.invalidate(); }
// These functions are used to track the texture parameters associated with the texture.
const TexParams& getCachedTexParams(GrGpu::ResetTimestamp* timestamp) const {
void init(const GrSurfaceDesc&, const IDDesc&);
- void onAbandon() SK_OVERRIDE;
- void onRelease() SK_OVERRIDE;
+ void onAbandon() override;
+ void onRelease() override;
private:
TexParams fTexParams;
}
protected:
- void onAbandon() SK_OVERRIDE {
+ void onAbandon() override {
GrGLRenderTarget::onAbandon();
GrGLTexture::onAbandon();
}
- void onRelease() SK_OVERRIDE {
+ void onRelease() override {
GrGLRenderTarget::onRelease();
GrGLTexture::onRelease();
}
private:
// GrGLRenderTarget accounts for the texture's memory and any MSAA renderbuffer's memory.
- size_t onGpuMemorySize() const SK_OVERRIDE {
+ size_t onGpuMemorySize() const override {
return GrGLRenderTarget::onGpuMemorySize();
}
void invalidateCachedState();
protected:
- size_t onGpuMemorySize() const SK_OVERRIDE { return 0; }
+ size_t onGpuMemorySize() const override { return 0; }
- void onAbandon() SK_OVERRIDE;
+ void onAbandon() override;
- void onRelease() SK_OVERRIDE;
+ void onRelease() override;
private:
GrGLuint fID;
}
protected:
- void onAbandon() SK_OVERRIDE;
- void onRelease() SK_OVERRIDE;
+ void onAbandon() override;
+ void onRelease() override;
private:
- void* onMap() SK_OVERRIDE;
- void onUnmap() SK_OVERRIDE;
- bool onUpdateData(const void* src, size_t srcSizeInBytes) SK_OVERRIDE;
+ void* onMap() override;
+ void onUnmap() override;
+ bool onUpdateData(const void* src, size_t srcSizeInBytes) override;
GrGLGpu* getGpuGL() const {
SkASSERT(!this->wasDestroyed());
class NullInterface : public GrGLInterface {
public:
NullInterface(State* state) : fState(SkRef(state)) {}
- ~NullInterface() SK_OVERRIDE {
+ ~NullInterface() override {
fState->unref();
}
State* fState;
GrGLFragmentShaderBuilder(GrGLProgramBuilder* program, uint8_t fragPosKey);
// true public interface, defined explicitly in the abstract interfaces above
- bool enableFeature(GLSLFeature) SK_OVERRIDE;
+ bool enableFeature(GLSLFeature) override;
virtual SkString ensureFSCoords2D(const GrGLProcessor::TransformedCoordsArray& coords,
- int index) SK_OVERRIDE;
- const char* fragmentPosition() SK_OVERRIDE;
- const char* dstColor() SK_OVERRIDE;
+ int index) override;
+ const char* fragmentPosition() override;
+ const char* dstColor() override;
private:
// Private public interface, used by GrGLProgramBuilder to build a fragment shader
GrGLNvprProgramBuilder(GrGLGpu* gpu, const DrawArgs& args)
: INHERITED(gpu, args) {}
- GrGLProgram* createProgram(GrGLuint programID) SK_OVERRIDE {
+ GrGLProgram* createProgram(GrGLuint programID) override {
// this is just for nvpr es, which has separable varyings that are plugged in after
// building
GrGLPathProcessor* pathProc =
GrSLPrecision precision,
const char* name,
int arrayCount,
- const char** outName) SK_OVERRIDE;
+ const char** outName) override;
- const GrGLShaderVar& getUniformVariable(UniformHandle u) const SK_OVERRIDE {
+ const GrGLShaderVar& getUniformVariable(UniformHandle u) const override {
return fUniforms[u.toShaderBuilderIndex()].fVariable;
}
- const char* getUniformCStr(UniformHandle u) const SK_OVERRIDE {
+ const char* getUniformCStr(UniformHandle u) const override {
return this->getUniformVariable(u).c_str();
}
- const GrGLContextInfo& ctxInfo() const SK_OVERRIDE;
+ const GrGLContextInfo& ctxInfo() const override;
- GrGLGpu* gpu() const SK_OVERRIDE { return fGpu; }
+ GrGLGpu* gpu() const override { return fGpu; }
- GrGLFPFragmentBuilder* getFragmentShaderBuilder() SK_OVERRIDE { return &fFS; }
- GrGLVertexBuilder* getVertexShaderBuilder() SK_OVERRIDE { return &fVS; }
+ GrGLFPFragmentBuilder* getFragmentShaderBuilder() override { return &fFS; }
+ GrGLVertexBuilder* getVertexShaderBuilder() override { return &fVS; }
void addVarying(
const char* name,
GrGLVarying*,
- GrSLPrecision fsPrecision = kDefault_GrSLPrecision) SK_OVERRIDE;
+ GrSLPrecision fsPrecision = kDefault_GrSLPrecision) override;
void addPassThroughAttribute(const GrPrimitiveProcessor::Attribute*,
- const char* output) SK_OVERRIDE;
+ const char* output) override;
// Handles for program uniforms (other than per-effect uniforms)
void setUsage(GrGLint usage) { fUsage = usage; }
GrGLint getUsage() const { return fUsage; }
- void deleteAction() SK_OVERRIDE;
+ void deleteAction() override;
protected:
private:
void setStencil(GrFBBindableObj *buffer);
GrFBBindableObj *getStencil() { return fStencilBuffer; }
- void deleteAction() SK_OVERRIDE {
+ void deleteAction() override {
setColor(NULL);
setDepth(NULL);
fWrapped.reset(interface);
}
- void abandon() const SK_OVERRIDE {
+ void abandon() const override {
GrDebugGL::abandon();
}
void AttachShader(GrShaderObj *shader);
- void deleteAction() SK_OVERRIDE;
+ void deleteAction() override;
// TODO: this flag system won't work w/ multiple contexts!
void setInUse() { fInUse = true; }
void resetBound() { fBound = false; }
bool getBound() const { return fBound; }
- void deleteAction() SK_OVERRIDE {
+ void deleteAction() override {
this->INHERITED::deleteAction();
}
void setType(GrGLenum type) { fType = type; }
GrGLenum getType() { return fType; }
- void deleteAction() SK_OVERRIDE;
+ void deleteAction() override;
protected:
private:
return 0 != fTextureUnitReferees.count();
}
- void deleteAction() SK_OVERRIDE;
+ void deleteAction() override;
protected:
class SkDebugGLContext : public SkGLContext {
public:
- ~SkDebugGLContext() SK_OVERRIDE;
- void makeCurrent() const SK_OVERRIDE {}
- void swapBuffers() const SK_OVERRIDE {}
+ ~SkDebugGLContext() override;
+ void makeCurrent() const override {}
+ void swapBuffers() const override {}
static SkDebugGLContext* Create(GrGLStandard forcedGpuAPI) {
if (kGLES_GrGLStandard == forcedGpuAPI) {
class EGLGLContext : public SkGLContext {
public:
EGLGLContext(GrGLStandard forcedGpuAPI);
- ~EGLGLContext() SK_OVERRIDE;
- void makeCurrent() const SK_OVERRIDE;
- void swapBuffers() const SK_OVERRIDE;
+ ~EGLGLContext() override;
+ void makeCurrent() const override;
+ void swapBuffers() const override;
private:
void destroyGLContext();
class GLXGLContext : public SkGLContext {
public:
GLXGLContext(GrGLStandard forcedGpuAPI);
- ~GLXGLContext() SK_OVERRIDE;
- void makeCurrent() const SK_OVERRIDE;
- void swapBuffers() const SK_OVERRIDE;
+ ~GLXGLContext() override;
+ void makeCurrent() const override;
+ void swapBuffers() const override;
private:
void destroyGLContext();
class IOSGLContext : public SkGLContext {
public:
IOSGLContext();
- ~IOSGLContext() SK_OVERRIDE;
- void makeCurrent() const SK_OVERRIDE;
- void swapBuffers() const SK_OVERRIDE;
+ ~IOSGLContext() override;
+ void makeCurrent() const override;
+ void swapBuffers() const override;
private:
void destroyGLContext();
class MacGLContext : public SkGLContext {
public:
MacGLContext();
- ~MacGLContext() SK_OVERRIDE;
- void makeCurrent() const SK_OVERRIDE;
- void swapBuffers() const SK_OVERRIDE;
+ ~MacGLContext() override;
+ void makeCurrent() const override;
+ void swapBuffers() const override;
private:
void destroyGLContext();
typedef intptr_t Context;
public:
- ~SkMesaGLContext() SK_OVERRIDE;
- void makeCurrent() const SK_OVERRIDE;
- void swapBuffers() const SK_OVERRIDE;
+ ~SkMesaGLContext() override;
+ void makeCurrent() const override;
+ void swapBuffers() const override;
static SkMesaGLContext* Create(GrGLStandard forcedGpuAPI) {
if (kGLES_GrGLStandard == forcedGpuAPI) {
class WinGLContext : public SkGLContext {
public:
WinGLContext(GrGLStandard forcedGpuAPI);
- ~WinGLContext() SK_OVERRIDE;
- void makeCurrent() const SK_OVERRIDE;
- void swapBuffers() const SK_OVERRIDE;
+ ~WinGLContext() override;
+ void makeCurrent() const override;
+ void swapBuffers() const override;
private:
void destroyGLContext();
SkImage_Gpu(const SkBitmap&, int sampleCountForNewSurfaces, SkSurface::Budgeted);
- void onDraw(SkCanvas*, SkScalar x, SkScalar y, const SkPaint*) const SK_OVERRIDE;
+ void onDraw(SkCanvas*, SkScalar x, SkScalar y, const SkPaint*) const override;
void onDrawRect(SkCanvas*, const SkRect* src, const SkRect& dst,
- const SkPaint*) const SK_OVERRIDE;
- SkSurface* onNewSurface(const SkImageInfo&, const SkSurfaceProps&) const SK_OVERRIDE;
- GrTexture* onGetTexture() const SK_OVERRIDE;
- bool getROPixels(SkBitmap*) const SK_OVERRIDE;
+ const SkPaint*) const override;
+ SkSurface* onNewSurface(const SkImageInfo&, const SkSurfaceProps&) const override;
+ GrTexture* onGetTexture() const override;
+ bool getROPixels(SkBitmap*) const override;
GrTexture* getTexture() const { return fBitmap.getTexture(); }
SkShader* onNewShader(SkShader::TileMode,
SkShader::TileMode,
- const SkMatrix* localMatrix) const SK_OVERRIDE;
+ const SkMatrix* localMatrix) const override;
- bool isOpaque() const SK_OVERRIDE;
+ bool isOpaque() const override;
void applyBudgetDecision() const {
if (fBudgeted) {
SkImage_Raster(const SkImageInfo&, SkData*, size_t rb, const SkSurfaceProps*);
virtual ~SkImage_Raster();
- void onDraw(SkCanvas*, SkScalar, SkScalar, const SkPaint*) const SK_OVERRIDE;
- void onDrawRect(SkCanvas*, const SkRect*, const SkRect&, const SkPaint*) const SK_OVERRIDE;
- SkSurface* onNewSurface(const SkImageInfo&, const SkSurfaceProps&) const SK_OVERRIDE;
- bool onReadPixels(const SkImageInfo&, void*, size_t, int srcX, int srcY) const SK_OVERRIDE;
- const void* onPeekPixels(SkImageInfo*, size_t* /*rowBytes*/) const SK_OVERRIDE;
- bool getROPixels(SkBitmap*) const SK_OVERRIDE;
+ void onDraw(SkCanvas*, SkScalar, SkScalar, const SkPaint*) const override;
+ void onDrawRect(SkCanvas*, const SkRect*, const SkRect&, const SkPaint*) const override;
+ SkSurface* onNewSurface(const SkImageInfo&, const SkSurfaceProps&) const override;
+ bool onReadPixels(const SkImageInfo&, void*, size_t, int srcX, int srcY) const override;
+ const void* onPeekPixels(SkImageInfo*, size_t* /*rowBytes*/) const override;
+ bool getROPixels(SkBitmap*) const override;
// exposed for SkSurface_Raster via SkNewImageFromPixelRef
SkImage_Raster(const SkImageInfo&, SkPixelRef*, const SkIPoint& pixelRefOrigin, size_t rowBytes,
virtual SkShader* onNewShader(SkShader::TileMode,
SkShader::TileMode,
- const SkMatrix* localMatrix) const SK_OVERRIDE;
+ const SkMatrix* localMatrix) const override;
- bool isOpaque() const SK_OVERRIDE;
+ bool isOpaque() const override;
SkImage_Raster(const SkBitmap& bm, const SkSurfaceProps* props)
: INHERITED(bm.width(), bm.height(), props)
SkSurface_Gpu(SkGpuDevice*);
virtual ~SkSurface_Gpu();
- SkCanvas* onNewCanvas() SK_OVERRIDE;
- SkSurface* onNewSurface(const SkImageInfo&) SK_OVERRIDE;
- SkImage* onNewImageSnapshot(Budgeted) SK_OVERRIDE;
+ SkCanvas* onNewCanvas() override;
+ SkSurface* onNewSurface(const SkImageInfo&) override;
+ SkImage* onNewImageSnapshot(Budgeted) override;
virtual void onDraw(SkCanvas*, SkScalar x, SkScalar y,
- const SkPaint*) SK_OVERRIDE;
- void onCopyOnWrite(ContentChangeMode) SK_OVERRIDE;
- void onDiscard() SK_OVERRIDE;
+ const SkPaint*) override;
+ void onCopyOnWrite(ContentChangeMode) override;
+ void onDiscard() override;
SkGpuDevice* getDevice() { return fDevice; }
const SkSurfaceProps*);
SkSurface_Raster(SkPixelRef*, const SkSurfaceProps*);
- SkCanvas* onNewCanvas() SK_OVERRIDE;
- SkSurface* onNewSurface(const SkImageInfo&) SK_OVERRIDE;
- SkImage* onNewImageSnapshot(Budgeted) SK_OVERRIDE;
+ SkCanvas* onNewCanvas() override;
+ SkSurface* onNewSurface(const SkImageInfo&) override;
+ SkImage* onNewImageSnapshot(Budgeted) override;
virtual void onDraw(SkCanvas*, SkScalar x, SkScalar y,
- const SkPaint*) SK_OVERRIDE;
- void onCopyOnWrite(ContentChangeMode) SK_OVERRIDE;
+ const SkPaint*) override;
+ void onCopyOnWrite(ContentChangeMode) override;
private:
SkBitmap fBitmap;
bool ditherImage);
protected:
- SkData* onRefEncodedData() SK_OVERRIDE;
+ SkData* onRefEncodedData() override;
#ifdef SK_SUPPORT_LEGACY_BOOL_ONGETINFO
- bool onGetInfo(SkImageInfo* info) SK_OVERRIDE {
+ bool onGetInfo(SkImageInfo* info) override {
*info = fInfo;
return true;
}
#endif
virtual Result onGetPixels(const SkImageInfo& info,
void* pixels, size_t rowBytes, const Options&,
- SkPMColor ctable[], int* ctableCount) SK_OVERRIDE;
+ SkPMColor ctable[], int* ctableCount) override;
virtual bool onGetYUV8Planes(SkISize sizes[3], void* planes[3], size_t rowBytes[3],
- SkYUVColorSpace* colorSpace) SK_OVERRIDE;
+ SkYUVColorSpace* colorSpace) override;
private:
typedef SkImageGenerator INHERITED;
public:
SkASTCImageDecoder() { }
- Format getFormat() const SK_OVERRIDE {
+ Format getFormat() const override {
return kASTC_Format;
}
protected:
- Result onDecode(SkStream* stream, SkBitmap* bm, Mode) SK_OVERRIDE;
+ Result onDecode(SkStream* stream, SkBitmap* bm, Mode) override;
private:
typedef SkImageDecoder INHERITED;
public:
SkKTXImageDecoder() { }
- Format getFormat() const SK_OVERRIDE {
+ Format getFormat() const override {
return kKTX_Format;
}
protected:
- Result onDecode(SkStream* stream, SkBitmap* bm, Mode) SK_OVERRIDE;
+ Result onDecode(SkStream* stream, SkBitmap* bm, Mode) override;
private:
typedef SkImageDecoder INHERITED;
class SkKTXImageEncoder : public SkImageEncoder {
protected:
- bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality) SK_OVERRIDE;
+ bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality) override;
private:
virtual bool encodePKM(SkWStream* stream, const SkData *data);
public:
SkBMPImageDecoder() {}
- Format getFormat() const SK_OVERRIDE {
+ Format getFormat() const override {
return kBMP_Format;
}
protected:
- Result onDecode(SkStream* stream, SkBitmap* bm, Mode mode) SK_OVERRIDE;
+ Result onDecode(SkStream* stream, SkBitmap* bm, Mode mode) override;
private:
typedef SkImageDecoder INHERITED;
class SkGIFImageDecoder : public SkImageDecoder {
public:
- Format getFormat() const SK_OVERRIDE {
+ Format getFormat() const override {
return kGIF_Format;
}
protected:
- Result onDecode(SkStream* stream, SkBitmap* bm, Mode mode) SK_OVERRIDE;
+ Result onDecode(SkStream* stream, SkBitmap* bm, Mode mode) override;
private:
typedef SkImageDecoder INHERITED;
public:
SkICOImageDecoder();
- Format getFormat() const SK_OVERRIDE {
+ Format getFormat() const override {
return kICO_Format;
}
protected:
- Result onDecode(SkStream* stream, SkBitmap* bm, Mode) SK_OVERRIDE;
+ Result onDecode(SkStream* stream, SkBitmap* bm, Mode) override;
private:
typedef SkImageDecoder INHERITED;
}
#endif
- Format getFormat() const SK_OVERRIDE {
+ Format getFormat() const override {
return kJPEG_Format;
}
protected:
#ifdef SK_BUILD_FOR_ANDROID
- bool onBuildTileIndex(SkStreamRewindable *stream, int *width, int *height) SK_OVERRIDE;
- bool onDecodeSubset(SkBitmap* bitmap, const SkIRect& rect) SK_OVERRIDE;
+ bool onBuildTileIndex(SkStreamRewindable *stream, int *width, int *height) override;
+ bool onDecodeSubset(SkBitmap* bitmap, const SkIRect& rect) override;
#endif
- Result onDecode(SkStream* stream, SkBitmap* bm, Mode) SK_OVERRIDE;
+ Result onDecode(SkStream* stream, SkBitmap* bm, Mode) override;
virtual bool onDecodeYUV8Planes(SkStream* stream, SkISize componentSizes[3],
void* planes[3], size_t rowBytes[3],
- SkYUVColorSpace* colorSpace) SK_OVERRIDE;
+ SkYUVColorSpace* colorSpace) override;
private:
#ifdef SK_BUILD_FOR_ANDROID
SkPNGImageDecoder() {
fImageIndex = NULL;
}
- Format getFormat() const SK_OVERRIDE {
+ Format getFormat() const override {
return kPNG_Format;
}
protected:
#ifdef SK_BUILD_FOR_ANDROID
- bool onBuildTileIndex(SkStreamRewindable *stream, int *width, int *height) SK_OVERRIDE;
- bool onDecodeSubset(SkBitmap* bitmap, const SkIRect& region) SK_OVERRIDE;
+ bool onBuildTileIndex(SkStreamRewindable *stream, int *width, int *height) override;
+ bool onDecodeSubset(SkBitmap* bitmap, const SkIRect& region) override;
#endif
- Result onDecode(SkStream* stream, SkBitmap* bm, Mode) SK_OVERRIDE;
+ Result onDecode(SkStream* stream, SkBitmap* bm, Mode) override;
private:
SkPNGImageIndex* fImageIndex;
class SkPNGImageEncoder : public SkImageEncoder {
protected:
- bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality) SK_OVERRIDE;
+ bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality) override;
private:
bool doEncode(SkWStream* stream, const SkBitmap& bm,
const bool& hasAlpha, int colorType,
fHasAlpha = 0;
}
- Format getFormat() const SK_OVERRIDE {
+ Format getFormat() const override {
return kWEBP_Format;
}
protected:
- bool onBuildTileIndex(SkStreamRewindable *stream, int *width, int *height) SK_OVERRIDE;
- bool onDecodeSubset(SkBitmap* bitmap, const SkIRect& rect) SK_OVERRIDE;
- Result onDecode(SkStream* stream, SkBitmap* bm, Mode) SK_OVERRIDE;
+ bool onBuildTileIndex(SkStreamRewindable *stream, int *width, int *height) override;
+ bool onDecodeSubset(SkBitmap* bitmap, const SkIRect& rect) override;
+ Result onDecode(SkStream* stream, SkBitmap* bm, Mode) override;
private:
/**
class SkWEBPImageEncoder : public SkImageEncoder {
protected:
- bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality) SK_OVERRIDE;
+ bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality) override;
private:
typedef SkImageEncoder INHERITED;
public:
SkPKMImageDecoder() { }
- Format getFormat() const SK_OVERRIDE {
+ Format getFormat() const override {
return kPKM_Format;
}
protected:
- Result onDecode(SkStream* stream, SkBitmap* bm, Mode) SK_OVERRIDE;
+ Result onDecode(SkStream* stream, SkBitmap* bm, Mode) override;
private:
typedef SkImageDecoder INHERITED;
class SkWBMPImageDecoder : public SkImageDecoder {
public:
- Format getFormat() const SK_OVERRIDE {
+ Format getFormat() const override {
return kWBMP_Format;
}
protected:
- Result onDecode(SkStream* stream, SkBitmap* bm, Mode) SK_OVERRIDE;
+ Result onDecode(SkStream* stream, SkBitmap* bm, Mode) override;
private:
typedef SkImageDecoder INHERITED;
class SkARGBImageEncoder : public SkImageEncoder {
protected:
- bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality) SK_OVERRIDE;
+ bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality) override;
private:
typedef SkImageEncoder INHERITED;
public:
DummyDecoder() {}
protected:
- Result onDecode(SkStream*, SkBitmap*, SkImageDecoder::Mode) SK_OVERRIDE {
+ Result onDecode(SkStream*, SkBitmap*, SkImageDecoder::Mode) override {
return kFailure;
}
};
protected:
virtual ~SkCachingPixelRef();
- bool onNewLockPixels(LockRec*) SK_OVERRIDE;
- void onUnlockPixels() SK_OVERRIDE;
- bool onLockPixelsAreWritable() const SK_OVERRIDE { return false; }
+ bool onNewLockPixels(LockRec*) override;
+ void onUnlockPixels() override;
+ bool onLockPixelsAreWritable() const override { return false; }
- SkData* onRefEncodedData() SK_OVERRIDE {
+ SkData* onRefEncodedData() override {
return fImageGenerator->refEncodedData();
}
DiscardableMemoryPool(size_t budget, SkBaseMutex* mutex = NULL);
virtual ~DiscardableMemoryPool();
- SkDiscardableMemory* create(size_t bytes) SK_OVERRIDE;
+ SkDiscardableMemory* create(size_t bytes) override;
- size_t getRAMUsed() SK_OVERRIDE;
- void setRAMBudget(size_t budget) SK_OVERRIDE;
- size_t getRAMBudget() SK_OVERRIDE { return fBudget; }
+ size_t getRAMUsed() override;
+ void setRAMBudget(size_t budget) override;
+ size_t getRAMBudget() override { return fBudget; }
/** purges all unlocked DMs */
- void dumpPool() SK_OVERRIDE;
+ void dumpPool() override;
#if SK_LAZY_CACHE_STATS // Defined in SkDiscardableMemoryPool.h
- int getCacheHits() SK_OVERRIDE { return fCacheHits; }
- int getCacheMisses() SK_OVERRIDE { return fCacheMisses; }
- void resetCacheHitsAndMisses() SK_OVERRIDE {
+ int getCacheHits() override { return fCacheHits; }
+ int getCacheMisses() override { return fCacheMisses; }
+ void resetCacheHitsAndMisses() override {
fCacheHits = fCacheMisses = 0;
}
int fCacheHits;
PoolDiscardableMemory(DiscardableMemoryPool* pool,
void* pointer, size_t bytes);
virtual ~PoolDiscardableMemory();
- bool lock() SK_OVERRIDE;
- void* data() SK_OVERRIDE;
- void unlock() SK_OVERRIDE;
+ bool lock() override;
+ void* data() override;
+ void unlock() override;
friend class DiscardableMemoryPool;
private:
SK_DECLARE_INTERNAL_LLIST_INTERFACE(PoolDiscardableMemory);
protected:
~SkDiscardablePixelRef();
- bool onNewLockPixels(LockRec*) SK_OVERRIDE;
- void onUnlockPixels() SK_OVERRIDE;
- bool onLockPixelsAreWritable() const SK_OVERRIDE { return false; }
+ bool onNewLockPixels(LockRec*) override;
+ void onUnlockPixels() override;
+ bool onLockPixelsAreWritable() const override { return false; }
- SkData* onRefEncodedData() SK_OVERRIDE {
+ SkData* onRefEncodedData() override {
return fGenerator->refEncodedData();
}
virtual bool onGetYUV8Planes(SkISize sizes[3],
void* planes[3],
size_t rowBytes[3],
- SkYUVColorSpace* colorSpace) SK_OVERRIDE {
+ SkYUVColorSpace* colorSpace) override {
// If the image was already decoded with lockPixels(), favor not
// re-decoding to YUV8 planes.
if (fDiscardableMemory) {
: INHERITED(rec, mode), fProcSIMD(procSIMD) {}
virtual void xfer32(SkPMColor dst[], const SkPMColor src[], int count,
- const SkAlpha aa[]) const SK_OVERRIDE;
+ const SkAlpha aa[]) const override;
virtual void xfer16(uint16_t dst[], const SkPMColor src[],
- int count, const SkAlpha aa[]) const SK_OVERRIDE;
+ int count, const SkAlpha aa[]) const override;
SK_TO_STRING_OVERRIDE()
: INHERITED(rec, mode), fProcSIMD(procSIMD) {}
virtual void xfer32(SkPMColor dst[], const SkPMColor src[], int count,
- const SkAlpha aa[]) const SK_OVERRIDE;
+ const SkAlpha aa[]) const override;
virtual void xfer16(uint16_t* SK_RESTRICT dst, const SkPMColor* SK_RESTRICT src,
- int count, const SkAlpha* SK_RESTRICT aa) const SK_OVERRIDE;
+ int count, const SkAlpha* SK_RESTRICT aa) const override;
SK_TO_STRING_OVERRIDE()
public:
PDFAlphaBitmap(const SkBitmap& bm) : fBitmap(bm) {}
~PDFAlphaBitmap() {}
- void emitObject(SkWStream*, SkPDFCatalog*) SK_OVERRIDE;
+ void emitObject(SkWStream*, SkPDFCatalog*) override;
private:
const SkBitmap fBitmap;
// Returns NULL on unsupported bitmap;
static SkPDFBitmap* Create(SkPDFCanon*, const SkBitmap&);
~SkPDFBitmap();
- void emitObject(SkWStream*, SkPDFCatalog*) SK_OVERRIDE;
- void addResources(SkPDFCatalog*) const SK_OVERRIDE;
+ void emitObject(SkWStream*, SkPDFCatalog*) override;
+ void addResources(SkPDFCatalog*) const override;
bool equals(const SkBitmap& other) const {
return fBitmap.getGenerationID() == other.getGenerationID() &&
fBitmap.pixelRefOrigin() == other.pixelRefOrigin() &&
and are handling any looping from the paint, and any effects from the
DrawFilter.
*/
- void drawPaint(const SkDraw&, const SkPaint& paint) SK_OVERRIDE;
+ void drawPaint(const SkDraw&, const SkPaint& paint) override;
void drawPoints(const SkDraw&, SkCanvas::PointMode mode,
size_t count, const SkPoint[],
- const SkPaint& paint) SK_OVERRIDE;
- void drawRect(const SkDraw&, const SkRect& r, const SkPaint& paint) SK_OVERRIDE;
- void drawOval(const SkDraw&, const SkRect& oval, const SkPaint& paint) SK_OVERRIDE;
- void drawRRect(const SkDraw&, const SkRRect& rr, const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
+ void drawRect(const SkDraw&, const SkRect& r, const SkPaint& paint) override;
+ void drawOval(const SkDraw&, const SkRect& oval, const SkPaint& paint) override;
+ void drawRRect(const SkDraw&, const SkRRect& rr, const SkPaint& paint) override;
void drawPath(const SkDraw&, const SkPath& origpath,
const SkPaint& paint, const SkMatrix* prePathMatrix,
- bool pathIsMutable) SK_OVERRIDE;
+ bool pathIsMutable) override;
void drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap,
const SkRect* src, const SkRect& dst,
const SkPaint& paint,
- SkCanvas::DrawBitmapRectFlags flags) SK_OVERRIDE;
+ SkCanvas::DrawBitmapRectFlags flags) override;
void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
- const SkMatrix& matrix, const SkPaint&) SK_OVERRIDE;
+ const SkMatrix& matrix, const SkPaint&) override;
void drawSprite(const SkDraw&, const SkBitmap& bitmap, int x, int y,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
void drawText(const SkDraw&, const void* text, size_t len,
- SkScalar x, SkScalar y, const SkPaint&) SK_OVERRIDE;
+ SkScalar x, SkScalar y, const SkPaint&) override;
void drawPosText(const SkDraw&, const void* text, size_t len,
const SkScalar pos[], int scalarsPerPos,
- const SkPoint& offset, const SkPaint&) SK_OVERRIDE;
+ const SkPoint& offset, const SkPaint&) override;
void drawVertices(const SkDraw&, SkCanvas::VertexMode,
int vertexCount, const SkPoint verts[],
const SkPoint texs[], const SkColor colors[],
SkXfermode* xmode, const uint16_t indices[],
- int indexCount, const SkPaint& paint) SK_OVERRIDE;
+ int indexCount, const SkPaint& paint) override;
void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
- void onAttachToCanvas(SkCanvas* canvas) SK_OVERRIDE;
- void onDetachFromCanvas() SK_OVERRIDE;
- SkImageInfo imageInfo() const SK_OVERRIDE;
+ void onAttachToCanvas(SkCanvas* canvas) override;
+ void onDetachFromCanvas() override;
+ SkImageInfo imageInfo() const override;
enum DrawingArea {
kContent_DrawingArea, // Drawing area for the page content.
#endif // SK_DEBUG
protected:
- const SkBitmap& onAccessBitmap() SK_OVERRIDE {
+ const SkBitmap& onAccessBitmap() override {
return fLegacyBitmap;
}
- SkSurface* newSurface(const SkImageInfo&, const SkSurfaceProps&) SK_OVERRIDE;
+ SkSurface* newSurface(const SkImageInfo&, const SkSurfaceProps&) override;
private:
// TODO(vandebo): push most of SkPDFDevice's state into a core object in
ContentEntry* getLastContentEntry();
void setLastContentEntry(ContentEntry* contentEntry);
- SkBaseDevice* onCreateDevice(const CreateInfo&, const SkPaint*) SK_OVERRIDE;
+ SkBaseDevice* onCreateDevice(const CreateInfo&, const SkPaint*) override;
void init();
void cleanUp(bool clearFontUsage);
virtual ~SkPDFStream();
// The SkPDFObject interface.
- virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog) SK_OVERRIDE;
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog) override;
protected:
enum State {
virtual ~SkPDFObjRef();
// The SkPDFObject interface.
- virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog) SK_OVERRIDE;
- virtual void addResources(SkPDFCatalog*) const SK_OVERRIDE;
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog) override;
+ virtual void addResources(SkPDFCatalog*) const override;
private:
SkAutoTUnref<SkPDFObject> fObj;
virtual ~SkPDFInt();
// The SkPDFObject interface.
- virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog) SK_OVERRIDE;
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog) override;
private:
int32_t fValue;
virtual ~SkPDFBool();
// The SkPDFObject interface.
- virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog) SK_OVERRIDE;
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog) override;
private:
bool fValue;
static void Append(SkScalar value, SkWStream* stream);
// The SkPDFObject interface.
- virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog) SK_OVERRIDE;
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog) override;
private:
SkScalar fValue;
virtual ~SkPDFString();
// The SkPDFObject interface.
- virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog) SK_OVERRIDE;
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog) override;
static SkString FormatString(const char* input, size_t len);
static SkString FormatString(const uint16_t* input, size_t len,
bool operator==(const SkPDFName& b) const;
// The SkPDFObject interface.
- virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog) SK_OVERRIDE;
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog) override;
private:
static const size_t kMaxLen = 127;
virtual ~SkPDFArray();
// The SkPDFObject interface.
- virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog) SK_OVERRIDE;
- virtual void addResources(SkPDFCatalog*) const SK_OVERRIDE;
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog) override;
+ virtual void addResources(SkPDFCatalog*) const override;
/** The size of the array.
*/
virtual ~SkPDFDict();
// The SkPDFObject interface.
- virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog) SK_OVERRIDE;
- virtual void addResources(SkPDFCatalog*) const SK_OVERRIDE;
+ virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog) override;
+ virtual void addResources(SkPDFCatalog*) const override;
/** The size of the dictionary.
*/
* these SkBitmaps for bitmap shaders. Used only in cross process mode
* without a shared heap.
*/
- SkBitmap* getBitmap(int32_t index) const SK_OVERRIDE {
+ SkBitmap* getBitmap(int32_t index) const override {
SkASSERT(shouldFlattenBitmaps(fFlags));
return fBitmaps[index];
}
/**
* Needed to be a non-abstract subclass of SkBitmapHeapReader.
*/
- void releaseRef(int32_t) SK_OVERRIDE {}
+ void releaseRef(int32_t) override {}
void setSharedHeap(SkBitmapHeap* heap) {
SkASSERT(!shouldFlattenBitmaps(fFlags) || NULL == heap);
fPointers.freeAll();
}
- void* allocThrow(size_t bytes) SK_OVERRIDE;
+ void* allocThrow(size_t bytes) override;
- void unalloc(void* ptr) SK_OVERRIDE;
+ void unalloc(void* ptr) override;
void setBitmapStorage(SkBitmapHeap* heap) {
this->setBitmapHeap(heap);
~BitmapShuttle();
- bool insert(const SkBitmap& bitmap, int32_t slot) SK_OVERRIDE;
+ bool insert(const SkBitmap& bitmap, int32_t slot) override;
/**
* Remove the SkGPipeCanvas used for insertion. After this, calls to
return (NULL == fBitmapHeap) ? 0 : fBitmapHeap->bytesAllocated();
}
- void beginCommentGroup(const char* description) SK_OVERRIDE;
- void addComment(const char* kywd, const char* value) SK_OVERRIDE;
- void endCommentGroup() SK_OVERRIDE;
+ void beginCommentGroup(const char* description) override;
+ void addComment(const char* kywd, const char* value) override;
+ void endCommentGroup() override;
/**
* Flatten an SkBitmap to send to the reader, where it will be referenced
bool shuttleBitmap(const SkBitmap&, int32_t slot);
protected:
- void willSave() SK_OVERRIDE;
- SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) SK_OVERRIDE;
- void willRestore() SK_OVERRIDE;
+ void willSave() override;
+ SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) override;
+ void willRestore() override;
- void didConcat(const SkMatrix&) SK_OVERRIDE;
- void didSetMatrix(const SkMatrix&) SK_OVERRIDE;
+ void didConcat(const SkMatrix&) override;
+ void didSetMatrix(const SkMatrix&) override;
- void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) SK_OVERRIDE;
+ void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) override;
virtual void onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
virtual void onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
virtual void onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
- SkScalar constY, const SkPaint&) SK_OVERRIDE;
+ SkScalar constY, const SkPaint&) override;
virtual void onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
- const SkMatrix* matrix, const SkPaint&) SK_OVERRIDE;
+ const SkMatrix* matrix, const SkPaint&) override;
virtual void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
virtual void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
const SkPoint texCoords[4], SkXfermode* xmode,
- const SkPaint& paint) SK_OVERRIDE;
- void onDrawPaint(const SkPaint&) SK_OVERRIDE;
- void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) SK_OVERRIDE;
- void onDrawRect(const SkRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawOval(const SkRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawRRect(const SkRRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawPath(const SkPath&, const SkPaint&) SK_OVERRIDE;
- void onDrawBitmap(const SkBitmap&, SkScalar left, SkScalar top, const SkPaint*) SK_OVERRIDE;
+ const SkPaint& paint) override;
+ void onDrawPaint(const SkPaint&) override;
+ void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) override;
+ void onDrawRect(const SkRect&, const SkPaint&) override;
+ void onDrawOval(const SkRect&, const SkPaint&) override;
+ void onDrawRRect(const SkRRect&, const SkPaint&) override;
+ void onDrawPath(const SkPath&, const SkPaint&) override;
+ void onDrawBitmap(const SkBitmap&, SkScalar left, SkScalar top, const SkPaint*) override;
void onDrawBitmapRect(const SkBitmap&, const SkRect* src, const SkRect& dst, const SkPaint*,
- DrawBitmapRectFlags flags) SK_OVERRIDE;
+ DrawBitmapRectFlags flags) override;
#if 0
// rely on decomposition into bitmap (for now)
- void onDrawImage(const SkImage*, SkScalar left, SkScalar top, const SkPaint*) SK_OVERRIDE;
+ void onDrawImage(const SkImage*, SkScalar left, SkScalar top, const SkPaint*) override;
void onDrawImageRect(const SkImage*, const SkRect* src, const SkRect& dst,
- const SkPaint*) SK_OVERRIDE;
+ const SkPaint*) override;
#endif
void onDrawBitmapNine(const SkBitmap&, const SkIRect& center, const SkRect& dst,
- const SkPaint*) SK_OVERRIDE;
- void onDrawSprite(const SkBitmap&, int left, int top, const SkPaint*) SK_OVERRIDE;
+ const SkPaint*) override;
+ void onDrawSprite(const SkBitmap&, int left, int top, const SkPaint*) override;
void onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
const SkColor colors[], SkXfermode* xmode,
const uint16_t indices[], int indexCount,
- const SkPaint&) SK_OVERRIDE;
- void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipRegion(const SkRegion&, SkRegion::Op) SK_OVERRIDE;
+ const SkPaint&) override;
+ void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipRegion(const SkRegion&, SkRegion::Op) override;
- void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) SK_OVERRIDE;
+ void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;
private:
void recordTranslate(const SkMatrix&);
public:
PipeController(SkCanvas* target, SkPicture::InstallPixelRefProc proc = NULL);
virtual ~PipeController();
- void* requestBlock(size_t minRequest, size_t* actual) SK_OVERRIDE;
- void notifyWritten(size_t bytes) SK_OVERRIDE;
+ void* requestBlock(size_t minRequest, size_t* actual) override;
+ void notifyWritten(size_t bytes) override;
protected:
const void* getData() { return (const char*) fBlock + fBytesWritten; }
SkGPipeReader fReader;
TiledPipeController(const SkBitmap&, SkPicture::InstallPixelRefProc proc = NULL,
const SkMatrix* initialMatrix = NULL);
virtual ~TiledPipeController() {};
- void notifyWritten(size_t bytes) SK_OVERRIDE;
- int numberOfReaders() const SK_OVERRIDE { return NumberOfTiles; }
+ void notifyWritten(size_t bytes) override;
+ int numberOfReaders() const override { return NumberOfTiles; }
private:
enum {
NumberOfTiles = 10
class ThreadSafePipeController : public SkGPipeController {
public:
ThreadSafePipeController(int numberOfReaders);
- void* requestBlock(size_t minRequest, size_t* actual) SK_OVERRIDE;
- void notifyWritten(size_t bytes) SK_OVERRIDE;
- int numberOfReaders() const SK_OVERRIDE { return fNumberOfReaders; }
+ void* requestBlock(size_t minRequest, size_t* actual) override;
+ void notifyWritten(size_t bytes) override;
+ int numberOfReaders() const override { return fNumberOfReaders; }
/**
* Play the stored drawing commands to the specified canvas. If SkGPipeWriter::startRecording
SkTypeface::Style requested,
FontIdentity* outFontIdentifier,
SkString* outFamilyName,
- SkTypeface::Style* outStyle) SK_OVERRIDE;
- SkStreamAsset* openStream(const FontIdentity&) SK_OVERRIDE;
+ SkTypeface::Style* outStyle) override;
+ SkStreamAsset* openStream(const FontIdentity&) override;
// new APIs
- SkDataTable* getFamilyNames() SK_OVERRIDE;
+ SkDataTable* getFamilyNames() override;
virtual bool matchFamilySet(const char inFamilyName[],
SkString* outFamilyName,
- SkTArray<FontIdentity>*) SK_OVERRIDE;
+ SkTArray<FontIdentity>*) override;
private:
SkMutex mutex_;
// we default to empty fFamilyName and fIdentity
}
- void onGetFamilyName(SkString* familyName) const SK_OVERRIDE;
- void onGetFontDescriptor(SkFontDescriptor*, bool*) const SK_OVERRIDE;
- SkStreamAsset* onOpenStream(int* ttcIndex) const SK_OVERRIDE;
+ void onGetFamilyName(SkString* familyName) const override;
+ void onGetFontDescriptor(SkFontDescriptor*, bool*) const override;
+ SkStreamAsset* onOpenStream(int* ttcIndex) const override;
private:
typedef SkTypeface_FreeType INHERITED;
}
protected:
- unsigned generateGlyphCount() SK_OVERRIDE;
- uint16_t generateCharToGlyph(SkUnichar uni) SK_OVERRIDE;
- void generateAdvance(SkGlyph* glyph) SK_OVERRIDE;
- void generateMetrics(SkGlyph* glyph) SK_OVERRIDE;
- void generateImage(const SkGlyph& glyph) SK_OVERRIDE;
- void generatePath(const SkGlyph& glyph, SkPath* path) SK_OVERRIDE;
- void generateFontMetrics(SkPaint::FontMetrics*) SK_OVERRIDE;
- SkUnichar generateGlyphToChar(uint16_t glyph) SK_OVERRIDE;
+ unsigned generateGlyphCount() override;
+ uint16_t generateCharToGlyph(SkUnichar uni) override;
+ void generateAdvance(SkGlyph* glyph) override;
+ void generateMetrics(SkGlyph* glyph) override;
+ void generateImage(const SkGlyph& glyph) override;
+ void generatePath(const SkGlyph& glyph, SkPath* path) override;
+ void generateFontMetrics(SkPaint::FontMetrics*) override;
+ SkUnichar generateGlyphToChar(uint16_t glyph) override;
private:
SkFaceRec* fFaceRec;
{}
virtual SkScalerContext* onCreateScalerContext(
- const SkDescriptor*) const SK_OVERRIDE;
- void onFilterRec(SkScalerContextRec*) const SK_OVERRIDE;
+ const SkDescriptor*) const override;
+ void onFilterRec(SkScalerContextRec*) const override;
virtual SkAdvancedTypefaceMetrics* onGetAdvancedTypefaceMetrics(
SkAdvancedTypefaceMetrics::PerGlyphInfo,
- const uint32_t*, uint32_t) const SK_OVERRIDE;
- int onGetUPEM() const SK_OVERRIDE;
+ const uint32_t*, uint32_t) const override;
+ int onGetUPEM() const override;
virtual bool onGetKerningPairAdjustments(const uint16_t glyphs[], int count,
- int32_t adjustments[]) const SK_OVERRIDE;
+ int32_t adjustments[]) const override;
virtual int onCharsToGlyphs(const void* chars, Encoding, uint16_t glyphs[],
- int glyphCount) const SK_OVERRIDE;
- int onCountGlyphs() const SK_OVERRIDE;
+ int glyphCount) const override;
+ int onCountGlyphs() const override;
- LocalizedStrings* onCreateFamilyNameIterator() const SK_OVERRIDE;
+ LocalizedStrings* onCreateFamilyNameIterator() const override;
- int onGetTableTags(SkFontTableTag tags[]) const SK_OVERRIDE;
+ int onGetTableTags(SkFontTableTag tags[]) const override;
virtual size_t onGetTableData(SkFontTableTag, size_t offset,
- size_t length, void* data) const SK_OVERRIDE;
+ size_t length, void* data) const override;
private:
mutable int fGlyphCount;
virtual const char* getUniqueString() const = 0;
protected:
- void onGetFamilyName(SkString* familyName) const SK_OVERRIDE {
+ void onGetFamilyName(SkString* familyName) const override {
*familyName = fFamilyName;
}
- void onGetFontDescriptor(SkFontDescriptor* desc, bool* isLocal) const SK_OVERRIDE {
+ void onGetFontDescriptor(SkFontDescriptor* desc, bool* isLocal) const override {
desc->setFamilyName(fFamilyName.c_str());
desc->setFontFileName(this->getUniqueString());
desc->setFontIndex(fIndex);
public:
SkTypeface_Empty() : INHERITED(SkFontStyle(), false, true, SkString(), 0) {}
- const char* getUniqueString() const SK_OVERRIDE { return NULL; }
+ const char* getUniqueString() const override { return NULL; }
protected:
- SkStreamAsset* onOpenStream(int*) const SK_OVERRIDE { return NULL; }
+ SkStreamAsset* onOpenStream(int*) const override { return NULL; }
private:
typedef SkTypeface_Custom INHERITED;
, fStream(stream)
{ }
- const char* getUniqueString() const SK_OVERRIDE { return NULL; }
+ const char* getUniqueString() const override { return NULL; }
protected:
- SkStreamAsset* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
+ SkStreamAsset* onOpenStream(int* ttcIndex) const override {
*ttcIndex = this->getIndex();
return fStream->duplicate();
}
, fStream(c_CustomTypefaceRetain ? SkStream::NewFromFile(fPath.c_str()) : NULL)
{ }
- const char* getUniqueString() const SK_OVERRIDE {
+ const char* getUniqueString() const override {
const char* str = strrchr(fPath.c_str(), '/');
if (str) {
str += 1; // skip the '/'
}
protected:
- SkStreamAsset* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
+ SkStreamAsset* onOpenStream(int* ttcIndex) const override {
*ttcIndex = this->getIndex();
if (fStream.get()) {
return fStream->duplicate();
public:
explicit SkFontStyleSet_Custom(const SkString familyName) : fFamilyName(familyName) { }
- int count() SK_OVERRIDE {
+ int count() override {
return fStyles.count();
}
- void getStyle(int index, SkFontStyle* style, SkString* name) SK_OVERRIDE {
+ void getStyle(int index, SkFontStyle* style, SkString* name) override {
SkASSERT(index < fStyles.count());
bool bold = fStyles[index]->isBold();
bool italic = fStyles[index]->isItalic();
name->reset();
}
- SkTypeface* createTypeface(int index) SK_OVERRIDE {
+ SkTypeface* createTypeface(int index) override {
SkASSERT(index < fStyles.count());
return SkRef(fStyles[index].get());
}
return score;
}
- SkTypeface* matchStyle(const SkFontStyle& pattern) SK_OVERRIDE {
+ SkTypeface* matchStyle(const SkFontStyle& pattern) override {
if (0 == fStyles.count()) {
return NULL;
}
}
protected:
- int onCountFamilies() const SK_OVERRIDE {
+ int onCountFamilies() const override {
return fFamilies.count();
}
- void onGetFamilyName(int index, SkString* familyName) const SK_OVERRIDE {
+ void onGetFamilyName(int index, SkString* familyName) const override {
SkASSERT(index < fFamilies.count());
familyName->set(fFamilies[index]->fFamilyName);
}
- SkFontStyleSet_Custom* onCreateStyleSet(int index) const SK_OVERRIDE {
+ SkFontStyleSet_Custom* onCreateStyleSet(int index) const override {
SkASSERT(index < fFamilies.count());
return SkRef(fFamilies[index].get());
}
- SkFontStyleSet_Custom* onMatchFamily(const char familyName[]) const SK_OVERRIDE {
+ SkFontStyleSet_Custom* onMatchFamily(const char familyName[]) const override {
for (int i = 0; i < fFamilies.count(); ++i) {
if (fFamilies[i]->fFamilyName.equals(familyName)) {
return SkRef(fFamilies[i].get());
}
virtual SkTypeface* onMatchFamilyStyle(const char familyName[],
- const SkFontStyle& fontStyle) const SK_OVERRIDE
+ const SkFontStyle& fontStyle) const override
{
SkAutoTUnref<SkFontStyleSet> sset(this->matchFamily(familyName));
return sset->matchStyle(fontStyle);
virtual SkTypeface* onMatchFamilyStyleCharacter(const char familyName[], const SkFontStyle&,
const char* bcp47[], int bcp47Count,
- SkUnichar character) const SK_OVERRIDE
+ SkUnichar character) const override
{
return NULL;
}
virtual SkTypeface* onMatchFaceStyle(const SkTypeface* familyMember,
- const SkFontStyle& fontStyle) const SK_OVERRIDE
+ const SkFontStyle& fontStyle) const override
{
for (int i = 0; i < fFamilies.count(); ++i) {
for (int j = 0; j < fFamilies[i]->fStyles.count(); ++j) {
return NULL;
}
- SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const SK_OVERRIDE {
+ SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const override {
return this->createFromStream(new SkMemoryStream(data), ttcIndex);
}
- SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const SK_OVERRIDE {
+ SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const override {
SkAutoTDelete<SkStreamAsset> stream(bareStream);
if (NULL == stream || stream->getLength() <= 0) {
return NULL;
}
}
- SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const SK_OVERRIDE {
+ SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override {
SkAutoTDelete<SkStreamAsset> stream(SkStream::NewFromFile(path));
return stream.get() ? this->createFromStream(stream.detach(), ttcIndex) : NULL;
}
virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
- unsigned styleBits) const SK_OVERRIDE
+ unsigned styleBits) const override
{
SkTypeface::Style oldStyle = (SkTypeface::Style)styleBits;
SkFontStyle style = SkFontStyle(oldStyle & SkTypeface::kBold
AutoCFRelease<CTFontRef> fFontRef;
protected:
- int onGetUPEM() const SK_OVERRIDE;
- SkStreamAsset* onOpenStream(int* ttcIndex) const SK_OVERRIDE;
- void onGetFamilyName(SkString* familyName) const SK_OVERRIDE;
- SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const SK_OVERRIDE;
- int onGetTableTags(SkFontTableTag tags[]) const SK_OVERRIDE;
+ int onGetUPEM() const override;
+ SkStreamAsset* onOpenStream(int* ttcIndex) const override;
+ void onGetFamilyName(SkString* familyName) const override;
+ SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const override;
+ int onGetTableTags(SkFontTableTag tags[]) const override;
virtual size_t onGetTableData(SkFontTableTag, size_t offset,
- size_t length, void* data) const SK_OVERRIDE;
- SkScalerContext* onCreateScalerContext(const SkDescriptor*) const SK_OVERRIDE;
- void onFilterRec(SkScalerContextRec*) const SK_OVERRIDE;
- void onGetFontDescriptor(SkFontDescriptor*, bool*) const SK_OVERRIDE;
+ size_t length, void* data) const override;
+ SkScalerContext* onCreateScalerContext(const SkDescriptor*) const override;
+ void onFilterRec(SkScalerContextRec*) const override;
+ void onGetFontDescriptor(SkFontDescriptor*, bool*) const override;
virtual SkAdvancedTypefaceMetrics* onGetAdvancedTypefaceMetrics(
SkAdvancedTypefaceMetrics::PerGlyphInfo,
- const uint32_t*, uint32_t) const SK_OVERRIDE;
+ const uint32_t*, uint32_t) const override;
virtual int onCharsToGlyphs(const void* chars, Encoding, uint16_t glyphs[],
- int glyphCount) const SK_OVERRIDE;
- int onCountGlyphs() const SK_OVERRIDE;
+ int glyphCount) const override;
+ int onCountGlyphs() const override;
private:
bool fIsLocalStream;
SkScalerContext_Mac(SkTypeface_Mac*, const SkDescriptor*);
protected:
- unsigned generateGlyphCount(void) SK_OVERRIDE;
- uint16_t generateCharToGlyph(SkUnichar uni) SK_OVERRIDE;
- void generateAdvance(SkGlyph* glyph) SK_OVERRIDE;
- void generateMetrics(SkGlyph* glyph) SK_OVERRIDE;
- void generateImage(const SkGlyph& glyph) SK_OVERRIDE;
- void generatePath(const SkGlyph& glyph, SkPath* path) SK_OVERRIDE;
- void generateFontMetrics(SkPaint::FontMetrics*) SK_OVERRIDE;
+ unsigned generateGlyphCount(void) override;
+ uint16_t generateCharToGlyph(SkUnichar uni) override;
+ void generateAdvance(SkGlyph* glyph) override;
+ void generateMetrics(SkGlyph* glyph) override;
+ void generateImage(const SkGlyph& glyph) override;
+ void generatePath(const SkGlyph& glyph, SkPath* path) override;
+ void generateFontMetrics(SkPaint::FontMetrics*) override;
private:
static void CTPathElement(void *info, const CGPathElement *element);
CFRelease(fFamilyName);
}
- int count() SK_OVERRIDE {
+ int count() override {
return fCount;
}
- void getStyle(int index, SkFontStyle* style, SkString* name) SK_OVERRIDE {
+ void getStyle(int index, SkFontStyle* style, SkString* name) override {
SkASSERT((unsigned)index < (unsigned)fCount);
CTFontDescriptorRef desc = (CTFontDescriptorRef)CFArrayGetValueAtIndex(fArray, index);
if (style) {
}
}
- SkTypeface* createTypeface(int index) SK_OVERRIDE {
+ SkTypeface* createTypeface(int index) override {
SkASSERT((unsigned)index < (unsigned)CFArrayGetCount(fArray));
CTFontDescriptorRef desc = (CTFontDescriptorRef)CFArrayGetValueAtIndex(fArray, index);
return createFromDesc(fFamilyName, desc);
}
- SkTypeface* matchStyle(const SkFontStyle& pattern) SK_OVERRIDE {
+ SkTypeface* matchStyle(const SkFontStyle& pattern) override {
if (0 == fCount) {
return NULL;
}
}
protected:
- int onCountFamilies() const SK_OVERRIDE {
+ int onCountFamilies() const override {
return fCount;
}
- void onGetFamilyName(int index, SkString* familyName) const SK_OVERRIDE {
+ void onGetFamilyName(int index, SkString* familyName) const override {
if ((unsigned)index < (unsigned)fCount) {
CFStringToSkString(this->stringAt(index), familyName);
} else {
}
}
- SkFontStyleSet* onCreateStyleSet(int index) const SK_OVERRIDE {
+ SkFontStyleSet* onCreateStyleSet(int index) const override {
if ((unsigned)index >= (unsigned)fCount) {
return NULL;
}
return CreateSet(this->stringAt(index));
}
- SkFontStyleSet* onMatchFamily(const char familyName[]) const SK_OVERRIDE {
+ SkFontStyleSet* onMatchFamily(const char familyName[]) const override {
AutoCFRelease<CFStringRef> cfName(make_CFString(familyName));
return CreateSet(cfName);
}
virtual SkTypeface* onMatchFamilyStyle(const char familyName[],
- const SkFontStyle&) const SK_OVERRIDE {
+ const SkFontStyle&) const override {
return NULL;
}
virtual SkTypeface* onMatchFamilyStyleCharacter(const char familyName[], const SkFontStyle&,
const char* bcp47[], int bcp47Count,
- SkUnichar character) const SK_OVERRIDE {
+ SkUnichar character) const override {
return NULL;
}
virtual SkTypeface* onMatchFaceStyle(const SkTypeface* familyMember,
- const SkFontStyle&) const SK_OVERRIDE {
+ const SkFontStyle&) const override {
return NULL;
}
- SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const SK_OVERRIDE {
+ SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const override {
AutoCFRelease<CGDataProviderRef> pr(SkCreateDataProviderFromData(data));
if (NULL == pr) {
return NULL;
return create_from_dataProvider(pr);
}
- SkTypeface* onCreateFromStream(SkStreamAsset* stream, int ttcIndex) const SK_OVERRIDE {
+ SkTypeface* onCreateFromStream(SkStreamAsset* stream, int ttcIndex) const override {
AutoCFRelease<CGDataProviderRef> pr(SkCreateDataProviderFromStream(stream));
if (NULL == pr) {
return NULL;
return create_from_dataProvider(pr);
}
- SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const SK_OVERRIDE {
+ SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override {
AutoCFRelease<CGDataProviderRef> pr(CGDataProviderCreateWithFilename(path));
if (NULL == pr) {
return NULL;
}
virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
- unsigned styleBits) const SK_OVERRIDE {
+ unsigned styleBits) const override {
SkFontStyle style = SkFontStyle((SkTypeface::Style)styleBits);
if (familyName) {
}
protected:
- SkStreamAsset* onOpenStream(int* ttcIndex) const SK_OVERRIDE;
- SkScalerContext* onCreateScalerContext(const SkDescriptor*) const SK_OVERRIDE;
- void onFilterRec(SkScalerContextRec*) const SK_OVERRIDE;
+ SkStreamAsset* onOpenStream(int* ttcIndex) const override;
+ SkScalerContext* onCreateScalerContext(const SkDescriptor*) const override;
+ void onFilterRec(SkScalerContextRec*) const override;
virtual SkAdvancedTypefaceMetrics* onGetAdvancedTypefaceMetrics(
SkAdvancedTypefaceMetrics::PerGlyphInfo,
- const uint32_t*, uint32_t) const SK_OVERRIDE;
- void onGetFontDescriptor(SkFontDescriptor*, bool*) const SK_OVERRIDE;
+ const uint32_t*, uint32_t) const override;
+ void onGetFontDescriptor(SkFontDescriptor*, bool*) const override;
virtual int onCharsToGlyphs(const void* chars, Encoding encoding,
- uint16_t glyphs[], int glyphCount) const SK_OVERRIDE;
- int onCountGlyphs() const SK_OVERRIDE;
- int onGetUPEM() const SK_OVERRIDE;
- void onGetFamilyName(SkString* familyName) const SK_OVERRIDE;
- SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const SK_OVERRIDE;
- int onGetTableTags(SkFontTableTag tags[]) const SK_OVERRIDE;
+ uint16_t glyphs[], int glyphCount) const override;
+ int onCountGlyphs() const override;
+ int onGetUPEM() const override;
+ void onGetFamilyName(SkString* familyName) const override;
+ SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const override;
+ int onGetTableTags(SkFontTableTag tags[]) const override;
virtual size_t onGetTableData(SkFontTableTag, size_t offset,
- size_t length, void* data) const SK_OVERRIDE;
+ size_t length, void* data) const override;
};
class FontMemResourceTypeface : public LogFontTypeface {
}
protected:
- void weak_dispose() const SK_OVERRIDE {
+ void weak_dispose() const override {
RemoveFontMemResourceEx(fFontMemResource);
//SkTypefaceCache::Remove(this);
INHERITED::weak_dispose();
bool isValid() const;
protected:
- unsigned generateGlyphCount() SK_OVERRIDE;
- uint16_t generateCharToGlyph(SkUnichar uni) SK_OVERRIDE;
- void generateAdvance(SkGlyph* glyph) SK_OVERRIDE;
- void generateMetrics(SkGlyph* glyph) SK_OVERRIDE;
- void generateImage(const SkGlyph& glyph) SK_OVERRIDE;
- void generatePath(const SkGlyph& glyph, SkPath* path) SK_OVERRIDE;
- void generateFontMetrics(SkPaint::FontMetrics*) SK_OVERRIDE;
+ unsigned generateGlyphCount() override;
+ uint16_t generateCharToGlyph(SkUnichar uni) override;
+ void generateAdvance(SkGlyph* glyph) override;
+ void generateMetrics(SkGlyph* glyph) override;
+ void generateImage(const SkGlyph& glyph) override;
+ void generatePath(const SkGlyph& glyph, SkPath* path) override;
+ void generateFontMetrics(SkPaint::FontMetrics*) override;
private:
DWORD getGDIGlyphPath(const SkGlyph& glyph, UINT flags,
::DeleteDC(hdc);
}
- int count() SK_OVERRIDE {
+ int count() override {
return fArray.count();
}
- void getStyle(int index, SkFontStyle* fs, SkString* styleName) SK_OVERRIDE {
+ void getStyle(int index, SkFontStyle* fs, SkString* styleName) override {
if (fs) {
*fs = get_style(fArray[index].elfLogFont);
}
}
}
- SkTypeface* createTypeface(int index) SK_OVERRIDE {
+ SkTypeface* createTypeface(int index) override {
return SkCreateTypefaceFromLOGFONT(fArray[index].elfLogFont);
}
- SkTypeface* matchStyle(const SkFontStyle& pattern) SK_OVERRIDE {
+ SkTypeface* matchStyle(const SkFontStyle& pattern) override {
// todo:
return SkCreateTypefaceFromLOGFONT(fArray[0].elfLogFont);
}
}
protected:
- int onCountFamilies() const SK_OVERRIDE {
+ int onCountFamilies() const override {
return fLogFontArray.count();
}
- void onGetFamilyName(int index, SkString* familyName) const SK_OVERRIDE {
+ void onGetFamilyName(int index, SkString* familyName) const override {
SkASSERT((unsigned)index < (unsigned)fLogFontArray.count());
tchar_to_skstring(fLogFontArray[index].elfLogFont.lfFaceName, familyName);
}
- SkFontStyleSet* onCreateStyleSet(int index) const SK_OVERRIDE {
+ SkFontStyleSet* onCreateStyleSet(int index) const override {
SkASSERT((unsigned)index < (unsigned)fLogFontArray.count());
return SkNEW_ARGS(SkFontStyleSetGDI, (fLogFontArray[index].elfLogFont.lfFaceName));
}
- SkFontStyleSet* onMatchFamily(const char familyName[]) const SK_OVERRIDE {
+ SkFontStyleSet* onMatchFamily(const char familyName[]) const override {
if (NULL == familyName) {
familyName = ""; // do we need this check???
}
}
virtual SkTypeface* onMatchFamilyStyle(const char familyName[],
- const SkFontStyle& fontstyle) const SK_OVERRIDE {
+ const SkFontStyle& fontstyle) const override {
// could be in base impl
SkAutoTUnref<SkFontStyleSet> sset(this->matchFamily(familyName));
return sset->matchStyle(fontstyle);
virtual SkTypeface* onMatchFamilyStyleCharacter(const char familyName[], const SkFontStyle&,
const char* bcp47[], int bcp47Count,
- SkUnichar character) const SK_OVERRIDE {
+ SkUnichar character) const override {
return NULL;
}
virtual SkTypeface* onMatchFaceStyle(const SkTypeface* familyMember,
- const SkFontStyle& fontstyle) const SK_OVERRIDE {
+ const SkFontStyle& fontstyle) const override {
// could be in base impl
SkString familyName;
((LogFontTypeface*)familyMember)->getFamilyName(&familyName);
return this->matchFamilyStyle(familyName.c_str(), fontstyle);
}
- SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const SK_OVERRIDE {
+ SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const override {
SkAutoTDelete<SkStreamAsset> stream(bareStream);
return create_from_stream(stream);
}
- SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const SK_OVERRIDE {
+ SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const override {
// could be in base impl
return this->createFromStream(SkNEW_ARGS(SkMemoryStream, (data)));
}
- SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const SK_OVERRIDE {
+ SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override {
// could be in base impl
return this->createFromStream(SkStream::NewFromFile(path));
}
virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
- unsigned styleBits) const SK_OVERRIDE {
+ unsigned styleBits) const override {
LOGFONT lf;
if (NULL == familyName) {
lf = get_default_font();
, fFamilyName(familyName) { }
protected:
- void onGetFamilyName(SkString* familyName) const SK_OVERRIDE {
+ void onGetFamilyName(SkString* familyName) const override {
*familyName = fFamilyName;
}
, fVariantStyle(variantStyle) { }
virtual void onGetFontDescriptor(SkFontDescriptor* desc,
- bool* serialize) const SK_OVERRIDE {
+ bool* serialize) const override {
SkASSERT(desc);
SkASSERT(serialize);
desc->setFamilyName(fFamilyName.c_str());
desc->setFontIndex(fIndex);
*serialize = false;
}
- SkStreamAsset* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
+ SkStreamAsset* onOpenStream(int* ttcIndex) const override {
*ttcIndex = fIndex;
return SkStream::NewFromFile(fPathName.c_str());
}
, fStream(stream) { }
virtual void onGetFontDescriptor(SkFontDescriptor* desc,
- bool* serialize) const SK_OVERRIDE {
+ bool* serialize) const override {
SkASSERT(desc);
SkASSERT(serialize);
desc->setFamilyName(fFamilyName.c_str());
*serialize = true;
}
- SkStreamAsset* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
+ SkStreamAsset* onOpenStream(int* ttcIndex) const override {
*ttcIndex = fIndex;
return fStream->duplicate();
}
}
}
- int count() SK_OVERRIDE {
+ int count() override {
return fStyles.count();
}
- void getStyle(int index, SkFontStyle* style, SkString* name) SK_OVERRIDE {
+ void getStyle(int index, SkFontStyle* style, SkString* name) override {
if (index < 0 || fStyles.count() <= index) {
return;
}
name->reset();
}
}
- SkTypeface_AndroidSystem* createTypeface(int index) SK_OVERRIDE {
+ SkTypeface_AndroidSystem* createTypeface(int index) override {
if (index < 0 || fStyles.count() <= index) {
return NULL;
}
* TODO: consider replacing with SkStyleSet_Indirect::matchStyle();
* this simpler version using match_score() passes all our tests.
*/
- SkTypeface_AndroidSystem* matchStyle(const SkFontStyle& pattern) SK_OVERRIDE {
+ SkTypeface_AndroidSystem* matchStyle(const SkFontStyle& pattern) override {
if (0 == fStyles.count()) {
return NULL;
}
/** Returns not how many families we have, but how many unique names
* exist among the families.
*/
- int onCountFamilies() const SK_OVERRIDE {
+ int onCountFamilies() const override {
return fNameToFamilyMap.count();
}
- void onGetFamilyName(int index, SkString* familyName) const SK_OVERRIDE {
+ void onGetFamilyName(int index, SkString* familyName) const override {
if (index < 0 || fNameToFamilyMap.count() <= index) {
familyName->reset();
return;
familyName->set(fNameToFamilyMap[index].name);
}
- SkFontStyleSet* onCreateStyleSet(int index) const SK_OVERRIDE {
+ SkFontStyleSet* onCreateStyleSet(int index) const override {
if (index < 0 || fNameToFamilyMap.count() <= index) {
return NULL;
}
return SkRef(fNameToFamilyMap[index].styleSet);
}
- SkFontStyleSet* onMatchFamily(const char familyName[]) const SK_OVERRIDE {
+ SkFontStyleSet* onMatchFamily(const char familyName[]) const override {
if (!familyName) {
return NULL;
}
}
virtual SkTypeface* onMatchFamilyStyle(const char familyName[],
- const SkFontStyle& style) const SK_OVERRIDE {
+ const SkFontStyle& style) const override {
SkAutoTUnref<SkFontStyleSet> sset(this->matchFamily(familyName));
return sset->matchStyle(style);
}
virtual SkTypeface* onMatchFaceStyle(const SkTypeface* typeface,
- const SkFontStyle& style) const SK_OVERRIDE {
+ const SkFontStyle& style) const override {
for (int i = 0; i < fFontStyleSets.count(); ++i) {
for (int j = 0; j < fFontStyleSets[i]->fStyles.count(); ++j) {
if (fFontStyleSets[i]->fStyles[j] == typeface) {
const SkFontStyle& style,
const char* bcp47[],
int bcp47Count,
- SkUnichar character) const SK_OVERRIDE
+ SkUnichar character) const override
{
// The variant 'elegant' is 'not squashed', 'compact' is 'stays in ascent/descent'.
// The variant 'default' means 'compact and elegant'.
return NULL;
}
- SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const SK_OVERRIDE {
+ SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const override {
return this->createFromStream(new SkMemoryStream(data), ttcIndex);
}
- SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const SK_OVERRIDE {
+ SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override {
SkAutoTDelete<SkStreamAsset> stream(SkStream::NewFromFile(path));
return stream.get() ? this->createFromStream(stream.detach(), ttcIndex) : NULL;
}
- SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const SK_OVERRIDE {
+ SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const override {
SkAutoTDelete<SkStreamAsset> stream(bareStream);
bool isFixedPitch;
SkFontStyle style;
virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
- unsigned styleBits) const SK_OVERRIDE {
+ unsigned styleBits) const override {
SkFontStyle style = SkFontStyle(styleBits);
if (familyName) {
, fIndex(index)
{ };
- void onGetFamilyName(SkString* familyName) const SK_OVERRIDE {
+ void onGetFamilyName(SkString* familyName) const override {
familyName->reset();
}
- void onGetFontDescriptor(SkFontDescriptor* desc, bool* serialize) const SK_OVERRIDE {
+ void onGetFontDescriptor(SkFontDescriptor* desc, bool* serialize) const override {
desc->setFontIndex(fIndex);
*serialize = true;
}
- SkStreamAsset* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
+ SkStreamAsset* onOpenStream(int* ttcIndex) const override {
*ttcIndex = fIndex;
return fStream->duplicate();
}
}
mutable SkAutoFcPattern fPattern;
- void onGetFamilyName(SkString* familyName) const SK_OVERRIDE {
+ void onGetFamilyName(SkString* familyName) const override {
*familyName = get_string(fPattern, FC_FAMILY);
}
- void onGetFontDescriptor(SkFontDescriptor* desc, bool* serialize) const SK_OVERRIDE {
+ void onGetFontDescriptor(SkFontDescriptor* desc, bool* serialize) const override {
FCLocker lock;
desc->setFamilyName(get_string(fPattern, FC_FAMILY));
desc->setFullName(get_string(fPattern, FC_FULLNAME));
*serialize = false;
}
- SkStreamAsset* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
+ SkStreamAsset* onOpenStream(int* ttcIndex) const override {
FCLocker lock;
*ttcIndex = get_int(fPattern, FC_INDEX, 0);
return SkStream::NewFromFile(get_string(fPattern, FC_FILE));
fFontSet.reset();
}
- int count() SK_OVERRIDE { return fFontSet->nfont; }
+ int count() override { return fFontSet->nfont; }
- void getStyle(int index, SkFontStyle* style, SkString* styleName) SK_OVERRIDE {
+ void getStyle(int index, SkFontStyle* style, SkString* styleName) override {
if (index < 0 || fFontSet->nfont <= index) {
return;
}
}
}
- SkTypeface* createTypeface(int index) SK_OVERRIDE {
+ SkTypeface* createTypeface(int index) override {
FCLocker lock;
FcPattern* match = fFontSet->fonts[index];
return fFontMgr->createTypefaceFromFcPattern(match);
}
- SkTypeface* matchStyle(const SkFontStyle& style) SK_OVERRIDE {
+ SkTypeface* matchStyle(const SkFontStyle& style) override {
FCLocker lock;
SkAutoFcPattern pattern;
}
protected:
- int onCountFamilies() const SK_OVERRIDE {
+ int onCountFamilies() const override {
return fFamilyNames->count();
}
- void onGetFamilyName(int index, SkString* familyName) const SK_OVERRIDE {
+ void onGetFamilyName(int index, SkString* familyName) const override {
familyName->set(fFamilyNames->atStr(index));
}
- SkFontStyleSet* onCreateStyleSet(int index) const SK_OVERRIDE {
+ SkFontStyleSet* onCreateStyleSet(int index) const override {
return this->onMatchFamily(fFamilyNames->atStr(index));
}
return false;
}
- SkFontStyleSet* onMatchFamily(const char familyName[]) const SK_OVERRIDE {
+ SkFontStyleSet* onMatchFamily(const char familyName[]) const override {
FCLocker lock;
SkAutoFcPattern pattern;
}
virtual SkTypeface* onMatchFamilyStyle(const char familyName[],
- const SkFontStyle& style) const SK_OVERRIDE
+ const SkFontStyle& style) const override
{
FCLocker lock;
const SkFontStyle& style,
const char* bcp47[],
int bcp47Count,
- SkUnichar character) const SK_OVERRIDE
+ SkUnichar character) const override
{
FCLocker lock;
}
virtual SkTypeface* onMatchFaceStyle(const SkTypeface* typeface,
- const SkFontStyle& style) const SK_OVERRIDE
+ const SkFontStyle& style) const override
{
//TODO: should the SkTypeface_fontconfig know its family?
const SkTypeface_fontconfig* fcTypeface =
return this->matchFamilyStyle(get_string(fcTypeface->fPattern, FC_FAMILY), style);
}
- SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const SK_OVERRIDE {
+ SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const override {
SkAutoTDelete<SkStreamAsset> stream(bareStream);
const size_t length = stream->getLength();
if (length <= 0 || (1u << 30) < length) {
static_cast<SkStreamAsset*>(stream.detach())));
}
- SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const SK_OVERRIDE {
+ SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const override {
return this->createFromStream(SkNEW_ARGS(SkMemoryStream, (data)), ttcIndex);
}
- SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const SK_OVERRIDE {
+ SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override {
return this->createFromStream(SkStream::NewFromFile(path), ttcIndex);
}
virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
- unsigned styleBits) const SK_OVERRIDE {
+ unsigned styleBits) const override {
bool bold = styleBits & SkTypeface::kBold;
bool italic = styleBits & SkTypeface::kItalic;
SkFontStyle style = SkFontStyle(bold ? SkFontStyle::kBold_Weight
}
protected:
- int onCountFamilies() const SK_OVERRIDE;
- void onGetFamilyName(int index, SkString* familyName) const SK_OVERRIDE;
- SkFontStyleSet* onCreateStyleSet(int index) const SK_OVERRIDE;
- SkFontStyleSet* onMatchFamily(const char familyName[]) const SK_OVERRIDE;
+ int onCountFamilies() const override;
+ void onGetFamilyName(int index, SkString* familyName) const override;
+ SkFontStyleSet* onCreateStyleSet(int index) const override;
+ SkFontStyleSet* onMatchFamily(const char familyName[]) const override;
virtual SkTypeface* onMatchFamilyStyle(const char familyName[],
- const SkFontStyle& fontstyle) const SK_OVERRIDE;
+ const SkFontStyle& fontstyle) const override;
virtual SkTypeface* onMatchFamilyStyleCharacter(const char familyName[], const SkFontStyle&,
const char* bcp47[], int bcp47Count,
- SkUnichar character) const SK_OVERRIDE;
+ SkUnichar character) const override;
virtual SkTypeface* onMatchFaceStyle(const SkTypeface* familyMember,
- const SkFontStyle& fontstyle) const SK_OVERRIDE;
- SkTypeface* onCreateFromStream(SkStreamAsset* stream, int ttcIndex) const SK_OVERRIDE;
- SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const SK_OVERRIDE;
- SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const SK_OVERRIDE;
+ const SkFontStyle& fontstyle) const override;
+ SkTypeface* onCreateFromStream(SkStreamAsset* stream, int ttcIndex) const override;
+ SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const override;
+ SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override;
virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
- unsigned styleBits) const SK_OVERRIDE;
+ unsigned styleBits) const override;
private:
HRESULT getByFamilyName(const WCHAR familyName[], IDWriteFontFamily** fontFamily) const;
, fFontFamily(SkRefComPtr(fontFamily))
{ }
- int count() SK_OVERRIDE;
- void getStyle(int index, SkFontStyle* fs, SkString* styleName) SK_OVERRIDE;
- SkTypeface* createTypeface(int index) SK_OVERRIDE;
- SkTypeface* matchStyle(const SkFontStyle& pattern) SK_OVERRIDE;
+ int count() override;
+ void getStyle(int index, SkFontStyle* fs, SkString* styleName) override;
+ SkTypeface* createTypeface(int index) override;
+ SkTypeface* matchStyle(const SkFontStyle& pattern) override;
private:
SkAutoTUnref<const SkFontMgr_DirectWrite> fFontMgr;
DWRITE_MEASURING_MODE measuringMode,
DWRITE_GLYPH_RUN const* glyphRun,
DWRITE_GLYPH_RUN_DESCRIPTION const* glyphRunDescription,
- IUnknown* clientDrawingEffect) SK_OVERRIDE
+ IUnknown* clientDrawingEffect) override
{
SkTScopedComPtr<IDWriteFont> font;
HRM(fOuter->fFontCollection->GetFontFromFontFace(glyphRun->fontFace, &font),
FLOAT baselineOriginX,
FLOAT baselineOriginY,
DWRITE_UNDERLINE const* underline,
- IUnknown* clientDrawingEffect) SK_OVERRIDE
+ IUnknown* clientDrawingEffect) override
{ return E_NOTIMPL; }
virtual HRESULT STDMETHODCALLTYPE DrawStrikethrough(
FLOAT baselineOriginX,
FLOAT baselineOriginY,
DWRITE_STRIKETHROUGH const* strikethrough,
- IUnknown* clientDrawingEffect) SK_OVERRIDE
+ IUnknown* clientDrawingEffect) override
{ return E_NOTIMPL; }
virtual HRESULT STDMETHODCALLTYPE DrawInlineObject(
IDWriteInlineObject* inlineObject,
BOOL isSideways,
BOOL isRightToLeft,
- IUnknown* clientDrawingEffect) SK_OVERRIDE
+ IUnknown* clientDrawingEffect) override
{ return E_NOTIMPL; }
// IDWritePixelSnapping methods
virtual HRESULT STDMETHODCALLTYPE IsPixelSnappingDisabled(
void* clientDrawingContext,
- BOOL* isDisabled) SK_OVERRIDE
+ BOOL* isDisabled) override
{
*isDisabled = FALSE;
return S_OK;
virtual HRESULT STDMETHODCALLTYPE GetCurrentTransform(
void* clientDrawingContext,
- DWRITE_MATRIX* transform) SK_OVERRIDE
+ DWRITE_MATRIX* transform) override
{
const DWRITE_MATRIX ident = { 1.0, 0.0, 0.0, 1.0, 0.0, 0.0 };
*transform = ident;
virtual HRESULT STDMETHODCALLTYPE GetPixelsPerDip(
void* clientDrawingContext,
- FLOAT* pixelsPerDip) SK_OVERRIDE
+ FLOAT* pixelsPerDip) override
{
*pixelsPerDip = 1.0f;
return S_OK;
}
// IUnknown methods
- ULONG STDMETHODCALLTYPE AddRef() SK_OVERRIDE {
+ ULONG STDMETHODCALLTYPE AddRef() override {
return InterlockedIncrement(&fRefCount);
}
- ULONG STDMETHODCALLTYPE Release() SK_OVERRIDE {
+ ULONG STDMETHODCALLTYPE Release() override {
ULONG newCount = InterlockedDecrement(&fRefCount);
if (0 == newCount) {
delete this;
return newCount;
}
- virtual HRESULT STDMETHODCALLTYPE QueryInterface(IID const& riid, void** ppvObject) SK_OVERRIDE{
+ virtual HRESULT STDMETHODCALLTYPE QueryInterface(IID const& riid, void** ppvObject) override{
if (__uuidof(IUnknown) == riid ||
__uuidof(IDWritePixelSnapping) == riid ||
__uuidof(IDWriteTextRenderer) == riid)
virtual HRESULT STDMETHODCALLTYPE GetTextAtPosition(
UINT32 textPosition,
WCHAR const** textString,
- UINT32* textLength) SK_OVERRIDE
+ UINT32* textLength) override
{
if (fLength <= textPosition) {
*textString = NULL;
virtual HRESULT STDMETHODCALLTYPE GetTextBeforePosition(
UINT32 textPosition,
WCHAR const** textString,
- UINT32* textLength) SK_OVERRIDE
+ UINT32* textLength) override
{
if (textPosition < 1 || fLength <= textPosition) {
*textString = NULL;
return S_OK;
}
- virtual DWRITE_READING_DIRECTION STDMETHODCALLTYPE GetParagraphReadingDirection() SK_OVERRIDE {
+ virtual DWRITE_READING_DIRECTION STDMETHODCALLTYPE GetParagraphReadingDirection() override {
// TODO: this is also interesting.
return DWRITE_READING_DIRECTION_LEFT_TO_RIGHT;
}
virtual HRESULT STDMETHODCALLTYPE GetLocaleName(
UINT32 textPosition,
UINT32* textLength,
- WCHAR const** localeName) SK_OVERRIDE
+ WCHAR const** localeName) override
{
*localeName = fLocale;
return S_OK;
virtual HRESULT STDMETHODCALLTYPE GetNumberSubstitution(
UINT32 textPosition,
UINT32* textLength,
- IDWriteNumberSubstitution** numberSubstitution) SK_OVERRIDE
+ IDWriteNumberSubstitution** numberSubstitution) override
{
*numberSubstitution = fNumberSubstitution;
return S_OK;
}
// IUnknown methods
- ULONG STDMETHODCALLTYPE AddRef() SK_OVERRIDE {
+ ULONG STDMETHODCALLTYPE AddRef() override {
return InterlockedIncrement(&fRefCount);
}
- ULONG STDMETHODCALLTYPE Release() SK_OVERRIDE {
+ ULONG STDMETHODCALLTYPE Release() override {
ULONG newCount = InterlockedDecrement(&fRefCount);
if (0 == newCount) {
delete this;
return newCount;
}
- virtual HRESULT STDMETHODCALLTYPE QueryInterface(IID const& riid, void** ppvObject) SK_OVERRIDE{
+ virtual HRESULT STDMETHODCALLTYPE QueryInterface(IID const& riid, void** ppvObject) override{
if (__uuidof(IUnknown) == riid ||
__uuidof(IDWriteTextAnalysisSource) == riid)
{
bool decodeStream(SkStream* stream, SkBitmap* bm, WICModes wicMode, Format* format) const;
protected:
- Result onDecode(SkStream* stream, SkBitmap* bm, Mode mode) SK_OVERRIDE;
+ Result onDecode(SkStream* stream, SkBitmap* bm, Mode mode) override;
};
struct FormatConversion {
{}
protected:
- bool allocPixelRef(SkBitmap* bm, SkColorTable* ctable) SK_OVERRIDE {
+ bool allocPixelRef(SkBitmap* bm, SkColorTable* ctable) override {
const SkImageInfo bmi = bm->info();
if (bmi.width() != fInfo.width() || bmi.height() != fInfo.height() ||
bmi.colorType() != fInfo.colorType())
{}
protected:
- SkData* onRefEncodedData() SK_OVERRIDE {
+ SkData* onRefEncodedData() override {
return SkRef(fData.get());
}
#ifdef SK_SUPPORT_LEGACY_BOOL_ONGETINFO
- virtual bool onGetInfo(SkImageInfo* info) SK_OVERRIDE {
+ virtual bool onGetInfo(SkImageInfo* info) override {
*info = fInfo;
return true;
}
virtual Result onGetPixels(const SkImageInfo& info, void* pixels, size_t rowBytes,
const Options&,
- SkPMColor ctableEntries[], int* ctableCount) SK_OVERRIDE {
+ SkPMColor ctableEntries[], int* ctableCount) override {
SkMemoryStream stream(fData->data(), fData->size(), false);
SkAutoTUnref<BareMemoryAllocator> allocator(SkNEW_ARGS(BareMemoryAllocator,
(info, pixels, rowBytes)));
}
bool onGetYUV8Planes(SkISize sizes[3], void* planes[3], size_t rowBytes[3],
- SkYUVColorSpace* colorSpace) SK_OVERRIDE {
+ SkYUVColorSpace* colorSpace) override {
SkMemoryStream stream(fData->data(), fData->size(), false);
return fDecoder->decodeYUV8Planes(&stream, sizes, planes, rowBytes, colorSpace);
}
memcpy(fLocaleName.get(), localeName, localeNameLength * sizeof(WCHAR));
}
- SkDataTable* getFamilyNames() const SK_OVERRIDE {
+ SkDataTable* getFamilyNames() const override {
int count = fFontCollection->GetFontFamilyCount();
SkDataTableBuilder names(1024);
return S_OK;
}
- SkRemotableFontIdentitySet* getIndex(int familyIndex) const SK_OVERRIDE {
+ SkRemotableFontIdentitySet* getIndex(int familyIndex) const override {
SkTScopedComPtr<IDWriteFontFamily> fontFamily;
HRNM(fFontCollection->GetFontFamily(familyIndex, &fontFamily),
"Could not get requested family.");
}
virtual SkFontIdentity matchIndexStyle(int familyIndex,
- const SkFontStyle& pattern) const SK_OVERRIDE
+ const SkFontStyle& pattern) const override
{
SkFontIdentity identity = { SkFontIdentity::kInvalidDataId };
return S_OK;
}
- SkRemotableFontIdentitySet* matchName(const char familyName[]) const SK_OVERRIDE {
+ SkRemotableFontIdentitySet* matchName(const char familyName[]) const override {
SkSMallocWCHAR dwFamilyName;
if (NULL == familyName) {
HR_GENERAL(getDefaultFontFamilyName(&dwFamilyName),
}
virtual SkFontIdentity matchNameStyle(const char familyName[],
- const SkFontStyle& style) const SK_OVERRIDE
+ const SkFontStyle& style) const override
{
SkFontIdentity identity = { SkFontIdentity::kInvalidDataId };
DWRITE_MEASURING_MODE measuringMode,
DWRITE_GLYPH_RUN const* glyphRun,
DWRITE_GLYPH_RUN_DESCRIPTION const* glyphRunDescription,
- IUnknown* clientDrawingEffect) SK_OVERRIDE
+ IUnknown* clientDrawingEffect) override
{
SkTScopedComPtr<IDWriteFont> font;
HRM(fOuter->fFontCollection->GetFontFromFontFace(glyphRun->fontFace, &font),
FLOAT baselineOriginX,
FLOAT baselineOriginY,
DWRITE_UNDERLINE const* underline,
- IUnknown* clientDrawingEffect) SK_OVERRIDE
+ IUnknown* clientDrawingEffect) override
{ return E_NOTIMPL; }
virtual HRESULT STDMETHODCALLTYPE DrawStrikethrough(
FLOAT baselineOriginX,
FLOAT baselineOriginY,
DWRITE_STRIKETHROUGH const* strikethrough,
- IUnknown* clientDrawingEffect) SK_OVERRIDE
+ IUnknown* clientDrawingEffect) override
{ return E_NOTIMPL; }
virtual HRESULT STDMETHODCALLTYPE DrawInlineObject(
IDWriteInlineObject* inlineObject,
BOOL isSideways,
BOOL isRightToLeft,
- IUnknown* clientDrawingEffect) SK_OVERRIDE
+ IUnknown* clientDrawingEffect) override
{ return E_NOTIMPL; }
// IDWritePixelSnapping methods
virtual HRESULT STDMETHODCALLTYPE IsPixelSnappingDisabled(
void* clientDrawingContext,
- BOOL* isDisabled) SK_OVERRIDE
+ BOOL* isDisabled) override
{
*isDisabled = FALSE;
return S_OK;
virtual HRESULT STDMETHODCALLTYPE GetCurrentTransform(
void* clientDrawingContext,
- DWRITE_MATRIX* transform) SK_OVERRIDE
+ DWRITE_MATRIX* transform) override
{
const DWRITE_MATRIX ident = {1.0, 0.0, 0.0, 1.0, 0.0, 0.0};
*transform = ident;
virtual HRESULT STDMETHODCALLTYPE GetPixelsPerDip(
void* clientDrawingContext,
- FLOAT* pixelsPerDip) SK_OVERRIDE
+ FLOAT* pixelsPerDip) override
{
*pixelsPerDip = 1.0f;
return S_OK;
}
// IUnknown methods
- ULONG STDMETHODCALLTYPE AddRef() SK_OVERRIDE {
+ ULONG STDMETHODCALLTYPE AddRef() override {
return InterlockedIncrement(&fRefCount);
}
- ULONG STDMETHODCALLTYPE Release() SK_OVERRIDE {
+ ULONG STDMETHODCALLTYPE Release() override {
ULONG newCount = InterlockedDecrement(&fRefCount);
if (0 == newCount) {
delete this;
}
virtual HRESULT STDMETHODCALLTYPE QueryInterface(
- IID const& riid, void** ppvObject) SK_OVERRIDE
+ IID const& riid, void** ppvObject) override
{
if (__uuidof(IUnknown) == riid ||
__uuidof(IDWritePixelSnapping) == riid ||
virtual SkFontIdentity matchNameStyleCharacter(const char familyName[],
const SkFontStyle& pattern,
const char* bcp47[], int bcp47Count,
- SkUnichar character) const SK_OVERRIDE
+ SkUnichar character) const override
{
SkFontIdentity identity = { SkFontIdentity::kInvalidDataId };
return fontFallbackRenderer->FallbackIdentity();
}
- SkStreamAsset* getData(int dataId) const SK_OVERRIDE {
+ SkStreamAsset* getData(int dataId) const override {
SkAutoMutexAcquire ama(fDataIdCacheMutex);
if (dataId >= fDataIdCache.count()) {
return NULL;
virtual ~SkScalerContext_DW();
protected:
- unsigned generateGlyphCount() SK_OVERRIDE;
- uint16_t generateCharToGlyph(SkUnichar uni) SK_OVERRIDE;
- void generateAdvance(SkGlyph* glyph) SK_OVERRIDE;
- void generateMetrics(SkGlyph* glyph) SK_OVERRIDE;
- void generateImage(const SkGlyph& glyph) SK_OVERRIDE;
- void generatePath(const SkGlyph& glyph, SkPath* path) SK_OVERRIDE;
- void generateFontMetrics(SkPaint::FontMetrics*) SK_OVERRIDE;
+ unsigned generateGlyphCount() override;
+ uint16_t generateCharToGlyph(SkUnichar uni) override;
+ void generateAdvance(SkGlyph* glyph) override;
+ void generateMetrics(SkGlyph* glyph) override;
+ void generateImage(const SkGlyph& glyph) override;
+ void generatePath(const SkGlyph& glyph, SkPath* path) override;
+ void generateFontMetrics(SkPaint::FontMetrics*) override;
private:
const void* drawDWMask(const SkGlyph& glyph,
: fIndex(0), fStrings(strings)
{ }
- bool next(SkTypeface::LocalizedString* localizedString) SK_OVERRIDE {
+ bool next(SkTypeface::LocalizedString* localizedString) override {
if (fIndex >= fStrings->GetCount()) {
return false;
}
}
protected:
- void weak_dispose() const SK_OVERRIDE {
+ void weak_dispose() const override {
if (fDWriteFontCollectionLoader.get()) {
HRV(fFactory->UnregisterFontCollectionLoader(fDWriteFontCollectionLoader.get()));
}
INHERITED::weak_dispose();
}
- SkStreamAsset* onOpenStream(int* ttcIndex) const SK_OVERRIDE;
- SkScalerContext* onCreateScalerContext(const SkDescriptor*) const SK_OVERRIDE;
- void onFilterRec(SkScalerContextRec*) const SK_OVERRIDE;
+ SkStreamAsset* onOpenStream(int* ttcIndex) const override;
+ SkScalerContext* onCreateScalerContext(const SkDescriptor*) const override;
+ void onFilterRec(SkScalerContextRec*) const override;
virtual SkAdvancedTypefaceMetrics* onGetAdvancedTypefaceMetrics(
SkAdvancedTypefaceMetrics::PerGlyphInfo,
- const uint32_t*, uint32_t) const SK_OVERRIDE;
- void onGetFontDescriptor(SkFontDescriptor*, bool*) const SK_OVERRIDE;
+ const uint32_t*, uint32_t) const override;
+ void onGetFontDescriptor(SkFontDescriptor*, bool*) const override;
virtual int onCharsToGlyphs(const void* chars, Encoding encoding,
- uint16_t glyphs[], int glyphCount) const SK_OVERRIDE;
- int onCountGlyphs() const SK_OVERRIDE;
- int onGetUPEM() const SK_OVERRIDE;
- void onGetFamilyName(SkString* familyName) const SK_OVERRIDE;
- SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const SK_OVERRIDE;
- int onGetTableTags(SkFontTableTag tags[]) const SK_OVERRIDE;
+ uint16_t glyphs[], int glyphCount) const override;
+ int onCountGlyphs() const override;
+ int onGetUPEM() const override;
+ void onGetFamilyName(SkString* familyName) const override;
+ SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const override;
+ int onGetTableTags(SkFontTableTag tags[]) const override;
virtual size_t onGetTableData(SkFontTableTag, size_t offset,
- size_t length, void* data) const SK_OVERRIDE;
+ size_t length, void* data) const override;
private:
typedef SkTypeface INHERITED;
*/
static LocalizedStrings_NameTable* CreateForFamilyNames(const SkTypeface& typeface);
- bool next(SkTypeface::LocalizedString* localizedString) SK_OVERRIDE;
+ bool next(SkTypeface::LocalizedString* localizedString) override;
private:
static SkOTTableName::Record::NameID::Predefined::Value familyNameTypes[3];
: fName(name), fLanguage(language), fHasNext(true)
{ }
- bool next(SkTypeface::LocalizedString* localizedString) SK_OVERRIDE {
+ bool next(SkTypeface::LocalizedString* localizedString) override {
localizedString->fString = fName;
localizedString->fLanguage = fLanguage;
public:
static SkBaseDevice* Create(const SkISize& size, SkXMLWriter* writer);
- virtual SkImageInfo imageInfo() const SK_OVERRIDE;
+ virtual SkImageInfo imageInfo() const override;
protected:
- virtual void drawPaint(const SkDraw&, const SkPaint& paint) SK_OVERRIDE;
+ virtual void drawPaint(const SkDraw&, const SkPaint& paint) override;
virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count,
- const SkPoint[], const SkPaint& paint) SK_OVERRIDE;
- virtual void drawRect(const SkDraw&, const SkRect& r, const SkPaint& paint) SK_OVERRIDE;
- virtual void drawOval(const SkDraw&, const SkRect& oval, const SkPaint& paint) SK_OVERRIDE;
- virtual void drawRRect(const SkDraw&, const SkRRect& rr, const SkPaint& paint) SK_OVERRIDE;
+ const SkPoint[], const SkPaint& paint) override;
+ virtual void drawRect(const SkDraw&, const SkRect& r, const SkPaint& paint) override;
+ virtual void drawOval(const SkDraw&, const SkRect& oval, const SkPaint& paint) override;
+ virtual void drawRRect(const SkDraw&, const SkRRect& rr, const SkPaint& paint) override;
virtual void drawPath(const SkDraw&, const SkPath& path,
const SkPaint& paint,
const SkMatrix* prePathMatrix = NULL,
- bool pathIsMutable = false) SK_OVERRIDE;
+ bool pathIsMutable = false) override;
virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
- const SkMatrix& matrix, const SkPaint& paint) SK_OVERRIDE;
+ const SkMatrix& matrix, const SkPaint& paint) override;
virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap,
- int x, int y, const SkPaint& paint) SK_OVERRIDE;
+ int x, int y, const SkPaint& paint) override;
virtual void drawBitmapRect(const SkDraw&, const SkBitmap&,
const SkRect* srcOrNull, const SkRect& dst,
const SkPaint& paint,
- SkCanvas::DrawBitmapRectFlags flags) SK_OVERRIDE;
+ SkCanvas::DrawBitmapRectFlags flags) override;
virtual void drawText(const SkDraw&, const void* text, size_t len,
- SkScalar x, SkScalar y, const SkPaint& paint) SK_OVERRIDE;
+ SkScalar x, SkScalar y, const SkPaint& paint) override;
virtual void drawPosText(const SkDraw&, const void* text, size_t len,
const SkScalar pos[], int scalarsPerPos,
- const SkPoint& offset, const SkPaint& paint) SK_OVERRIDE;
+ const SkPoint& offset, const SkPaint& paint) override;
virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len,
const SkPath& path, const SkMatrix* matrix,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount,
const SkPoint verts[], const SkPoint texs[],
const SkColor colors[], SkXfermode* xmode,
const uint16_t indices[], int indexCount,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
- const SkPaint&) SK_OVERRIDE;
- virtual const SkBitmap& onAccessBitmap() SK_OVERRIDE;
+ const SkPaint&) override;
+ virtual const SkBitmap& onAccessBitmap() override;
private:
SkSVGDevice(const SkISize& size, SkXMLWriter* writer);
virtual ~SkCanvasStack();
void pushCanvas(SkCanvas* canvas, const SkIPoint& origin);
- void removeAll() SK_OVERRIDE;
+ void removeAll() override;
/*
* The following add/remove canvas methods are overrides from SkNWayCanvas
* can share most of the other implementation of NWay we override those
* methods to be no-ops.
*/
- void addCanvas(SkCanvas*) SK_OVERRIDE { SkDEBUGFAIL("Invalid Op"); }
- void removeCanvas(SkCanvas*) SK_OVERRIDE { SkDEBUGFAIL("Invalid Op"); }
+ void addCanvas(SkCanvas*) override { SkDEBUGFAIL("Invalid Op"); }
+ void removeCanvas(SkCanvas*) override { SkDEBUGFAIL("Invalid Op"); }
protected:
- void didSetMatrix(const SkMatrix&) SK_OVERRIDE;
+ void didSetMatrix(const SkMatrix&) override;
- void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipRegion(const SkRegion&, SkRegion::Op) SK_OVERRIDE;
+ void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipRegion(const SkRegion&, SkRegion::Op) override;
private:
void clipToZOrderedBounds();
bool failed() { return fFailed; }
// ClipVisitor
- void clipRect(const SkRect& rect, SkRegion::Op op, bool antialias) SK_OVERRIDE {
+ void clipRect(const SkRect& rect, SkRegion::Op op, bool antialias) override {
fFailed |= antialias;
}
- void clipRRect(const SkRRect& rrect, SkRegion::Op op, bool antialias) SK_OVERRIDE {
+ void clipRRect(const SkRRect& rrect, SkRegion::Op op, bool antialias) override {
fFailed |= antialias;
}
- void clipPath(const SkPath&, SkRegion::Op, bool antialias) SK_OVERRIDE {
+ void clipPath(const SkPath&, SkRegion::Op, bool antialias) override {
fFailed |= antialias;
}
DeferredPipeController();
void setPlaybackCanvas(SkCanvas*);
virtual ~DeferredPipeController();
- void* requestBlock(size_t minRequest, size_t* actual) SK_OVERRIDE;
- void notifyWritten(size_t bytes) SK_OVERRIDE;
+ void* requestBlock(size_t minRequest, size_t* actual) override;
+ void notifyWritten(size_t bytes) override;
void playback(bool silent);
bool hasPendingCommands() const { return fAllocator.totalUsed() != 0; }
size_t storageAllocatedForRecording() const { return fAllocator.totalCapacity(); }
void recordedDrawCommand();
void setIsDrawingToLayer(bool value) {fIsDrawingToLayer = value;}
- SkImageInfo imageInfo() const SK_OVERRIDE;
+ SkImageInfo imageInfo() const override;
- GrRenderTarget* accessRenderTarget() SK_OVERRIDE;
+ GrRenderTarget* accessRenderTarget() override;
- SkBaseDevice* onCreateDevice(const CreateInfo&, const SkPaint*) SK_OVERRIDE;
+ SkBaseDevice* onCreateDevice(const CreateInfo&, const SkPaint*) override;
- SkSurface* newSurface(const SkImageInfo&, const SkSurfaceProps&) SK_OVERRIDE;
+ SkSurface* newSurface(const SkImageInfo&, const SkSurfaceProps&) override;
protected:
- const SkBitmap& onAccessBitmap() SK_OVERRIDE;
- bool onReadPixels(const SkImageInfo&, void*, size_t, int x, int y) SK_OVERRIDE;
- bool onWritePixels(const SkImageInfo&, const void*, size_t, int x, int y) SK_OVERRIDE;
+ const SkBitmap& onAccessBitmap() override;
+ bool onReadPixels(const SkImageInfo&, void*, size_t, int x, int y) override;
+ bool onWritePixels(const SkImageInfo&, const void*, size_t, int x, int y) override;
// None of the following drawing methods should ever get called on the
// deferred device
- void drawPaint(const SkDraw&, const SkPaint& paint) SK_OVERRIDE
+ void drawPaint(const SkDraw&, const SkPaint& paint) override
{SkASSERT(0);}
virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode,
size_t count, const SkPoint[],
- const SkPaint& paint) SK_OVERRIDE
+ const SkPaint& paint) override
{SkASSERT(0);}
virtual void drawRect(const SkDraw&, const SkRect& r,
- const SkPaint& paint) SK_OVERRIDE
+ const SkPaint& paint) override
{SkASSERT(0);}
- void drawOval(const SkDraw&, const SkRect&, const SkPaint&) SK_OVERRIDE
+ void drawOval(const SkDraw&, const SkRect&, const SkPaint&) override
{SkASSERT(0);}
virtual void drawRRect(const SkDraw&, const SkRRect& rr,
- const SkPaint& paint) SK_OVERRIDE
+ const SkPaint& paint) override
{SkASSERT(0);}
virtual void drawPath(const SkDraw&, const SkPath& path,
const SkPaint& paint,
const SkMatrix* prePathMatrix = NULL,
- bool pathIsMutable = false) SK_OVERRIDE
+ bool pathIsMutable = false) override
{SkASSERT(0);}
virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
- const SkMatrix& matrix, const SkPaint& paint) SK_OVERRIDE
+ const SkMatrix& matrix, const SkPaint& paint) override
{SkASSERT(0);}
virtual void drawBitmapRect(const SkDraw&, const SkBitmap&, const SkRect*,
const SkRect&, const SkPaint&,
- SkCanvas::DrawBitmapRectFlags) SK_OVERRIDE
+ SkCanvas::DrawBitmapRectFlags) override
{SkASSERT(0);}
virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap,
- int x, int y, const SkPaint& paint) SK_OVERRIDE
+ int x, int y, const SkPaint& paint) override
{SkASSERT(0);}
virtual void drawText(const SkDraw&, const void* text, size_t len,
- SkScalar x, SkScalar y, const SkPaint& paint) SK_OVERRIDE
+ SkScalar x, SkScalar y, const SkPaint& paint) override
{SkASSERT(0);}
virtual void drawPosText(const SkDraw&, const void* text, size_t len,
const SkScalar pos[], int scalarsPerPos,
- const SkPoint& offset, const SkPaint& paint) SK_OVERRIDE
+ const SkPoint& offset, const SkPaint& paint) override
{SkASSERT(0);}
virtual void drawTextOnPath(const SkDraw&, const void* text,
size_t len, const SkPath& path,
const SkMatrix* matrix,
- const SkPaint& paint) SK_OVERRIDE
+ const SkPaint& paint) override
{SkASSERT(0);}
virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode,
int vertexCount, const SkPoint verts[],
const SkPoint texs[], const SkColor colors[],
SkXfermode* xmode, const uint16_t indices[],
- int indexCount, const SkPaint& paint) SK_OVERRIDE
+ int indexCount, const SkPaint& paint) override
{SkASSERT(0);}
virtual void drawPatch(const SkDraw&, const SkPoint cubics[12], const SkColor colors[4],
const SkPoint texCoords[4], SkXfermode* xmode,
- const SkPaint& paint) SK_OVERRIDE
+ const SkPaint& paint) override
{SkASSERT(0);}
virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
- const SkPaint&) SK_OVERRIDE
+ const SkPaint&) override
{SkASSERT(0);}
- void lockPixels() SK_OVERRIDE {}
- void unlockPixels() SK_OVERRIDE {}
+ void lockPixels() override {}
+ void unlockPixels() override {}
- bool canHandleImageFilter(const SkImageFilter*) SK_OVERRIDE {
+ bool canHandleImageFilter(const SkImageFilter*) override {
return false;
}
virtual bool filterImage(const SkImageFilter*, const SkBitmap&,
- const SkImageFilter::Context&, SkBitmap*, SkIPoint*) SK_OVERRIDE {
+ const SkImageFilter::Context&, SkBitmap*, SkIPoint*) override {
return false;
}
private:
- void flush() SK_OVERRIDE;
- void replaceBitmapBackendForRasterSurface(const SkBitmap&) SK_OVERRIDE {}
+ void flush() override;
+ void replaceBitmapBackendForRasterSurface(const SkBitmap&) override {}
void beginRecording();
void init();
const char** argNames,
const uint8_t* argTypes,
const uint64_t* argValues,
- uint8_t flags) SK_OVERRIDE { return 0; }
+ uint8_t flags) override { return 0; }
virtual void
updateTraceEventDuration(const uint8_t* categoryEnabledFlag,
const char* name,
- SkEventTracer::Handle handle) SK_OVERRIDE {};
+ SkEventTracer::Handle handle) override {};
- const uint8_t* getCategoryGroupEnabled(const char* name) SK_OVERRIDE {
+ const uint8_t* getCategoryGroupEnabled(const char* name) override {
static uint8_t no = 0;
return &no;
};
virtual const char* getCategoryGroupName(
- const uint8_t* categoryEnabledFlag) SK_OVERRIDE {
+ const uint8_t* categoryEnabledFlag) override {
static const char* dummy = "dummy";
return dummy;
};
// Called by Create.
FrontBufferedStream(SkStream*, size_t bufferSize);
- size_t read(void* buffer, size_t size) SK_OVERRIDE;
+ size_t read(void* buffer, size_t size) override;
- bool isAtEnd() const SK_OVERRIDE;
+ bool isAtEnd() const override;
- bool rewind() SK_OVERRIDE;
+ bool rewind() override;
- bool hasPosition() const SK_OVERRIDE { return true; }
+ bool hasPosition() const override { return true; }
- size_t getPosition() const SK_OVERRIDE { return fOffset; }
+ size_t getPosition() const override { return fOffset; }
- bool hasLength() const SK_OVERRIDE { return fHasLength; }
+ bool hasLength() const override { return fHasLength; }
- size_t getLength() const SK_OVERRIDE { return fLength; }
+ size_t getLength() const override { return fLength; }
- SkStreamRewindable* duplicate() const SK_OVERRIDE { return NULL; }
+ SkStreamRewindable* duplicate() const override { return NULL; }
private:
SkAutoTDelete<SkStream> fStream;
/** Processes input, adding it to the digest.
* Note that this treats the buffer as a series of uint8_t values.
*/
- bool write(const void* buffer, size_t size) SK_OVERRIDE {
+ bool write(const void* buffer, size_t size) override {
this->update(reinterpret_cast<const uint8_t*>(buffer), size);
return true;
}
- size_t bytesWritten() const SK_OVERRIDE { return SkToSizeT(this->byteCount); }
+ size_t bytesWritten() const override { return SkToSizeT(this->byteCount); }
/** Processes input, adding it to the digest. Calling this after finish is undefined. */
void update(const uint8_t* input, size_t length);
/** Processes input, adding it to the digest.
* Note that this treats the buffer as a series of uint8_t values.
*/
- bool write(const void* buffer, size_t size) SK_OVERRIDE {
+ bool write(const void* buffer, size_t size) override {
update(reinterpret_cast<const uint8_t*>(buffer), size);
return true;
}
- size_t bytesWritten() const SK_OVERRIDE { return SkToSizeT(this->byteCount); }
+ size_t bytesWritten() const override { return SkToSizeT(this->byteCount); }
/** Processes input, adding it to the digest. Calling this after finish is undefined. */
void update(const uint8_t* input, size_t length);
CanvasVisitor(SkCanvas* canvas) : fCanvas(canvas) {}
virtual void operator()(const char text[], size_t length, SkScalar x, SkScalar y,
- const SkPaint& paint) SK_OVERRIDE {
+ const SkPaint& paint) override {
fCanvas->drawText(text, length, x, y, paint);
}
};
SkTextBlobBuilder fBuilder;
virtual void operator()(const char text[], size_t length, SkScalar x, SkScalar y,
- const SkPaint& paint) SK_OVERRIDE {
+ const SkPaint& paint) override {
SkPaint p(paint);
p.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
const int count = paint.countText(text, length);
virtual ~SkTCompressedAlphaBlitter() { this->flushRuns(); }
// Blit a horizontal run of one or more pixels.
- void blitH(int x, int y, int width) SK_OVERRIDE {
+ void blitH(int x, int y, int width) override {
// This function is intended to be called from any standard RGB
// buffer, so we should never encounter it. However, if some code
// path does end up here, then this needs to be investigated.
// zero-terminated run-length encoding of spans of constant alpha values.
virtual void blitAntiH(int x, int y,
const SkAlpha antialias[],
- const int16_t runs[]) SK_OVERRIDE {
+ const int16_t runs[]) override {
SkASSERT(0 == x);
// Make sure that the new row to blit is either the first
}
// Blit a vertical run of pixels with a constant alpha value.
- void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE {
+ void blitV(int x, int y, int height, SkAlpha alpha) override {
// This function is currently not implemented. It is not explicitly
// required by the contract, but if at some time a code path runs into
// this function (which is entirely possible), it needs to be implemented.
#ifdef SK_DEBUG
bool fCalledOnceWithNonzeroY;
#endif
- void blitRect(int x, int y, int width, int height) SK_OVERRIDE {
+ void blitRect(int x, int y, int width, int height) override {
// Assumptions:
SkASSERT(0 == x);
// width (zero or more) opaque pixels, and one alpha-blended column
// on the right. The result will always be at least two pixels wide.
virtual void blitAntiRect(int x, int y, int width, int height,
- SkAlpha leftAlpha, SkAlpha rightAlpha) SK_OVERRIDE {
+ SkAlpha leftAlpha, SkAlpha rightAlpha) override {
// This function is currently not implemented. It is not explicitly
// required by the contract, but if at some time a code path runs into
// this function (which is entirely possible), it needs to be implemented.
#ifdef SK_DEBUG
bool fBlitMaskCalled;
#endif
- void blitMask(const SkMask& mask, const SkIRect& clip) SK_OVERRIDE {
+ void blitMask(const SkMask& mask, const SkIRect& clip) override {
// Assumptions:
SkASSERT(!fBlitMaskCalled);
// If the blitter just sets a single value for each pixel, return the
// bitmap it draws into, and assign value. If not, return NULL and ignore
// the value parameter.
- const SkBitmap* justAnOpaqueColor(uint32_t* value) SK_OVERRIDE {
+ const SkBitmap* justAnOpaqueColor(uint32_t* value) override {
return NULL;
}
* to preserve semantics if blitAntiH doesn't get called in too many
* weird ways...
*/
- int requestRowsPreserved() const SK_OVERRIDE { return BlockDim; }
+ int requestRowsPreserved() const override { return BlockDim; }
private:
static const int kPixelsPerBlock = BlockDim * BlockDim;
// FILTERING
- void onDrawPaint(const SkPaint& paint) SK_OVERRIDE;
+ void onDrawPaint(const SkPaint& paint) override;
void onDrawPoints(PointMode pMode, size_t count, const SkPoint pts[],
- const SkPaint& paint) SK_OVERRIDE;
- void onDrawOval(const SkRect& r, const SkPaint& paint) SK_OVERRIDE;
- void onDrawRect(const SkRect& r, const SkPaint& paint) SK_OVERRIDE;
- void onDrawRRect(const SkRRect& r, const SkPaint& paint) SK_OVERRIDE;
- void onDrawPath(const SkPath& path, const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
+ void onDrawOval(const SkRect& r, const SkPaint& paint) override;
+ void onDrawRect(const SkRect& r, const SkPaint& paint) override;
+ void onDrawRRect(const SkRRect& r, const SkPaint& paint) override;
+ void onDrawPath(const SkPath& path, const SkPaint& paint) override;
void onDrawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
- const SkPaint* paint) SK_OVERRIDE;
+ const SkPaint* paint) override;
void onDrawBitmapRect(const SkBitmap& bitmap, const SkRect* src, const SkRect& dst,
- const SkPaint* paint, DrawBitmapRectFlags flags) SK_OVERRIDE;
+ const SkPaint* paint, DrawBitmapRectFlags flags) override;
void onDrawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
- const SkRect& dst, const SkPaint* paint) SK_OVERRIDE;
+ const SkRect& dst, const SkPaint* paint) override;
void onDrawSprite(const SkBitmap& bitmap, int left, int top,
- const SkPaint* paint) SK_OVERRIDE;
+ const SkPaint* paint) override;
void onDrawVertices(VertexMode vMode, int vertexCount, const SkPoint vertices[],
const SkPoint texs[], const SkColor colors[], SkXfermode* xMode,
const uint16_t indices[], int indexCount,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
void onDrawDRRect(const SkRRect& outer, const SkRRect& inner,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
void onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
void onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
void onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
- SkScalar constY, const SkPaint& paint) SK_OVERRIDE;
+ SkScalar constY, const SkPaint& paint) override;
void onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
- const SkMatrix* matrix, const SkPaint& paint) SK_OVERRIDE;
+ const SkMatrix* matrix, const SkPaint& paint) override;
void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
const SkPoint texCoords[4], SkXfermode* xmode,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
- void onDrawImage(const SkImage*, SkScalar, SkScalar, const SkPaint*) SK_OVERRIDE;
+ void onDrawImage(const SkImage*, SkScalar, SkScalar, const SkPaint*) override;
void onDrawImageRect(const SkImage*, const SkRect*, const SkRect&, const SkPaint*)
- SK_OVERRIDE;
+ override;
void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*);
// PASS THROUGH
- void onDrawDrawable(SkDrawable*) SK_OVERRIDE;
- SkISize getBaseLayerSize() const SK_OVERRIDE;
- bool getClipBounds(SkRect*) const SK_OVERRIDE;
- bool getClipDeviceBounds(SkIRect*) const SK_OVERRIDE;
- bool isClipEmpty() const SK_OVERRIDE;
- bool isClipRect() const SK_OVERRIDE;
- SkSurface* onNewSurface(const SkImageInfo&, const SkSurfaceProps&) SK_OVERRIDE;
- const void* onPeekPixels(SkImageInfo*, size_t*) SK_OVERRIDE;
- void* onAccessTopLayerPixels(SkImageInfo*, size_t*) SK_OVERRIDE;
- void willSave() SK_OVERRIDE;
- void willRestore() SK_OVERRIDE;
- void didRestore() SK_OVERRIDE;
- void didConcat(const SkMatrix&) SK_OVERRIDE;
- void didSetMatrix(const SkMatrix&) SK_OVERRIDE;
- void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipRegion(const SkRegion&, SkRegion::Op) SK_OVERRIDE;
- void onDiscard() SK_OVERRIDE;
+ void onDrawDrawable(SkDrawable*) override;
+ SkISize getBaseLayerSize() const override;
+ bool getClipBounds(SkRect*) const override;
+ bool getClipDeviceBounds(SkIRect*) const override;
+ bool isClipEmpty() const override;
+ bool isClipRect() const override;
+ SkSurface* onNewSurface(const SkImageInfo&, const SkSurfaceProps&) override;
+ const void* onPeekPixels(SkImageInfo*, size_t*) override;
+ void* onAccessTopLayerPixels(SkImageInfo*, size_t*) override;
+ void willSave() override;
+ void willRestore() override;
+ void didRestore() override;
+ void didConcat(const SkMatrix&) override;
+ void didSetMatrix(const SkMatrix&) override;
+ void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipRegion(const SkRegion&, SkRegion::Op) override;
+ void onDiscard() override;
protected:
SkCanvas* fProxyTarget;
class OverdrawXfermode : public SkXfermode {
public:
- SkPMColor xferColor(SkPMColor src, SkPMColor dst) const SK_OVERRIDE {
+ SkPMColor xferColor(SkPMColor src, SkPMColor dst) const override {
// This table encodes the color progression of the overdraw visualization
static const SkPMColor gTable[] = {
SkPackARGB32(0x00, 0x00, 0x00, 0x00),
return gTable[idx];
}
- Factory getFactory() const SK_OVERRIDE { return NULL; }
+ Factory getFactory() const override { return NULL; }
#ifndef SK_IGNORE_TO_STRING
- virtual void toString(SkString* str) const SK_OVERRIDE { str->set("OverdrawXfermode"); }
+ virtual void toString(SkString* str) const override { str->set("OverdrawXfermode"); }
#endif
};
delete fXferMode;
}
- bool filter(SkPaint* p, Type) SK_OVERRIDE {
+ bool filter(SkPaint* p, Type) override {
p->setXfermode(fXferMode);
p->setAntiAlias(false);
return true;
fFilterQuality = filterQuality;
}
- bool filter(SkPaint* p, Type) SK_OVERRIDE {
+ bool filter(SkPaint* p, Type) override {
p->setFilterQuality(fFilterQuality);
return true;
}
public:
SkDebugClipVisitor(SkCanvas* canvas) : fCanvas(canvas) {}
- void clipRect(const SkRect& r, SkRegion::Op, bool doAA) SK_OVERRIDE {
+ void clipRect(const SkRect& r, SkRegion::Op, bool doAA) override {
SkPaint p;
p.setColor(SK_ColorRED);
p.setStyle(SkPaint::kStroke_Style);
p.setAntiAlias(doAA);
fCanvas->drawRect(r, p);
}
- void clipRRect(const SkRRect& rr, SkRegion::Op, bool doAA) SK_OVERRIDE {
+ void clipRRect(const SkRRect& rr, SkRegion::Op, bool doAA) override {
SkPaint p;
p.setColor(SK_ColorGREEN);
p.setStyle(SkPaint::kStroke_Style);
p.setAntiAlias(doAA);
fCanvas->drawRRect(rr, p);
}
- void clipPath(const SkPath& path, SkRegion::Op, bool doAA) SK_OVERRIDE {
+ void clipPath(const SkPath& path, SkRegion::Op, bool doAA) override {
SkPaint p;
p.setColor(SK_ColorBLUE);
p.setStyle(SkPaint::kStroke_Style);
// Inherited from SkCanvas
////////////////////////////////////////////////////////////////////////////////
- void beginCommentGroup(const char* description) SK_OVERRIDE;
- void addComment(const char* kywd, const char* value) SK_OVERRIDE;
- void endCommentGroup() SK_OVERRIDE;
+ void beginCommentGroup(const char* description) override;
+ void addComment(const char* kywd, const char* value) override;
+ void endCommentGroup() override;
static const int kVizImageHeight = 256;
static const int kVizImageWidth = 256;
- bool isClipEmpty() const SK_OVERRIDE { return false; }
- bool isClipRect() const SK_OVERRIDE { return true; }
- bool getClipBounds(SkRect* bounds) const SK_OVERRIDE {
+ bool isClipEmpty() const override { return false; }
+ bool isClipRect() const override { return true; }
+ bool getClipBounds(SkRect* bounds) const override {
if (bounds) {
bounds->setXYWH(0, 0,
SkIntToScalar(this->imageInfo().width()),
}
return true;
}
- bool getClipDeviceBounds(SkIRect* bounds) const SK_OVERRIDE {
+ bool getClipDeviceBounds(SkIRect* bounds) const override {
if (bounds) {
bounds->setLargest();
}
}
protected:
- void willSave() SK_OVERRIDE;
- SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) SK_OVERRIDE;
- void willRestore() SK_OVERRIDE;
+ void willSave() override;
+ SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) override;
+ void willRestore() override;
- void didConcat(const SkMatrix&) SK_OVERRIDE;
- void didSetMatrix(const SkMatrix&) SK_OVERRIDE;
+ void didConcat(const SkMatrix&) override;
+ void didSetMatrix(const SkMatrix&) override;
- void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) SK_OVERRIDE;
+ void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) override;
void onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
void onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
- const SkPaint&) SK_OVERRIDE;
+ const SkPaint&) override;
void onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
- SkScalar constY, const SkPaint&) SK_OVERRIDE;
+ SkScalar constY, const SkPaint&) override;
void onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
- const SkMatrix* matrix, const SkPaint&) SK_OVERRIDE;
+ const SkMatrix* matrix, const SkPaint&) override;
void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
- const SkPaint& paint) SK_OVERRIDE;
+ const SkPaint& paint) override;
void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint);
- void onDrawPaint(const SkPaint&) SK_OVERRIDE;
+ void onDrawPaint(const SkPaint&) override;
- void onDrawRect(const SkRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawOval(const SkRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawRRect(const SkRRect&, const SkPaint&) SK_OVERRIDE;
- void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) SK_OVERRIDE;
+ void onDrawRect(const SkRect&, const SkPaint&) override;
+ void onDrawOval(const SkRect&, const SkPaint&) override;
+ void onDrawRRect(const SkRRect&, const SkPaint&) override;
+ void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) override;
void onDrawVertices(VertexMode vmode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
const SkColor colors[], SkXfermode* xmode,
const uint16_t indices[], int indexCount,
- const SkPaint&) SK_OVERRIDE;
- void onDrawPath(const SkPath&, const SkPaint&) SK_OVERRIDE;
- void onDrawBitmap(const SkBitmap&, SkScalar left, SkScalar top, const SkPaint*) SK_OVERRIDE;
+ const SkPaint&) override;
+ void onDrawPath(const SkPath&, const SkPaint&) override;
+ void onDrawBitmap(const SkBitmap&, SkScalar left, SkScalar top, const SkPaint*) override;
void onDrawBitmapRect(const SkBitmap&, const SkRect* src, const SkRect& dst, const SkPaint*,
- DrawBitmapRectFlags flags) SK_OVERRIDE;
- void onDrawImage(const SkImage*, SkScalar left, SkScalar top, const SkPaint*) SK_OVERRIDE;
+ DrawBitmapRectFlags flags) override;
+ void onDrawImage(const SkImage*, SkScalar left, SkScalar top, const SkPaint*) override;
void onDrawImageRect(const SkImage*, const SkRect* src, const SkRect& dst,
- const SkPaint*) SK_OVERRIDE;
+ const SkPaint*) override;
void onDrawBitmapNine(const SkBitmap&, const SkIRect& center, const SkRect& dst,
- const SkPaint*) SK_OVERRIDE;
- void onDrawSprite(const SkBitmap&, int left, int top, const SkPaint*) SK_OVERRIDE;
- void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
- void onClipRegion(const SkRegion& region, SkRegion::Op) SK_OVERRIDE;
-
- void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) SK_OVERRIDE;
+ const SkPaint*) override;
+ void onDrawSprite(const SkBitmap&, int left, int top, const SkPaint*) override;
+ void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) override;
+ void onClipRegion(const SkRegion& region, SkRegion::Op) override;
+
+ void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;
void markActiveCommands(int index);
class SkRestoreCommand : public SkDrawCommand {
public:
SkRestoreCommand();
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
- Action action() const SK_OVERRIDE { return kPopLayer_Action; }
+ void execute(SkCanvas* canvas) const override;
+ Action action() const override { return kPopLayer_Action; }
private:
typedef SkDrawCommand INHERITED;
class SkClearCommand : public SkDrawCommand {
public:
SkClearCommand(SkColor color);
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
private:
SkColor fColor;
class SkClipPathCommand : public SkDrawCommand {
public:
SkClipPathCommand(const SkPath& path, SkRegion::Op op, bool doAA);
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
- bool render(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
+ bool render(SkCanvas* canvas) const override;
private:
SkPath fPath;
SkRegion::Op fOp;
class SkClipRegionCommand : public SkDrawCommand {
public:
SkClipRegionCommand(const SkRegion& region, SkRegion::Op op);
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
private:
SkRegion fRegion;
SkRegion::Op fOp;
class SkClipRectCommand : public SkDrawCommand {
public:
SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool doAA);
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
const SkRect& rect() const { return fRect; }
SkRegion::Op op() const { return fOp; }
class SkClipRRectCommand : public SkDrawCommand {
public:
SkClipRRectCommand(const SkRRect& rrect, SkRegion::Op op, bool doAA);
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
- bool render(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
+ bool render(SkCanvas* canvas) const override;
const SkRRect& rrect() const { return fRRect; }
SkRegion::Op op() const { return fOp; }
class SkConcatCommand : public SkDrawCommand {
public:
SkConcatCommand(const SkMatrix& matrix);
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
private:
SkMatrix fMatrix;
public:
SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left, SkScalar top,
const SkPaint* paint);
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
- bool render(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
+ bool render(SkCanvas* canvas) const override;
private:
SkBitmap fBitmap;
SkScalar fLeft;
public:
SkDrawBitmapNineCommand(const SkBitmap& bitmap, const SkIRect& center,
const SkRect& dst, const SkPaint* paint);
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
- bool render(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
+ bool render(SkCanvas* canvas) const override;
private:
SkBitmap fBitmap;
SkIRect fCenter;
SkDrawBitmapRectCommand(const SkBitmap& bitmap, const SkRect* src,
const SkRect& dst, const SkPaint* paint,
SkCanvas::DrawBitmapRectFlags flags);
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
- bool render(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
+ bool render(SkCanvas* canvas) const override;
const SkBitmap& bitmap() const { return fBitmap; }
class SkBeginCommentGroupCommand : public SkDrawCommand {
public:
SkBeginCommentGroupCommand(const char* description);
- void execute(SkCanvas* canvas) const SK_OVERRIDE {
+ void execute(SkCanvas* canvas) const override {
canvas->beginCommentGroup(fDescription.c_str());
};
private:
class SkCommentCommand : public SkDrawCommand {
public:
SkCommentCommand(const char* kywd, const char* value);
- void execute(SkCanvas* canvas) const SK_OVERRIDE {
+ void execute(SkCanvas* canvas) const override {
canvas->addComment(fKywd.c_str(), fValue.c_str());
};
private:
class SkEndCommentGroupCommand : public SkDrawCommand {
public:
SkEndCommentGroupCommand();
- void execute(SkCanvas* canvas) const SK_OVERRIDE {
+ void execute(SkCanvas* canvas) const override {
canvas->endCommentGroup();
};
private:
class SkDrawOvalCommand : public SkDrawCommand {
public:
SkDrawOvalCommand(const SkRect& oval, const SkPaint& paint);
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
- bool render(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
+ bool render(SkCanvas* canvas) const override;
private:
SkRect fOval;
SkPaint fPaint;
class SkDrawPaintCommand : public SkDrawCommand {
public:
SkDrawPaintCommand(const SkPaint& paint);
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
- bool render(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
+ bool render(SkCanvas* canvas) const override;
private:
SkPaint fPaint;
class SkDrawPathCommand : public SkDrawCommand {
public:
SkDrawPathCommand(const SkPath& path, const SkPaint& paint);
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
- bool render(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
+ bool render(SkCanvas* canvas) const override;
private:
SkPath fPath;
class SkDrawPictureCommand : public SkDrawCommand {
public:
SkDrawPictureCommand(const SkPicture* picture, const SkMatrix* matrix, const SkPaint* paint);
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
- bool render(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
+ bool render(SkCanvas* canvas) const override;
private:
SkAutoTUnref<const SkPicture> fPicture;
SkDrawPointsCommand(SkCanvas::PointMode mode, size_t count, const SkPoint pts[],
const SkPaint& paint);
virtual ~SkDrawPointsCommand() { delete [] fPts; }
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
- bool render(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
+ bool render(SkCanvas* canvas) const override;
private:
SkCanvas::PointMode fMode;
size_t fCount;
SkDrawTextCommand(const void* text, size_t byteLength, SkScalar x, SkScalar y,
const SkPaint& paint);
virtual ~SkDrawTextCommand() { delete [] fText; }
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
private:
char* fText;
size_t fByteLength;
SkDrawPosTextCommand(const void* text, size_t byteLength, const SkPoint pos[],
const SkPaint& paint);
virtual ~SkDrawPosTextCommand() { delete [] fPos; delete [] fText; }
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
private:
char* fText;
size_t fByteLength;
SkDrawTextOnPathCommand(const void* text, size_t byteLength, const SkPath& path,
const SkMatrix* matrix, const SkPaint& paint);
virtual ~SkDrawTextOnPathCommand() { delete [] fText; }
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
private:
char* fText;
size_t fByteLength;
SkDrawPosTextHCommand(const void* text, size_t byteLength, const SkScalar xpos[],
SkScalar constY, const SkPaint& paint);
virtual ~SkDrawPosTextHCommand() { delete [] fXpos; delete [] fText; }
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
private:
SkScalar* fXpos;
char* fText;
public:
SkDrawTextBlobCommand(const SkTextBlob* blob, SkScalar x, SkScalar y, const SkPaint& paint);
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
- bool render(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
+ bool render(SkCanvas* canvas) const override;
private:
SkAutoTUnref<const SkTextBlob> fBlob;
SkDrawPatchCommand(const SkPoint cubics[12], const SkColor colors[4],
const SkPoint texCoords[4], SkXfermode* xmode,
const SkPaint& paint);
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
private:
SkPoint fCubics[12];
class SkDrawRectCommand : public SkDrawCommand {
public:
SkDrawRectCommand(const SkRect& rect, const SkPaint& paint);
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
const SkRect& rect() const { return fRect; }
const SkPaint& paint() const { return fPaint; }
class SkDrawRRectCommand : public SkDrawCommand {
public:
SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint);
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
- bool render(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
+ bool render(SkCanvas* canvas) const override;
private:
SkRRect fRRect;
SkPaint fPaint;
public:
SkDrawDRRectCommand(const SkRRect& outer, const SkRRect& inner,
const SkPaint& paint);
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
- bool render(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
+ bool render(SkCanvas* canvas) const override;
private:
SkRRect fOuter;
SkRRect fInner;
class SkDrawSpriteCommand : public SkDrawCommand {
public:
SkDrawSpriteCommand(const SkBitmap& bitmap, int left, int top, const SkPaint* paint);
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
- bool render(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
+ bool render(SkCanvas* canvas) const override;
private:
SkBitmap fBitmap;
int fLeft;
const uint16_t indices[], int indexCount,
const SkPaint& paint);
virtual ~SkDrawVerticesCommand();
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
+ void execute(SkCanvas* canvas) const override;
private:
SkCanvas::VertexMode fVmode;
int fVertexCount;
class SkSaveCommand : public SkDrawCommand {
public:
SkSaveCommand();
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
- Action action() const SK_OVERRIDE { return kPushLayer_Action; }
+ void execute(SkCanvas* canvas) const override;
+ Action action() const override { return kPushLayer_Action; }
private:
typedef SkDrawCommand INHERITED;
};
public:
SkSaveLayerCommand(const SkRect* bounds, const SkPaint* paint,
SkCanvas::SaveFlags flags);
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
- void vizExecute(SkCanvas* canvas) const SK_OVERRIDE;
- Action action() const SK_OVERRIDE{ return kPushLayer_Action; }
- void setActive(bool active) SK_OVERRIDE { fActive = active; }
- bool active() const SK_OVERRIDE { return fActive; }
+ void execute(SkCanvas* canvas) const override;
+ void vizExecute(SkCanvas* canvas) const override;
+ Action action() const override{ return kPushLayer_Action; }
+ void setActive(bool active) override { fActive = active; }
+ bool active() const override { return fActive; }
const SkPaint* paint() const { return fPaintPtr; }
class SkSetMatrixCommand : public SkDrawCommand {
public:
SkSetMatrixCommand(const SkMatrix& matrix);
- void setUserMatrix(const SkMatrix&) SK_OVERRIDE;
- void execute(SkCanvas* canvas) const SK_OVERRIDE;
+ void setUserMatrix(const SkMatrix&) override;
+ void execute(SkCanvas* canvas) const override;
private:
SkMatrix fUserMatrix;
SkMatrix fMatrix;
explicit SkDWriteFontFileStream(IDWriteFontFileStream* fontFileStream);
virtual ~SkDWriteFontFileStream();
- size_t read(void* buffer, size_t size) SK_OVERRIDE;
- bool isAtEnd() const SK_OVERRIDE;
- bool rewind() SK_OVERRIDE;
- SkDWriteFontFileStream* duplicate() const SK_OVERRIDE;
- size_t getPosition() const SK_OVERRIDE;
- bool seek(size_t position) SK_OVERRIDE;
- bool move(long offset) SK_OVERRIDE;
- SkDWriteFontFileStream* fork() const SK_OVERRIDE;
- size_t getLength() const SK_OVERRIDE;
- const void* getMemoryBase() SK_OVERRIDE;
+ size_t read(void* buffer, size_t size) override;
+ bool isAtEnd() const override;
+ bool rewind() override;
+ SkDWriteFontFileStream* duplicate() const override;
+ size_t getPosition() const override;
+ bool seek(size_t position) override;
+ bool move(long offset) override;
+ SkDWriteFontFileStream* fork() const override;
+ size_t getLength() const override;
+ const void* getMemoryBase() override;
private:
SkTScopedComPtr<IDWriteFontFileStream> fFontFileStream;
virtual ~SkDWriteGeometrySink();
public:
- HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, void **object) SK_OVERRIDE;
- ULONG STDMETHODCALLTYPE AddRef(void) SK_OVERRIDE;
- ULONG STDMETHODCALLTYPE Release(void) SK_OVERRIDE;
-
- void STDMETHODCALLTYPE SetFillMode(D2D1_FILL_MODE fillMode) SK_OVERRIDE;
- void STDMETHODCALLTYPE SetSegmentFlags(D2D1_PATH_SEGMENT vertexFlags) SK_OVERRIDE;
- void STDMETHODCALLTYPE BeginFigure(D2D1_POINT_2F startPoint, D2D1_FIGURE_BEGIN figureBegin) SK_OVERRIDE;
- void STDMETHODCALLTYPE AddLines(const D2D1_POINT_2F *points, UINT pointsCount) SK_OVERRIDE;
- void STDMETHODCALLTYPE AddBeziers(const D2D1_BEZIER_SEGMENT *beziers, UINT beziersCount) SK_OVERRIDE;
- void STDMETHODCALLTYPE EndFigure(D2D1_FIGURE_END figureEnd) SK_OVERRIDE;
- HRESULT STDMETHODCALLTYPE Close() SK_OVERRIDE;
+ HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, void **object) override;
+ ULONG STDMETHODCALLTYPE AddRef(void) override;
+ ULONG STDMETHODCALLTYPE Release(void) override;
+
+ void STDMETHODCALLTYPE SetFillMode(D2D1_FILL_MODE fillMode) override;
+ void STDMETHODCALLTYPE SetSegmentFlags(D2D1_PATH_SEGMENT vertexFlags) override;
+ void STDMETHODCALLTYPE BeginFigure(D2D1_POINT_2F startPoint, D2D1_FIGURE_BEGIN figureBegin) override;
+ void STDMETHODCALLTYPE AddLines(const D2D1_POINT_2F *points, UINT pointsCount) override;
+ void STDMETHODCALLTYPE AddBeziers(const D2D1_BEZIER_SEGMENT *beziers, UINT beziersCount) override;
+ void STDMETHODCALLTYPE EndFigure(D2D1_FIGURE_END figureEnd) override;
+ HRESULT STDMETHODCALLTYPE Close() override;
static HRESULT Create(SkPath* path, IDWriteGeometrySink** geometryToPath);
};
struct SimpleFlatController : public SkFlatController {
SimpleFlatController() : SkFlatController() {}
~SimpleFlatController() { fAllocations.freeAll(); }
- void* allocThrow(size_t bytes) SK_OVERRIDE {
+ void* allocThrow(size_t bytes) override {
fAllocations.push(sk_malloc_throw(bytes));
return fAllocations.top();
}
- void unalloc(void*) SK_OVERRIDE { }
+ void unalloc(void*) override { }
void setBitmapStorage(SkBitmapHeap* h) { this->setBitmapHeap(h); }
private:
SkTDArray<void*> fAllocations;
}
#ifdef SK_SUPPORT_LEGACY_BOOL_ONGETINFO
- bool onGetInfo(SkImageInfo* info) SK_OVERRIDE {
+ bool onGetInfo(SkImageInfo* info) override {
REPORTER_ASSERT(fReporter, info);
*info = GetMyInfo();
return true;
virtual Result onGetPixels(const SkImageInfo& info, void* pixels, size_t rowBytes,
const Options&,
- SkPMColor ctable[], int* ctableCount) SK_OVERRIDE {
+ SkPMColor ctable[], int* ctableCount) override {
REPORTER_ASSERT(fReporter, pixels != NULL);
REPORTER_ASSERT(fReporter, rowBytes >= info.minRowBytes());
if (fType != kSucceedGetPixels_TestType) {
class TestDrawFilter : public SkDrawFilter {
public:
- bool filter(SkPaint*, Type) SK_OVERRIDE { return true; }
+ bool filter(SkPaint*, Type) override { return true; }
};
DEF_TEST(CanvasState_test_draw_filters, reporter) {
public:
Canvas2CanvasClipVisitor(SkCanvas* target) : fTarget(target) {}
- void clipRect(const SkRect& r, SkRegion::Op op, bool aa) SK_OVERRIDE {
+ void clipRect(const SkRect& r, SkRegion::Op op, bool aa) override {
fTarget->clipRect(r, op, aa);
}
- void clipRRect(const SkRRect& r, SkRegion::Op op, bool aa) SK_OVERRIDE {
+ void clipRRect(const SkRRect& r, SkRegion::Op op, bool aa) override {
fTarget->clipRRect(r, op, aa);
}
- void clipPath(const SkPath& p, SkRegion::Op op, bool aa) SK_OVERRIDE {
+ void clipPath(const SkPath& p, SkRegion::Op op, bool aa) override {
fTarget->clipPath(p, op, aa);
}
fBitmap.allocN32Pixels(width, height);
}
- SkCanvas* onNewCanvas() SK_OVERRIDE {
+ SkCanvas* onNewCanvas() override {
return SkNEW_ARGS(SkCanvas, (fBitmap));
}
- SkSurface* onNewSurface(const SkImageInfo&) SK_OVERRIDE {
+ SkSurface* onNewSurface(const SkImageInfo&) override {
return NULL;
}
- SkImage* onNewImageSnapshot(Budgeted) SK_OVERRIDE {
+ SkImage* onNewImageSnapshot(Budgeted) override {
return SkNewImageFromBitmap(fBitmap, true, &this->props());
}
- void onCopyOnWrite(ContentChangeMode mode) SK_OVERRIDE {
+ void onCopyOnWrite(ContentChangeMode mode) override {
if (mode == SkSurface::kDiscard_ContentChangeMode) {
fCOWDiscardCount++;
} else {
}
}
- void onDiscard() SK_OVERRIDE {
+ void onDiscard() override {
fDiscardCount++;
}
fDrawBitmapCallCount = 0;
}
virtual void drawBitmap(const SkDraw&, const SkBitmap&,
- const SkMatrix&, const SkPaint&) SK_OVERRIDE {
+ const SkMatrix&, const SkPaint&) override {
fDrawBitmapCallCount++;
}
fFlushedDrawCommandsCount = fSkippedPendingDrawCommandsCount = 0;
}
- void prepareForDraw() SK_OVERRIDE {
+ void prepareForDraw() override {
fPrepareForDrawCount++;
}
- void storageAllocatedForRecordingChanged(size_t) SK_OVERRIDE {
+ void storageAllocatedForRecordingChanged(size_t) override {
fStorageAllocatedChangedCount++;
}
- void flushedDrawCommands() SK_OVERRIDE {
+ void flushedDrawCommands() override {
fFlushedDrawCommandsCount++;
}
- void skippedPendingDrawCommands() SK_OVERRIDE {
+ void skippedPendingDrawCommands() override {
fSkippedPendingDrawCommandsCount++;
}
FailureImageGenerator() : SkImageGenerator(SkImageInfo::MakeN32Premul(100, 100)) {}
protected:
#ifdef SK_SUPPORT_LEGACY_BOOL_ONGETINFO
- bool onGetInfo(SkImageInfo* info) SK_OVERRIDE {
+ bool onGetInfo(SkImageInfo* info) override {
*info = SkImageInfo::MakeN32Premul(100, 100);
return true;
}
: INHERITED(data, size, ownMemory)
, fIsAtEnd(false) {}
- size_t read(void* dst, size_t requested) SK_OVERRIDE {
+ size_t read(void* dst, size_t requested) override {
size_t bytesRead = this->INHERITED::read(dst, requested);
if (bytesRead < requested) {
fIsAtEnd = true;
return bytesRead;
}
- bool isAtEnd() const SK_OVERRIDE {
+ bool isAtEnd() const override {
return fIsAtEnd;
}
, fHasPosition(hasPosition)
{}
- bool hasLength() const SK_OVERRIDE {
+ bool hasLength() const override {
return fHasLength;
}
- bool hasPosition() const SK_OVERRIDE {
+ bool hasPosition() const override {
return fHasPosition;
}
- size_t read(void*, size_t) SK_OVERRIDE {
+ size_t read(void*, size_t) override {
return 0;
}
- bool isAtEnd() const SK_OVERRIDE {
+ bool isAtEnd() const override {
return true;
}
: fAtEnd(false)
, fReadAfterEnd(false)
{}
- size_t read(void* buffer, size_t size) SK_OVERRIDE {
+ size_t read(void* buffer, size_t size) override {
if (fAtEnd) {
fReadAfterEnd = true;
} else {
return 0;
}
- bool isAtEnd() const SK_OVERRIDE {
+ bool isAtEnd() const override {
return fAtEnd;
}
return SkRef(gBigKeyProcessor);
}
- const char* name() const SK_OVERRIDE { return "Big Ole Key"; }
+ const char* name() const override { return "Big Ole Key"; }
virtual void getGLProcessorKey(const GrGLCaps& caps,
- GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrProcessorKeyBuilder* b) const override {
GLBigKeyProcessor::GenKey(*this, caps, b);
}
- GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ GrGLFragmentProcessor* createGLInstance() const override {
return SkNEW_ARGS(GLBigKeyProcessor, (*this));
}
BigKeyProcessor() {
this->initClassID<BigKeyProcessor>();
}
- bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE { return true; }
- void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE { }
+ bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override { }
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
TestingKey fKey;
intptr_t fValue;
- const Key& getKey() const SK_OVERRIDE { return fKey; }
- size_t bytesUsed() const SK_OVERRIDE { return sizeof(fKey) + sizeof(fValue); }
+ const Key& getKey() const override { return fKey; }
+ size_t bytesUsed() const override { return sizeof(fKey) + sizeof(fValue); }
static bool Visitor(const SkResourceCache::Rec& baseRec, void* context) {
const TestingRec& rec = static_cast<const TestingRec&>(baseRec);
SingleAllocator(void* p, size_t s) : fPixels(p), fSize(s) { }
~SingleAllocator() {}
// If the pixels in fPixels are big enough, use them.
- bool allocPixelRef(SkBitmap* bm, SkColorTable* ct) SK_OVERRIDE {
+ bool allocPixelRef(SkBitmap* bm, SkColorTable* ct) override {
SkASSERT(bm);
if (bm->info().getSafeSize(bm->rowBytes()) <= fSize) {
bm->setPixels(fPixels, ct);
}
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context& ctx,
- SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE {
+ SkBitmap* result, SkIPoint* offset) const override {
REPORTER_ASSERT(fReporter, ctx.ctm() == fExpectedMatrix);
return true;
}
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(MatrixTestImageFilter)
protected:
- void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
+ void flatten(SkWriteBuffer& buffer) const override {
this->INHERITED::flatten(buffer);
buffer.writeFunctionPtr(fReporter);
buffer.writeMatrix(fExpectedMatrix);
FakeDevice() : SkBitmapDevice(make_bm(100, 100)) { }
virtual void drawRect(const SkDraw& draw, const SkRect& r,
- const SkPaint& paint) SK_OVERRIDE {
+ const SkPaint& paint) override {
fLastMatrix = *draw.fMatrix;
this->INHERITED::drawRect(draw, r, paint);
}
struct Racer : public SkRunnable {
Racer() : fLazy(NULL), fSeen(NULL) {}
- void run() SK_OVERRIDE { fSeen = fLazy->get(); }
+ void run() override { fSeen = fLazy->get(); }
SkLazyPtr<int>* fLazy;
int* fSeen;
SkOnceFlag* once;
int* ptr;
- void run() SK_OVERRIDE {
+ void run() override {
SkOnce(once, add_six, ptr);
}
};
public:
InvalidPixelRef(const SkImageInfo& info) : SkPixelRef(info) {}
private:
- bool onNewLockPixels(LockRec*) SK_OVERRIDE { return false; }
- void onUnlockPixels() SK_OVERRIDE {
+ bool onNewLockPixels(LockRec*) override { return false; }
+ void onUnlockPixels() override {
SkDEBUGFAIL("InvalidPixelRef can't be locked");
}
};
class DummyImageFilter : public SkImageFilter {
public:
DummyImageFilter(bool visited = false) : SkImageFilter(0, NULL), fVisited(visited) {}
- ~DummyImageFilter() SK_OVERRIDE {}
+ ~DummyImageFilter() override {}
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
- SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE {
+ SkBitmap* result, SkIPoint* offset) const override {
fVisited = true;
offset->fX = offset->fY = 0;
*result = src;
class TestRunnable : public SkRunnable {
public:
- void run() SK_OVERRIDE {
+ void run() override {
SkGraphics::SetTLSFontCacheLimit(1 * 1024 * 1024);
(*fTestFun)(&fState);
}
public: \
static Test* Factory(void*) { return SkNEW(name##Class); } \
protected: \
- void onGetName(SkString* name) SK_OVERRIDE { \
+ void onGetName(SkString* name) override { \
name->set(#name); \
} \
- void onRun() SK_OVERRIDE { test_##name(); } \
+ void onRun() override { test_##name(); } \
}; \
static TestRegistry gReg_##name##Class(name##Class::Factory); \
static void test_##name()
fTestFun = testFun;
}
- void run() SK_OVERRIDE {
+ void run() override {
SkBitmap bitmap;
fState.fBitmap = &bitmap;
char pathStr[PATH_STR_SIZE];
: PictureBBHTestBase(2, 2, 1, 1) { }
virtual ~DrawEmptyPictureBBHTest() { }
- void doTest(SkCanvas&, SkCanvas&) SK_OVERRIDE { }
+ void doTest(SkCanvas&, SkCanvas&) override { }
};
// Test to verify the playback of a picture into a canvas that has
EmptyClipPictureBBHTest()
: PictureBBHTestBase(2, 2, 3, 3) { }
- void doTest(SkCanvas& playbackCanvas, SkCanvas& recordingCanvas) SK_OVERRIDE {
+ void doTest(SkCanvas& playbackCanvas, SkCanvas& recordingCanvas) override {
// intersect with out of bounds rect -> empty clip.
playbackCanvas.clipRect(SkRect::MakeXYWH(SkIntToScalar(10), SkIntToScalar(10),
SkIntToScalar(1), SkIntToScalar(1)), SkRegion::kIntersect_Op);
}
virtual SaveLayerStrategy willSaveLayer(const SkRect* bounds, const SkPaint* paint,
- SaveFlags flags) SK_OVERRIDE {
+ SaveFlags flags) override {
++fSaveLayerCount;
return this->INHERITED::willSaveLayer(bounds, paint, flags);
}
- void willSave() SK_OVERRIDE {
+ void willSave() override {
++fSaveCount;
this->INHERITED::willSave();
}
- void willRestore() SK_OVERRIDE {
+ void willRestore() override {
++fRestoreCount;
this->INHERITED::willRestore();
}
virtual void onClipRect(const SkRect& r,
SkRegion::Op op,
- ClipEdgeStyle edgeStyle) SK_OVERRIDE {
+ ClipEdgeStyle edgeStyle) override {
fClipCount += 1;
this->INHERITED::onClipRect(r, op, edgeStyle);
}
virtual void onClipRRect(const SkRRect& rrect,
SkRegion::Op op,
- ClipEdgeStyle edgeStyle)SK_OVERRIDE {
+ ClipEdgeStyle edgeStyle)override {
fClipCount += 1;
this->INHERITED::onClipRRect(rrect, op, edgeStyle);
}
virtual void onClipPath(const SkPath& path,
SkRegion::Op op,
- ClipEdgeStyle edgeStyle) SK_OVERRIDE {
+ ClipEdgeStyle edgeStyle) override {
fClipCount += 1;
this->INHERITED::onClipPath(path, op, edgeStyle);
}
- void onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) SK_OVERRIDE {
+ void onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) override {
fClipCount += 1;
this->INHERITED::onClipRegion(deviceRgn, op);
}
CountingBBH(const SkRect& bound) : searchCalls(0), rootBound(bound) {}
- void search(const SkRect& query, SkTDArray<unsigned>* results) const SK_OVERRIDE {
+ void search(const SkRect& query, SkTDArray<unsigned>* results) const override {
this->searchCalls++;
}
- void insert(const SkRect[], int) SK_OVERRIDE {}
- virtual size_t bytesUsed() const SK_OVERRIDE { return 0; }
- SkRect getRootBound() const SK_OVERRIDE { return rootBound; }
+ void insert(const SkRect[], int) override {}
+ virtual size_t bytesUsed() const override { return 0; }
+ SkRect getRootBound() const override { return rootBound; }
};
class SpoonFedBBHFactory : public SkBBHFactory {
public:
explicit SpoonFedBBHFactory(SkBBoxHierarchy* bbh) : fBBH(bbh) {}
- SkBBoxHierarchy* operator()(const SkRect&) const SK_OVERRIDE {
+ SkBBoxHierarchy* operator()(const SkRect&) const override {
return SkRef(fBBH);
}
private:
class TestListener : public SkPixelRef::GenIDChangeListener {
public:
explicit TestListener(int* ptr) : fPtr(ptr) {}
- void onChange() SK_OVERRIDE { (*fPtr)++; }
+ void onChange() override { (*fPtr)++; }
private:
int* fPtr;
};
class TestLooper : public SkDrawLooper {
public:
- SkDrawLooper::Context* createContext(SkCanvas*, void* storage) const SK_OVERRIDE {
+ SkDrawLooper::Context* createContext(SkCanvas*, void* storage) const override {
return SkNEW_PLACEMENT(storage, TestDrawLooperContext);
}
- size_t contextSize() const SK_OVERRIDE { return sizeof(TestDrawLooperContext); }
+ size_t contextSize() const override { return sizeof(TestDrawLooperContext); }
#ifndef SK_IGNORE_TO_STRING
- void toString(SkString* str) const SK_OVERRIDE {
+ void toString(SkString* str) const override {
str->append("TestLooper:");
}
#endif
TestDrawLooperContext() : fOnce(true) {}
virtual ~TestDrawLooperContext() {}
- bool next(SkCanvas* canvas, SkPaint*) SK_OVERRIDE {
+ bool next(SkCanvas* canvas, SkPaint*) override {
if (fOnce) {
fOnce = false;
canvas->translate(SkIntToScalar(10), 0);
public:
JustOneDraw() : fCalls(0) {}
- bool abort() SK_OVERRIDE { return fCalls++ > 0; }
+ bool abort() override { return fCalls++ > 0; }
private:
int fCalls;
};
}
struct TestBBH : public SkBBoxHierarchy {
- void insert(const SkRect boundsArray[], int N) SK_OVERRIDE {
+ void insert(const SkRect boundsArray[], int N) override {
fEntries.setCount(N);
for (int i = 0; i < N; i++) {
Entry e = { (unsigned)i, boundsArray[i] };
}
}
- void search(const SkRect& query, SkTDArray<unsigned>* results) const SK_OVERRIDE {}
- size_t bytesUsed() const SK_OVERRIDE { return 0; }
- SkRect getRootBound() const SK_OVERRIDE { return SkRect::MakeEmpty(); }
+ void search(const SkRect& query, SkTDArray<unsigned>* results) const override {}
+ size_t bytesUsed() const override { return 0; }
+ SkRect getRootBound() const override { return SkRect::MakeEmpty(); }
struct Entry {
unsigned opIndex;
}
void onDrawImage(const SkImage* image, SkScalar left, SkScalar top,
- const SkPaint* paint) SK_OVERRIDE {
+ const SkPaint* paint) override {
fDrawImageCalled = true;
}
void onDrawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst,
- const SkPaint* paint) SK_OVERRIDE {
+ const SkPaint* paint) override {
fDrawImageRectCalled = true;
}
public:
JustOneDraw() : fCalls(0) {}
- bool abort() SK_OVERRIDE { return fCalls++ > 0; }
+ bool abort() override { return fCalls++ > 0; }
private:
int fCalls;
};
this->registerWithCache();
}
- size_t onGpuMemorySize() const SK_OVERRIDE { return fSize; }
+ size_t onGpuMemorySize() const override { return fSize; }
TestResource* fToDelete;
size_t fSize;
fTestFun = testFun;
}
- void run() SK_OVERRIDE {
+ void run() override {
SkGraphics::SetTLSFontCacheLimit(1 * 1024 * 1024);
(*fTestFun)(&fState);
}
struct TestReporter : public skiatest::Reporter {
public:
TestReporter() : fError(false), fTestCount(0) {}
- void bumpTestCount() SK_OVERRIDE { ++fTestCount; }
- bool allowExtendedTest() const SK_OVERRIDE {
+ void bumpTestCount() override { ++fTestCount; }
+ bool allowExtendedTest() const override {
return FLAGS_extendedTest;
}
- bool verbose() const SK_OVERRIDE { return FLAGS_veryVerbose; }
- void reportFailed(const skiatest::Failure& failure) SK_OVERRIDE {
+ bool verbose() const override { return FLAGS_veryVerbose; }
+ void reportFailed(const skiatest::Failure& failure) override {
SkDebugf("\nFAILED: %s", failure.toString().c_str());
fError = true;
}
const SkString* mismatchPath,
const SkString* inputFilename,
bool useChecksumBasedFilenames,
- bool useMultiPictureDraw) SK_OVERRIDE;
+ bool useMultiPictureDraw) override;
/**
* Similar to TiledPictureRenderer, this will draw a PNG for each tile. However, the
* numbering (and actual tiles) will be different.
*/
- bool render(SkBitmap** out) SK_OVERRIDE;
+ bool render(SkBitmap** out) override;
- bool supportsTimingIndividualTiles() SK_OVERRIDE { return false; }
+ bool supportsTimingIndividualTiles() override { return false; }
private:
int fXTilesPerLargeTile;
int fLargeTileWidth;
int fLargeTileHeight;
- SkString getConfigNameInternal() SK_OVERRIDE;
+ SkString getConfigNameInternal() override;
typedef TiledPictureRenderer INHERITED;
};
RecordPictureRenderer(const GrContext::Options &opts) : INHERITED(opts) { }
#endif
- bool render(SkBitmap** out = NULL) SK_OVERRIDE;
+ bool render(SkBitmap** out = NULL) override;
- SkString getPerIterTimeFormat() SK_OVERRIDE { return SkString("%.4f"); }
+ SkString getPerIterTimeFormat() override { return SkString("%.4f"); }
- SkString getNormalTimeFormat() SK_OVERRIDE { return SkString("%6.4f"); }
+ SkString getNormalTimeFormat() override { return SkString("%6.4f"); }
protected:
- SkCanvas* setupCanvas(int width, int height) SK_OVERRIDE;
+ SkCanvas* setupCanvas(int width, int height) override;
private:
- SkString getConfigNameInternal() SK_OVERRIDE;
+ SkString getConfigNameInternal() override;
typedef PictureRenderer INHERITED;
};
PipePictureRenderer(const GrContext::Options &opts) : INHERITED(opts) { }
#endif
- bool render(SkBitmap** out = NULL) SK_OVERRIDE;
+ bool render(SkBitmap** out = NULL) override;
private:
- SkString getConfigNameInternal() SK_OVERRIDE;
+ SkString getConfigNameInternal() override;
typedef PictureRenderer INHERITED;
};
const SkString* mismatchPath,
const SkString* inputFilename,
bool useChecksumBasedFilenames,
- bool useMultiPictureDraw) SK_OVERRIDE;
+ bool useMultiPictureDraw) override;
- bool render(SkBitmap** out = NULL) SK_OVERRIDE;
+ bool render(SkBitmap** out = NULL) override;
private:
- SkString getConfigNameInternal() SK_OVERRIDE;
+ SkString getConfigNameInternal() override;
typedef PictureRenderer INHERITED;
};
const SkString* mismatchPath,
const SkString* inputFilename,
bool useChecksumBasedFilenames,
- bool useMultiPictureDraw) SK_OVERRIDE;
+ bool useMultiPictureDraw) override;
/**
* Renders to tiles, rather than a single canvas.
* If fWritePath was provided, a separate file is
* created for each tile, named "path0.png", "path1.png", etc.
*/
- bool render(SkBitmap** out = NULL) SK_OVERRIDE;
+ bool render(SkBitmap** out = NULL) override;
- void end() SK_OVERRIDE;
+ void end() override;
void setTileWidth(int width) {
fTileWidth = width;
return fTileMinPowerOf2Width;
}
- TiledPictureRenderer* getTiledRenderer() SK_OVERRIDE { return this; }
+ TiledPictureRenderer* getTiledRenderer() override { return this; }
virtual bool supportsTimingIndividualTiles() { return true; }
protected:
SkTDArray<SkIRect> fTileRects;
- SkCanvas* setupCanvas(int width, int height) SK_OVERRIDE;
- SkString getConfigNameInternal() SK_OVERRIDE;
+ SkCanvas* setupCanvas(int width, int height) override;
+ SkString getConfigNameInternal() override;
private:
int fTileWidth;
PlaybackCreationRenderer(const GrContext::Options &opts) : INHERITED(opts) { }
#endif
- void setup() SK_OVERRIDE;
+ void setup() override;
- bool render(SkBitmap** out = NULL) SK_OVERRIDE;
+ bool render(SkBitmap** out = NULL) override;
- SkString getPerIterTimeFormat() SK_OVERRIDE { return SkString("%.4f"); }
+ SkString getPerIterTimeFormat() override { return SkString("%.4f"); }
- SkString getNormalTimeFormat() SK_OVERRIDE { return SkString("%6.4f"); }
+ SkString getNormalTimeFormat() override { return SkString("%6.4f"); }
private:
SkAutoTDelete<SkPictureRecorder> fRecorder;
- SkString getConfigNameInternal() SK_OVERRIDE;
+ SkString getConfigNameInternal() override;
typedef PictureRenderer INHERITED;
};
fWriters.push_back(newWriter);
}
virtual ~PictureResultsMultiWriter() {}
- void bench(const char name[], int32_t x, int32_t y) SK_OVERRIDE {
+ void bench(const char name[], int32_t x, int32_t y) override {
for(int i=0; i<fWriters.count(); ++i) {
fWriters[i]->bench(name, x, y);
}
}
- void logRenderer(sk_tools::PictureRenderer *pr) SK_OVERRIDE {
+ void logRenderer(sk_tools::PictureRenderer *pr) override {
for(int i=0; i<fWriters.count(); ++i) {
fWriters[i]->logRenderer(pr);
}
}
- void tileMeta(int x, int y, int tx, int ty) SK_OVERRIDE {
+ void tileMeta(int x, int y, int tx, int ty) override {
for(int i=0; i<fWriters.count(); ++i) {
fWriters[i]->tileMeta(x, y, tx, ty);
}
}
- void addTileFlag(PictureResultsWriter::TileFlags flag) SK_OVERRIDE {
+ void addTileFlag(PictureResultsWriter::TileFlags flag) override {
for(int i=0; i<fWriters.count(); ++i) {
fWriters[i]->addTileFlag(flag);
}
const char format[],
const TimerData::Result result,
uint32_t timerTypes,
- int numInnerLoops = 1) SK_OVERRIDE {
+ int numInnerLoops = 1) override {
for(int i=0; i<fWriters.count(); ++i) {
fWriters[i]->tileData(data, format, result, timerTypes,
numInnerLoops);
}
}
- void end() SK_OVERRIDE {
+ void end() override {
for(int i=0; i<fWriters.count(); ++i) {
fWriters[i]->end();
}
public:
PictureResultsLoggerWriter(BenchLogger* log)
: fLogger(log), fCurrentLine() {}
- void bench(const char name[], int32_t x, int32_t y) SK_OVERRIDE {
+ void bench(const char name[], int32_t x, int32_t y) override {
SkString result;
result.printf("running bench [%i %i] %s ", x, y, name);
this->logProgress(result.c_str());
}
- void logRenderer(sk_tools::PictureRenderer* renderer) SK_OVERRIDE {
+ void logRenderer(sk_tools::PictureRenderer* renderer) override {
fCurrentLine = renderer->getConfigName();
}
- void tileMeta(int x, int y, int tx, int ty) SK_OVERRIDE {
+ void tileMeta(int x, int y, int tx, int ty) override {
fCurrentLine.appendf(": tile [%i,%i] out of [%i,%i]", x, y, tx, ty);
}
- void addTileFlag(PictureResultsWriter::TileFlags flag) SK_OVERRIDE {
+ void addTileFlag(PictureResultsWriter::TileFlags flag) override {
if(flag == PictureResultsWriter::kPurging) {
fCurrentLine.append(" <withPurging>");
} else if(flag == PictureResultsWriter::kAvg) {
const char format[],
const TimerData::Result result,
uint32_t timerTypes,
- int numInnerLoops = 1) SK_OVERRIDE {
+ int numInnerLoops = 1) override {
SkString results = data->getResult(format, result,
fCurrentLine.c_str(), timerTypes, numInnerLoops);
results.append("\n");
this->logProgress(results.c_str());
}
- void end() SK_OVERRIDE {}
+ void end() override {}
private:
BenchLogger* fLogger;
SkString fCurrentLine;
fBuilderData = this->makeBuilderJson();
}
- void bench(const char name[], int32_t x, int32_t y) SK_OVERRIDE {
+ void bench(const char name[], int32_t x, int32_t y) override {
fBenchName = SkString(name);
}
- void logRenderer(sk_tools::PictureRenderer* pr) SK_OVERRIDE {
+ void logRenderer(sk_tools::PictureRenderer* pr) override {
fParams = pr->getJSONConfig();
fConfigString = pr->getConfigName();
}
// Apparently tiles aren't used, so tileMeta is empty
- void tileMeta(int x, int y, int tx, int ty) SK_OVERRIDE {}
+ void tileMeta(int x, int y, int tx, int ty) override {}
// Flags aren't used, so addTileFlag is empty
- void addTileFlag(PictureResultsWriter::TileFlags flag) SK_OVERRIDE {}
+ void addTileFlag(PictureResultsWriter::TileFlags flag) override {}
virtual void tileData(
TimerData* data,
const char format[],
const TimerData::Result result,
uint32_t timerTypes,
- int numInnerLoops = 1) SK_OVERRIDE {
+ int numInnerLoops = 1) override {
Json::Value newData = data->getJSON(timerTypes, result, numInnerLoops);
Json::Value combinedParams(fBuilderData);
for(Json::ValueIterator iter = fParams.begin(); iter != fParams.end();
fStream.writeText(Json::FastWriter().write(data).c_str());
}
}
- void end() SK_OVERRIDE {
+ void end() override {
fStream.flush();
}
private:
virtual ~ShellWindow();
protected:
- void onSizeChange() SK_OVERRIDE;
+ void onSizeChange() override;
virtual bool onDispatchClick(int x, int y, Click::State, void* owner,
- unsigned modi) SK_OVERRIDE;
+ unsigned modi) override;
private:
typedef SkOSWindow INHERITED;
class NullWStream : public SkWStream {
public:
NullWStream() : fBytesWritten(0) { }
- bool write(const void*, size_t size) SK_OVERRIDE {
+ bool write(const void*, size_t size) override {
fBytesWritten += size;
return true;
}
- size_t bytesWritten() const SK_OVERRIDE { return fBytesWritten; }
+ size_t bytesWritten() const override { return fBytesWritten; }
size_t fBytesWritten;
};
} // namespace
// used.
class PngPixelSerializer : public SkPixelSerializer {
public:
- bool onUseEncodedData(const void*, size_t) SK_OVERRIDE { return true; }
+ bool onUseEncodedData(const void*, size_t) override { return true; }
SkData* onEncodePixels(const SkImageInfo& info, const void* pixels,
- size_t rowBytes) SK_OVERRIDE {
+ size_t rowBytes) override {
return SkImageEncoder::EncodeData(info, pixels, rowBytes,
SkImageEncoder::kPNG_Type, 100);
}
public:
SkCLImageDiffer();
- bool requiresOpenCL() const SK_OVERRIDE { return true; }
+ bool requiresOpenCL() const override { return true; }
/**
* Initializes the OpenCL resources this differ needs to work
fTestPath = testPath;
}
- void run() SK_OVERRIDE {
+ void run() override {
fDiffContext->addDiff(fBaselinePath.c_str(), fTestPath.c_str());
}
public SkImageDiffer {
#endif
public:
- const char* getName() const SK_OVERRIDE;
+ const char* getName() const override;
virtual bool diff(SkBitmap* baseline, SkBitmap* test,
const BitmapsToCreate& bitmapsToCreate,
- Result* result) const SK_OVERRIDE;
+ Result* result) const override;
protected:
#if SK_SUPPORT_OPENCL
- bool onInit() SK_OVERRIDE;
+ bool onInit() override;
#endif
private:
*/
class SkPMetric : public SkImageDiffer {
public:
- const char* getName() const SK_OVERRIDE { return "perceptual"; }
+ const char* getName() const override { return "perceptual"; }
virtual bool diff(SkBitmap* baseline, SkBitmap* test, const BitmapsToCreate& bitmapsToCreate,
- Result* result) const SK_OVERRIDE;
+ Result* result) const override;
private:
typedef SkImageDiffer INHERITED;
projects / platform / upstream / libSkiaSharp.git / commitdiff