310 lines
9.6 KiB
Java
310 lines
9.6 KiB
Java
/*
|
|
* Copyright (C) 2013 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.android.settings.accessibility;
|
|
|
|
import android.content.ContentResolver;
|
|
import android.content.Context;
|
|
import android.content.res.ColorStateList;
|
|
import android.graphics.Canvas;
|
|
import android.graphics.Color;
|
|
import android.graphics.Paint;
|
|
import android.graphics.Paint.Cap;
|
|
import android.graphics.Paint.Join;
|
|
import android.graphics.Paint.Style;
|
|
import android.os.Parcel;
|
|
import android.support.v4.view.ViewCompat;
|
|
import android.text.Editable;
|
|
import android.text.ParcelableSpan;
|
|
import android.text.TextPaint;
|
|
import android.text.TextUtils;
|
|
import android.text.style.CharacterStyle;
|
|
import android.text.style.UpdateAppearance;
|
|
import android.util.AttributeSet;
|
|
import android.view.accessibility.CaptioningManager;
|
|
import android.view.accessibility.CaptioningManager.CaptionStyle;
|
|
import android.widget.TextView;
|
|
|
|
public class CaptioningTextView extends TextView {
|
|
private MutableBackgroundColorSpan mBackgroundSpan;
|
|
private ColorStateList mOutlineColorState;
|
|
private float mOutlineWidth;
|
|
private int mOutlineColor;
|
|
|
|
private int mEdgeType = CaptionStyle.EDGE_TYPE_NONE;
|
|
private int mEdgeColor = Color.TRANSPARENT;
|
|
private float mEdgeWidth = 0;
|
|
|
|
private boolean mHasBackground = false;
|
|
|
|
public CaptioningTextView(Context context, AttributeSet attrs, int defStyle) {
|
|
super(context, attrs, defStyle);
|
|
}
|
|
|
|
public CaptioningTextView(Context context, AttributeSet attrs) {
|
|
super(context, attrs);
|
|
}
|
|
|
|
public CaptioningTextView(Context context) {
|
|
super(context);
|
|
}
|
|
|
|
public void applyStyleAndFontSize(int styleId) {
|
|
final Context context = mContext;
|
|
final ContentResolver cr = context.getContentResolver();
|
|
final CaptionStyle style;
|
|
if (styleId == CaptionStyle.PRESET_CUSTOM) {
|
|
style = CaptionStyle.getCustomStyle(cr);
|
|
} else {
|
|
style = CaptionStyle.PRESETS[styleId];
|
|
}
|
|
|
|
setTextColor(style.foregroundColor);
|
|
setBackgroundColor(style.backgroundColor);
|
|
setTypeface(style.getTypeface());
|
|
|
|
// Clears all outlines.
|
|
applyEdge(style.edgeType, style.edgeColor, 4.0f);
|
|
|
|
final float fontSize = CaptioningManager.getFontSize(cr);
|
|
if (fontSize != 0) {
|
|
setTextSize(fontSize);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Applies an edge preset using a combination of {@link #setOutlineLayer}
|
|
* and {@link #setShadowLayer}. Any subsequent calls to either of these
|
|
* methods will invalidate the applied preset.
|
|
*
|
|
* @param type Type of edge to apply, one of:
|
|
* <ul>
|
|
* <li>{@link CaptionStyle#EDGE_TYPE_NONE}
|
|
* <li>{@link CaptionStyle#EDGE_TYPE_OUTLINE}
|
|
* <li>{@link CaptionStyle#EDGE_TYPE_DROP_SHADOW}
|
|
* </ul>
|
|
* @param color Edge color as a packed 32-bit ARGB color.
|
|
* @param width Width of the edge in pixels.
|
|
*/
|
|
public void applyEdge(int type, int color, float width) {
|
|
if (mEdgeType != type || mEdgeColor != color || mEdgeWidth != width) {
|
|
final int textColor = getTextColors().getDefaultColor();
|
|
switch (type) {
|
|
case CaptionStyle.EDGE_TYPE_DROP_SHADOW:
|
|
setOutlineLayer(0, 0);
|
|
super.setShadowLayer(width, width, width, color);
|
|
break;
|
|
case CaptionStyle.EDGE_TYPE_OUTLINE:
|
|
setOutlineLayer(width, color);
|
|
super.setShadowLayer(0, 0, 0, 0);
|
|
break;
|
|
default:
|
|
super.setShadowLayer(0, 0, 0, 0);
|
|
setOutlineLayer(0, 0);
|
|
}
|
|
|
|
mEdgeType = type;
|
|
mEdgeColor = color;
|
|
mEdgeWidth = width;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setShadowLayer(float radius, float dx, float dy, int color) {
|
|
mEdgeType = CaptionStyle.EDGE_TYPE_NONE;
|
|
|
|
super.setShadowLayer(radius, dx, dy, color);
|
|
}
|
|
|
|
/**
|
|
* Gives the text an outline of the specified pixel width and color.
|
|
*/
|
|
public void setOutlineLayer(float width, int color) {
|
|
width *= 2.0f;
|
|
|
|
mEdgeType = CaptionStyle.EDGE_TYPE_NONE;
|
|
|
|
if (mOutlineColor != color || mOutlineWidth != width) {
|
|
mOutlineColorState = ColorStateList.valueOf(color);
|
|
mOutlineColor = color;
|
|
mOutlineWidth = width;
|
|
invalidate();
|
|
|
|
// TODO: Remove after display list bug is fixed.
|
|
if (width > 0 && Color.alpha(color) != 0) {
|
|
setLayerType(ViewCompat.LAYER_TYPE_SOFTWARE, null);
|
|
} else {
|
|
setLayerType(ViewCompat.LAYER_TYPE_HARDWARE, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return the color of the outline layer
|
|
* @see #setOutlineLayer(float, int)
|
|
*/
|
|
public int getOutlineColor() {
|
|
return mOutlineColor;
|
|
}
|
|
|
|
/**
|
|
* @return the width of the outline layer
|
|
* @see #setOutlineLayer(float, int)
|
|
*/
|
|
public float getOutlineWidth() {
|
|
return mOutlineWidth;
|
|
}
|
|
|
|
@Override
|
|
public Editable getEditableText() {
|
|
final CharSequence text = getText();
|
|
if (text instanceof Editable) {
|
|
return (Editable) text;
|
|
}
|
|
|
|
setText(text, BufferType.EDITABLE);
|
|
return (Editable) getText();
|
|
}
|
|
|
|
@Override
|
|
public void setBackgroundColor(int color) {
|
|
if (Color.alpha(color) == 0) {
|
|
if (mHasBackground) {
|
|
mHasBackground = false;
|
|
getEditableText().removeSpan(mBackgroundSpan);
|
|
}
|
|
} else {
|
|
if (mBackgroundSpan == null) {
|
|
mBackgroundSpan = new MutableBackgroundColorSpan(color);
|
|
} else {
|
|
mBackgroundSpan.setColor(color);
|
|
}
|
|
|
|
if (mHasBackground) {
|
|
invalidate();
|
|
} else {
|
|
mHasBackground = true;
|
|
getEditableText().setSpan(mBackgroundSpan, 0, length(), 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void onTextChanged(CharSequence text, int start, int lengthBefore, int lengthAfter) {
|
|
super.onTextChanged(text, start, lengthBefore, lengthAfter);
|
|
|
|
if (mBackgroundSpan != null) {
|
|
getEditableText().setSpan(mBackgroundSpan, 0, lengthAfter, 0);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void onDraw(Canvas c) {
|
|
if (mOutlineWidth > 0 && Color.alpha(mOutlineColor) > 0) {
|
|
final TextPaint textPaint = getPaint();
|
|
final Paint.Style previousStyle = textPaint.getStyle();
|
|
final ColorStateList previousColors = getTextColors();
|
|
textPaint.setStyle(Style.STROKE);
|
|
textPaint.setStrokeWidth(mOutlineWidth);
|
|
textPaint.setStrokeCap(Cap.ROUND);
|
|
textPaint.setStrokeJoin(Join.ROUND);
|
|
|
|
setTextColor(mOutlineColorState);
|
|
|
|
// Remove the shadow.
|
|
final float shadowRadius = getShadowRadius();
|
|
final float shadowDx = getShadowDx();
|
|
final float shadowDy = getShadowDy();
|
|
final int shadowColor = getShadowColor();
|
|
if (shadowRadius > 0) {
|
|
setShadowLayer(0, 0, 0, 0);
|
|
}
|
|
|
|
// Draw outline and background only.
|
|
super.onDraw(c);
|
|
|
|
// Restore the shadow.
|
|
if (shadowRadius > 0) {
|
|
setShadowLayer(shadowRadius, shadowDx, shadowDy, shadowColor);
|
|
}
|
|
|
|
// Restore original settings.
|
|
textPaint.setStyle(previousStyle);
|
|
setTextColor(previousColors);
|
|
|
|
// Remove the background.
|
|
final int color;
|
|
if (mBackgroundSpan != null) {
|
|
color = mBackgroundSpan.getBackgroundColor();
|
|
mBackgroundSpan.setColor(Color.TRANSPARENT);
|
|
} else {
|
|
color = 0;
|
|
}
|
|
|
|
// Draw foreground only.
|
|
super.onDraw(c);
|
|
|
|
// Restore the background.
|
|
if (mBackgroundSpan != null) {
|
|
mBackgroundSpan.setColor(color);
|
|
}
|
|
} else {
|
|
super.onDraw(c);
|
|
}
|
|
}
|
|
|
|
public static class MutableBackgroundColorSpan extends CharacterStyle
|
|
implements UpdateAppearance, ParcelableSpan {
|
|
private int mColor;
|
|
|
|
public MutableBackgroundColorSpan(int color) {
|
|
mColor = color;
|
|
}
|
|
|
|
public MutableBackgroundColorSpan(Parcel src) {
|
|
mColor = src.readInt();
|
|
}
|
|
|
|
public void setColor(int color) {
|
|
mColor = color;
|
|
}
|
|
|
|
@Override
|
|
public int getSpanTypeId() {
|
|
return TextUtils.BACKGROUND_COLOR_SPAN;
|
|
}
|
|
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(Parcel dest, int flags) {
|
|
dest.writeInt(mColor);
|
|
}
|
|
|
|
public int getBackgroundColor() {
|
|
return mColor;
|
|
}
|
|
|
|
@Override
|
|
public void updateDrawState(TextPaint ds) {
|
|
ds.bgColor = mColor;
|
|
}
|
|
}
|
|
}
|