AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
82d619699d
skia2/samplecode/SampleAAGeometry.cpp
John Stiles 30212b7941 Fix implicit fallthroughs throughout Skia. 
This CL is not fully comprehensive; for instance, it does not contain
fixes for backends that don't compile on Mac. But it does resolve the
vast majority of cases that trigger -Wimplicit-fallthrough.

A few minor bugs were found and fixed, but none that were likely to
affect normal operation.

Change-Id: I43487602b0d56200ce8b42702e04f66390d82f60
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/295916
Reviewed-by: Mike Klein <mtklein@google.com>
Commit-Queue: John Stiles <johnstiles@google.com>
2020-06-11 22:29:53 +00:00

1766 lines
60 KiB
C++
Raw Blame History

/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkString.h"
#include "include/private/SkMacros.h"
#include "include/utils/SkTextUtils.h"
#include "samplecode/Sample.h"
#include "src/core/SkGeometry.h"
#include "src/core/SkPathPriv.h"
#include "src/core/SkPointPriv.h"
#include "src/pathops/SkIntersections.h"
#include "src/pathops/SkOpEdgeBuilder.h"
#include "tools/ToolUtils.h"
#if 0
void SkStrokeSegment::dump() const {
SkDebugf("{{{%1.9g,%1.9g}, {%1.9g,%1.9g}", fPts[0].fX, fPts[0].fY, fPts[1].fX, fPts[1].fY);
if (SkPath::kQuad_Verb == fVerb) {
SkDebugf(", {%1.9g,%1.9g}", fPts[2].fX, fPts[2].fY);
}
SkDebugf("}}");
#ifdef SK_DEBUG
SkDebugf(" id=%d", fDebugID);
#endif
SkDebugf("\n");
}
void SkStrokeSegment::dumpAll() const {
const SkStrokeSegment* segment = this;
while (segment) {
segment->dump();
segment = segment->fNext;
}
}
void SkStrokeTriple::dump() const {
SkDebugf("{{{%1.9g,%1.9g}, {%1.9g,%1.9g}", fPts[0].fX, fPts[0].fY, fPts[1].fX, fPts[1].fY);
if (SkPath::kQuad_Verb <= fVerb) {
SkDebugf(", {%1.9g,%1.9g}", fPts[2].fX, fPts[2].fY);
}
if (SkPath::kCubic_Verb == fVerb) {
SkDebugf(", {%1.9g,%1.9g}", fPts[3].fX, fPts[3].fY);
} else if (SkPath::kConic_Verb == fVerb) {
SkDebugf(", %1.9g", weight());
}
SkDebugf("}}");
#ifdef SK_DEBUG
SkDebugf(" triple id=%d", fDebugID);
#endif
SkDebugf("\ninner:\n");
fInner->dumpAll();
SkDebugf("outer:\n");
fOuter->dumpAll();
SkDebugf("join:\n");
fJoin->dumpAll();
}
void SkStrokeTriple::dumpAll() const {
const SkStrokeTriple* triple = this;
while (triple) {
triple->dump();
triple = triple->fNext;
}
}
void SkStrokeContour::dump() const {
#ifdef SK_DEBUG
SkDebugf("id=%d ", fDebugID);
#endif
SkDebugf("head:\n");
fHead->dumpAll();
SkDebugf("head cap:\n");
fHeadCap->dumpAll();
SkDebugf("tail cap:\n");
fTailCap->dumpAll();
}
void SkStrokeContour::dumpAll() const {
const SkStrokeContour* contour = this;
while (contour) {
contour->dump();
contour = contour->fNext;
}
}
#endif
SkScalar gCurveDistance = 10;
#if 0 // unused
static SkPath::Verb get_path_verb(int index, const SkPath& path) {
if (index < 0) {
return SkPath::kMove_Verb;
}
SkPoint pts[4];
SkPath::Verb verb;
SkPath::Iter iter(path, true);
int counter = -1;
while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
if (++counter < index) {
continue;
}
return verb;
}
SkASSERT(0);
return SkPath::kMove_Verb;
}
#endif
static SkScalar get_path_weight(int index, const SkPath& path) {
SkPoint pts[4];
SkPath::Verb verb;
SkPath::Iter iter(path, true);
int counter = -1;
while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
if (++counter < index) {
continue;
}
return verb == SkPath::kConic_Verb ? iter.conicWeight() : 1;
}
SkASSERT(0);
return 0;
}
static void add_path_segment(int index, SkPath* path) {
SkPath result;
SkPoint firstPt = { 0, 0 }; // init to avoid warning
SkPoint lastPt = { 0, 0 }; // init to avoid warning
int counter = -1;
SkPoint chop[7];
SkConic conicChop[2];
for (auto [verb, pts, w] : SkPathPriv::Iterate(*path)) {
if (++counter == index) {
switch (verb) {
case SkPathVerb::kLine:
result.lineTo((pts[0].fX + pts[1].fX) / 2, (pts[0].fY + pts[1].fY) / 2);
break;
case SkPathVerb::kQuad: {
SkChopQuadAtHalf(pts, chop);
result.quadTo(chop[1], chop[2]);
pts = chop + 2;
} break;
case SkPathVerb::kConic: {
SkConic conic;
conic.set(pts, *w);
if (!conic.chopAt(0.5f, conicChop)) {
return;
}
result.conicTo(conicChop[0].fPts[1], conicChop[0].fPts[2], conicChop[0].fW);
pts = conicChop[1].fPts;
w = &conicChop[1].fW;
} break;
case SkPathVerb::kCubic: {
SkChopCubicAtHalf(pts, chop);
result.cubicTo(chop[1], chop[2], chop[3]);
pts = chop + 3;
} break;
case SkPathVerb::kClose: {
result.lineTo((lastPt.fX + firstPt.fX) / 2, (lastPt.fY + firstPt.fY) / 2);
} break;
default:
SkASSERT(0);
}
}
switch (verb) {
case SkPathVerb::kMove:
result.moveTo(firstPt = pts[0]);
break;
case SkPathVerb::kLine:
result.lineTo(lastPt = pts[1]);
break;
case SkPathVerb::kQuad:
result.quadTo(pts[1], lastPt = pts[2]);
break;
case SkPathVerb::kConic:
result.conicTo(pts[1], lastPt = pts[2], *w);
break;
case SkPathVerb::kCubic:
result.cubicTo(pts[1], pts[2], lastPt = pts[3]);
break;
case SkPathVerb::kClose:
result.close();
break;
default:
SkASSERT(0);
}
}
*path = result;
}
static void delete_path_segment(int index, SkPath* path) {
SkPath result;
int counter = -1;
for (auto [verb, pts, w] : SkPathPriv::Iterate(*path)) {
if (++counter == index) {
continue;
}
switch (verb) {
case SkPathVerb::kMove:
result.moveTo(pts[0]);
break;
case SkPathVerb::kLine:
result.lineTo(pts[1]);
break;
case SkPathVerb::kQuad:
result.quadTo(pts[1], pts[2]);
break;
case SkPathVerb::kConic:
result.conicTo(pts[1], pts[2], *w);
break;
case SkPathVerb::kCubic:
result.cubicTo(pts[1], pts[2], pts[3]);
break;
case SkPathVerb::kClose:
result.close();
break;
default:
SkASSERT(0);
}
}
*path = result;
}
static void set_path_weight(int index, SkScalar w, SkPath* path) {
SkPath result;
SkPoint pts[4];
SkPath::Verb verb;
SkPath::Iter iter(*path, true);
int counter = -1;
while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
++counter;
switch (verb) {
case SkPath::kMove_Verb:
result.moveTo(pts[0]);
break;
case SkPath::kLine_Verb:
result.lineTo(pts[1]);
break;
case SkPath::kQuad_Verb:
result.quadTo(pts[1], pts[2]);
break;
case SkPath::kConic_Verb:
result.conicTo(pts[1], pts[2], counter == index ? w : iter.conicWeight());
break;
case SkPath::kCubic_Verb:
result.cubicTo(pts[1], pts[2], pts[3]);
break;
case SkPath::kClose_Verb:
result.close();
break;
case SkPath::kDone_Verb:
break;
default:
SkASSERT(0);
}
}
*path = result;
}
static void set_path_verb(int index, SkPath::Verb v, SkPath* path, SkScalar w) {
SkASSERT(SkPath::kLine_Verb <= v && v <= SkPath::kCubic_Verb);
SkPath result;
SkPoint pts[4];
SkPath::Verb verb;
SkPath::Iter iter(*path, true);
int counter = -1;
while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
SkScalar weight = verb == SkPath::kConic_Verb ? iter.conicWeight() : 1;
if (++counter == index && v != verb) {
SkASSERT(SkPath::kLine_Verb <= verb && verb <= SkPath::kCubic_Verb);
switch (verb) {
case SkPath::kLine_Verb:
switch (v) {
case SkPath::kConic_Verb:
weight = w;
[[fallthrough]];
case SkPath::kQuad_Verb:
pts[2] = pts[1];
pts[1].fX = (pts[0].fX + pts[2].fX) / 2;
pts[1].fY = (pts[0].fY + pts[2].fY) / 2;
break;
case SkPath::kCubic_Verb:
pts[3] = pts[1];
pts[1].fX = (pts[0].fX * 2 + pts[3].fX) / 3;
pts[1].fY = (pts[0].fY * 2 + pts[3].fY) / 3;
pts[2].fX = (pts[0].fX + pts[3].fX * 2) / 3;
pts[2].fY = (pts[0].fY + pts[3].fY * 2) / 3;
break;
default:
SkASSERT(0);
break;
}
break;
case SkPath::kQuad_Verb:
case SkPath::kConic_Verb:
switch (v) {
case SkPath::kLine_Verb:
pts[1] = pts[2];
break;
case SkPath::kConic_Verb:
weight = w;
[[fallthrough]];
case SkPath::kQuad_Verb:
break;
case SkPath::kCubic_Verb: {
SkDQuad dQuad;
dQuad.set(pts);
SkDCubic dCubic = dQuad.debugToCubic();
pts[3] = pts[2];
pts[1] = dCubic[1].asSkPoint();
pts[2] = dCubic[2].asSkPoint();
} break;
default:
SkASSERT(0);
break;
}
break;
case SkPath::kCubic_Verb:
switch (v) {
case SkPath::kLine_Verb:
pts[1] = pts[3];
break;
case SkPath::kConic_Verb:
weight = w;
[[fallthrough]];
case SkPath::kQuad_Verb: {
SkDCubic dCubic;
dCubic.set(pts);
SkDQuad dQuad = dCubic.toQuad();
pts[1] = dQuad[1].asSkPoint();
pts[2] = pts[3];
} break;
default:
SkASSERT(0);
break;
}
break;
default:
SkASSERT(0);
break;
}
verb = v;
}
switch (verb) {
case SkPath::kMove_Verb:
result.moveTo(pts[0]);
break;
case SkPath::kLine_Verb:
result.lineTo(pts[1]);
break;
case SkPath::kQuad_Verb:
result.quadTo(pts[1], pts[2]);
break;
case SkPath::kConic_Verb:
result.conicTo(pts[1], pts[2], weight);
break;
case SkPath::kCubic_Verb:
result.cubicTo(pts[1], pts[2], pts[3]);
break;
case SkPath::kClose_Verb:
result.close();
break;
default:
SkASSERT(0);
break;
}
}
*path = result;
}
static void add_to_map(SkScalar coverage, int x, int y, uint8_t* distanceMap, int w, int h) {
int byteCoverage = (int) (coverage * 256);
if (byteCoverage < 0) {
byteCoverage = 0;
} else if (byteCoverage > 255) {
byteCoverage = 255;
}
SkASSERT(x < w);
SkASSERT(y < h);
distanceMap[y * w + x] = std::max(distanceMap[y * w + x], (uint8_t) byteCoverage);
}
static void filter_coverage(const uint8_t* map, int len, uint8_t min, uint8_t max,
uint8_t* filter) {
for (int index = 0; index < len; ++index) {
uint8_t in = map[index];
filter[index] = in < min ? 0 : max < in ? 0 : in;
}
}
static void construct_path(SkPath& path) {
path.reset();
path.moveTo(442, 101.5f);
path.quadTo(413.5f, 691, 772, 514);
path.lineTo(346, 721.5f);
path.lineTo(154, 209);
path.lineTo(442, 101.5f);
path.close();
}
struct ButtonPaints {
static const int kMaxStateCount = 3;
SkPaint fDisabled;
SkPaint fStates[kMaxStateCount];
SkFont fLabelFont;
ButtonPaints() {
fStates[0].setAntiAlias(true);
fStates[0].setStyle(SkPaint::kStroke_Style);
fStates[0].setColor(0xFF3F0000);
fStates[1] = fStates[0];
fStates[1].setStrokeWidth(3);
fStates[2] = fStates[1];
fStates[2].setColor(0xFFcf0000);
fLabelFont.setSize(25.0f);
}
};
struct Button {
SkRect fBounds;
int fStateCount;
int fState;
char fLabel;
bool fVisible;
Button(char label) {
fStateCount = 2;
fState = 0;
fLabel = label;
fVisible = false;
}
Button(char label, int stateCount) {
SkASSERT(stateCount <= ButtonPaints::kMaxStateCount);
fStateCount = stateCount;
fState = 0;
fLabel = label;
fVisible = false;
}
bool contains(const SkRect& rect) {
return fVisible && fBounds.contains(rect);
}
bool enabled() {
return SkToBool(fState);
}
void draw(SkCanvas* canvas, const ButtonPaints& paints) {
if (!fVisible) {
return;
}
canvas->drawRect(fBounds, paints.fStates[fState]);
SkTextUtils::Draw(canvas, &fLabel, 1, SkTextEncoding::kUTF8, fBounds.centerX(), fBounds.fBottom - 5,
paints.fLabelFont, SkPaint(), SkTextUtils::kCenter_Align);
}
void toggle() {
if (++fState == fStateCount) {
fState = 0;
}
}
void setEnabled(bool enabled) {
fState = (int) enabled;
}
};
struct ControlPaints {
SkPaint fOutline;
SkPaint fIndicator;
SkPaint fFill;
SkPaint fLabel;
SkPaint fValue;
SkFont fLabelFont;
SkFont fValueFont;
ControlPaints() {
fOutline.setAntiAlias(true);
fOutline.setStyle(SkPaint::kStroke_Style);
fIndicator = fOutline;
fIndicator.setColor(SK_ColorRED);
fFill.setAntiAlias(true);
fFill.setColor(0x7fff0000);
fLabel.setAntiAlias(true);
fLabelFont.setSize(13.0f);
fValue.setAntiAlias(true);
fValueFont.setSize(11.0f);
}
};
struct UniControl {
SkString fName;
SkRect fBounds;
SkScalar fMin;
SkScalar fMax;
SkScalar fValLo;
SkScalar fYLo;
bool fVisible;
UniControl(const char* name, SkScalar min, SkScalar max) {
fName = name;
fValLo = fMin = min;
fMax = max;
fVisible = false;
}
virtual ~UniControl() {}
bool contains(const SkRect& rect) {
return fVisible && fBounds.contains(rect);
}
virtual void draw(SkCanvas* canvas, const ControlPaints& paints) {
if (!fVisible) {
return;
}
canvas->drawRect(fBounds, paints.fOutline);
fYLo = fBounds.fTop + (fValLo - fMin) * fBounds.height() / (fMax - fMin);
canvas->drawLine(fBounds.fLeft - 5, fYLo, fBounds.fRight + 5, fYLo, paints.fIndicator);
SkString label;
label.printf("%0.3g", fValLo);
canvas->drawString(label, fBounds.fLeft + 5, fYLo - 5, paints.fValueFont, paints.fValue);
canvas->drawString(fName, fBounds.fLeft, fBounds.bottom() + 11, paints.fLabelFont,
paints.fLabel);
}
};
struct BiControl : public UniControl {
SkScalar fValHi;
BiControl(const char* name, SkScalar min, SkScalar max)
: UniControl(name, min, max)
, fValHi(fMax) {
}
virtual ~BiControl() {}
virtual void draw(SkCanvas* canvas, const ControlPaints& paints) {
UniControl::draw(canvas, paints);
if (!fVisible || fValHi == fValLo) {
return;
}
SkScalar yPos = fBounds.fTop + (fValHi - fMin) * fBounds.height() / (fMax - fMin);
canvas->drawLine(fBounds.fLeft - 5, yPos, fBounds.fRight + 5, yPos, paints.fIndicator);
SkString label;
label.printf("%0.3g", fValHi);
if (yPos < fYLo + 10) {
yPos = fYLo + 10;
}
canvas->drawString(label, fBounds.fLeft + 5, yPos - 5, paints.fValueFont, paints.fValue);
SkRect fill = { fBounds.fLeft, fYLo, fBounds.fRight, yPos };
canvas->drawRect(fill, paints.fFill);
}
};
class MyClick : public Sample::Click {
public:
enum ClickType {
kInvalidType = -1,
kPtType,
kVerbType,
kControlType,
kPathType,
} fType;
enum ControlType {
kInvalidControl = -1,
kFirstControl,
kFilterControl = kFirstControl,
kResControl,
kWeightControl,
kWidthControl,
kLastControl = kWidthControl,
kFirstButton,
kCubicButton = kFirstButton,
kConicButton,
kQuadButton,
kLineButton,
kLastVerbButton = kLineButton,
kAddButton,
kDeleteButton,
kInOutButton,
kFillButton,
kSkeletonButton,
kFilterButton,
kBisectButton,
kJoinButton,
kLastButton = kJoinButton,
kPathMove,
} fControl;
SkPath::Verb fVerb;
SkScalar fWeight;
MyClick(ClickType type, ControlType control)
: fType(type)
, fControl(control)
, fVerb((SkPath::Verb) -1)
, fWeight(1) {
}
MyClick(ClickType type, int index)
: fType(type)
, fControl((ControlType) index)
, fVerb((SkPath::Verb) -1)
, fWeight(1) {
}
MyClick(ClickType type, int index, SkPath::Verb verb, SkScalar weight)
: fType(type)
, fControl((ControlType) index)
, fVerb(verb)
, fWeight(weight) {
}
bool isButton() {
return kFirstButton <= fControl && fControl <= kLastButton;
}
int ptHit() const {
SkASSERT(fType == kPtType);
return (int) fControl;
}
int verbHit() const {
SkASSERT(fType == kVerbType);
return (int) fControl;
}
};
enum {
kControlCount = MyClick::kLastControl - MyClick::kFirstControl + 1,
};
static struct ControlPair {
UniControl* fControl;
MyClick::ControlType fControlType;
} kControlList[kControlCount];
enum {
kButtonCount = MyClick::kLastButton - MyClick::kFirstButton + 1,
kVerbCount = MyClick::kLastVerbButton - MyClick::kFirstButton + 1,
};
static struct ButtonPair {
Button* fButton;
MyClick::ControlType fButtonType;
} kButtonList[kButtonCount];
static void enable_verb_button(MyClick::ControlType type) {
for (int index = 0; index < kButtonCount; ++index) {
MyClick::ControlType testType = kButtonList[index].fButtonType;
if (MyClick::kFirstButton <= testType && testType <= MyClick::kLastVerbButton) {
Button* button = kButtonList[index].fButton;
button->setEnabled(testType == type);
}
}
}
struct Stroke;
struct Active {
Active* fNext;
Stroke* fParent;
SkScalar fStart;
SkScalar fEnd;
void reset() {
fNext = nullptr;
fStart = 0;
fEnd = 1;
}
};
struct Stroke {
SkPath fPath;
Active fActive;
bool fInner;
void reset() {
fPath.reset();
fActive.reset();
}
};
struct PathUndo {
SkPath fPath;
std::unique_ptr<PathUndo> fNext;
};
class AAGeometryView : public Sample {
SkPaint fActivePaint;
SkPaint fComplexPaint;
SkPaint fCoveragePaint;
SkFont fLegendLeftFont;
SkFont fLegendRightFont;
SkPaint fPointPaint;
SkPaint fSkeletonPaint;
SkPaint fLightSkeletonPaint;
SkPath fPath;
ControlPaints fControlPaints;
UniControl fResControl;
UniControl fWeightControl;
UniControl fWidthControl;
BiControl fFilterControl;
ButtonPaints fButtonPaints;
Button fCubicButton;
Button fConicButton;
Button fQuadButton;
Button fLineButton;
Button fAddButton;
Button fDeleteButton;
Button fFillButton;
Button fSkeletonButton;
Button fFilterButton;
Button fBisectButton;
Button fJoinButton;
Button fInOutButton;
SkTArray<Stroke> fStrokes;
std::unique_ptr<PathUndo> fUndo;
int fActivePt;
int fActiveVerb;
bool fHandlePathMove;
bool fShowLegend;
bool fHideAll;
const int kHitToleranace = 25;
public:
AAGeometryView()
: fResControl("error", 0, 10)
, fWeightControl("weight", 0, 5)
, fWidthControl("width", FLT_EPSILON, 100)
, fFilterControl("filter", 0, 255)
, fCubicButton('C')
, fConicButton('K')
, fQuadButton('Q')
, fLineButton('L')
, fAddButton('+')
, fDeleteButton('x')
, fFillButton('p')
, fSkeletonButton('s')
, fFilterButton('f', 3)
, fBisectButton('b')
, fJoinButton('j')
, fInOutButton('|')
, fActivePt(-1)
, fActiveVerb(-1)
, fHandlePathMove(true)
, fShowLegend(false)
, fHideAll(false)
{
fCoveragePaint.setAntiAlias(true);
fCoveragePaint.setColor(SK_ColorBLUE);
SkPaint strokePaint;
strokePaint.setAntiAlias(true);
strokePaint.setStyle(SkPaint::kStroke_Style);
fPointPaint = strokePaint;
fPointPaint.setColor(0x99ee3300);
fSkeletonPaint = strokePaint;
fSkeletonPaint.setColor(SK_ColorRED);
fLightSkeletonPaint = fSkeletonPaint;
fLightSkeletonPaint.setColor(0xFFFF7f7f);
fActivePaint = strokePaint;
fActivePaint.setColor(0x99ee3300);
fActivePaint.setStrokeWidth(5);
fComplexPaint = fActivePaint;
fComplexPaint.setColor(SK_ColorBLUE);
fLegendLeftFont.setSize(13);
fLegendRightFont = fLegendLeftFont;
construct_path(fPath);
fFillButton.fVisible = fSkeletonButton.fVisible = fFilterButton.fVisible
= fBisectButton.fVisible = fJoinButton.fVisible = fInOutButton.fVisible = true;
fSkeletonButton.setEnabled(true);
fInOutButton.setEnabled(true);
fJoinButton.setEnabled(true);
fFilterControl.fValLo = 120;
fFilterControl.fValHi = 141;
fFilterControl.fVisible = fFilterButton.fState == 2;
fResControl.fValLo = 5;
fResControl.fVisible = true;
fWidthControl.fValLo = 50;
fWidthControl.fVisible = true;
init_controlList();
init_buttonList();
}
~AAGeometryView() override {
// Free linked list without deep recursion.
std::unique_ptr<PathUndo> undo = std::move(fUndo);
while (undo) {
undo = std::move(undo->fNext);
}
}
bool constructPath() {
construct_path(fPath);
return true;
}
void savePath(skui::InputState state) {
if (state != skui::InputState::kDown) {
return;
}
if (fUndo && fUndo->fPath == fPath) {
return;
}
std::unique_ptr<PathUndo> undo(new PathUndo);
undo->fPath = fPath;
undo->fNext = std::move(fUndo);
fUndo = std::move(undo);
}
bool undo() {
if (!fUndo) {
return false;
}
fPath = std::move(fUndo->fPath);
fUndo = std::move(fUndo->fNext);
validatePath();
return true;
}
void validatePath() {}
void set_controlList(int index, UniControl* control, MyClick::ControlType type) {
kControlList[index].fControl = control;
kControlList[index].fControlType = type;
}
#define SET_CONTROL(Name) set_controlList(index++, &f##Name##Control, \
MyClick::k##Name##Control)
bool hideAll() {
fHideAll ^= true;
return true;
}
void init_controlList() {
int index = 0;
SET_CONTROL(Width);
SET_CONTROL(Res);
SET_CONTROL(Filter);
SET_CONTROL(Weight);
}
#undef SET_CONTROL
void set_buttonList(int index, Button* button, MyClick::ControlType type) {
kButtonList[index].fButton = button;
kButtonList[index].fButtonType = type;
}
#define SET_BUTTON(Name) set_buttonList(index++, &f##Name##Button, \
MyClick::k##Name##Button)
void init_buttonList() {
int index = 0;
SET_BUTTON(Fill);
SET_BUTTON(Skeleton);
SET_BUTTON(Filter);
SET_BUTTON(Bisect);
SET_BUTTON(Join);
SET_BUTTON(InOut);
SET_BUTTON(Cubic);
SET_BUTTON(Conic);
SET_BUTTON(Quad);
SET_BUTTON(Line);
SET_BUTTON(Add);
SET_BUTTON(Delete);
}
#undef SET_BUTTON
SkString name() override { return SkString("AAGeometry"); }
bool onChar(SkUnichar) override;
void onSizeChange() override {
setControlButtonsPos();
this->INHERITED::onSizeChange();
}
bool pathDump() {
fPath.dump();
return true;
}
bool scaleDown() {
SkMatrix matrix;
SkRect bounds = fPath.getBounds();
matrix.setScale(1.f / 1.5f, 1.f / 1.5f, bounds.centerX(), bounds.centerY());
fPath.transform(matrix);
validatePath();
return true;
}
bool scaleToFit() {
SkMatrix matrix;
SkRect bounds = fPath.getBounds();
SkScalar scale = std::min(this->width() / bounds.width(), this->height() / bounds.height())
* 0.8f;
matrix.setScale(scale, scale, bounds.centerX(), bounds.centerY());
fPath.transform(matrix);
bounds = fPath.getBounds();
SkScalar offsetX = (this->width() - bounds.width()) / 2 - bounds.fLeft;
SkScalar offsetY = (this->height() - bounds.height()) / 2 - bounds.fTop;
fPath.offset(offsetX, offsetY);
validatePath();
return true;
}
bool scaleUp() {
SkMatrix matrix;
SkRect bounds = fPath.getBounds();
matrix.setScale(1.5f, 1.5f, bounds.centerX(), bounds.centerY());
fPath.transform(matrix);
validatePath();
return true;
}
void setControlButtonsPos() {
SkScalar widthOffset = this->width() - 100;
for (int index = 0; index < kControlCount; ++index) {
if (kControlList[index].fControl->fVisible) {
kControlList[index].fControl->fBounds.setXYWH(widthOffset, 30, 30, 400);
widthOffset -= 50;
}
}
SkScalar buttonOffset = 0;
for (int index = 0; index < kButtonCount; ++index) {
kButtonList[index].fButton->fBounds.setXYWH(this->width() - 50,
buttonOffset += 50, 30, 30);
}
}
bool showLegend() {
fShowLegend ^= true;
return true;
}
void draw_bisect(SkCanvas* canvas, const SkVector& lastVector, const SkVector& vector,
const SkPoint& pt) {
SkVector lastV = lastVector;
SkScalar lastLen = lastVector.length();
SkVector nextV = vector;
SkScalar nextLen = vector.length();
if (lastLen < nextLen) {
lastV.setLength(nextLen);
} else {
nextV.setLength(lastLen);
}
SkVector bisect = { (lastV.fX + nextV.fX) / 2, (lastV.fY + nextV.fY) / 2 };
bisect.setLength(fWidthControl.fValLo * 2);
if (fBisectButton.enabled()) {
canvas->drawLine(pt, pt + bisect, fSkeletonPaint);
}
lastV.setLength(fWidthControl.fValLo);
if (fBisectButton.enabled()) {
canvas->drawLine(pt, {pt.fX - lastV.fY, pt.fY + lastV.fX}, fSkeletonPaint);
}
nextV.setLength(fWidthControl.fValLo);
if (fBisectButton.enabled()) {
canvas->drawLine(pt, {pt.fX + nextV.fY, pt.fY - nextV.fX}, fSkeletonPaint);
}
if (fJoinButton.enabled()) {
SkScalar r = fWidthControl.fValLo;
SkRect oval = { pt.fX - r, pt.fY - r, pt.fX + r, pt.fY + r};
SkScalar startAngle = SkScalarATan2(lastV.fX, -lastV.fY) * 180.f / SK_ScalarPI;
SkScalar endAngle = SkScalarATan2(-nextV.fX, nextV.fY) * 180.f / SK_ScalarPI;
if (endAngle > startAngle) {
canvas->drawArc(oval, startAngle, endAngle - startAngle, false, fSkeletonPaint);
} else {
canvas->drawArc(oval, startAngle, 360 - (startAngle - endAngle), false,
fSkeletonPaint);
}
}
}
void draw_bisects(SkCanvas* canvas, bool activeOnly) {
SkVector firstVector, lastVector, nextLast, vector;
SkPoint pts[4];
SkPoint firstPt = { 0, 0 }; // init to avoid warning;
SkPath::Verb verb;
SkPath::Iter iter(fPath, true);
bool foundFirst = false;
int counter = -1;
while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
++counter;
if (activeOnly && counter != fActiveVerb && counter - 1 != fActiveVerb
&& counter + 1 != fActiveVerb
&& (fActiveVerb != 1 || counter != fPath.countVerbs())) {
continue;
}
switch (verb) {
case SkPath::kLine_Verb:
nextLast = pts[0] - pts[1];
vector = pts[1] - pts[0];
break;
case SkPath::kQuad_Verb: {
nextLast = pts[1] - pts[2];
if (SkScalarNearlyZero(nextLast.length())) {
nextLast = pts[0] - pts[2];
}
vector = pts[1] - pts[0];
if (SkScalarNearlyZero(vector.length())) {
vector = pts[2] - pts[0];
}
if (!fBisectButton.enabled()) {
break;
}
SkScalar t = SkFindQuadMaxCurvature(pts);
if (0 < t && t < 1) {
SkPoint maxPt = SkEvalQuadAt(pts, t);
SkVector tangent = SkEvalQuadTangentAt(pts, t);
tangent.setLength(fWidthControl.fValLo * 2);
canvas->drawLine(maxPt, {maxPt.fX + tangent.fY, maxPt.fY - tangent.fX},
fSkeletonPaint);
}
} break;
case SkPath::kConic_Verb:
nextLast = pts[1] - pts[2];
if (SkScalarNearlyZero(nextLast.length())) {
nextLast = pts[0] - pts[2];
}
vector = pts[1] - pts[0];
if (SkScalarNearlyZero(vector.length())) {
vector = pts[2] - pts[0];
}
if (!fBisectButton.enabled()) {
break;
}
// FIXME : need max curvature or equivalent here
break;
case SkPath::kCubic_Verb: {
nextLast = pts[2] - pts[3];
if (SkScalarNearlyZero(nextLast.length())) {
nextLast = pts[1] - pts[3];
if (SkScalarNearlyZero(nextLast.length())) {
nextLast = pts[0] - pts[3];
}
}
vector = pts[0] - pts[1];
if (SkScalarNearlyZero(vector.length())) {
vector = pts[0] - pts[2];
if (SkScalarNearlyZero(vector.length())) {
vector = pts[0] - pts[3];
}
}
if (!fBisectButton.enabled()) {
break;
}
SkScalar tMax[2];
int tMaxCount = SkFindCubicMaxCurvature(pts, tMax);
for (int tIndex = 0; tIndex < tMaxCount; ++tIndex) {
if (0 >= tMax[tIndex] || tMax[tIndex] >= 1) {
continue;
}
SkPoint maxPt;
SkVector tangent;
SkEvalCubicAt(pts, tMax[tIndex], &maxPt, &tangent, nullptr);
tangent.setLength(fWidthControl.fValLo * 2);
canvas->drawLine(maxPt, {maxPt.fX + tangent.fY, maxPt.fY - tangent.fX},
fSkeletonPaint);
}
} break;
case SkPath::kClose_Verb:
if (foundFirst) {
draw_bisect(canvas, lastVector, firstVector, firstPt);
foundFirst = false;
}
break;
default:
break;
}
if (SkPath::kLine_Verb <= verb && verb <= SkPath::kCubic_Verb) {
if (!foundFirst) {
firstPt = pts[0];
firstVector = vector;
foundFirst = true;
} else {
draw_bisect(canvas, lastVector, vector, pts[0]);
}
lastVector = nextLast;
}
}
}
void draw_legend(SkCanvas* canvas);
void draw_segment(SkCanvas* canvas) {
SkPoint pts[4];
SkPath::Verb verb;
SkPath::Iter iter(fPath, true);
int counter = -1;
while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
if (++counter < fActiveVerb) {
continue;
}
switch (verb) {
case SkPath::kLine_Verb:
canvas->drawPoints(SkCanvas::kLines_PointMode, 2, pts, fActivePaint);
draw_points(canvas, pts, 2);
break;
case SkPath::kQuad_Verb: {
SkPath qPath;
qPath.moveTo(pts[0]);
qPath.quadTo(pts[1], pts[2]);
canvas->drawPath(qPath, fActivePaint);
draw_points(canvas, pts, 3);
} break;
case SkPath::kConic_Verb: {
SkPath conicPath;
conicPath.moveTo(pts[0]);
conicPath.conicTo(pts[1], pts[2], iter.conicWeight());
canvas->drawPath(conicPath, fActivePaint);
draw_points(canvas, pts, 3);
} break;
case SkPath::kCubic_Verb: {
SkScalar loopT[3];
int complex = SkDCubic::ComplexBreak(pts, loopT);
SkPath cPath;
cPath.moveTo(pts[0]);
cPath.cubicTo(pts[1], pts[2], pts[3]);
canvas->drawPath(cPath, complex ? fComplexPaint : fActivePaint);
draw_points(canvas, pts, 4);
} break;
default:
break;
}
return;
}
}
void draw_points(SkCanvas* canvas, SkPoint* points, int count) {
for (int index = 0; index < count; ++index) {
canvas->drawCircle(points[index].fX, points[index].fY, 10, fPointPaint);
}
}
int hittest_verb(SkPoint pt, SkPath::Verb* verbPtr, SkScalar* weight) {
SkIntersections i;
SkDLine hHit = {{{pt.fX - kHitToleranace, pt.fY }, {pt.fX + kHitToleranace, pt.fY}}};
SkDLine vHit = {{{pt.fX, pt.fY - kHitToleranace }, {pt.fX, pt.fY + kHitToleranace}}};
SkPoint pts[4];
SkPath::Verb verb;
SkPath::Iter iter(fPath, true);
int counter = -1;
while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
++counter;
switch (verb) {
case SkPath::kLine_Verb: {
SkDLine line;
line.set(pts);
if (i.intersect(line, hHit) || i.intersect(line, vHit)) {
*verbPtr = verb;
*weight = 1;
return counter;
}
} break;
case SkPath::kQuad_Verb: {
SkDQuad quad;
quad.set(pts);
if (i.intersect(quad, hHit) || i.intersect(quad, vHit)) {
*verbPtr = verb;
*weight = 1;
return counter;
}
} break;
case SkPath::kConic_Verb: {
SkDConic conic;
SkScalar w = iter.conicWeight();
conic.set(pts, w);
if (i.intersect(conic, hHit) || i.intersect(conic, vHit)) {
*verbPtr = verb;
*weight = w;
return counter;
}
} break;
case SkPath::kCubic_Verb: {
SkDCubic cubic;
cubic.set(pts);
if (i.intersect(cubic, hHit) || i.intersect(cubic, vHit)) {
*verbPtr = verb;
*weight = 1;
return counter;
}
} break;
default:
break;
}
}
return -1;
}
SkScalar pt_to_line(SkPoint s, SkPoint e, int x, int y) {
SkScalar radius = fWidthControl.fValLo;
SkVector adjOpp = e - s;
SkScalar lenSq = SkPointPriv::LengthSqd(adjOpp);
SkPoint rotated = {
(y - s.fY) * adjOpp.fY + (x - s.fX) * adjOpp.fX,
(y - s.fY) * adjOpp.fX - (x - s.fX) * adjOpp.fY,
};
if (rotated.fX < 0 || rotated.fX > lenSq) {
return -radius;
}
rotated.fY /= SkScalarSqrt(lenSq);
return std::max(-radius, std::min(radius, rotated.fY));
}
// given a line, compute the interior and exterior gradient coverage
bool coverage(SkPoint s, SkPoint e, uint8_t* distanceMap, int w, int h) {
SkScalar radius = fWidthControl.fValLo;
int minX = std::max(0, (int) (std::min(s.fX, e.fX) - radius));
int minY = std::max(0, (int) (std::min(s.fY, e.fY) - radius));
int maxX = std::min(w, (int) (std::max(s.fX, e.fX) + radius) + 1);
int maxY = std::min(h, (int) (std::max(s.fY, e.fY) + radius) + 1);
for (int y = minY; y < maxY; ++y) {
for (int x = minX; x < maxX; ++x) {
SkScalar ptToLineDist = pt_to_line(s, e, x, y);
if (ptToLineDist > -radius && ptToLineDist < radius) {
SkScalar coverage = ptToLineDist / radius;
add_to_map(1 - SkScalarAbs(coverage), x, y, distanceMap, w, h);
}
SkVector ptToS = { x - s.fX, y - s.fY };
SkScalar dist = ptToS.length();
if (dist < radius) {
SkScalar coverage = dist / radius;
add_to_map(1 - SkScalarAbs(coverage), x, y, distanceMap, w, h);
}
SkVector ptToE = { x - e.fX, y - e.fY };
dist = ptToE.length();
if (dist < radius) {
SkScalar coverage = dist / radius;
add_to_map(1 - SkScalarAbs(coverage), x, y, distanceMap, w, h);
}
}
}
return true;
}
void quad_coverage(SkPoint pts[3], uint8_t* distanceMap, int w, int h) {
SkScalar dist = pts[0].Distance(pts[0], pts[2]);
if (dist < gCurveDistance) {
(void) coverage(pts[0], pts[2], distanceMap, w, h);
return;
}
SkPoint split[5];
SkChopQuadAt(pts, split, 0.5f);
quad_coverage(&split[0], distanceMap, w, h);
quad_coverage(&split[2], distanceMap, w, h);
}
void conic_coverage(SkPoint pts[3], SkScalar weight, uint8_t* distanceMap, int w, int h) {
SkScalar dist = pts[0].Distance(pts[0], pts[2]);
if (dist < gCurveDistance) {
(void) coverage(pts[0], pts[2], distanceMap, w, h);
return;
}
SkConic split[2];
SkConic conic;
conic.set(pts, weight);
if (conic.chopAt(0.5f, split)) {
conic_coverage(split[0].fPts, split[0].fW, distanceMap, w, h);
conic_coverage(split[1].fPts, split[1].fW, distanceMap, w, h);
}
}
void cubic_coverage(SkPoint pts[4], uint8_t* distanceMap, int w, int h) {
SkScalar dist = pts[0].Distance(pts[0], pts[3]);
if (dist < gCurveDistance) {
(void) coverage(pts[0], pts[3], distanceMap, w, h);
return;
}
SkPoint split[7];
SkChopCubicAt(pts, split, 0.5f);
cubic_coverage(&split[0], distanceMap, w, h);
cubic_coverage(&split[3], distanceMap, w, h);
}
void path_coverage(const SkPath& path, uint8_t* distanceMap, int w, int h) {
memset(distanceMap, 0, sizeof(distanceMap[0]) * w * h);
SkPoint pts[4];
SkPath::Verb verb;
SkPath::Iter iter(path, true);
while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
switch (verb) {
case SkPath::kLine_Verb:
(void) coverage(pts[0], pts[1], distanceMap, w, h);
break;
case SkPath::kQuad_Verb:
quad_coverage(pts, distanceMap, w, h);
break;
case SkPath::kConic_Verb:
conic_coverage(pts, iter.conicWeight(), distanceMap, w, h);
break;
case SkPath::kCubic_Verb:
cubic_coverage(pts, distanceMap, w, h);
break;
default:
break;
}
}
}
static uint8_t* set_up_dist_map(const SkImageInfo& imageInfo, SkBitmap* distMap) {
distMap->setInfo(imageInfo);
distMap->setIsVolatile(true);
SkAssertResult(distMap->tryAllocPixels());
SkASSERT((int) distMap->rowBytes() == imageInfo.width());
return distMap->getAddr8(0, 0);
}
void path_stroke(int index, SkPath* inner, SkPath* outer) {
#if 0
SkPathStroker stroker(fPath, fWidthControl.fValLo, 0,
SkPaint::kRound_Cap, SkPaint::kRound_Join, fResControl.fValLo);
SkPoint pts[4], firstPt, lastPt;
SkPath::Verb verb;
SkPath::Iter iter(fPath, true);
int counter = -1;
while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
++counter;
switch (verb) {
case SkPath::kMove_Verb:
firstPt = pts[0];
break;
case SkPath::kLine_Verb:
if (counter == index) {
stroker.moveTo(pts[0]);
stroker.lineTo(pts[1]);
goto done;
}
lastPt = pts[1];
break;
case SkPath::kQuad_Verb:
if (counter == index) {
stroker.moveTo(pts[0]);
stroker.quadTo(pts[1], pts[2]);
goto done;
}
lastPt = pts[2];
break;
case SkPath::kConic_Verb:
if (counter == index) {
stroker.moveTo(pts[0]);
stroker.conicTo(pts[1], pts[2], iter.conicWeight());
goto done;
}
lastPt = pts[2];
break;
case SkPath::kCubic_Verb:
if (counter == index) {
stroker.moveTo(pts[0]);
stroker.cubicTo(pts[1], pts[2], pts[3]);
goto done;
}
lastPt = pts[3];
break;
case SkPath::kClose_Verb:
if (counter == index) {
stroker.moveTo(lastPt);
stroker.lineTo(firstPt);
goto done;
}
break;
case SkPath::kDone_Verb:
break;
default:
SkASSERT(0);
}
}
done:
*inner = stroker.fInner;
*outer = stroker.fOuter;
#endif
}
void draw_stroke(SkCanvas* canvas, int active) {
SkPath inner, outer;
path_stroke(active, &inner, &outer);
canvas->drawPath(inner, fSkeletonPaint);
canvas->drawPath(outer, fSkeletonPaint);
}
void gather_strokes() {
fStrokes.reset();
for (int index = 0; index < fPath.countVerbs(); ++index) {
Stroke& inner = fStrokes.push_back();
inner.reset();
inner.fInner = true;
Stroke& outer = fStrokes.push_back();
outer.reset();
outer.fInner = false;
path_stroke(index, &inner.fPath, &outer.fPath);
}
}
void trim_strokes() {
// eliminate self-itersecting loops
// trim outside edges
gather_strokes();
for (int index = 0; index < fStrokes.count(); ++index) {
SkPath& outPath = fStrokes[index].fPath;
for (int inner = 0; inner < fStrokes.count(); ++inner) {
if (index == inner) {
continue;
}
SkPath& inPath = fStrokes[inner].fPath;
if (!outPath.getBounds().intersects(inPath.getBounds())) {
continue;
}
}
}
}
void onDrawContent(SkCanvas* canvas) override {
#if 0
SkDEBUGCODE(SkDebugStrokeGlobals debugGlobals);
SkOpAA aaResult(fPath, fWidthControl.fValLo, fResControl.fValLo
SkDEBUGPARAMS(&debugGlobals));
#endif
SkPath strokePath;
// aaResult.simplify(&strokePath);
canvas->drawPath(strokePath, fSkeletonPaint);
SkRect bounds = fPath.getBounds();
SkScalar radius = fWidthControl.fValLo;
int w = (int) (bounds.fRight + radius + 1);
int h = (int) (bounds.fBottom + radius + 1);
SkImageInfo imageInfo = SkImageInfo::MakeA8(w, h);
SkBitmap distMap;
uint8_t* distanceMap = set_up_dist_map(imageInfo, &distMap);
path_coverage(fPath, distanceMap, w, h);
if (fFillButton.enabled()) {
canvas->drawPath(fPath, fCoveragePaint);
}
if (fFilterButton.fState == 2
&& (0 < fFilterControl.fValLo || fFilterControl.fValHi < 255)) {
SkBitmap filteredMap;
uint8_t* filtered = set_up_dist_map(imageInfo, &filteredMap);
filter_coverage(distanceMap, sizeof(uint8_t) * w * h, (uint8_t) fFilterControl.fValLo,
(uint8_t) fFilterControl.fValHi, filtered);
canvas->drawBitmap(filteredMap, 0, 0, &fCoveragePaint);
} else if (fFilterButton.enabled()) {
canvas->drawBitmap(distMap, 0, 0, &fCoveragePaint);
}
if (fSkeletonButton.enabled()) {
canvas->drawPath(fPath, fActiveVerb >= 0 ? fLightSkeletonPaint : fSkeletonPaint);
}
if (fActiveVerb >= 0) {
draw_segment(canvas);
}
if (fBisectButton.enabled() || fJoinButton.enabled()) {
draw_bisects(canvas, fActiveVerb >= 0);
}
if (fInOutButton.enabled()) {
if (fActiveVerb >= 0) {
draw_stroke(canvas, fActiveVerb);
} else {
for (int index = 0; index < fPath.countVerbs(); ++index) {
draw_stroke(canvas, index);
}
}
}
if (fHideAll) {
return;
}
for (int index = 0; index < kControlCount; ++index) {
kControlList[index].fControl->draw(canvas, fControlPaints);
}
for (int index = 0; index < kButtonCount; ++index) {
kButtonList[index].fButton->draw(canvas, fButtonPaints);
}
if (fShowLegend) {
draw_legend(canvas);
}
#if 0
SkPaint paint;
paint.setARGB(255, 34, 31, 31);
paint.setAntiAlias(true);
SkPath path;
path.moveTo(18,439);
path.lineTo(414,439);
path.lineTo(414,702);
path.lineTo(18,702);
path.lineTo(18,439);
path.moveTo(19,701);
path.lineTo(413,701);
path.lineTo(413,440);
path.lineTo(19,440);
path.lineTo(19,701);
path.close();
canvas->drawPath(path, paint);
canvas->scale(1.0f, -1.0f);
canvas->translate(0.0f, -800.0f);
canvas->drawPath(path, paint);
#endif
}
int hittest_pt(SkPoint pt) {
for (int index = 0; index < fPath.countPoints(); ++index) {
if (SkPoint::Distance(fPath.getPoint(index), pt) <= kHitToleranace * 2) {
return index;
}
}
return -1;
}
virtual Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey modi) override {
SkPoint pt = {x, y};
int ptHit = hittest_pt(pt);
if (ptHit >= 0) {
return new MyClick(MyClick::kPtType, ptHit);
}
SkPath::Verb verb;
SkScalar weight;
int verbHit = hittest_verb(pt, &verb, &weight);
if (verbHit >= 0) {
return new MyClick(MyClick::kVerbType, verbHit, verb, weight);
}
if (!fHideAll) {
const SkRect& rectPt = SkRect::MakeXYWH(x, y, 1, 1);
for (int index = 0; index < kControlCount; ++index) {
if (kControlList[index].fControl->contains(rectPt)) {
return new MyClick(MyClick::kControlType,
kControlList[index].fControlType);
}
}
for (int index = 0; index < kButtonCount; ++index) {
if (kButtonList[index].fButton->contains(rectPt)) {
return new MyClick(MyClick::kControlType, kButtonList[index].fButtonType);
}
}
}
fLineButton.fVisible = fQuadButton.fVisible = fConicButton.fVisible
= fCubicButton.fVisible = fWeightControl.fVisible = fAddButton.fVisible
= fDeleteButton.fVisible = false;
fActiveVerb = -1;
fActivePt = -1;
if (fHandlePathMove) {
return new MyClick(MyClick::kPathType, MyClick::kPathMove);
}
return nullptr;
}
static SkScalar MapScreenYtoValue(int y, const UniControl& control) {
return std::min(1.f, std::max(0.f,
SkIntToScalar(y) - control.fBounds.fTop) / control.fBounds.height())
* (control.fMax - control.fMin) + control.fMin;
}
bool onClick(Click* click) override {
MyClick* myClick = (MyClick*) click;
switch (myClick->fType) {
case MyClick::kPtType: {
savePath(click->fState);
fActivePt = myClick->ptHit();
SkPoint pt = fPath.getPoint((int) myClick->fControl);
pt.offset(SkIntToScalar(click->fCurr.fX - click->fPrev.fX),
SkIntToScalar(click->fCurr.fY - click->fPrev.fY));
SkPathPriv::UpdatePathPoint(&fPath, fActivePt, pt);
validatePath();
return true;
}
case MyClick::kPathType:
savePath(click->fState);
fPath.offset(SkIntToScalar(click->fCurr.fX - click->fPrev.fX),
SkIntToScalar(click->fCurr.fY - click->fPrev.fY));
validatePath();
return true;
case MyClick::kVerbType: {
fActiveVerb = myClick->verbHit();
fLineButton.fVisible = fQuadButton.fVisible = fConicButton.fVisible
= fCubicButton.fVisible = fAddButton.fVisible = fDeleteButton.fVisible
= true;
fLineButton.setEnabled(myClick->fVerb == SkPath::kLine_Verb);
fQuadButton.setEnabled(myClick->fVerb == SkPath::kQuad_Verb);
fConicButton.setEnabled(myClick->fVerb == SkPath::kConic_Verb);
fCubicButton.setEnabled(myClick->fVerb == SkPath::kCubic_Verb);
fWeightControl.fValLo = myClick->fWeight;
fWeightControl.fVisible = myClick->fVerb == SkPath::kConic_Verb;
} break;
case MyClick::kControlType: {
if (click->fState != skui::InputState::kDown && myClick->isButton()) {
return true;
}
switch (myClick->fControl) {
case MyClick::kFilterControl: {
SkScalar val = MapScreenYtoValue(click->fCurr.fY, fFilterControl);
if (val - fFilterControl.fValLo < fFilterControl.fValHi - val) {
fFilterControl.fValLo = std::max(0.f, val);
} else {
fFilterControl.fValHi = std::min(255.f, val);
}
} break;
case MyClick::kResControl:
fResControl.fValLo = MapScreenYtoValue(click->fCurr.fY, fResControl);
break;
case MyClick::kWeightControl: {
savePath(click->fState);
SkScalar w = MapScreenYtoValue(click->fCurr.fY, fWeightControl);
set_path_weight(fActiveVerb, w, &fPath);
validatePath();
fWeightControl.fValLo = w;
} break;
case MyClick::kWidthControl:
fWidthControl.fValLo = MapScreenYtoValue(click->fCurr.fY, fWidthControl);
break;
case MyClick::kLineButton:
savePath(click->fState);
enable_verb_button(myClick->fControl);
fWeightControl.fVisible = false;
set_path_verb(fActiveVerb, SkPath::kLine_Verb, &fPath, 1);
validatePath();
break;
case MyClick::kQuadButton:
savePath(click->fState);
enable_verb_button(myClick->fControl);
fWeightControl.fVisible = false;
set_path_verb(fActiveVerb, SkPath::kQuad_Verb, &fPath, 1);
validatePath();
break;
case MyClick::kConicButton: {
savePath(click->fState);
enable_verb_button(myClick->fControl);
fWeightControl.fVisible = true;
const SkScalar defaultConicWeight = 1.f / SkScalarSqrt(2);
set_path_verb(fActiveVerb, SkPath::kConic_Verb, &fPath, defaultConicWeight);
validatePath();
fWeightControl.fValLo = get_path_weight(fActiveVerb, fPath);
} break;
case MyClick::kCubicButton:
savePath(click->fState);
enable_verb_button(myClick->fControl);
fWeightControl.fVisible = false;
set_path_verb(fActiveVerb, SkPath::kCubic_Verb, &fPath, 1);
validatePath();
break;
case MyClick::kAddButton:
savePath(click->fState);
add_path_segment(fActiveVerb, &fPath);
validatePath();
if (fWeightControl.fVisible) {
fWeightControl.fValLo = get_path_weight(fActiveVerb, fPath);
}
break;
case MyClick::kDeleteButton:
savePath(click->fState);
delete_path_segment(fActiveVerb, &fPath);
validatePath();
break;
case MyClick::kFillButton:
fFillButton.toggle();
break;
case MyClick::kSkeletonButton:
fSkeletonButton.toggle();
break;
case MyClick::kFilterButton:
fFilterButton.toggle();
fFilterControl.fVisible = fFilterButton.fState == 2;
break;
case MyClick::kBisectButton:
fBisectButton.toggle();
break;
case MyClick::kJoinButton:
fJoinButton.toggle();
break;
case MyClick::kInOutButton:
fInOutButton.toggle();
break;
default:
SkASSERT(0);
break;
}
} break;
default:
SkASSERT(0);
break;
}
setControlButtonsPos();
return true;
}
private:
typedef Sample INHERITED;
};
static struct KeyCommand {
char fKey;
char fAlternate;
const char* fDescriptionL;
const char* fDescriptionR;
bool (AAGeometryView::*fFunction)();
} kKeyCommandList[] = {
{ ' ', 0, "space", "center path", &AAGeometryView::scaleToFit },
{ '-', 0, "-", "zoom out", &AAGeometryView::scaleDown },
{ '+', '=', "+/=", "zoom in", &AAGeometryView::scaleUp },
{ 'D', 0, "D", "dump to console", &AAGeometryView::pathDump },
{ 'H', 0, "H", "hide controls", &AAGeometryView::hideAll },
{ 'R', 0, "R", "reset path", &AAGeometryView::constructPath },
{ 'Z', 0, "Z", "undo", &AAGeometryView::undo },
{ '?', 0, "?", "show legend", &AAGeometryView::showLegend },
};
const int kKeyCommandCount = (int) SK_ARRAY_COUNT(kKeyCommandList);
void AAGeometryView::draw_legend(SkCanvas* canvas) {
SkScalar bottomOffset = this->height() - 10;
for (int index = kKeyCommandCount - 1; index >= 0; --index) {
bottomOffset -= 15;
SkTextUtils::DrawString(canvas, kKeyCommandList[index].fDescriptionL, this->width() - 160, bottomOffset,
fLegendLeftFont, SkPaint());
SkTextUtils::DrawString(canvas, kKeyCommandList[index].fDescriptionR,
this->width() - 20, bottomOffset,
fLegendRightFont, SkPaint(), SkTextUtils::kRight_Align);
}
}
bool AAGeometryView::onChar(SkUnichar uni) {
for (int index = 0; index < kButtonCount; ++index) {
Button* button = kButtonList[index].fButton;
if (button->fVisible && uni == button->fLabel) {
MyClick click(MyClick::kControlType, kButtonList[index].fButtonType);
click.fState = skui::InputState::kDown;
(void) this->onClick(&click);
return true;
}
}
for (int index = 0; index < kKeyCommandCount; ++index) {
KeyCommand& keyCommand = kKeyCommandList[index];
if (uni == keyCommand.fKey || uni == keyCommand.fAlternate) {
return (this->*keyCommand.fFunction)();
}
}
if (('A' <= uni && uni <= 'Z') || ('a' <= uni && uni <= 'z')) {
for (int index = 0; index < kButtonCount; ++index) {
Button* button = kButtonList[index].fButton;
if (button->fVisible && (uni & ~0x20) == (button->fLabel & ~0x20)) {
MyClick click(MyClick::kControlType, kButtonList[index].fButtonType);
click.fState = skui::InputState::kDown;
(void) this->onClick(&click);
return true;
}
}
}
return false;
}
DEF_SAMPLE( return new AAGeometryView; )
Reference in New Issue View Git Blame Copy Permalink