fState = kPath_State;
}
+ bool operator==(const Rec& b) const {
+ if (fSaveCount != b.fSaveCount || fOp != b.fOp || fState != b.fState) {
+ return false;
+ }
+ switch (fState) {
+ case kEmpty_State:
+ return true;
+ case kRect_State:
+ return fRect == b.fRect;
+ case kPath_State:
+ return fPath == b.fPath;
+ }
+ return false; // Silence the compiler.
+ }
+
+ bool operator!=(const Rec& b) const {
+ return !(*this == b);
+ }
+
+
/**
* Returns true if this Rec can be intersected in place with a new clip
*/
bool canBeIntersected(int saveCount, SkRegion::Op op) const {
- if (kEmpty_State == fState) {
+ if (kEmpty_State == fState && (
+ SkRegion::kDifference_Op == op ||
+ SkRegion::kIntersect_Op == op)) {
return true;
}
return fSaveCount == saveCount &&
fSaveCount = 0;
}
+SkClipStack::SkClipStack(const SkClipStack& b) : fDeque(sizeof(Rec)) {
+ *this = b;
+}
+
+SkClipStack& SkClipStack::operator=(const SkClipStack& b) {
+ if (this == &b) {
+ return *this;
+ }
+ reset();
+
+ fSaveCount = b.fSaveCount;
+ SkDeque::F2BIter recIter(b.fDeque);
+ for (const Rec* rec = (const Rec*)recIter.next();
+ rec != NULL;
+ rec = (const Rec*)recIter.next()) {
+ new (fDeque.push_back()) Rec(*rec);
+ }
+
+ return *this;
+}
+
+bool SkClipStack::operator==(const SkClipStack& b) const {
+ if (fSaveCount != b.fSaveCount || fDeque.count() != b.fDeque.count()) {
+ return false;
+ }
+ SkDeque::F2BIter myIter(fDeque);
+ SkDeque::F2BIter bIter(b.fDeque);
+ const Rec* myRec = (const Rec*)myIter.next();
+ const Rec* bRec = (const Rec*)bIter.next();
+
+ while (myRec != NULL && bRec != NULL) {
+ if (*myRec != *bRec) {
+ return false;
+ }
+ myRec = (const Rec*)myIter.next();
+ bRec = (const Rec*)bIter.next();
+ }
+ return myRec == NULL && bRec == NULL;
+}
+
void SkClipStack::reset() {
// don't have a reset() on SkDeque, so fake it here
fDeque.~SkDeque();
#include "Test.h"
#include "SkClipStack.h"
+#include "SkPath.h"
+#include "SkRect.h"
+
+static void test_assign_and_comparison(skiatest::Reporter* reporter) {
+ SkClipStack s;
+
+ // Build up a clip stack with a path, an empty clip, and a rect.
+ s.save();
+ SkPath p;
+ p.moveTo(5, 6);
+ p.lineTo(7, 8);
+ p.lineTo(5, 9);
+ p.close();
+ s.clipDevPath(p);
+
+ s.save();
+ SkRect r = SkRect::MakeLTRB(1, 2, 3, 4);
+ s.clipDevRect(r);
+ r = SkRect::MakeLTRB(10, 11, 12, 13);
+ s.clipDevRect(r);
+
+ s.save();
+ r = SkRect::MakeLTRB(14, 15, 16, 17);
+ s.clipDevRect(r, SkRegion::kUnion_Op);
+
+ // Test that assignment works.
+ SkClipStack copy = s;
+ REPORTER_ASSERT(reporter, s == copy);
+
+ // Test that different save levels triggers not equal.
+ s.restore();
+ REPORTER_ASSERT(reporter, s != copy);
+
+ // Test that an equal, but not copied version is equal.
+ s.save();
+ r = SkRect::MakeLTRB(14, 15, 16, 17);
+ s.clipDevRect(r, SkRegion::kUnion_Op);
+ REPORTER_ASSERT(reporter, s == copy);
+
+ // Test that a different op on one level triggers not equal.
+ s.restore();
+ s.save();
+ r = SkRect::MakeLTRB(14, 15, 16, 17);
+ s.clipDevRect(r);
+ REPORTER_ASSERT(reporter, s != copy);
+
+ // Test that different state (clip type) triggers not equal.
+ s.restore();
+ s.save();
+ SkPath rp;
+ rp.addRect(r);
+ s.clipDevPath(rp, SkRegion::kUnion_Op);
+ REPORTER_ASSERT(reporter, s != copy);
+
+ // Test that different rects triggers not equal.
+ s.restore();
+ s.save();
+ r = SkRect::MakeLTRB(24, 25, 26, 27);
+ s.clipDevRect(r, SkRegion::kUnion_Op);
+ REPORTER_ASSERT(reporter, s != copy);
+
+ // Sanity check
+ s.restore();
+ copy.restore();
+ REPORTER_ASSERT(reporter, s == copy);
+ s.restore();
+ copy.restore();
+ REPORTER_ASSERT(reporter, s == copy);
+
+ // Test that different paths triggers not equal.
+ s.restore();
+ s.save();
+ p.addRect(r);
+ s.clipDevPath(p);
+ REPORTER_ASSERT(reporter, s != copy);
+}
static void assert_count(skiatest::Reporter* reporter, const SkClipStack& stack,
int count) {
stack.reset();
assert_count(reporter, stack, 0);
+
+ test_assign_and_comparison(reporter);
}
#include "TestClassDef.h"