Ist es möglich, mehrere Stile für verschiedene Textteile in einer Textansicht festzulegen?

Zum Beispiel setze ich den Text wie folgt:

tv.setText(line1 + "\n" + line2 + "\n" + word1 + "\t" + word2 + "\t" + word3);

Ist es möglich, für jedes Textelement einen anderen Stil zu haben? ZB Zeile1 fett, Wort1 kursiv usw.

Die allgemeinen Aufgaben und die Vorgehensweise des Entwicklerhandbuchs in Android umfassen das Auswählen, Hervorheben oder Stylen von Textteilen :

// Get our EditText object.
EditText vw = (EditText)findViewById(R.id.text);

// Set the EditText's text.
vw.setText("Italic, highlighted, bold.");

// If this were just a TextView, we could do:
// vw.setText("Italic, highlighted, bold.", TextView.BufferType.SPANNABLE);
// to force it to use Spannable storage so styles can be attached.
// Or we could specify that in the XML.

// Get the EditText's internal text storage
Spannable str = vw.getText();

// Create our span sections, and assign a format to each.
str.setSpan(new StyleSpan(android.graphics.Typeface.ITALIC), 0, 7, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
str.setSpan(new BackgroundColorSpan(0xFFFFFF00), 8, 19, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
str.setSpan(new StyleSpan(android.graphics.Typeface.BOLD), 21, str.length() - 1, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);

Dabei werden jedoch explizite Positionsnummern im Text verwendet. Gibt es einen saubereren Weg, dies zu tun?

Für den Fall, dass sich jemand fragt, wie das geht, gibt es eine Möglichkeit: (Nochmals vielen Dank an Mark!)

mBox = new TextView(context);
mBox.setText(Html.fromHtml("<b>" + title + "</b>" +  "<br />" + 
            "<small>" + description + "</small>" + "<br />" + 
            "<small>" + DateAdded + "</small>"));

Eine inoffizielle Liste der von dieser Methode unterstützten Tags finden Sie unter diesem Link oder in dieser Frage: Welche HTML-Tags werden von Android TextView unterstützt?

Versuchen Sie es Html.fromHtml()und markieren Sie Ihren Text mit fetten und kursiven HTML-Tags, z.

Spanned text = Html.fromHtml("This mixes <b>bold</b> and <i>italic</i> stuff");
textView.setText(text);

Etwas abseits des Themas, aber ich fand das zu nützlich, um hier nicht erwähnt zu werden.

Was ist, wenn wir den HTML-Text aus der Ressource string.xml lesen und so die Lokalisierung vereinfachen möchten ? CDATA machen dies möglich:

<string name="my_text">
  <![CDATA[
    <b>Autor:</b> Mr Nice Guy<br/>
    <b>Contact:</b> myemail@grail.com<br/>
    <i>Copyright © 2011-2012 Intergalactic Spacebar Confederation </i>
  ]]>
</string> 

Aus unserem Java-Code könnten wir ihn jetzt folgendermaßen verwenden:

TextView tv = (TextView) findViewById(R.id.myTextView);
tv.setText(Html.fromHtml(getString(R.string.my_text))); 

Ich hatte nicht erwartet, dass das funktioniert. Aber es tat es.

Hoffe, es ist nützlich für einige von euch!

Wenn Sie keine Lust auf HTML haben, können Sie einfach eine styles.xml erstellen und wie folgt verwenden:

TextView tv = (TextView) findViewById(R.id.textview);
SpannableString text = new SpannableString(myString);

text.setSpan(new TextAppearanceSpan(getContext(), R.style.myStyle), 0, 5, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
text.setSpan(new TextAppearanceSpan(getContext(), R.style.myNextStyle), 6, 10, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);

tv.setText(text, TextView.BufferType.SPANNABLE);

Es ist leichter, ein SpannableStringanstelle von HTML-Markup zu verwenden. Es hilft mir, visuelle Beispiele zu sehen, daher hier eine ergänzende Antwort.

Dies ist eine Single TextView.

// set the text
SpannableString s1 = new SpannableString("bold\n");
SpannableString s2 = new SpannableString("italic\n");
SpannableString s3 = new SpannableString("foreground color\n");
SpannableString s4 = new SpannableString("background color\n");
SpannableString s5 = new SpannableString("underline\n");
SpannableString s6 = new SpannableString("strikethrough\n");
SpannableString s7 = new SpannableString("bigger\n");
SpannableString s8 = new SpannableString("smaller\n");
SpannableString s9 = new SpannableString("font\n");
SpannableString s10 = new SpannableString("URL span\n");
SpannableString s11 = new SpannableString("clickable span\n");
SpannableString s12 = new SpannableString("overlapping spans\n");

// set the style
int flag = Spanned.SPAN_EXCLUSIVE_EXCLUSIVE;
s1.setSpan(new StyleSpan(Typeface.BOLD), 0, s1.length(), flag);
s2.setSpan(new StyleSpan(Typeface.ITALIC), 0, s2.length(), flag);
s3.setSpan(new ForegroundColorSpan(Color.RED), 0, s3.length(), flag);
s4.setSpan(new BackgroundColorSpan(Color.YELLOW), 0, s4.length(), flag);
s5.setSpan(new UnderlineSpan(), 0, s5.length(), flag);
s6.setSpan(new StrikethroughSpan(), 0, s6.length(), flag);
s7.setSpan(new RelativeSizeSpan(2), 0, s7.length(), flag);
s8.setSpan(new RelativeSizeSpan(0.5f), 0, s8.length(), flag);
s9.setSpan(new TypefaceSpan("monospace"), 0, s9.length(), flag);
s10.setSpan(new URLSpan("https://developer.android.com"), 0, s10.length(), flag);
s11.setSpan(new ClickableSpan() {
    @Override
    public void onClick(View widget) {
        Toast.makeText(getApplicationContext(), "Span clicked", Toast.LENGTH_SHORT).show();
    }
}, 0, s11.length(), flag);
s12.setSpan(new ForegroundColorSpan(Color.RED), 0, 11, flag);
s12.setSpan(new BackgroundColorSpan(Color.YELLOW), 4, s12.length(), flag);
s12.setSpan(new UnderlineSpan(), 4, 11, flag);

// build the string
SpannableStringBuilder builder = new SpannableStringBuilder();
builder.append(s1);
builder.append(s2);
builder.append(s3);
builder.append(s4);
builder.append(s5);
builder.append(s6);
builder.append(s7);
builder.append(s8);
builder.append(s9);
builder.append(s10);
builder.append(s11);
builder.append(s12);

// set the text view with the styled text
textView.setText(builder);
// enables clicking on spans for clickable span and url span
textView.setMovementMethod(LinkMovementMethod.getInstance());

Weitere Studie

• Erläutern Sie die Bedeutung von Span-Flags wie SPAN_EXCLUSIVE_EXCLUSIVE
• Android Spanned, SpannedString, Spannable, SpannableString und CharSequence
• Arten von Spannweiten

Dieses Beispiel wurde ursprünglich von hier inspiriert .

Die Liste der unterstützten Tags lautet:

Wenn Sie eine Zeichenfolgenressource verwenden, können Sie ein einfaches Styling hinzufügen, z. B. fett oder kursiv in HTML-Notation. Die derzeit unterstützten Tags sind: B(fett), I(kursiv), U(unterstrichen), TT(Monospace) BIG, SMALL, SUP(Exponent), SUB(Index) und STRIKE( durchgestrichen). So res/values/strings.xmlkönnten Sie beispielsweise Folgendes deklarieren:

<resource>
    <string id="@+id/styled_welcome_message">We are <b><i>so</i></b> glad to see you.</string>
</resources>

(Von http://developer.android.com/guide/faq/commontasks.html#selectingtext - Webarchiv-Link ist <resource>Tippfehler im Original!)

Es zeigt auch, dass dies Html.fromHtmlin einfachen Fällen nicht wirklich benötigt wird.

Ich hatte das gleiche Problem. Ich könnte fromHtml verwenden, aber ich bin jetzt Android, nicht Web, also habe ich beschlossen, dies auszuprobieren. Ich muss dies allerdings lokalisieren, also habe ich es mit dem String-Ersatz-Konzept versucht. Ich habe den Stil in der Textansicht als Hauptstil festgelegt und dann nur die anderen Teile formatiert.

Ich hoffe, dies hilft anderen, die das Gleiche tun möchten - ich weiß nicht, warum dies im Framework nicht einfacher ist.

Meine Saiten sehen so aus:

<string name="my_text">{0} You will need a {1} to complete this assembly</string>
<string name="text_sub0">1:</string>
<string name="text_sub1">screwdriver, hammer, and measuring tape</string>

Hier sind die Stile:

<style name="MainStyle">
    <item name="android:textSize">@dimen/regular_text</item>
    <item name="android:textColor">@color/regular_text</item>
</style>
<style name="style0">
    <item name="android:textSize">@dimen/paragraph_bullet</item>
    <item name="android:textColor">@color/standout_text</item>
    <item name="android:textStyle">bold</item>
</style>
<style name="style1">
    <item name="android:textColor">@color/standout_light_text</item>
    <item name="android:textStyle">italic</item>
</style>

Hier ist mein Code, der meine formatStyles-Methode aufruft:

SpannableString formattedSpan = formatStyles(getString(R.string.my_text), getString(R.string.text_sub0), R.style.style0, getString(R.string.main_text_sub1), R.style.style1);
textView.setText(formattedSpan, TextView.BufferType.SPANNABLE);

Die Formatierungsmethode:

private SpannableString formatStyles(String value, String sub0, int style0, String sub1, int style1)
{
    String tag0 = "{0}";
    int startLocation0 = value.indexOf(tag0);
    value = value.replace(tag0, sub0);

    String tag1 = "{1}";
    int startLocation1 = value.indexOf(tag1);
    if (sub1 != null && !sub1.equals(""))
    {
        value = value.replace(tag1, sub1);
    }

    SpannableString styledText = new SpannableString(value);
    styledText.setSpan(new TextAppearanceSpan(getActivity(), style0), startLocation0, startLocation0 + sub0.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
    if (sub1 != null && !sub1.equals(""))
    {
        styledText.setSpan(new TextAppearanceSpan(getActivity(), style1), startLocation1, startLocation1 + sub1.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
    }

    return styledText;
}

Jetzt ist das <b>Element veraltet. <strong>rendert als <b>und <em>rendert als <i>.

tv.setText(Html.fromHtml("<strong>bold</strong> and <em>italic</em> "));

Das funktioniert gut für mich

Hier ist eine einfache Möglichkeit, dies mit HTMLBuilder zu tun

    myTextView.setText(new HtmlBuilder().
                    open(HtmlBuilder.Type.BOLD).
                    append("Some bold text ").
                    close(HtmlBuilder.Type.BOLD).
                    open(HtmlBuilder.Type.ITALIC).
                    append("Some italic text").
                    close(HtmlBuilder.Type.ITALIC).
                    build()
    );

Ergebnis:

Einige fette Texte Einige kursive Texte

Wenn Sie den gestalteten Text in XML hinzufügen möchten, können Sie eine benutzerdefinierte Ansicht erstellen, die TextView erweitert, und setText () überschreiben:

public class HTMLStyledTextView extends TextView
{
    public HTMLStyledTextView(Context context) {
        super(context);
    }

    public HTMLStyledTextView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public HTMLStyledTextView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    @Override
    public void setText(CharSequence text, BufferType type)
    {
       super.setText(Html.fromHtml(text.toString()), type);
    }
}

Dann können Sie es wie folgt verwenden (durch PACKAGE_NAMEIhren Paketnamen ersetzen ):

<PACKAGE_NAME.HTMLStyledTextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="<![CDATA[
        <b>Bolded Text:</b> Non-Bolded Text
    ]]>"
/>

Wie angegeben, verwenden TextView.setText(Html.fromHtml(String))

Und verwenden Sie diese Tags in Ihrer HTML-formatierten Zeichenfolge:

<a href="...">
<b>
<big>
<blockquote>
<br>
<cite>
<dfn>
<div align="...">
<em>
<font size="..." color="..." face="...">
<h1>
<h2>
<h3>
<h4>
<h5>
<h6>
<i>
<img src="...">
<p>
<small>
<strike>
<strong>
<sub>
<sup>
<tt>
<u>

http://commonsware.com/blog/Android/2010/05/26/html-tags-supported-by-textview.html

Ich auch

Wie wäre es mit einem schönen Markup mit Kotlin und Anko -

import org.jetbrains.anko.*
override fun onCreate(savedInstanceState: Bundle?) {
    title = "Created with Beautiful Markup"
    super.onCreate(savedInstanceState)

    verticalLayout {
        editText {
            hint = buildSpanned {
                append("Italic, ", Italic)
                append("highlighted", backgroundColor(0xFFFFFF00.toInt()))
                append(", Bold", Bold)
            }
        }
    }
}

Ja, es ist möglich mit SpannedString. Wenn Sie Kotlin verwenden, wird die Verwendung noch einfacher core-ktx, da hierfür eine domänenspezifische Sprache (DSL) bereitgestellt wird:

    val string: SpannedString = buildSpannedString {
        bold {
            append("1111")
        }
        append("Devansh")     
    }

Weitere Optionen sind:

append("Hello There")
bold {
    append("bold")
    italic {
        append("bold and italic")
        underline {
            append("then some text with underline")
        }
    }
}

Endlich können Sie einfach:

textView.text = string

Mit Ausnahme des HTML-Objekts können Sie auch die Spannable-Typklassen verwenden, z. B. TextAppearanceSpan oder TypefaceSpan und SpannableString zusammen. Die HTML-Klasse verwendet diese Mechanismen ebenfalls. Mit den Spannable-Typklassen haben Sie jedoch mehr Freiheit.

Es kann so einfach sein, wie die Methode length () des Strings zu nutzen:

1. Teilen Sie die Textzeichenfolge in der Strings-XML-Datei in so viele Unterzeichenfolgen (aus Sicht von Android eine separate Zeichenfolge) auf, wie viele verschiedene Stile benötigen. Es könnte also so aussehen: str1, str2, str3 (wie in Ihrem Fall), Wenn sie zusammengefügt werden, ist dies die gesamte einzelne Zeichenfolge, die Sie verwenden.

2. Und dann folgen Sie einfach der "Span" -Methode, genau wie Sie es mit Ihrem Code dargestellt haben. Kombinieren Sie jedoch anstelle einer einzelnen Zeichenfolge alle Teilzeichenfolgen, die sie zu einer einzigen zusammenführen, die jeweils einen anderen benutzerdefinierten Stil haben.

Sie verwenden die Zahlen immer noch, jedoch nicht direkt - sie haben jetzt keine fest codierte Form mehr (wie in Ihrem Code), sondern werden durch die kombinierten length () -Methoden ersetzt (beachten Sie zwei Sterne vor und mit dem Suffix str. Länge () anstelle der absoluten Zahl, um die Änderung auszulöschen):

str.setSpan(new StyleSpan(android.graphics.Typeface.ITALIC), 0, **str.length()**, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);

für die erste Zeichenfolgengröße dann str.length () + 1, str.length () + str2.length () für die zweite Zeichenfolgengröße usw. mit allen Teilzeichenfolgen anstelle von z. B. 0,7 oder 8,19 und so weiter...

Verwenden einer zusätzlichen überspannbaren Klasse als Android String Resources- Freigabe am Ende der Webseite. Sie können dies erreichen, CharSquencesindem Sie ihnen einen Stil erstellen und geben.

Aber in dem Beispiel, das sie uns geben, ist nur für fett, kursiv und sogar kolorieren Text. Ich musste mehrere Stile in a CharSequenceeinschließen, um sie in a zu setzen TextView. Also habe ich dieser Klasse (ich habe sie genannt CharSequenceStyles) gerade diese Funktion hinzugefügt.

public static CharSequence applyGroup(LinkedList<CharSequence> content){
    SpannableStringBuilder text = new SpannableStringBuilder();
    for (CharSequence item : content) {
        text.append(item);
    }
    return text;
}

Und in der Ansicht habe ich dies hinzugefügt.

            message.push(postMessageText);
            message.push(limitDebtAmount);
            message.push(pretMessageText);
            TextView.setText(CharSequenceStyles.applyGroup(message));

Ich hoffe das hilft dir!

Spanny vereinfacht die Verwendung von SpannableString.

Spanny spanny = new Spanny("Underline text", new UnderlineSpan())
                .append("\nRed text", new ForegroundColorSpan(Color.RED))
                .append("\nPlain text");
textView.setText(spanny)

Wie Jon sagte , ist dies für mich die beste Lösung und Sie müssen zur Laufzeit keinen Text festlegen. Verwenden Sie nur diese benutzerdefinierte Klasse HtmlTextView

public class HtmlTextView extends TextView {

  public HtmlTextView(Context context) {
      super(context);
  }

  public HtmlTextView(Context context, AttributeSet attrs) {
      super(context, attrs);
  }

  public HtmlTextView(Context context, AttributeSet attrs, int defStyleAttr) 
  {
      super(context, attrs, defStyleAttr);
  }

  @TargetApi(21)
  public HtmlTextView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
      super(context, attrs, defStyleAttr, defStyleRes);
  }

  @Override
  public void setText(CharSequence s,BufferType b){
      super.setText(Html.fromHtml(s.toString()),b);
  }

}

und das wars, jetzt nur noch in dein XML

<com.fitc.views.HtmlTextView
    android:id="@+id/html_TV"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@string/example_html" />

mit Ihrem HTML-String

<string name="example_html">
<![CDATA[
<b>Author:</b> Mr Donuthead<br/>
<b>Contact:</b> me@donut.com<br/>
<i>Donuts for life </i>
]]>