#include <math.h>
-static inline SkPMColor rgb2gray(SkPMColor c)
-{
+static inline SkPMColor rgb2gray(SkPMColor c) {
unsigned r = SkGetPackedR32(c);
unsigned g = SkGetPackedG32(c);
unsigned b = SkGetPackedB32(c);
class SkGrayScaleColorFilter : public SkColorFilter {
public:
- virtual void filterSpan(const SkPMColor src[], int count, SkPMColor result[])
- {
+ virtual void filterSpan(const SkPMColor src[], int count, SkPMColor result[]) {
for (int i = 0; i < count; i++)
result[i] = rgb2gray(src[i]);
}
class SkChannelMaskColorFilter : public SkColorFilter {
public:
- SkChannelMaskColorFilter(U8CPU redMask, U8CPU greenMask, U8CPU blueMask)
- {
+ SkChannelMaskColorFilter(U8CPU redMask, U8CPU greenMask, U8CPU blueMask) {
fMask = SkPackARGB32(0xFF, redMask, greenMask, blueMask);
}
- virtual void filterSpan(const SkPMColor src[], int count, SkPMColor result[])
- {
+ virtual void filterSpan(const SkPMColor src[], int count, SkPMColor result[]) {
SkPMColor mask = fMask;
- for (int i = 0; i < count; i++)
+ for (int i = 0; i < count; i++) {
result[i] = src[i] & mask;
+ }
}
private:
///////////////////////////////////////////////////////////
-static void r0(SkLayerRasterizer* rast, SkPaint& p)
-{
+static void r0(SkLayerRasterizer* rast, SkPaint& p) {
p.setMaskFilter(SkBlurMaskFilter::Create(SkIntToScalar(3),
SkBlurMaskFilter::kNormal_BlurStyle))->unref();
rast->addLayer(p, SkIntToScalar(3), SkIntToScalar(3));
rast->addLayer(p);
}
-static void r1(SkLayerRasterizer* rast, SkPaint& p)
-{
+static void r1(SkLayerRasterizer* rast, SkPaint& p) {
rast->addLayer(p);
p.setAlpha(0x40);
rast->addLayer(p);
}
-static void r2(SkLayerRasterizer* rast, SkPaint& p)
-{
+static void r2(SkLayerRasterizer* rast, SkPaint& p) {
p.setStyle(SkPaint::kStrokeAndFill_Style);
p.setStrokeWidth(SK_Scalar1*4);
rast->addLayer(p);
rast->addLayer(p);
}
-static void r3(SkLayerRasterizer* rast, SkPaint& p)
-{
+static void r3(SkLayerRasterizer* rast, SkPaint& p) {
p.setStyle(SkPaint::kStroke_Style);
p.setStrokeWidth(SK_Scalar1*3);
rast->addLayer(p);
rast->addLayer(p);
}
-static void r4(SkLayerRasterizer* rast, SkPaint& p)
-{
+static void r4(SkLayerRasterizer* rast, SkPaint& p) {
p.setAlpha(0x60);
rast->addLayer(p, SkIntToScalar(3), SkIntToScalar(3));
rast->addLayer(p);
}
-static void r5(SkLayerRasterizer* rast, SkPaint& p)
-{
+static void r5(SkLayerRasterizer* rast, SkPaint& p) {
rast->addLayer(p);
p.setPathEffect(new SkDiscretePathEffect(SK_Scalar1*4, SK_Scalar1*3))->unref();
rast->addLayer(p);
}
-static void r6(SkLayerRasterizer* rast, SkPaint& p)
-{
+static void r6(SkLayerRasterizer* rast, SkPaint& p) {
rast->addLayer(p);
p.setAntiAlias(false);
Dot2DPathEffect(SkScalar radius, const SkMatrix& matrix)
: Sk2DPathEffect(matrix), fRadius(radius) {}
- virtual void flatten(SkFlattenableWriteBuffer& buffer)
- {
+ virtual void flatten(SkFlattenableWriteBuffer& buffer) {
this->INHERITED::flatten(buffer);
buffer.writeScalar(fRadius);
virtual Factory getFactory() { return CreateProc; }
protected:
- virtual void next(const SkPoint& loc, int u, int v, SkPath* dst)
- {
+ virtual void next(const SkPoint& loc, int u, int v, SkPath* dst) {
dst->addCircle(loc.fX, loc.fY, fRadius);
}
- Dot2DPathEffect(SkFlattenableReadBuffer& buffer) : Sk2DPathEffect(buffer)
- {
+ Dot2DPathEffect(SkFlattenableReadBuffer& buffer) : Sk2DPathEffect(buffer) {
fRadius = buffer.readScalar();
}
private:
SkScalar fRadius;
- static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer)
- {
+ static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
return new Dot2DPathEffect(buffer);
}
typedef Sk2DPathEffect INHERITED;
};
-static void r7(SkLayerRasterizer* rast, SkPaint& p)
-{
+static void r7(SkLayerRasterizer* rast, SkPaint& p) {
SkMatrix lattice;
lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0);
lattice.postSkew(SK_Scalar1/3, 0, 0, 0);
rast->addLayer(p);
}
-static void r8(SkLayerRasterizer* rast, SkPaint& p)
-{
+static void r8(SkLayerRasterizer* rast, SkPaint& p) {
rast->addLayer(p);
SkMatrix lattice;
Line2DPathEffect(SkScalar width, const SkMatrix& matrix)
: Sk2DPathEffect(matrix), fWidth(width) {}
- virtual bool filterPath(SkPath* dst, const SkPath& src, SkScalar* width)
- {
- if (this->INHERITED::filterPath(dst, src, width))
- {
+ virtual bool filterPath(SkPath* dst, const SkPath& src, SkScalar* width) {
+ if (this->INHERITED::filterPath(dst, src, width)) {
*width = fWidth;
return true;
}
}
virtual Factory getFactory() { return CreateProc; }
- virtual void flatten(SkFlattenableWriteBuffer& buffer)
- {
+ virtual void flatten(SkFlattenableWriteBuffer& buffer) {
this->INHERITED::flatten(buffer);
buffer.writeScalar(fWidth);
}
protected:
- virtual void nextSpan(int u, int v, int ucount, SkPath* dst)
- {
- if (ucount > 1)
- {
+ virtual void nextSpan(int u, int v, int ucount, SkPath* dst) {
+ if (ucount > 1) {
SkPoint src[2], dstP[2];
src[0].set(SkIntToScalar(u) + SK_ScalarHalf,
}
}
- Line2DPathEffect(SkFlattenableReadBuffer& buffer) : Sk2DPathEffect(buffer)
- {
+ Line2DPathEffect(SkFlattenableReadBuffer& buffer) : Sk2DPathEffect(buffer) {
fWidth = buffer.readScalar();
}
typedef Sk2DPathEffect INHERITED;
};
-static void r9(SkLayerRasterizer* rast, SkPaint& p)
-{
+static void r9(SkLayerRasterizer* rast, SkPaint& p) {
rast->addLayer(p);
SkMatrix lattice;
{ 0xFFFFFF, 0x000000 } // identity case
};
-static unsigned color_dist16(uint16_t a, uint16_t b)
-{
+static unsigned color_dist16(uint16_t a, uint16_t b) {
unsigned dr = SkAbs32(SkPacked16ToR32(a) - SkPacked16ToR32(b));
unsigned dg = SkAbs32(SkPacked16ToG32(a) - SkPacked16ToG32(b));
unsigned db = SkAbs32(SkPacked16ToB32(a) - SkPacked16ToB32(b));
return SkMax32(dr, SkMax32(dg, db));
}
-static unsigned scale_dist(unsigned dist, unsigned scale)
-{
+static unsigned scale_dist(unsigned dist, unsigned scale) {
dist >>= 6;
dist = (dist << 2) | dist;
dist = (dist << 4) | dist;
// return SkAlphaMul(dist, scale);
}
-static void apply_shader(SkPaint* paint, int index)
-{
+static void apply_shader(SkPaint* paint, int index) {
raster_proc proc = gRastProcs[index];
- if (proc)
- {
+ if (proc) {
SkPaint p;
SkLayerRasterizer* rast = new SkLayerRasterizer;
#endif
}
-class DemoView : public SkView {
+class DemoView : public SampleView {
public:
DemoView() {}
protected:
// overrides from SkEventSink
- virtual bool onQuery(SkEvent* evt)
- {
- if (SampleCode::TitleQ(*evt))
- {
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "Demo");
return true;
}
return this->INHERITED::onQuery(evt);
}
- virtual bool onClick(Click* click)
- {
+ virtual bool onClick(Click* click) {
return this->INHERITED::onClick(click);
}
- void makePath(SkPath& path)
- {
+ void makePath(SkPath& path) {
path.addCircle(SkIntToScalar(20), SkIntToScalar(20), SkIntToScalar(20),
SkPath::kCCW_Direction);
for (int index = 0; index < 10; index++) {
path.close();
}
- virtual void onDraw(SkCanvas* canvas)
- {
- canvas->drawColor(SK_ColorWHITE);
+ virtual void onDrawContent(SkCanvas* canvas) {
canvas->save();
drawPicture(canvas, 0);
canvas->restore();
}
}
- void drawPicture(SkCanvas* canvas, int spriteOffset)
- {
+ void drawPicture(SkCanvas* canvas, int spriteOffset) {
SkMatrix matrix; matrix.reset();
SkPaint paint;
SkPath path;
SkCornerPathEffect.h:28:class SkCornerPathEffect : public SkPathEffect {
*/
- virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y)
- {
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
fClickPt.set(x, y);
this->inval(NULL);
return this->INHERITED::onFindClickHandler(x, y);
}
- SkPathEffect* pathEffectTest()
- {
+ SkPathEffect* pathEffectTest() {
static const int gXY[] = { 1, 0, 0, -1, 2, -1, 3, 0, 2, 1, 0, 1 };
SkScalar gPhase = 0;
SkPath path;
return result;
}
- SkPathEffect* pathEffectTest2() // unsure this works (has no visible effect)
- {
+ SkPathEffect* pathEffectTest2() { // unsure this works (has no visible effect)
SkPathEffect* outer = new SkStrokePathEffect(SkIntToScalar(4),
SkPaint::kStroke_Style, SkPaint::kMiter_Join, SkPaint::kButt_Cap);
static const SkScalar intervals[] = {SkIntToScalar(1), SkIntToScalar(2),
return result;
}
- SkShader* shaderTest()
- {
+ SkShader* shaderTest() {
SkPoint pts[] = {0, 0, SkIntToScalar(100), 0 };
SkColor colors[] = { SK_ColorRED, SK_ColorBLUE };
SkShader* shaderA = SkGradientShader::CreateLinear(pts, colors, NULL,
SkImageDecoder::DecodeFile("/Users/caryclark/Desktop/05psp04.gif", &fTx);
}
- void drawRaster(SkCanvas* canvas)
- {
+ void drawRaster(SkCanvas* canvas) {
for (int index = 0; index < SK_ARRAY_COUNT(gRastProcs); index++)
drawOneRaster(canvas);
}
- void drawOneRaster(SkCanvas* canvas)
- {
+ void drawOneRaster(SkCanvas* canvas) {
canvas->save();
SkScalar x = SkIntToScalar(20);
SkString str("GOOGLE");
- for (int i = 0; i < SK_ARRAY_COUNT(gRastProcs); i++)
- {
+ for (int i = 0; i < SK_ARRAY_COUNT(gRastProcs); i++) {
apply_shader(&paint, i);
// paint.setMaskFilter(NULL);
private:
SkPoint fClickPt;
SkBitmap fBug, fTb, fTx;
- typedef SkView INHERITED;
+ typedef SampleView INHERITED;
};
//////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
-class AvoidView : public SkView {
+class AvoidView : public SampleView {
SkShader* fShader;
enum {
return this->INHERITED::onQuery(evt);
}
- virtual void onDraw(SkCanvas* canvas) {
- canvas->drawColor(SK_ColorWHITE);
-
+ virtual void onDrawContent(SkCanvas* canvas) {
SkPaint paint;
SkRect r = { 0, 0, SkIntToScalar(W), SkIntToScalar(H) };
}
private:
- typedef SkView INHERITED;
+ typedef SampleView INHERITED;
};
//////////////////////////////////////////////////////////////////////////////
#include "SkRandom.h"
#include "SkImageDecoder.h"
-class CameraView : public SkView {
+class CameraView : public SampleView {
SkTDArray<SkShader*> fShaders;
int fShaderIndex;
bool fFrontFace;
break;
}
}
+ this->setBGColor(0xFFDDDDDD);
}
virtual ~CameraView() {
return this->INHERITED::onQuery(evt);
}
- void drawBG(SkCanvas* canvas) {
- canvas->drawColor(0xFFDDDDDD);
- }
-
- virtual void onDraw(SkCanvas* canvas) {
- this->drawBG(canvas);
-
+ virtual void onDrawContent(SkCanvas* canvas) {
canvas->translate(this->width()/2, this->height()/2);
Sk3DView view;
view.applyToCanvas(canvas);
SkPaint paint;
- SkScalar rad = SkIntToScalar(50);
- SkScalar dim = rad*2;
if (fShaders.count() > 0) {
bool frontFace = view.dotWithNormal(0, 0, SK_Scalar1) < 0;
if (frontFace != fFrontFace) {
paint.setAntiAlias(true);
paint.setShader(fShaders[fShaderIndex]);
-#if 0
- canvas->drawCircle(0, 0, rad, paint);
- canvas->drawCircle(-dim, -dim, rad, paint);
- canvas->drawCircle(-dim, dim, rad, paint);
- canvas->drawCircle( dim, -dim, rad, paint);
- canvas->drawCircle( dim, dim, rad, paint);
-#else
SkRect r = { -150, -150, 150, 150 };
canvas->drawRoundRect(r, 30, 30, paint);
-#endif
}
fRY += SampleCode::GetAnimSecondsDelta() * 90;
private:
SkScalar fRX, fRY, fRZ;
- typedef SkView INHERITED;
+ typedef SampleView INHERITED;
};
//////////////////////////////////////////////////////////////////////////////
#endif
}
-class CircleView : public SkView {
+class CircleView : public SampleView {
public:
static const SkScalar ANIM_DX;
static const SkScalar ANIM_DY;
return this->INHERITED::onQuery(evt);
}
- void drawBG(SkCanvas* canvas) {
- canvas->drawColor(SK_ColorWHITE);
- }
-
void circle(SkCanvas* canvas, int width, bool aa) {
SkPaint paint;
canvas->translate(px, py);
}
- virtual void onDraw(SkCanvas* canvas) {
- this->drawBG(canvas);
-
+ virtual void onDrawContent(SkCanvas* canvas) {
SkPaint paint;
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
canvas->translate(-SK_Scalar1, 0);
canvas->drawPath(path, paint);
}
-
- if (false) {
- test_circlebounds(canvas);
-
- SkScalar dx = SkIntToScalar(32);
- SkScalar dy = SkIntToScalar(32);
-
- canvas->translate(dx + fDX, dy + fDY);
- drawSix(canvas, dx, dy);
-
- canvas->translate(dx, 0);
- canvas->translate(SK_ScalarHalf, SK_ScalarHalf);
- drawSix(canvas, dx, dy);
-
- fDX += ANIM_DX;
- fDY += ANIM_DY;
- fRAD += ANIM_RAD;
- fN += 1;
- if (fN > 40) {
- fN = 3;
- }
- this->inval(NULL);
- }
}
private:
int fN;
- typedef SkView INHERITED;
+ typedef SampleView INHERITED;
};
const SkScalar CircleView::ANIM_DX(SK_Scalar1 / 67);
///////////////////////////////////////////////////////////////////////////////
-class EffectsView : public SkView {
+class EffectsView : public SampleView {
public:
SkPath fPath;
SkPaint fPaint[SK_ARRAY_COUNT(gPaintProcs)];
SkColorMatrix cm;
cm.setRotate(SkColorMatrix::kG_Axis, 180);
cm.setIdentity();
+
+ this->setBGColor(0xFFDDDDDD);
}
protected:
return this->INHERITED::onQuery(evt);
}
- void drawBG(SkCanvas* canvas) {
- canvas->drawColor(0xFFDDDDDD);
- }
-
- virtual void onDraw(SkCanvas* canvas) {
- this->drawBG(canvas);
-
+ virtual void onDrawContent(SkCanvas* canvas) {
canvas->scale(3, 3);
canvas->translate(10, 30);
for (size_t i = 0; i < SK_ARRAY_COUNT(fPaint); i++) {
}
private:
- typedef SkView INHERITED;
+ typedef SampleView INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
-class FuzzView : public SkView {
+class FuzzView : public SampleView {
public:
- FuzzView() {}
+ FuzzView() {
+ this->setBGColor(0xFFDDDDDD);
+ }
protected:
// overrides from SkEventSink
canvas->drawColor(0xFFDDDDDD);
}
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDrawContent(SkCanvas* canvas) {
SkIRect r = canvas->getTotalClip().getBounds();
- this->drawBG(canvas);
do_fuzz(canvas);
this->inval(NULL);
}
return (index + 1) % SK_ARRAY_COUNT(gProcs);
}
-class HairlineView : public SkView {
+class HairlineView : public SampleView {
SkMSec fNow;
int fProcIndex;
bool fDoAA;
canvas->drawBitmap(b1, SkIntToScalar(b0.width()), 0, NULL);
}
- void drawBG(SkCanvas* canvas) {
-// canvas->drawColor(0xFFDDDDDD);
- canvas->drawColor(SK_ColorWHITE);
- // canvas->drawColor(SK_ColorBLACK);
- }
-
int fCounter;
- virtual void onDraw(SkCanvas* canvas) {
- this->drawBG(canvas);
-
+ virtual void onDrawContent(SkCanvas* canvas) {
gRand.setSeed(fNow);
if (false) {
private:
- typedef SkView INHERITED;
+ typedef SampleView INHERITED;
};
//////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
-class LayerMaskView : public SkView {
+class LayerMaskView : public SampleView {
public:
- LayerMaskView() {}
+ LayerMaskView() {
+ this->setBGColor(0xFFDDDDDD);
+ }
protected:
// overrides from SkEventSink
}
}
- void drawBG(SkCanvas* canvas) {
- canvas->drawColor(0xFFDDDDDD);
- }
-
- virtual void onDraw(SkCanvas* canvas) {
- this->drawBG(canvas);
-
+ virtual void onDrawContent(SkCanvas* canvas) {
SkRect r;
r.set(SkIntToScalar(20), SkIntToScalar(20), SkIntToScalar(120), SkIntToScalar(120));
canvas->saveLayer(&r, NULL, SkCanvas::kARGB_ClipLayer_SaveFlag);
}
private:
- typedef SkView INHERITED;
+ typedef SampleView INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
return bitmap;
}
-class MipMapView : public SkView {
+class MipMapView : public SampleView {
SkBitmap fBitmap;
enum {
N = 64
}
}
- void drawBG(SkCanvas* canvas) {
- canvas->drawColor(SK_ColorWHITE);
- }
-
- virtual void onDraw(SkCanvas* canvas) {
- this->drawBG(canvas);
-
+ virtual void onDrawContent(SkCanvas* canvas) {
canvas->translate(SkIntToScalar(10), SkIntToScalar(10));
canvas->scale(1.00000001f, 0.9999999f);
private:
int fWidth;
- typedef SkView INHERITED;
+ typedef SampleView INHERITED;
};
//////////////////////////////////////////////////////////////////////////////
patch->draw(canvas, paint, 10, 10, true, true);
}
-class PatchView : public SkView {
+class PatchView : public SampleView {
SkShader* fShader0;
SkShader* fShader1;
SkIPoint fSize0, fSize1;
fPts[9].set(S*0, T*4);
fPts[10].set(S*0, T*3);
fPts[11].set(S*0, T*2);
+
+ this->setBGColor(SK_ColorGRAY);
}
virtual ~PatchView() {
return this->INHERITED::onQuery(evt);
}
- void drawBG(SkCanvas* canvas) {
- canvas->drawColor(SK_ColorGRAY);
- }
-
- virtual void onDraw(SkCanvas* canvas) {
- this->drawBG(canvas);
-
+ virtual void onDrawContent(SkCanvas* canvas) {
SkPaint paint;
paint.setDither(true);
paint.setFilterBitmap(true);
}
private:
- typedef SkView INHERITED;
+ typedef SampleView INHERITED;
};
//////////////////////////////////////////////////////////////////////////////
paint);
}
-class PictureView : public SkView {
+class PictureView : public SampleView {
SkBitmap fBitmap;
public:
PictureView() {
return this->INHERITED::onQuery(evt);
}
- void drawBG(SkCanvas* canvas) {
-// canvas->drawColor(0xFFDDDDDD);
- canvas->drawColor(SK_ColorWHITE);
- // canvas->drawColor(SK_ColorBLACK);
- }
-
void drawSomething(SkCanvas* canvas) {
SkPaint paint;
}
- virtual void onDraw(SkCanvas* canvas) {
- this->drawBG(canvas);
-
+ virtual void onDrawContent(SkCanvas* canvas) {
drawSomething(canvas);
SkPicture* pict = new SkPicture;
SkPicture* fPicture;
SkPicture* fSubPicture;
- typedef SkView INHERITED;
+ typedef SampleView INHERITED;
};
//////////////////////////////////////////////////////////////////////////////
}
}
-class RegionView : public SkView {
+class RegionView : public SampleView {
public:
- RegionView()
- {
+ RegionView() {
fBase.set(100, 100, 150, 150);
fRect = fBase;
fRect.inset(5, 5);
fRect.offset(25, 25);
+ this->setBGColor(0xFFDDDDDD);
}
- void build_rgn(SkRegion* rgn, SkRegion::Op op)
- {
+ void build_rgn(SkRegion* rgn, SkRegion::Op op) {
rgn->setRect(fBase);
SkIRect r = fBase;
r.offset(75, 20);
protected:
// overrides from SkEventSink
- virtual bool onQuery(SkEvent* evt)
- {
- if (SampleCode::TitleQ(*evt))
- {
+ virtual bool onQuery(SkEvent* evt) {
+ if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "Regions");
return true;
}
return this->INHERITED::onQuery(evt);
}
- void drawOrig(SkCanvas* canvas, bool bg)
- {
+ void drawOrig(SkCanvas* canvas, bool bg) {
SkRect r;
SkPaint paint;
canvas->drawRect(r, paint);
}
- void drawRgnOped(SkCanvas* canvas, SkRegion::Op op, SkColor color)
- {
+ void drawRgnOped(SkCanvas* canvas, SkRegion::Op op, SkColor color) {
SkRegion rgn;
this->build_rgn(&rgn, op);
paint_rgn(canvas, rgn, paint);
}
- void drawPathOped(SkCanvas* canvas, SkRegion::Op op, SkColor color)
- {
+ void drawPathOped(SkCanvas* canvas, SkRegion::Op op, SkColor color) {
SkRegion rgn;
SkPath path;
canvas->drawPath(path, paint);
}
- void drawBG(SkCanvas* canvas)
- {
- canvas->drawColor(0xFFDDDDDD);
- return;
-
-#if 0
- SkColorTable ct;
- SkPMColor colors[] = { SK_ColorRED, SK_ColorBLUE };
- ct.setColors(colors, 2);
- ct.setFlags(ct.getFlags() | SkColorTable::kColorsAreOpaque_Flag);
-
- SkBitmap bm;
- bm.setConfig(SkBitmap::kIndex8_Config, 20, 20, 21);
- bm.setColorTable(&ct);
- bm.allocPixels();
- sk_memset16((uint16_t*)bm.getAddr8(0, 0), 0x0001, bm.rowBytes() * bm.height() / 2);
-#endif
-#if 0
- SkBitmap bm;
- bm.setConfig(SkBitmap::kRGB_565_Config, 20, 20, 42);
- bm.allocPixels();
- sk_memset32((uint32_t*)bm.getAddr16(0, 0), 0x0000FFFF, bm.rowBytes() * bm.height() / 4);
-#endif
-#if 1
- SkBitmap bm;
- bm.setConfig(SkBitmap::kARGB_8888_Config, 20, 20);
- bm.allocPixels();
- sk_memset32((uint32_t*)bm.getAddr32(0, 0), 0xFFDDDDDD, bm.rowBytes() * bm.height() / 4);
-#endif
-
- SkPaint paint;
-
-// SkShader* shader = SkShader::CreateBitmapShader(bm, false, SkPaint::kBilinear_FilterType, SkShader::kRepeat_TileMode);
- SkPoint pts[] = { 0, 0, SkIntToScalar(100), SkIntToScalar(0) };
- SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE };
- SkShader* shader = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kMirror_TileMode);
- paint.setShader(shader)->unref();
-
- canvas->drawPaint(paint);
- }
-
- virtual void onDraw(SkCanvas* canvas) {
- this->drawBG(canvas);
-
- if (false) {
- SkPaint paint;
- paint.setAntiAlias(true);
- SkBitmap bm;
- bm.setConfig(SkBitmap::kA8_Config, 100, 100);
- bm.allocPixels();
- bm.eraseColor(0);
- SkCanvas c(bm);
- c.drawCircle(50, 50, 50, paint);
-
- paint.setColor(SK_ColorBLUE);
- canvas->drawBitmap(bm, 0, 0, &paint);
- canvas->scale(SK_Scalar1/2, SK_Scalar1/2);
- paint.setColor(SK_ColorRED);
- canvas->drawBitmap(bm, 0, 0, &paint);
- return;
- }
-
+ virtual void onDrawContent(SkCanvas* canvas) {
#ifdef SK_DEBUG
if (true) {
SkRegion a, b, c;
canvas->translate(0, SkIntToScalar(200));
- for (int op = 0; op < SK_ARRAY_COUNT(gOps); op++)
- {
+ for (int op = 0; op < SK_ARRAY_COUNT(gOps); op++) {
canvas->drawText(gOps[op].fName, strlen(gOps[op].fName), SkIntToScalar(75), SkIntToScalar(50), textPaint);
this->drawRgnOped(canvas, gOps[op].fOp, gOps[op].fColor);
- if (true)
- {
- canvas->save();
- canvas->translate(0, SkIntToScalar(200));
- this->drawPathOped(canvas, gOps[op].fOp, gOps[op].fColor);
- canvas->restore();
- }
+ canvas->save();
+ canvas->translate(0, SkIntToScalar(200));
+ this->drawPathOped(canvas, gOps[op].fOp, gOps[op].fColor);
+ canvas->restore();
canvas->translate(SkIntToScalar(200), 0);
}
}
- virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y)
- {
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
return fRect.contains(SkScalarRound(x), SkScalarRound(y)) ? new Click(this) : NULL;
}
- virtual bool onClick(Click* click)
- {
+ virtual bool onClick(Click* click) {
fRect.offset(click->fICurr.fX - click->fIPrev.fX,
click->fICurr.fY - click->fIPrev.fY);
this->inval(NULL);
private:
SkIRect fBase, fRect;
- typedef SkView INHERITED;
+ typedef SampleView INHERITED;
};
//////////////////////////////////////////////////////////////////////////////
return shader;
}
-class ShaderView : public SkView {
+class ShaderView : public SampleView {
public:
SkShader* fShader;
SkBitmap fBitmap;
- ShaderView()
- {
+ ShaderView() {
SkImageDecoder::DecodeFile("/skimages/logo.gif", &fBitmap);
SkPoint pts[2];
shaderB->unref();
mode->unref();
}
- virtual ~ShaderView()
- {
+ virtual ~ShaderView() {
SkSafeUnref(fShader);
}
return this->INHERITED::onQuery(evt);
}
- void drawBG(SkCanvas* canvas)
- {
-// canvas->drawColor(0xFFDDDDDD);
- canvas->drawColor(SK_ColorWHITE);
- }
-
- virtual void onDraw(SkCanvas* canvas)
- {
- this->drawBG(canvas);
-
+ virtual void onDrawContent(SkCanvas* canvas) {
canvas->drawBitmap(fBitmap, 0, 0);
canvas->translate(SkIntToScalar(20), SkIntToScalar(120));
canvas->drawRect(r, paint);
}
- virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y)
- {
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
this->inval(NULL);
return this->INHERITED::onFindClickHandler(x, y);
}
- virtual bool onClick(Click* click)
- {
+ virtual bool onClick(Click* click) {
return this->INHERITED::onClick(click);
}
private:
- typedef SkView INHERITED;
+ typedef SampleView INHERITED;
};
//////////////////////////////////////////////////////////////////////////////
canvas.drawPath(path, paint);
}
-class StrokeTextView : public SkView {
+class StrokeTextView : public SampleView {
bool fAA;
public:
- StrokeTextView() : fAA(false) {}
+ StrokeTextView() : fAA(false) {
+ this->setBGColor(0xFFCC8844);
+ }
protected:
// overrides from SkEventSink
return this->INHERITED::onQuery(evt);
}
- void drawBG(SkCanvas* canvas) {
- canvas->drawColor(0xFF333333);
- canvas->drawColor(0xFFCC8844);
- }
-
- virtual void onDraw(SkCanvas* canvas) {
- this->drawBG(canvas);
-
+ virtual void onDrawContent(SkCanvas* canvas) {
SkBitmap bm;
SkPaint paint;
private:
- typedef SkView INHERITED;
+ typedef SampleView INHERITED;
};
//////////////////////////////////////////////////////////////////////////////
}
}
-class TextAlphaView : public SkView {
+class TextAlphaView : public SampleView {
public:
TextAlphaView() {
fByte = 0xFF;
return this->INHERITED::onQuery(evt);
}
- void drawBG(SkCanvas* canvas) {
- canvas->drawColor(SK_ColorWHITE);
- }
-
- virtual void onDraw(SkCanvas* canvas) {
- this->drawBG(canvas);
-
+ virtual void onDrawContent(SkCanvas* canvas) {
const char* str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
SkPaint paint;
SkScalar x = SkIntToScalar(10);
private:
int fByte;
- typedef SkView INHERITED;
+ typedef SampleView INHERITED;
};
//////////////////////////////////////////////////////////////////////////////
view->setText(str);
}
-class UnitMapperView : public SkView {
+class UnitMapperView : public SampleView {
SkPoint fPts[4];
SkMatrix fMatrix;
SkStaticTextView* fViews[4];
return this->INHERITED::onQuery(evt);
}
- void drawBG(SkCanvas* canvas) {
- canvas->drawColor(SK_ColorWHITE);
- }
-
- virtual void onDraw(SkCanvas* canvas) {
- this->drawBG(canvas);
-
+ virtual void onDrawContent(SkCanvas* canvas) {
SkPaint paint;
paint.setAntiAlias(true);
paint.setColor(0xFF8888FF);
private:
int fDragIndex;
- typedef SkView INHERITED;
+ typedef SampleView INHERITED;
};
//////////////////////////////////////////////////////////////////////////////