case 1: {
sk_sp<SkPathEffect> a = make_path_effect(false);
sk_sp<SkPathEffect> b = make_path_effect(false);
- pathEffect = SkComposePathEffect::Make(a, b);
+ pathEffect = SkPathEffect::MakeCompose(a, b);
break;
}
case 2: {
default: {
sk_sp<SkPathEffect> a = make_path_effect(false);
sk_sp<SkPathEffect> b = make_path_effect(false);
- pathEffect = SkSumPathEffect::Make(a, b);
+ pathEffect = SkPathEffect::MakeCompose(a, b);
break;
}
}
sk_sp<SkPathEffect> corner = SkCornerPathEffect::Make(25);
sk_sp<SkPathEffect> compose;
if (pe) {
- compose = SkComposePathEffect::Make(sk_ref_sp(pe), corner);
+ compose = SkPathEffect::MakeCompose(sk_ref_sp(pe), corner);
} else {
compose = corner;
}
"SK_SUPPORT_EXOTIC_CLIPOPS",
"SK_SUPPORT_LEGACY_CANVAS_HELPERS",
"SK_SUPPORT_LEGACY_PAINT_TEXTDECORATION",
+ "SK_SUPPORT_LEGACY_PATHEFFECT_SUBCLASSES",
]
-
/*
* Copyright 2006 The Android Open Source Project
*
* found in the LICENSE file.
*/
-
#ifndef SkPathEffect_DEFINED
#define SkPathEffect_DEFINED
*/
class SK_API SkPathEffect : public SkFlattenable {
public:
+ static sk_sp<SkPathEffect> MakeSum(sk_sp<SkPathEffect> first, sk_sp<SkPathEffect> second);
+ static sk_sp<SkPathEffect> MakeCompose(sk_sp<SkPathEffect> outer, sk_sp<SkPathEffect> inner);
+
/**
* Given a src path (input) and a stroke-rec (input and output), apply
* this effect to the src path, returning the new path in dst, and return
virtual bool exposedInAndroidJavaAPI() const { return false; }
#endif
+ SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP()
+
protected:
SkPathEffect() {}
typedef SkFlattenable INHERITED;
};
+#ifdef SK_SUPPORT_LEGACY_PATHEFFECT_SUBCLASSES
+
/** \class SkPairPathEffect
Common baseclass for Compose and Sum. This subclass manages two pathEffects,
// illegal
SkComposePathEffect(const SkComposePathEffect&);
SkComposePathEffect& operator=(const SkComposePathEffect&);
+ friend class SkPathEffect;
typedef SkPairPathEffect INHERITED;
};
// illegal
SkSumPathEffect(const SkSumPathEffect&);
SkSumPathEffect& operator=(const SkSumPathEffect&);
+ friend class SkPathEffect;
typedef SkPairPathEffect INHERITED;
};
+#endif
#endif
"SK_NO_ANALYTIC_AA",
"SK_SUPPORT_LEGACY_BITMAP_SETPIXELREF",
"SK_SUPPORT_LEGACY_CLIPOP_EXOTIC_NAMES",
+ "SK_SUPPORT_LEGACY_PATHEFFECT_SUBCLASSES",
]
################################################################################
gPhase, SkPath1DPathEffect::kRotate_Style);
auto inner = SkDiscretePathEffect::Make(SkIntToScalar(2),
SkIntToScalar(1)/10); // SkCornerPathEffect(SkIntToScalar(2));
- return SkComposePathEffect::Make(outer, inner);
+ return SkPathEffect::MakeCompose(outer, inner);
}
sk_sp<SkShader> shaderTest() {
pathEffect = SkArcToPathEffect::Make(make_scalar(true));
break;
case 1:
- pathEffect = SkComposePathEffect::Make(make_path_effect(false),
+ pathEffect = SkPathEffect::MakeCompose(make_path_effect(false),
make_path_effect(false));
break;
case 2:
break;
case 8:
default:
- pathEffect = SkSumPathEffect::Make(make_path_effect(false),
+ pathEffect = SkPathEffect::MakeSum(make_path_effect(false),
make_path_effect(false));
break;
}
auto inner = SkCornerPathEffect::Make(SkIntToScalar(CORNER_RADIUS));
- return SkComposePathEffect::Make(outer, inner);
+ return SkPathEffect::MakeCompose(outer, inner);
}
static sk_sp<SkPathEffect> make_warp_pe(SkScalar phase) {
path, 12, phase, SkPath1DPathEffect::kMorph_Style);
auto inner = SkCornerPathEffect::Make(SkIntToScalar(CORNER_RADIUS));
- return SkComposePathEffect::Make(outer, inner);
+ return SkPathEffect::MakeCompose(outer, inner);
}
///////////////////////////////////////////////////////////
sk_sp<SkPathEffect> corner = SkCornerPathEffect::Make(25);
sk_sp<SkPathEffect> compose;
if (pe) {
- compose = SkComposePathEffect::Make(sk_ref_sp(pe), corner);
+ compose = SkPathEffect::MakeCompose(sk_ref_sp(pe), corner);
} else {
compose = corner;
}
SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLocalMatrixShader)
SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkPictureShader)
- // PathEffect
- SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkComposePathEffect)
// ImageFilter
SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkMatrixImageFilter)
- // ColorFilter
SkColorFilter::InitializeFlattenables();
-
+ SkPathEffect::InitializeFlattenables();
SkShader::InitializeFlattenables();
-
- // Xfermode
SkXfermode::InitializeFlattenables();
// Drawable
///////////////////////////////////////////////////////////////////////////////
+#ifndef SK_SUPPORT_LEGACY_PATHEFFECT_SUBCLASSES
+
+/** \class SkPairPathEffect
+
+ Common baseclass for Compose and Sum. This subclass manages two pathEffects,
+ including flattening them. It does nothing in filterPath, and is only useful
+ for managing the lifetimes of its two arguments.
+ */
+class SK_API SkPairPathEffect : public SkPathEffect {
+protected:
+ SkPairPathEffect(sk_sp<SkPathEffect> pe0, sk_sp<SkPathEffect> pe1);
+
+ void flatten(SkWriteBuffer&) const override;
+
+ // these are visible to our subclasses
+ sk_sp<SkPathEffect> fPE0;
+ sk_sp<SkPathEffect> fPE1;
+
+ SK_TO_STRING_OVERRIDE()
+
+private:
+ typedef SkPathEffect INHERITED;
+};
+
+/** \class SkComposePathEffect
+
+ This subclass of SkPathEffect composes its two arguments, to create
+ a compound pathEffect.
+ */
+class SK_API SkComposePathEffect : public SkPairPathEffect {
+public:
+ /** Construct a pathEffect whose effect is to apply first the inner pathEffect
+ and the the outer pathEffect (e.g. outer(inner(path)))
+ The reference counts for outer and inner are both incremented in the constructor,
+ and decremented in the destructor.
+ */
+ static sk_sp<SkPathEffect> Make(sk_sp<SkPathEffect> outer, sk_sp<SkPathEffect> inner) {
+ if (!outer) {
+ return inner;
+ }
+ if (!inner) {
+ return outer;
+ }
+ return sk_sp<SkPathEffect>(new SkComposePathEffect(outer, inner));
+ }
+
+ virtual bool filterPath(SkPath* dst, const SkPath& src,
+ 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 override { return true; }
+#endif
+
+protected:
+ SkComposePathEffect(sk_sp<SkPathEffect> outer, sk_sp<SkPathEffect> inner)
+ : INHERITED(outer, inner) {}
+
+private:
+ // illegal
+ SkComposePathEffect(const SkComposePathEffect&);
+ SkComposePathEffect& operator=(const SkComposePathEffect&);
+ friend class SkPathEffect;
+
+ typedef SkPairPathEffect INHERITED;
+};
+
+/** \class SkSumPathEffect
+
+ This subclass of SkPathEffect applies two pathEffects, one after the other.
+ Its filterPath() returns true if either of the effects succeeded.
+ */
+class SK_API SkSumPathEffect : public SkPairPathEffect {
+public:
+ /** Construct a pathEffect whose effect is to apply two effects, in sequence.
+ (e.g. first(path) + second(path))
+ The reference counts for first and second are both incremented in the constructor,
+ and decremented in the destructor.
+ */
+ static sk_sp<SkPathEffect> Make(sk_sp<SkPathEffect> first, sk_sp<SkPathEffect> second) {
+ if (!first) {
+ return second;
+ }
+ if (!second) {
+ return first;
+ }
+ return sk_sp<SkPathEffect>(new SkSumPathEffect(first, second));
+ }
+
+ virtual bool filterPath(SkPath* dst, const SkPath& src,
+ 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 override { return true; }
+#endif
+
+protected:
+ SkSumPathEffect(sk_sp<SkPathEffect> first, sk_sp<SkPathEffect> second)
+ : INHERITED(first, second) {}
+
+private:
+ // illegal
+ SkSumPathEffect(const SkSumPathEffect&);
+ SkSumPathEffect& operator=(const SkSumPathEffect&);
+ friend class SkPathEffect;
+
+ typedef SkPairPathEffect INHERITED;
+};
+#endif
+
SkPairPathEffect::SkPairPathEffect(sk_sp<SkPathEffect> pe0, sk_sp<SkPathEffect> pe1)
: fPE0(std::move(pe0)), fPE1(std::move(pe1))
{
str->appendf(")");
}
#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+sk_sp<SkPathEffect> SkPathEffect::MakeSum(sk_sp<SkPathEffect> first, sk_sp<SkPathEffect> second) {
+ return SkSumPathEffect::Make(std::move(first), std::move(second));
+}
+
+sk_sp<SkPathEffect> SkPathEffect::MakeCompose(sk_sp<SkPathEffect> outer,
+ sk_sp<SkPathEffect> inner) {
+ return SkComposePathEffect::Make(std::move(outer), std::move(inner));
+}
+
+SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkPathEffect)
+ SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkComposePathEffect)
+ SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSumPathEffect)
+SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkPath1DPathEffect)
SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLine2DPathEffect)
SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkPath2DPathEffect)
- SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSumPathEffect)
// ImageFilter
SkImageFilter::InitializeFlattenables();