/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*/
package com.facebook.react.flat;
import javax.annotation.Nullable;
import android.graphics.Typeface;
import android.text.Spannable;
import android.text.SpannableStringBuilder;
import android.text.TextUtils;
import com.facebook.react.bridge.ReadableMap;
import com.facebook.react.uimanager.PixelUtil;
import com.facebook.react.uimanager.ReactShadowNode;
import com.facebook.react.uimanager.ViewProps;
import com.facebook.react.uimanager.annotations.ReactProp;
/**
* RCTVirtualText is a {@link FlatTextShadowNode} that can contain font styling information.
*/
/* package */ class RCTVirtualText extends FlatTextShadowNode {
private static final String BOLD = "bold";
private static final String ITALIC = "italic";
private static final String NORMAL = "normal";
private static final String PROP_SHADOW_OFFSET = "textShadowOffset";
private static final String PROP_SHADOW_RADIUS = "textShadowRadius";
private static final String PROP_SHADOW_COLOR = "textShadowColor";
private static final int DEFAULT_TEXT_SHADOW_COLOR = 0x55000000;
private FontStylingSpan mFontStylingSpan = FontStylingSpan.INSTANCE;
private ShadowStyleSpan mShadowStyleSpan = ShadowStyleSpan.INSTANCE;
@Override
public void addChildAt(ReactShadowNode child, int i) {
super.addChildAt(child, i);
notifyChanged(true);
}
@Override
protected void performCollectText(SpannableStringBuilder builder) {
for (int i = 0, childCount = getChildCount(); i < childCount; ++i) {
FlatTextShadowNode child = (FlatTextShadowNode) getChildAt(i);
child.collectText(builder);
}
}
@Override
protected void performApplySpans(SpannableStringBuilder builder, int begin, int end, boolean isEditable) {
mFontStylingSpan.freeze();
// All spans will automatically extend to the right of the text, but not the left - except
// for spans that start at the beginning of the text.
final int flag;
if (isEditable) {
flag = Spannable.SPAN_EXCLUSIVE_EXCLUSIVE;
} else {
flag = begin == 0 ?
Spannable.SPAN_INCLUSIVE_INCLUSIVE :
Spannable.SPAN_EXCLUSIVE_INCLUSIVE;
}
builder.setSpan(
mFontStylingSpan,
begin,
end,
flag);
if (mShadowStyleSpan.getColor() != 0 && mShadowStyleSpan.getRadius() != 0) {
mShadowStyleSpan.freeze();
builder.setSpan(
mShadowStyleSpan,
begin,
end,
flag);
}
for (int i = 0, childCount = getChildCount(); i < childCount; ++i) {
FlatTextShadowNode child = (FlatTextShadowNode) getChildAt(i);
child.applySpans(builder, isEditable);
}
}
@Override
protected void performCollectAttachDetachListeners(StateBuilder stateBuilder) {
for (int i = 0, childCount = getChildCount(); i < childCount; ++i) {
FlatTextShadowNode child = (FlatTextShadowNode) getChildAt(i);
child.performCollectAttachDetachListeners(stateBuilder);
}
}
@ReactProp(name = ViewProps.FONT_SIZE, defaultFloat = Float.NaN)
public void setFontSize(float fontSizeSp) {
final int fontSize;
if (Float.isNaN(fontSizeSp)) {
fontSize = getDefaultFontSize();
} else {
fontSize = fontSizeFromSp(fontSizeSp);
}
if (mFontStylingSpan.getFontSize() != fontSize) {
getSpan().setFontSize(fontSize);
notifyChanged(true);
}
}
@ReactProp(name = ViewProps.COLOR, defaultDouble = Double.NaN)
public void setColor(double textColor) {
if (mFontStylingSpan.getTextColor() != textColor) {
getSpan().setTextColor(textColor);
notifyChanged(false);
}
}
@Override
public void setBackgroundColor(int backgroundColor) {
if (isVirtual()) {
// for nested Text elements, we want to apply background color to the text only
// e.g. Hello <style backgroundColor=red>World</style>, "World" will have red background color
if (mFontStylingSpan.getBackgroundColor() != backgroundColor) {
getSpan().setBackgroundColor(backgroundColor);
notifyChanged(false);
}
} else {
// for top-level Text element, background needs to be applied for the entire shadow node
//
// For example: <Text style={flex:1}>Hello World</Text>
// "Hello World" may only occupy e.g. 200 pixels, but the node may be measured at e.g. 500px.
// In this case, we want background to be 500px wide as well, and this is exactly what
// FlatShadowNode does.
super.setBackgroundColor(backgroundColor);
}
}
@ReactProp(name = ViewProps.FONT_FAMILY)
public void setFontFamily(@Nullable String fontFamily) {
if (!TextUtils.equals(mFontStylingSpan.getFontFamily(), fontFamily)) {
getSpan().setFontFamily(fontFamily);
notifyChanged(true);
}
}
@ReactProp(name = ViewProps.FONT_WEIGHT)
public void setFontWeight(@Nullable String fontWeightString) {
final int fontWeight;
if (fontWeightString == null) {
fontWeight = -1;
} else if (BOLD.equals(fontWeightString)) {
fontWeight = Typeface.BOLD;
} else if (NORMAL.equals(fontWeightString)) {
fontWeight = Typeface.NORMAL;
} else {
int fontWeightNumeric = parseNumericFontWeight(fontWeightString);
if (fontWeightNumeric == -1) {
throw new RuntimeException("invalid font weight " + fontWeightString);
}
fontWeight = fontWeightNumeric >= 500 ? Typeface.BOLD : Typeface.NORMAL;
}
if (mFontStylingSpan.getFontWeight() != fontWeight) {
getSpan().setFontWeight(fontWeight);
notifyChanged(true);
}
}
@ReactProp(name = ViewProps.TEXT_DECORATION_LINE)
public void setTextDecorationLine(@Nullable String textDecorationLineString) {
boolean isUnderlineTextDecorationSet = false;
boolean isLineThroughTextDecorationSet = false;
if (textDecorationLineString != null) {
for (String textDecorationLineSubString : textDecorationLineString.split(" ")) {
if ("underline".equals(textDecorationLineSubString)) {
isUnderlineTextDecorationSet = true;
} else if ("line-through".equals(textDecorationLineSubString)) {
isLineThroughTextDecorationSet = true;
}
}
}
if (isUnderlineTextDecorationSet != mFontStylingSpan.hasUnderline() ||
isLineThroughTextDecorationSet != mFontStylingSpan.hasStrikeThrough()) {
FontStylingSpan span = getSpan();
span.setHasUnderline(isUnderlineTextDecorationSet);
span.setHasStrikeThrough(isLineThroughTextDecorationSet);
notifyChanged(true);
}
}
@ReactProp(name = ViewProps.FONT_STYLE)
public void setFontStyle(@Nullable String fontStyleString) {
final int fontStyle;
if (fontStyleString == null) {
fontStyle = -1;
} else if (ITALIC.equals(fontStyleString)) {
fontStyle = Typeface.ITALIC;
} else if (NORMAL.equals(fontStyleString)) {
fontStyle = Typeface.NORMAL;
} else {
throw new RuntimeException("invalid font style " + fontStyleString);
}
if (mFontStylingSpan.getFontStyle() != fontStyle) {
getSpan().setFontStyle(fontStyle);
notifyChanged(true);
}
}
@ReactProp(name = PROP_SHADOW_OFFSET)
public void setTextShadowOffset(@Nullable ReadableMap offsetMap) {
float dx = 0;
float dy = 0;
if (offsetMap != null) {
if (offsetMap.hasKey("width")) {
dx = PixelUtil.toPixelFromDIP(offsetMap.getDouble("width"));
}
if (offsetMap.hasKey("height")) {
dy = PixelUtil.toPixelFromDIP(offsetMap.getDouble("height"));
}
}
if (!mShadowStyleSpan.offsetMatches(dx, dy)) {
getShadowSpan().setOffset(dx, dy);
notifyChanged(false);
}
}
@ReactProp(name = PROP_SHADOW_RADIUS)
public void setTextShadowRadius(float textShadowRadius) {
textShadowRadius = PixelUtil.toPixelFromDIP(textShadowRadius);
if (mShadowStyleSpan.getRadius() != textShadowRadius) {
getShadowSpan().setRadius(textShadowRadius);
notifyChanged(false);
}
}
@ReactProp(name = PROP_SHADOW_COLOR, defaultInt = DEFAULT_TEXT_SHADOW_COLOR, customType = "Color")
public void setTextShadowColor(int textShadowColor) {
if (mShadowStyleSpan.getColor() != textShadowColor) {
getShadowSpan().setColor(textShadowColor);
notifyChanged(false);
}
}
/**
* Returns font size for this node.
* When called on RCTText, this value is never -1 (unset).
*/
protected final int getFontSize() {
return mFontStylingSpan.getFontSize();
}
/**
* Returns font style for this node.
*/
protected final int getFontStyle() {
int style = mFontStylingSpan.getFontStyle();
return style >= 0 ? style : Typeface.NORMAL;
}
protected int getDefaultFontSize() {
return -1;
}
/* package */ static int fontSizeFromSp(float sp) {
return (int) Math.ceil(PixelUtil.toPixelFromSP(sp));
}
protected final FontStylingSpan getSpan() {
if (mFontStylingSpan.isFrozen()) {
mFontStylingSpan = mFontStylingSpan.mutableCopy();
}
return mFontStylingSpan;
}
/**
* Returns a new SpannableStringBuilder that includes all the text and styling information to
* create the Layout.
*/
/* package */ final SpannableStringBuilder getText() {
SpannableStringBuilder sb = new SpannableStringBuilder();
collectText(sb);
applySpans(sb, isEditable());
return sb;
}
private final ShadowStyleSpan getShadowSpan() {
if (mShadowStyleSpan.isFrozen()) {
mShadowStyleSpan = mShadowStyleSpan.mutableCopy();
}
return mShadowStyleSpan;
}
/**
* Return -1 if the input string is not a valid numeric fontWeight (100, 200, ..., 900), otherwise
* return the weight.
*/
private static int parseNumericFontWeight(String fontWeightString) {
// This should be much faster than using regex to verify input and Integer.parseInt
return fontWeightString.length() == 3 && fontWeightString.endsWith("00")
&& fontWeightString.charAt(0) <= '9' && fontWeightString.charAt(0) >= '1' ?
100 * (fontWeightString.charAt(0) - '0') : -1;
}
}