Como ajustar kerning texto em TextView Android?
https://stackoverflow.com/questions/1640659
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Existe uma maneira de ajustar o espaçamento entre caracteres em um TextView Android? Eu acredito que este é normalmente chamado de "kerning".
Estou ciente do atributo android:textScaleX, mas que comprime os personagens, juntamente com o espaçamento.
Solução
AFAIK, você não pode ajustar kerning em TextView. Você pode ser capaz de ajustar kerning se você desenhar o texto na Canvas-se usando as APIs de gráficos 2D.
Outras dicas
Eu construí uma classe personalizada que estende TextView e adiciona um método "setSpacing". A solução é semelhante ao que @Noah disse. O método adiciona um espaço entre cada letra da corda e com SpannedString mudanças o TextScaleX dos espaços, permitindo positivo e espaçamento negativo.
Espero que ajude alguém ^^
/**
* Text view that allows changing the letter spacing of the text.
*
* @author Pedro Barros (pedrobarros.dev at gmail.com)
* @since May 7, 2013
*/
import android.content.Context;
import android.text.Spannable;
import android.text.SpannableString;
import android.text.style.ScaleXSpan;
import android.util.AttributeSet;
import android.widget.TextView;
public class LetterSpacingTextView extends TextView {
private float spacing = Spacing.NORMAL;
private CharSequence originalText = "";
public LetterSpacingTextView(Context context) {
super(context);
}
public LetterSpacingTextView(Context context, AttributeSet attrs){
super(context, attrs);
}
public LetterSpacingTextView(Context context, AttributeSet attrs, int defStyle){
super(context, attrs, defStyle);
}
public float getSpacing() {
return this.spacing;
}
public void setSpacing(float spacing) {
this.spacing = spacing;
applySpacing();
}
@Override
public void setText(CharSequence text, BufferType type) {
originalText = text;
applySpacing();
}
@Override
public CharSequence getText() {
return originalText;
}
private void applySpacing() {
if (this == null || this.originalText == null) return;
StringBuilder builder = new StringBuilder();
for(int i = 0; i < originalText.length(); i++) {
builder.append(originalText.charAt(i));
if(i+1 < originalText.length()) {
builder.append("\u00A0");
}
}
SpannableString finalText = new SpannableString(builder.toString());
if(builder.toString().length() > 1) {
for(int i = 1; i < builder.toString().length(); i+=2) {
finalText.setSpan(new ScaleXSpan((spacing+1)/10), i, i+1, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
}
}
super.setText(finalText, BufferType.SPANNABLE);
}
public class Spacing {
public final static float NORMAL = 0;
}
}
Usando-o:
LetterSpacingTextView textView = new LetterSpacingTextView(context);
textView.setSpacing(10); //Or any float. To reset to normal, use 0 or LetterSpacingTextView.Spacing.NORMAL
textView.setText("My text");
//Add the textView in a layout, for instance:
((LinearLayout) findViewById(R.id.myLinearLayout)).addView(textView);
Se alguém está procurando uma maneira simples de aplicar o kerning a qualquer string (tecnicamente, CharSequence) sem usar um TextView:
public static Spannable applyKerning(CharSequence src, float kerning)
{
if (src == null) return null;
final int srcLength = src.length();
if (srcLength < 2) return src instanceof Spannable
? (Spannable)src
: new SpannableString(src);
final String nonBreakingSpace = "\u00A0";
final SpannableStringBuilder builder = src instanceof SpannableStringBuilder
? (SpannableStringBuilder)src
: new SpannableStringBuilder(src);
for (int i = src.length() - 1; i >= 1; i--)
{
builder.insert(i, nonBreakingSpace);
builder.setSpan(new ScaleXSpan(kerning), i, i + 1,
Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
}
return builder;
}
Aqui está a minha solução, o que aumenta o espaçamento uniforme (em pixels) entre cada caractere. Este espaço assume todo o texto é em uma única linha. Isso basicamente implementa o @commonsWare sugere.
SpannableStringBuilder builder = new SpannableStringBuilder("WIDE normal");
builder.setSpan(new TrackingSpan(20), 0, 4, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
...
private static class TrackingSpan extends ReplacementSpan {
private float mTrackingPx;
public TrackingSpan(float tracking) {
mTrackingPx = tracking;
}
@Override
public int getSize(Paint paint, CharSequence text,
int start, int end, Paint.FontMetricsInt fm) {
return (int) (paint.measureText(text, start, end)
+ mTrackingPx * (end - start - 1));
}
@Override
public void draw(Canvas canvas, CharSequence text,
int start, int end, float x, int top, int y,
int bottom, Paint paint) {
float dx = x;
for (int i = start; i < end; i++) {
canvas.drawText(text, i, i + 1, dx, y, paint);
dx += paint.measureText(text, i, i + 1) + mTrackingPx;
}
}
}
A única maneira que eu encontrei para ajustar o kerning, é criar uma fonte personalizada em que o avanço glifo é alterada.
Você também pode tentar usar um SpannedString mas você precisa analisá-lo e alterar o espaçamento entre caracteres para cada uma das palavras
Esta resposta pode ser útil para alguém que quer desenhar texto com kerning em uma lona, ??usando drawText (não se trata de texto em um TextView).
Desde Lollipop, o método setLetterSpacing está disponível no Paint. Se o SDK é LOLLIPOP e sobre, setLetterSpacing é usado. Caso contrário, um método é invocado que faz algo semelhante à sugestão de @ dgmltn acima:
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
paint.setLetterSpacing(-0.04f); // setLetterSpacing is only available from LOLLIPOP and on
canvas.drawText(text, xOffset, yOffset, paint);
} else {
float spacePercentage = 0.05f;
drawKernedText(canvas, text, xOffset, yOffset, paint, spacePercentage);
}
/**
* Programatically drawn kerned text by drawing the text string character by character with a space in between.
* Return the width of the text.
* If canvas is null, the text won't be drawn, but the width will still be returned
* kernPercentage determines the space between each letter. If it's 0, there will be no space between letters.
* Otherwise, there will be space between each letter. The value is a fraction of the width of a blank space.
*/
private int drawKernedText(Canvas canvas, String text, float xOffset, float yOffset, Paint paint, float kernPercentage) {
Rect textRect = new Rect();
int width = 0;
int space = Math.round(paint.measureText(" ") * kernPercentage);
for (int i = 0; i < text.length(); i++) {
if (canvas != null) {
canvas.drawText(String.valueOf(text.charAt(i)), xOffset, yOffset, paint);
}
int charWidth;
if (text.charAt(i) == ' ') {
charWidth = Math.round(paint.measureText(String.valueOf(text.charAt(i)))) + space;
} else {
paint.getTextBounds(text, i, i + 1, textRect);
charWidth = textRect.width() + space;
}
xOffset += charWidth;
width += charWidth;
}
return width;
}
É difícil ajustar o espaçamento entre caracteres, quando você estiver usando TextView. Mas se você pode lidar com o mesmo desenho, deve haver alguma maneira de fazer isso.
A minha resposta a esta pergunta é:. usar o seu costume Span
Meu código:
public class LetterSpacingSpan extends ReplacementSpan {
private int letterSpacing = 0;
public LetterSpacingSpan spacing(int space) {
letterSpacing = space;
return this;
}
@Override
public int getSize(@NonNull Paint paint, CharSequence text, int start, int end, @Nullable Paint.FontMetricsInt fm) {
return (int) paint.measureText(text, start, end) + (text.length() - 1) * letterSpacing;
}
@Override
public void draw(@NonNull Canvas canvas, CharSequence text, int start, int end, float x, int top, int y, int bottom, @NonNull Paint paint) {
int length = text.length();
float currentX = x;
for (int i = 1; i < length; i++) {
canvas.drawText(text, i, i + 1, currentX, y, paint);
currentX += paint.measureText(text, i, i + 1) + letterSpacing;
}
}
}
Explique:
Construir seu próprio Span pode ajudar a conseguir muitos efeitos incrível, como fazer um TextView borrão, mudar o fundo ou primeiro plano para o seu TextView, até mesmo fazer alguma animação. I aprender muito com este post Span um poderoso conceito .
Como você está adicionando espaçamento para cada personagem, por isso, devemos usar uma extensão de base de nível de personagem, neste caso, ReplacementSpan é a melhor escolha. Eu adicionar um método spacing, então quando usá-lo, você pode simplesmente passar o espaço que você deseja para cada personagem como parâmetro.
Ao construir o seu espaço personalizado, você precisará substituir pelo menos dois método, getSize e draw. O método getSize deve retornar a largura final depois de adicionar o espaçamento para toda a CharSequence, e dentro do bloco método draw, você pode controlar o Canvas para fazer o desenho que quiser.
Assim como nós usamos este LetterSpacingSpan? É fácil:
Uso:
TextView textView;
Spannable content = new SpannableString("This is the content");
textView.setSpan(new LetterSpacingSpan(), 0, 4, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
textView.setText(content);
E é isso.
Há uma pequena edição de resposta @Pedro Barros. É útil se você usar SpannableString para defini-la, por exemplo, se você quiser fazer cores diferentes de alguns personagens:
private void applySpacing() {
SpannableString finalText;
if (!(originalText instanceof SpannableString)) {
if (this.originalText == null) return;
StringBuilder builder = new StringBuilder();
for (int i = 0; i < originalText.length(); i++) {
builder.append(originalText.charAt(i));
if (i + 1 < originalText.length()) {
builder.append("\u00A0");
}
}
finalText = new SpannableString(builder.toString());
} else {
finalText = (SpannableString) originalText;
}
for (int i = 1; i < finalText.length(); i += 2) {
finalText.setSpan(new ScaleXSpan((spacing + 1) / 10), i, i + 1, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
}
super.setText(finalText, TextView.BufferType.SPANNABLE);
}
Eu queria usar @PedroBarros resposta, mas por definir o que o espaçamento deve estar em pixel.
Aqui está a minha edição para o método applySpacing:
private void applySpacing() {
if (this == null || this.originalText == null) return;
Paint testPaint = new Paint();
testPaint.set(this.getPaint());
float spaceOriginalSize = testPaint.measureText("\u00A0");
float spaceScaleXFactor = ( spaceOriginalSize > 0 ? spacing/spaceOriginalSize : 1);
StringBuilder builder = new StringBuilder();
for(int i = 0; i < originalText.length(); i++) {
builder.append(originalText.charAt(i));
if(i+1 < originalText.length()) {
builder.append("\u00A0");
}
}
SpannableString finalText = new SpannableString(builder.toString());
if(builder.toString().length() > 1) {
for(int i = 1; i < builder.toString().length(); i+=2) {
finalText.setSpan(new ScaleXSpan(spaceScaleXFactor), i, i+1, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
}
}
super.setText(finalText, BufferType.SPANNABLE);
}
Eu sou um iniciante como um desenvolvedor Android, sinta-se livre para deixar-me saber se isso não é bom!
Mais uma solução.
public static SpannableStringBuilder getSpacedSpannable(Context context, String text, int dp) {
if (text == null) return null;
if (dp < 0) throw new RuntimeException("WRONG SPACING " + dp);
Canvas canvas = new Canvas();
Drawable drawable = ContextCompat.getDrawable(context, R.drawable.pixel_1dp);
Bitmap main = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
canvas.setBitmap(main);
drawable.setBounds(0, 0, drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight());
drawable.draw(canvas);
SpannableStringBuilder builder = new SpannableStringBuilder();
char[] array = text.toCharArray();
Bitmap bitmap = Bitmap.createScaledBitmap(main, dp * main.getWidth(), main.getHeight(), false);
for (char ch : array) {
builder.append(ch);
builder.append(" ");
ImageSpan imageSpan = new ImageSpan(context, bitmap);
builder.setSpan(imageSpan, builder.length() - 1, builder.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
}
return builder;
}
Onde pixel_1dp é XML:
<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android">
<solid android:color="@android:color/transparent"/>
<size android:height="1dp" android:width="1dp"/>
</shape>
Para definir o espaçamento use o código como este:
textView.setText(getSpacedSpannable(context, textView.getText().toString(), <Your spacing DP>), TextView.BufferType.SPANNABLE);
Desde Android 21, você pode usar definir o atributo letterSpacing.
<TextView
android:width="..."
android:height="..."
android:letterSpacing="1.3"/>
