Verwenden eines benutzerdefinierten Schriftbilds in Android

Ich möchte eine benutzerdefinierte Schriftart für meine Android-Anwendung verwenden, die ich erstelle.
Ich kann die Schriftart jedes Objekts von Code einzeln ändern, aber ich habe Hunderte von ihnen.

Damit,

  • Gibt es eine Möglichkeit, dies aus dem XML zu tun? [Festlegen einer benutzerdefinierten Schriftart]
  • Gibt es eine Möglichkeit, dies an einer Stelle mit Code zu tun, um zu sagen, dass die gesamte Anwendung und alle Komponenten die benutzerdefinierte Schriftart anstelle der Standardschrift verwenden sollten?

Gibt es eine Möglichkeit, dies aus dem XML zu tun?

Nein Entschuldigung. Sie können die integrierten fonts nur über XML angeben.

Gibt es eine Möglichkeit, dies an einer Stelle mit Code zu tun, um zu sagen, dass die gesamte Anwendung und alle Komponenten die benutzerdefinierte Schriftart anstelle der Standardschrift verwenden sollten?

Nicht dass ich wüsste.

Für diese gibt es heutzutage eine Vielzahl von Möglichkeiten:

  • Font-Ressourcen und Backports im Android SDK, wenn Sie appcompat

  • Bibliotheken von Drittanbietern für appcompat , die appcompat nicht verwenden, obwohl nicht alle Bibliotheken die Definition der Schriftart in Layout-Ressourcen unterstützen

Ja, es ist möglich.

Sie müssen eine benutzerdefinierte Ansicht erstellen, die die Textansicht erweitert.

Im Ordner attrs.xml in values :

        

In main.xml :

     

In MyTextView.java :

 package com.lht.ui; import android.content.Context; import android.graphics.Typeface; import android.util.AttributeSet; import android.util.Log; import android.widget.TextView; public class MyTextView extends TextView { Context context; String ttfName; String TAG = getClass().getName(); public MyTextView(Context context, AttributeSet attrs) { super(context, attrs); this.context = context; for (int i = 0; i < attrs.getAttributeCount(); i++) { Log.i(TAG, attrs.getAttributeName(i)); /* * Read value of custom attributes */ this.ttfName = attrs.getAttributeValue( "http://schemas.android.com/apk/res/com.lht", "ttf_name"); Log.i(TAG, "firstText " + firstText); // Log.i(TAG, "lastText "+ lastText); init(); } } private void init() { Typeface font = Typeface.createFromAsset(context.getAssets(), ttfName); setTypeface(font); } @Override public void setTypeface(Typeface tf) { // TODO Auto-generated method stub super.setTypeface(tf); } } 

Ich habe dies in einer “Brute-Force” -Methode getan, die keine Änderungen am Layout-XML oder den Aktivitäten erfordert.

Getestet auf Android Version 2.1 bis 4.4. Führen Sie dies beim Start der App in Ihrer Anwendungsklasse aus:

 private void setDefaultFont() { try { final Typeface bold = Typeface.createFromAsset(getAssets(), DEFAULT_BOLD_FONT_FILENAME); final Typeface italic = Typeface.createFromAsset(getAssets(), DEFAULT_ITALIC_FONT_FILENAME); final Typeface boldItalic = Typeface.createFromAsset(getAssets(), DEFAULT_BOLD_ITALIC_FONT_FILENAME); final Typeface regular = Typeface.createFromAsset(getAssets(),DEFAULT_NORMAL_FONT_FILENAME); Field DEFAULT = Typeface.class.getDeclaredField("DEFAULT"); DEFAULT.setAccessible(true); DEFAULT.set(null, regular); Field DEFAULT_BOLD = Typeface.class.getDeclaredField("DEFAULT_BOLD"); DEFAULT_BOLD.setAccessible(true); DEFAULT_BOLD.set(null, bold); Field sDefaults = Typeface.class.getDeclaredField("sDefaults"); sDefaults.setAccessible(true); sDefaults.set(null, new Typeface[]{ regular, bold, italic, boldItalic }); } catch (NoSuchFieldException e) { logFontError(e); } catch (IllegalAccessException e) { logFontError(e); } catch (Throwable e) { //cannot crash app if there is a failure with overriding the default font! logFontError(e); } } 

Ein vollständigeres Beispiel finden Sie unter http://github.com/perchrh/FontOverrideExample

Obwohl ich Manishs Antwort als schnellste und zielgerichteteste Methode aufgewertet habe, habe ich auch naive Lösungen gesehen, die rekursiv durch eine Ansichtshierarchie iterieren und die Schriften aller Elemente der Reihe nach aktualisieren. Etwas wie das:

 public static void applyFonts(final View v, Typeface fontToSet) { try { if (v instanceof ViewGroup) { ViewGroup vg = (ViewGroup) v; for (int i = 0; i < vg.getChildCount(); i++) { View child = vg.getChildAt(i); applyFonts(child, fontToSet); } } else if (v instanceof TextView) { ((TextView)v).setTypeface(fontToSet); } } catch (Exception e) { e.printStackTrace(); // ignore } } 

Sie müssten diese function in Ihren Ansichten aufrufen, nachdem Sie das Layout onContentChanged() und die onContentChanged() -Methoden Ihrer Aktivität verwenden.

Ich konnte das zentralisiert machen, hier ist das Ergebnis:

Bildbeschreibung hier eingeben

Ich habe folgende Activity und ich erweitere daraus, wenn ich benutzerdefinierte fonts benötige:

 import android.app.Activity; import android.content.Context; import android.os.Bundle; import android.util.AttributeSet; import android.view.LayoutInflater.Factory; import android.view.LayoutInflater; import android.view.View; import android.widget.TextView; public class CustomFontActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { getLayoutInflater().setFactory(new Factory() { @Override public View onCreateView(String name, Context context, AttributeSet attrs) { View v = tryInflate(name, context, attrs); if (v instanceof TextView) { setTypeFace((TextView) v); } return v; } }); super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } private View tryInflate(String name, Context context, AttributeSet attrs) { LayoutInflater li = LayoutInflater.from(context); View v = null; try { v = li.createView(name, null, attrs); } catch (Exception e) { try { v = li.createView("android.widget." + name, null, attrs); } catch (Exception e1) { } } return v; } private void setTypeFace(TextView tv) { tv.setTypeface(FontUtils.getFonts(this, "MTCORSVA.TTF")); } } 

Wenn ich jedoch eine Aktivität aus dem Support-Paket zB FragmentActivity ich diese Activity :

 import android.annotation.TargetApi; import android.content.Context; import android.os.Build; import android.os.Bundle; import android.support.v4.app.FragmentActivity; import android.util.AttributeSet; import android.view.LayoutInflater; import android.view.View; import android.widget.TextView; public class CustomFontFragmentActivity extends FragmentActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } // we can't setLayout Factory as its already set by FragmentActivity so we // use this approach @Override public View onCreateView(String name, Context context, AttributeSet attrs) { View v = super.onCreateView(name, context, attrs); if (v == null) { v = tryInflate(name, context, attrs); if (v instanceof TextView) { setTypeFace((TextView) v); } } return v; } @TargetApi(Build.VERSION_CODES.HONEYCOMB) @Override public View onCreateView(View parent, String name, Context context, AttributeSet attrs) { View v = super.onCreateView(parent, name, context, attrs); if (v == null) { v = tryInflate(name, context, attrs); if (v instanceof TextView) { setTypeFace((TextView) v); } } return v; } private View tryInflate(String name, Context context, AttributeSet attrs) { LayoutInflater li = LayoutInflater.from(context); View v = null; try { v = li.createView(name, null, attrs); } catch (Exception e) { try { v = li.createView("android.widget." + name, null, attrs); } catch (Exception e1) { } } return v; } private void setTypeFace(TextView tv) { tv.setTypeface(FontUtils.getFonts(this, "MTCORSVA.TTF")); } } 

Ich habe diesen Code noch nicht mit Fragment s getestet, aber hoffentlich wird es funktionieren.

My FontUtils ist einfach und triggers auch das hier erwähnte Problem vor ICS https://code.google.com/p/android/issues/detail?id=9904 :

 import java.util.HashMap; import java.util.Map; import android.content.Context; import android.graphics.Typeface; public class FontUtils { private static Map TYPEFACE = new HashMap(); public static Typeface getFonts(Context context, String name) { Typeface typeface = TYPEFACE.get(name); if (typeface == null) { typeface = Typeface.createFromAsset(context.getAssets(), "fonts/" + name); TYPEFACE.put(name, typeface); } return typeface; } } 

Hey ich brauche auch 2 verschiedene fonts in meiner App für verschiedene widgeds! Ich benutze diesen Weg:

In meiner Application-class erstelle ich eine statische Methode:

 public static Typeface getTypeface(Context context, String typeface) { if (mFont == null) { mFont = Typeface.createFromAsset(context.getAssets(), typeface); } return mFont; } 

Die Zeichenkette String repräsentiert die Datei xyz.ttf im Asset-Ordner. (Ich habe eine Constants-class erstellt) Jetzt können Sie dies überall in Ihrer App verwenden:

 mTextView = (TextView) findViewById(R.id.text_view); mTextView.setTypeface(MyApplication.getTypeface(this, Constants.TYPEFACE_XY)); 

Das einzige Problem ist, dass Sie dies für jedes Widget benötigen, in dem Sie den Font verwenden möchten! Aber ich denke, das ist der beste Weg.

Mit dem Vorschlag von pospi und der Arbeit mit der ‘ tag’- Eigenschaft, wie Richard , habe ich eine benutzerdefinierte class erstellt, die meine benutzerdefinierten fonts lädt und sie entsprechend ihren Tags auf die Ansichten anwendet.

Anstatt das TypeFace im Attribut android: fontFamily zu setzen, verwenden Sie den android: -Tag attritube und setzen ihn auf eines der definierten enums.

 public class Fonts { private AssetManager mngr; public Fonts(Context context) { mngr = context.getAssets(); } private enum AssetTypefaces { RobotoLight, RobotoThin, RobotoCondensedBold, RobotoCondensedLight, RobotoCondensedRegular } private Typeface getTypeface(AssetTypefaces font) { Typeface tf = null; switch (font) { case RobotoLight: tf = Typeface.createFromAsset(mngr,"fonts/Roboto-Light.ttf"); break; case RobotoThin: tf = Typeface.createFromAsset(mngr,"fonts/Roboto-Thin.ttf"); break; case RobotoCondensedBold: tf = Typeface.createFromAsset(mngr,"fonts/RobotoCondensed-Bold.ttf"); break; case RobotoCondensedLight: tf = Typeface.createFromAsset(mngr,"fonts/RobotoCondensed-Light.ttf"); break; case RobotoCondensedRegular: tf = Typeface.createFromAsset(mngr,"fonts/RobotoCondensed-Regular.ttf"); break; default: tf = Typeface.DEFAULT; break; } return tf; } public void setupLayoutTypefaces(View v) { try { if (v instanceof ViewGroup) { ViewGroup vg = (ViewGroup) v; for (int i = 0; i < vg.getChildCount(); i++) { View child = vg.getChildAt(i); setupLayoutTypefaces(child); } } else if (v instanceof TextView) { if (v.getTag().toString().equals(AssetTypefaces.RobotoLight.toString())){ ((TextView)v).setTypeface(getTypeface(AssetTypefaces.RobotoLight)); }else if (v.getTag().toString().equals(AssetTypefaces.RobotoCondensedRegular.toString())) { ((TextView)v).setTypeface(getTypeface(AssetTypefaces.RobotoCondensedRegular)); }else if (v.getTag().toString().equals(AssetTypefaces.RobotoCondensedBold.toString())) { ((TextView)v).setTypeface(getTypeface(AssetTypefaces.RobotoCondensedBold)); }else if (v.getTag().toString().equals(AssetTypefaces.RobotoCondensedLight.toString())) { ((TextView)v).setTypeface(getTypeface(AssetTypefaces.RobotoCondensedLight)); }else if (v.getTag().toString().equals(AssetTypefaces.RobotoThin.toString())) { ((TextView)v).setTypeface(getTypeface(AssetTypefaces.RobotoThin)); } } } catch (Exception e) { e.printStackTrace(); // ignore } } } 

In deiner Aktivität oder deinem Fragment rufst du einfach an

 Fonts fonts = new Fonts(getActivity()); fonts.setupLayoutTypefaces(mainLayout); 

Ich denke, es kann einen besseren Weg geben, es zu tun. Die folgende class legt ein benutzerdefiniertes Schriftbild für alle Ihre Komponenten Ihrer Anwendung fest (mit einer Einstellung pro class).

 /** * Base Activity of our app hierarchy. * @author SNI */ public class BaseActivity extends Activity { private static final String FONT_LOG_CAT_TAG = "FONT"; private static final boolean ENABLE_FONT_LOGGING = false; private Typeface helloTypeface; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); helloTypeface = Typeface.createFromAsset(getAssets(), "fonts/.ttf"); } @Override public View onCreateView(String name, Context context, AttributeSet attrs) { View view = super.onCreateView(name, context, attrs); return setCustomTypeFaceIfNeeded(name, attrs, view); } @Override public View onCreateView(View parent, String name, Context context, AttributeSet attrs) { View view = super.onCreateView(parent, name, context, attrs); return setCustomTypeFaceIfNeeded(name, attrs, view); } protected View setCustomTypeFaceIfNeeded(String name, AttributeSet attrs, View view) { View result = null; if ("TextView".equals(name)) { result = new TextView(this, attrs); ((TextView) result).setTypeface(helloTypeface); } if ("EditText".equals(name)) { result = new EditText(this, attrs); ((EditText) result).setTypeface(helloTypeface); } if ("Button".equals(name)) { result = new Button(this, attrs); ((Button) result).setTypeface(helloTypeface); } if (result == null) { return view; } else { if (ENABLE_FONT_LOGGING) { Log.v(FONT_LOG_CAT_TAG, "A type face was set on " + result.getId()); } return result; } } } 

Ich habe auf dem Blog von Lisa Wray eine nette Lösung gefunden. Mit der neuen Datenbindung ist es möglich, die Schriftart in Ihren XML-Dateien festzulegen.

 @BindingAdapter({"bind:font"}) public static void setFont(TextView textView, String fontName){ textView.setTypeface(Typeface.createFromAsset(textView.getContext().getAssets(), "fonts/" + fontName)); } 

In XML:

  

Die Standardimplementierungen von LayoutInFlater unterstützen die Angabe der Schriftart aus XML nicht. Ich habe es jedoch in xml gesehen, indem ich eine benutzerdefinierte Factory für das LayoutInflater bereitgestellt habe, die solche Attribute vom XML-Tag analysieren wird.

Die Grundstruktur würde das mögen.

 public class TypefaceInflaterFactory implements LayoutInflater.Factory { @Override public View onCreateView(String name, Context context, AttributeSet attrs) { // CUSTOM CODE TO CREATE VIEW WITH TYPEFACE HERE // RETURNING NULL HERE WILL TELL THE INFLATER TO USE THE // DEFAULT MECHANISMS FOR INFLATING THE VIEW FROM THE XML } } public class BaseActivity extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); LayoutInflater.from(this).setFactory(new TypefaceInflaterFactory()); } } 

Dieser Artikel bietet eine ausführlichere Erklärung dieser Mechanismen und wie der Autor versucht, XML-Layout-Unterstützung für fonts auf diese Weise bereitzustellen. Der Code für die Implementierung des Autors finden Sie hier .

Festlegen einer benutzerdefinierten Schriftart für einen normalen ProgressDialog / AlertDialog:

 font=Typeface.createFromAsset(getAssets(),"DroidSans.ttf"); ProgressDialog dialog = ProgressDialog.show(this, "titleText", "messageText", true); ((TextView)dialog.findViewById(Resources.getSystem().getIdentifier("message", "id", "android"))).setTypeface(font); ((TextView)dialog.findViewById(Resources.getSystem().getIdentifier("alertTitle", "id", "android"))).setTypeface(font); 

Ja, es ist möglich, indem Sie die Standardschriftart überschreiben. Ich folgte dieser Lösung und es funktionierte wie ein Zauber für alle TextViews und ActionBar Text mit einer einzigen Änderung.

 public class MyApp extends Application { @Override public void onCreate() { TypefaceUtil.overrideFont(getApplicationContext(), "SERIF", "fonts/Roboto-Regular.ttf"); // font from assets: "assets/fonts/Roboto-Regular.ttf } } 

styles.xml

   

Anstelle von themes.xml, wie im obigen Link erwähnt, erwähnte ich die Standardschrift, die in meiner styles.xml in meinem Standard-App-Thementag überschrieben werden soll. Die Standardschriftarten, die überschrieben werden können, sind Serif, Sans, Monospace und Normal.

SchriftbildUtil.java

 public class TypefaceUtil { /** * Using reflection to override default typeface * NOTICE: DO NOT FORGET TO SET TYPEFACE FOR APP THEME AS DEFAULT TYPEFACE WHICH WILL BE OVERRIDDEN * @param context to work with assets * @param defaultFontNameToOverride for example "monospace" * @param customFontFileNameInAssets file name of the font from assets */ public static void overrideFont(Context context, String defaultFontNameToOverride, String customFontFileNameInAssets) { try { final Typeface customFontTypeface = Typeface.createFromAsset(context.getAssets(), customFontFileNameInAssets); final Field defaultFontTypefaceField = Typeface.class.getDeclaredField(defaultFontNameToOverride); defaultFontTypefaceField.setAccessible(true); defaultFontTypefaceField.set(null, customFontTypeface); } catch (Exception e) { Log.e("Can not set custom font " + customFontFileNameInAssets + " instead of " + defaultFontNameToOverride); } } } 

Anfangs wusste ich nicht, dass die zu überschreibenden Schriften fest und definiert sind, aber letztendlich half es mir zu verstehen, wie Android mit fonts und fonts und ihren Standardwerten umgeht, was natürlich anders ist.

Ich weiß nicht, ob es die gesamte App ändert, aber ich habe es geschafft, einige Komponenten zu ändern, die sonst nicht geändert werden könnten:

 Typeface tf = Typeface.createFromAsset(getAssets(), "fonts/Lucida Sans Unicode.ttf"); Typeface.class.getField("DEFAULT").setAccessible(true); Typeface.class.getField("DEFAULT_BOLD").setAccessible(true); Typeface.class.getField("DEFAULT").set(null, tf); Typeface.class.getField("DEFAULT_BOLD").set(null, tf); 

Ich mag Posps Vorschlag. Verwenden Sie die Eigenschaft ‘tag’ einer Ansicht (die Sie in XML angeben können – ‘android: tag’), um zusätzliche Stile anzugeben, die Sie in XML nicht ausführen können. Ich mag JSON, also würde ich eine JSON-Zeichenfolge verwenden, um einen Schlüssel / Wert festzulegen. Diese class erledigt die Arbeit – rufen Style.setContentView(this, [resource id]) einfach Style.setContentView(this, [resource id]) in Ihrer Aktivität auf.

 public class Style { /** * Style a single view. */ public static void apply(View v) { if (v.getTag() != null) { try { JSONObject json = new JSONObject((String)v.getTag()); if (json.has("typeface") && v instanceof TextView) { ((TextView)v).setTypeface(Typeface.createFromAsset(v.getContext().getAssets(), json.getString("typeface"))); } } catch (JSONException e) { // Some views have a tag without it being explicitly set! } } } /** * Style the passed view hierarchy. */ public static View applyTree(View v) { apply(v); if (v instanceof ViewGroup) { ViewGroup g = (ViewGroup)v; for (int i = 0; i < g.getChildCount(); i++) { applyTree(g.getChildAt(i)); } } return v; } /** * Inflate, style, and set the content view for the passed activity. */ public static void setContentView(Activity activity, int resource) { activity.setContentView(applyTree(activity.getLayoutInflater().inflate(resource, null))); } } 

Offensichtlich würden Sie mehr als nur die Schriftart behandeln wollen, die sich mit JSON lohnt.

Ein Vorteil der Eigenschaft 'tag' besteht darin, dass Sie sie auf einen Basisstil einstellen können, den Sie als Thema verwenden, sodass sie automatisch auf alle Ihre Ansichten angewendet wird. EDIT: Dies führt zu einem Absturz während der Inflation auf Android 4.0.3. Sie können weiterhin einen Stil verwenden und ihn einzeln auf Textansichten anwenden.

Eine Sache, die Sie im Code sehen werden - einige Ansichten haben ein Tag, ohne dass eines explizit angegeben wird - seltsamerweise ist es die Zeichenfolge "Αποκοπή" - die laut google translate "griechisch" ist. Was zum Teufel...?

@ majinboos Antwort wurde für die Performance- und Speicherverwaltung überarbeitet. Wenn mehr als eine Schriftart benötigt wird, kann Activity diese Font-class verwenden, indem sie den Konstruktor selbst als Parameter angibt.

 @Override public void onCreate(Bundle savedInstanceState) { Font font = new Font(this); } 

Überarbeitete fonts-class ist wie folgt:

 public class Fonts { private HashMap hashMapFonts; private enum AssetTypefaces { RobotoLight, RobotoThin, RobotoCondensedBold, RobotoCondensedLight, RobotoCondensedRegular } public Fonts(Context context) { AssetManager mngr = context.getAssets(); hashMapFonts = new HashMap(); hashMapFonts.put(AssetTypefaces.RobotoLight, Typeface.createFromAsset(mngr, "fonts/Roboto-Light.ttf")); hashMapFonts.put(AssetTypefaces.RobotoThin, Typeface.createFromAsset(mngr, "fonts/Roboto-Thin.ttf")); hashMapFonts.put(AssetTypefaces.RobotoCondensedBold, Typeface.createFromAsset(mngr, "fonts/RobotoCondensed-Bold.ttf")); hashMapFonts.put(AssetTypefaces.RobotoCondensedLight, Typeface.createFromAsset(mngr, "fonts/RobotoCondensed-Light.ttf")); hashMapFonts.put(AssetTypefaces.RobotoCondensedRegular, Typeface.createFromAsset(mngr, "fonts/RobotoCondensed-Regular.ttf")); } private Typeface getTypeface(String fontName) { try { AssetTypefaces typeface = AssetTypefaces.valueOf(fontName); return hashMapFonts.get(typeface); } catch (IllegalArgumentException e) { // e.printStackTrace(); return Typeface.DEFAULT; } } public void setupLayoutTypefaces(View v) { try { if (v instanceof ViewGroup) { ViewGroup vg = (ViewGroup) v; for (int i = 0; i < vg.getChildCount(); i++) { View child = vg.getChildAt(i); setupLayoutTypefaces(child); } } else if (v instanceof TextView) { ((TextView) v).setTypeface(getTypeface(v.getTag().toString())); } } catch (Exception e) { e.printStackTrace(); // ignore } } } 

Arbeiten für Xamarin.Android:

class:

 public class FontsOverride { public static void SetDefaultFont(Context context, string staticTypefaceFieldName, string fontAssetName) { Typeface regular = Typeface.CreateFromAsset(context.Assets, fontAssetName); ReplaceFont(staticTypefaceFieldName, regular); } protected static void ReplaceFont(string staticTypefaceFieldName, Typeface newTypeface) { try { Field staticField = ((Java.Lang.Object)(newTypeface)).Class.GetDeclaredField(staticTypefaceFieldName); staticField.Accessible = true; staticField.Set(null, newTypeface); } catch (Exception e) { Console.WriteLine(e.Message); } } } 

Anwendungsimplementierung:

 namespace SomeAndroidApplication { [Application] public class App : Application { public App() { } public App(IntPtr handle, JniHandleOwnership transfer) : base(handle, transfer) { } public override void OnCreate() { base.OnCreate(); FontsOverride.SetDefaultFont(this, "MONOSPACE", "fonts/Roboto-Light.ttf"); } } } 

Stil:

  

Es sieht so aus, als wäre die Verwendung von benutzerdefinierten fonts mit Android O leicht gemacht worden, Sie können grundsätzlich xml verwenden, um dies zu erreichen. Ich habe einen Link zur offiziellen Android-Dokumentation als Referenz beigefügt, und hoffentlich hilft das Leuten, die diese Lösung noch benötigen. Mit benutzerdefinierten fonts in Android arbeiten

Mit der neuen Support-Bibliothek 26 können Sie jetzt Zeichensätze in XML verwenden.

Hier ist, wie es fonts in XML

Absolut möglich. Viele Möglichkeiten, es zu tun. Der schnellste Weg, erstellen Sie eine Bedingung mit try – catch – Methode .. versuchen Sie Ihre bestimmte Schriftart Stil Bedingung, fangen Sie den Fehler, und definieren Sie die andere Schriftart.