fix warnings related to constness in overrides of SkColorFilter
update samples for circle testing
git-svn-id: http://skia.googlecode.com/svn/trunk@6943 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/samplecode/SampleRotateCircles.cpp b/samplecode/SampleRotateCircles.cpp
index 8a04bcd..8e8bc01 100644
--- a/samplecode/SampleRotateCircles.cpp
+++ b/samplecode/SampleRotateCircles.cpp
@@ -9,6 +9,8 @@
#include "SkView.h"
#include "SkCanvas.h"
#include "SkRandom.h"
+#include "SkRRect.h"
+#include "SkColorPriv.h"
static void rotateAbout(SkCanvas* canvas, SkScalar degrees,
SkScalar cx, SkScalar cy) {
@@ -65,12 +67,17 @@
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(rad*2);
-
+
canvas->save();
rotateAbout(canvas, fAngle * scale * sign, cx + DX, cy);
canvas->drawCircle(cx + DX, cy, 10, paint);
canvas->restore();
+ canvas->save();
+ rotateAbout(canvas, fAngle * scale * sign, cx + DX, cy + DX);
+ canvas->drawCircle(cx + DX, cy + DX, 10, paint);
+ canvas->restore();
+
}
fAngle = (fAngle + 1) % 360;
@@ -82,6 +89,272 @@
typedef SkView INHERITED;
};
+class TestCirclesView : public SampleView {
+public:
+ TestCirclesView() {
+ }
+
+protected:
+ virtual bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "RotateCircles2");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void draw_real_circle(SkCanvas* canvas, SkScalar radius) {
+ int w = SkScalarCeilToInt(radius * 2);
+ int h = w;
+
+ SkBitmap bm;
+ bm.setConfig(SkBitmap::kARGB_8888_Config, w, h);
+ bm.allocPixels();
+ bm.eraseColor(0);
+
+ SkAutoLockPixels alp(bm);
+
+ SkScalar cx = radius;
+ SkScalar cy = radius;
+ for (int y = 0; y < h; y += 1) {
+ for (int x = 0; x < w; x += 1) {
+ float d = sqrtf((x - cx)*(x - cx) + (y - cy)*(y - cy));
+ if (d <= radius) {
+ *bm.getAddr32(x, y) = SkPackARGB32(0xFF, 0, 0, 0);
+ }
+ }
+ }
+
+ canvas->drawBitmap(bm, 0, 0, NULL);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkScalar radius = 256;
+ canvas->translate(10, 10);
+
+ draw_real_circle(canvas, radius);
+
+ SkPaint paint;
+ paint.setAntiAlias(true);
+
+ paint.setColor(0x80FF0000);
+ canvas->drawCircle(radius, radius, radius, paint);
+
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setStrokeWidth(radius);
+ paint.setColor(0x8000FF00);
+ canvas->drawCircle(radius, radius, radius/2, paint);
+ }
+
+private:
+ typedef SkView INHERITED;
+};
+
+static bool hittest(const SkPoint& target, SkScalar x, SkScalar y) {
+ const SkScalar TOL = 7;
+ return SkPoint::Distance(target, SkPoint::Make(x, y)) <= TOL;
+}
+
+static int getOnCurvePoints(const SkPath& path, SkPoint storage[]) {
+ SkPath::RawIter iter(path);
+ SkPoint pts[4];
+ SkPath::Verb verb;
+
+ int count = 0;
+ while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
+ switch (verb) {
+ case SkPath::kMove_Verb:
+ case SkPath::kLine_Verb:
+ case SkPath::kQuad_Verb:
+ case SkPath::kCubic_Verb:
+ storage[count++] = pts[0];
+ break;
+ default:
+ break;
+ }
+ }
+ return count;
+}
+
+#include "SkPathMeasure.h"
+
+class TestStrokeView : public SampleView {
+ enum {
+ SKELETON_COLOR = 0xFF0000FF,
+ WIREFRAME_COLOR = 0x80FF0000
+ };
+
+ enum {
+ kCount = 9
+ };
+ SkPoint fPts[kCount];
+ SkScalar fWidth, fDWidth;
+public:
+ TestStrokeView() {
+ this->setBGColor(SK_ColorLTGRAY);
+
+ fPts[0].set(50, 200);
+ fPts[1].set(50, 100);
+ fPts[2].set(150, 50);
+ fPts[3].set(300, 50);
+
+ fPts[4].set(350, 200);
+ fPts[5].set(350, 100);
+ fPts[6].set(450, 50);
+
+ fPts[7].set(200, 200);
+ fPts[8].set(400, 400);
+
+ fWidth = 50;
+ fDWidth = 0.25f;
+ }
+
+protected:
+ virtual bool onQuery(SkEvent* evt) SK_OVERRIDE {
+ if (SampleCode::TitleQ(*evt)) {
+ SampleCode::TitleR(evt, "RotateCircles3");
+ return true;
+ }
+ return this->INHERITED::onQuery(evt);
+ }
+
+ void draw_points(SkCanvas* canvas, const SkPath& path, SkColor color,
+ bool show_lines) {
+ SkPaint paint;
+ paint.setColor(color);
+ paint.setAlpha(0x80);
+
+ int n = path.countPoints();
+ SkAutoSTArray<32, SkPoint> pts(n);
+ if (show_lines) {
+ path.getPoints(pts.get(), n);
+ canvas->drawPoints(SkCanvas::kPolygon_PointMode, n, pts.get(), paint);
+ } else {
+ n = getOnCurvePoints(path, pts.get());
+ }
+ paint.setStrokeWidth(5);
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, n, pts.get(), paint);
+ }
+
+ void draw_ribs(SkCanvas* canvas, const SkPath& path, SkScalar width,
+ SkColor color) {
+ const SkScalar radius = width / 2;
+
+ SkPathMeasure meas(path, false);
+ SkScalar total = meas.getLength();
+
+ SkScalar delta = 8;
+ SkPaint paint;
+ paint.setColor(color);
+
+ SkPoint pos, tan;
+ for (SkScalar dist = 0; dist <= total; dist += delta) {
+ (void)meas.getPosTan(dist, &pos, &tan);
+ tan.scale(radius);
+ tan.rotateCCW();
+ canvas->drawLine(pos.x() + tan.x(), pos.y() + tan.y(),
+ pos.x() - tan.x(), pos.y() - tan.y(), paint);
+ }
+ }
+
+ void draw_stroke(SkCanvas* canvas, const SkPath& path, SkScalar width) {
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setStyle(SkPaint::kStroke_Style);
+
+ paint.setColor(SKELETON_COLOR);
+ canvas->drawPath(path, paint);
+ draw_points(canvas, path, SKELETON_COLOR, true);
+
+ draw_ribs(canvas, path, width, 0xFF00FF00);
+
+ SkPath fill;
+
+ SkPaint p;
+ p.setStyle(SkPaint::kStroke_Style);
+ p.setStrokeWidth(width);
+ p.getFillPath(path, &fill);
+
+ paint.setColor(WIREFRAME_COLOR);
+ canvas->drawPath(fill, paint);
+ draw_points(canvas, fill, WIREFRAME_COLOR, false);
+ }
+
+ virtual void onDrawContent(SkCanvas* canvas) {
+ SkPath path;
+ SkScalar width = fWidth;
+
+ path.moveTo(fPts[0]);
+ path.cubicTo(fPts[1], fPts[2], fPts[3]);
+ draw_stroke(canvas, path, width);
+
+ path.reset();
+ path.moveTo(fPts[4]);
+ path.quadTo(fPts[5], fPts[6]);
+ draw_stroke(canvas, path, width);
+
+ SkScalar rad = 32;
+ SkRect r;
+ r.set(&fPts[7], 2);
+ path.reset();
+ SkRRect rr;
+ rr.setRectXY(r, rad, rad);
+ path.addRRect(rr);
+ draw_stroke(canvas, path, width);
+
+ path.reset();
+ SkRRect rr2;
+ rr.inset(width/2, width/2, &rr2);
+ path.addRRect(rr2, SkPath::kCCW_Direction);
+ rr.inset(-width/2, -width/2, &rr2);
+ path.addRRect(rr2, SkPath::kCW_Direction);
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setColor(0x40FF8844);
+ canvas->drawPath(path, paint);
+
+ fWidth += fDWidth;
+ if (fDWidth > 0 && fWidth > 100) {
+ fDWidth = -fDWidth;
+ } else if (fDWidth < 0 && fWidth < 10) {
+ fDWidth = -fDWidth;
+ }
+ this->inval(NULL);
+ }
+
+ class MyClick : public Click {
+ public:
+ int fIndex;
+ MyClick(SkView* target, int index) : Click(target), fIndex(index) {}
+ };
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+ for (size_t i = 0; i < SK_ARRAY_COUNT(fPts); ++i) {
+ if (hittest(fPts[i], x, y)) {
+ return new MyClick(this, i);
+ }
+ }
+ return this->INHERITED::onFindClickHandler(x, y);
+ }
+
+ virtual bool onClick(Click* click) {
+ int index = ((MyClick*)click)->fIndex;
+ fPts[index].offset(click->fICurr.fX - click->fIPrev.fX,
+ click->fICurr.fY - click->fIPrev.fY);
+ this->inval(NULL);
+ return true;
+ }
+
+private:
+ typedef SkView INHERITED;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
static SkView* F0() { return new RotateCirclesView; }
static SkViewRegister gR0(F0);
+static SkView* F1() { return new TestCirclesView; }
+static SkViewRegister gR1(F1);
+static SkView* F2() { return new TestStrokeView; }
+static SkViewRegister gR2(F2);