1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
/*
* Copyright 2013 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkBitmap.h"
#include "SkColorFilter.h"
#include "SkPaintPriv.h"
#include "SkImage.h"
#include "SkPaint.h"
#include "SkShaderBase.h"
#include "SkUtils.h"
#include "SkXfermodePriv.h"
static bool changes_alpha(const SkPaint& paint) {
SkColorFilter* cf = paint.getColorFilter();
return cf && !(cf->getFlags() & SkColorFilter::kAlphaUnchanged_Flag);
}
bool SkPaintPriv::Overwrites(const SkPaint* paint, ShaderOverrideOpacity overrideOpacity) {
if (!paint) {
// No paint means we default to SRC_OVER, so we overwrite iff our shader-override
// is opaque, or we don't have one.
return overrideOpacity != kNotOpaque_ShaderOverrideOpacity;
}
SkXfermode::SrcColorOpacity opacityType = SkXfermode::kUnknown_SrcColorOpacity;
if (!changes_alpha(*paint)) {
const unsigned paintAlpha = paint->getAlpha();
if (0xff == paintAlpha && overrideOpacity != kNotOpaque_ShaderOverrideOpacity &&
(!paint->getShader() || paint->getShader()->isOpaque()))
{
opacityType = SkXfermode::kOpaque_SrcColorOpacity;
} else if (0 == paintAlpha) {
if (overrideOpacity == kNone_ShaderOverrideOpacity && !paint->getShader()) {
opacityType = SkXfermode::kTransparentBlack_SrcColorOpacity;
} else {
opacityType = SkXfermode::kTransparentAlpha_SrcColorOpacity;
}
}
}
return SkXfermode::IsOpaque(paint->getBlendMode(), opacityType);
}
bool SkPaintPriv::Overwrites(const SkBitmap& bitmap, const SkPaint* paint) {
return Overwrites(paint, bitmap.isOpaque() ? kOpaque_ShaderOverrideOpacity
: kNotOpaque_ShaderOverrideOpacity);
}
bool SkPaintPriv::Overwrites(const SkImage* image, const SkPaint* paint) {
return Overwrites(paint, image->isOpaque() ? kOpaque_ShaderOverrideOpacity
: kNotOpaque_ShaderOverrideOpacity);
}
void SkPaintPriv::ScaleFontMetrics(SkPaint::FontMetrics* metrics, SkScalar scale) {
metrics->fTop *= scale;
metrics->fAscent *= scale;
metrics->fDescent *= scale;
metrics->fBottom *= scale;
metrics->fLeading *= scale;
metrics->fAvgCharWidth *= scale;
metrics->fMaxCharWidth *= scale;
metrics->fXMin *= scale;
metrics->fXMax *= scale;
metrics->fXHeight *= scale;
metrics->fCapHeight *= scale;
metrics->fUnderlineThickness *= scale;
metrics->fUnderlinePosition *= scale;
metrics->fStrikeoutThickness *= scale;
metrics->fStrikeoutPosition *= scale;
}
bool SkPaintPriv::ShouldDither(const SkPaint& p, SkColorType dstCT) {
// The paint dither flag can veto.
if (!p.isDither()) {
return false;
}
// We always dither 565 or 4444 when requested.
if (dstCT == kRGB_565_SkColorType || dstCT == kARGB_4444_SkColorType) {
return true;
}
// Otherwise, dither is only needed for non-const paints.
return p.getImageFilter() || p.getMaskFilter()
|| !p.getShader() || !as_SB(p.getShader())->isConstant();
}
int SkPaintPriv::ValidCountText(const void* text, size_t length, SkPaint::TextEncoding encoding) {
if (length == 0) {
return 0;
}
switch (encoding) {
case SkPaint::kUTF8_TextEncoding: return SkUTF8_CountUnichars(text, length);
case SkPaint::kUTF16_TextEncoding: return SkUTF16_CountUnichars(text, length);
case SkPaint::kUTF32_TextEncoding: return SkUTF32_CountUnichars(text, length);
case SkPaint::kGlyphID_TextEncoding:
if (SkIsAlign2(intptr_t(text)) && SkIsAlign2(length)) {
return length >> 1;
}
break;
}
return 0;
}
|
