it-swarm.com.de

Wie kann man eine bestimmte Schriftart für einen Schaltflächentext in Android einstellen?

Ich möchte, dass mein Schaltflächentext in der Schriftart Copperplate Gothic Light angezeigt wird, und ich bin noch nicht auf einen einfachen, sauberen Code für eine einfache Funktion wie diese gestoßen. Hilfe! 

PS: Da Android mit Ariel und ein paar anderen Schriftarten allein geliefert wird, müssen wir import (entschuldigen Sie sich für das Fehlen eines besseren Wortes, da ich neu dazu bin) die Schriftart, die wir verwenden möchten. Dies ist alles, was ich bisher sammeln konnte, und hier endet der Weg für mich.

37
Garima Tiwari

Wenn Sie vorhaben, die gleiche Schriftart zu mehreren Schaltflächen hinzuzufügen, empfehlen wir Ihnen, die gesamte Schriftart als Stil- und Unterklassenschaltfläche zu implementieren:

public class ButtonPlus extends Button {

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

    public ButtonPlus(Context context, AttributeSet attrs) {
        super(context, attrs);
        CustomFontHelper.setCustomFont(this, context, attrs);
    }

    public ButtonPlus(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        CustomFontHelper.setCustomFont(this, context, attrs);
    }
}

Dies ist eine Hilfsklasse zum Festlegen einer Schriftart in einer TextView (denken Sie daran, Button ist eine Unterklasse von TextView), die auf dem Attribut com.my.package: font basiert:

public class CustomFontHelper {

    /**
     * Sets a font on a textview based on the custom com.my.package:font attribute
     * If the custom font attribute isn't found in the attributes nothing happens
     * @param textview
     * @param context
     * @param attrs
     */
    public static void setCustomFont(TextView textview, Context context, AttributeSet attrs) {
        TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.CustomFont);
        String font = a.getString(R.styleable.CustomFont_font);
        setCustomFont(textview, font, context);
        a.recycle();
    }

    /**
     * Sets a font on a textview
     * @param textview
     * @param font
     * @param context
     */
    public static void setCustomFont(TextView textview, String font, Context context) {
        if(font == null) {
            return;
        }
        Typeface tf = FontCache.get(font, context);
        if(tf != null) {
            textview.setTypeface(tf);
        }
    }

}

Und hier ist der FontCache, um den Speicherbedarf auf älteren Geräten zu reduzieren :

public class FontCache {

    private static Hashtable<String, Typeface> fontCache = new Hashtable<String, Typeface>();

    public static Typeface get(String name, Context context) {
        Typeface tf = fontCache.get(name);
        if(tf == null) {
            try {
                tf = Typeface.createFromAsset(context.getAssets(), name);
            }
            catch (Exception e) {
                return null;
            }
            fontCache.put(name, tf);
        }
        return tf;
    }
}

In res/values ​​/ attrs.xml definieren wir das benutzerdefinierte styleable-Attribut

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <declare-styleable name="CustomFont">
        <attr name="font" format="string"/>
    </declare-styleable>
</resources>

Und zum Schluss noch ein Beispiel in einem Layout:

    <com.my.package.buttons.ButtonPlus
        style="@style/button"
        Android:layout_width="wrap_content"
        Android:layout_height="wrap_content"
        Android:text="@string/button_sometext"/>

Und in res/values ​​/ style.xml

<style name="button" parent="@Android:style/Widget.Button">
    <item name="com.my.package:font">fonts/copperplate_gothic_light.TTF</item>
</style>

Das mag eine Menge Arbeit sein, aber Sie werden mir danken, wenn Sie ein paar Handvoll Schaltflächen und Textfelder haben, an denen Sie die Schriftart ändern möchten.

133
britzl

1) Holen Sie sich die gewünschte Schriftart als .ttf-Datei (beispielsweise CopperplateGothicLight.ttf) und platzieren Sie sie im Verzeichnis/assets/Ihres Projekts

2) Verwenden Sie diesen Code, um auf die Schriftart zu verweisen und setzen Sie sie auf Ihre Schaltfläche:

Typeface copperplateGothicLight = Typeface.createFromAsset(getAppContext().getAssets(), "CopperplateGothicLight.ttf"); 
yourButton.setTypeface(copperplateGothicLight);
11
npace

Nach mehreren Recherchen war meine beste Option:

public class CustomButton extends Button {

    Typeface normalTypeface = FontCache.get("fonts/CopperplateGothicLight.ttf", getContext());
    Typeface boldTypeface = FontCache.get("fonts/CopperplateGothicBold.ttf", getContext());

    /**
     * @param context
     */
    public CustomButton(Context context) {
        super(context);
    }

    /**
     * @param context
     * @param attrs
     */
    public CustomButton(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    /**
     * @param context
     * @param attrs
     * @param defStyleAttr
     */
    public CustomButton(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

}

dann Verwenden von fontCache aus der ersten Antwort zu diesem Thema: Der Speicher verliert mit der benutzerdefinierten Schriftart, um die benutzerdefinierte Schriftart festzulegen

public class FontCache {
    private static Hashtable<String, Typeface> fontCache = new Hashtable<String, Typeface>();

    public static Typeface get(String name, Context context) {
        Typeface tf = fontCache.get(name);
        if(tf == null) {
            try {
                tf = Typeface.createFromAsset(context.getAssets(), name);
            }
            catch (Exception e) {
                return null;
            }
            fontCache.put(name, tf);
        }
        return tf;
    }
}

Weniger Code und mehr Nutzung der Android-Standards!

3

Hauptaktivität.Java

    package com.mehuljoisar.customfontdemo;

import Android.app.Activity;
import Android.graphics.Typeface;
import Android.os.Bundle;
import Android.view.Menu;
import Android.widget.Button;

public class MainActivity extends Activity {

    private Button button1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        button1 = (Button)findViewById(R.id.button1);
        button1.setTypeface(Typeface.createFromAsset(getAssets(), "copperplate-gothic-light.ttf"));
        button1.setText("hello");
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.activity_main, menu);
        return true;
    }

}

activity_main.xml

<RelativeLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
xmlns:tools="http://schemas.Android.com/tools"
Android:layout_width="match_parent"
Android:layout_height="match_parent"
tools:context=".MainActivity" >

<TextView
    Android:layout_width="wrap_content"
    Android:layout_height="wrap_content"
    Android:layout_centerHorizontal="true"
    Android:layout_centerVertical="true"
    Android:text="@string/hello_world" />

<Button
    Android:id="@+id/button1"
    Android:layout_width="wrap_content"
    Android:layout_height="wrap_content"
    Android:layout_alignParentLeft="true"
    Android:layout_alignParentTop="true"
    Android:layout_marginTop="24dp"
    Android:text="Button" />

Downloadlink für Ihre gewünschte Schriftart: copperplate_gothic_light

legen Sie es in Ihren Anlagenordner.

Bildschirmfoto:enter image description here

Ich hoffe es wird hilfreich sein !!

2
Mehul Joisar

Sie können die benutzerdefinierte Button-Klasse wie unten angegeben verwenden. Legen Sie Ihre Schriftart in den Asset/Font-Ordner ab.

public class CustomButton extends Button{


    public CustomButton(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
        // TODO Auto-generated constructor stub
    }
    public CustomButton(Context context) {
        super(context);
        init();
        // TODO Auto-generated constructor stub
    }
    public CustomButton(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init();
        // TODO Auto-generated constructor stub
    }
    private void init(){
        Typeface font_type=Typeface.createFromAsset(getContext().getAssets(), "font/ProximaNova-Bold.ttf");
        setTypeface(font_type);
    }
}

Jetzt können Sie die Schaltfläche in xml wie unten angegeben verwenden.

<model.CustomButton
            Android:id="@+id/search"
            Android:layout_width="@dimen/edittext_width_large"
            Android:layout_height="@dimen/button_height"
            Android:layout_below="@+id/cars"
            Android:layout_centerHorizontal="true"
            Android:layout_marginTop="@dimen/pad_20dp"
            Android:background="@drawable/button_pressed_bg"
            Android:text="@string/find_car"
            Android:textColor="@color/white" />
0
jinosh

Sie können den folgenden Code verwenden. Ersetzen Sie einfach den Schriftartnamen in der mTextFont () -Methode gemäß Ihrer Anforderung.

public class Button_Roboto_Regular extends Button {
public Button_Roboto_Regular(Context context) {
    super(context);
    mTextFont(context);
}

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

public Button_Roboto_Regular(Context context, AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
    mTextFont(context);
}
private void mTextFont(Context context) {
    Typeface face = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-Regular_0.ttf");
    this.setTypeface(face);
}
0
VIVEK CHOUDHARY

Laden Sie zunächst die TTF-Datei für den Schriftstil herunter und legen Sie sie im Ordner assets Ihres Projekts ab.

Sie können es programmgesteuert auf folgende Weise einstellen:

Typeface font_style = Typeface.createFromAsset(getAssets(), "yourcystomfontstyle.ttf");  
yourbutton.setTypeface(font_style);
0
Rahil2952

Versuche dies. Auch nützlich für EditTextViews, TextViews ... was auch immer!

<your.namespace.app.FontButton
     app:font="montserrat"
     Android:layout_width="wrap_content"
     Android:layout_height="wrap_content"/>

Wer ist möglich Auf diese Weise!

public class FontButton extends Button {

public FontEditText(Context context) {
    this( context, null );
}

public FontEditText(Context context, AttributeSet attrs) {
    this( context, attrs, 0 );
    init( context, attrs );
}

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

public FontEditText(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
    super( context, attrs, defStyleAttr, defStyleRes );
    init( context, attrs );
}

private void init(Context context, AttributeSet attrs) {
    TypedArray ta = context.obtainStyledAttributes( attrs, R.styleable.Fonts );

    if ( ta != null ) {
        String fontAsset = ta.getString( R.styleable.Fonts_font );
        if ( !StringUtils.isEmpty( fontAsset ) ) {
            int type = Integer.parseInt( fontAsset );

            Typeface typeFace = FontManager.getInstance( context ).getByType( type );
            ta.recycle();
            super.setTypeface( typeFace );
        }
    }
}

}

public class FontManager {

private static FontManager Instance;

private Context context;

private Typeface robotoCondensedBold;
private Typeface robotoCondensed;
private Typeface robotoLight;
private Typeface kronica;
private Typeface montserrat;
private Typeface montserratLight;
private Typeface keepCalmMedium;

private FontManager(Context context) {
    this.context = context;
    this.robotoCondensedBold = Typeface.createFromAsset( context.getAssets(), "fonts/RobotoCondensed-Bold.ttf" );
    this.robotoCondensed = Typeface.createFromAsset( context.getAssets(), "fonts/RobotoCondensed-Regular.ttf" );
    this.robotoLight = Typeface.createFromAsset( context.getAssets(), "fonts/Roboto-Light.ttf" );
    this.kronica = Typeface.createFromAsset( context.getAssets(), "fonts/kronika.ttf" );
    this.montserrat = Typeface.createFromAsset( context.getAssets(), "fonts/Montserrat-Regular.ttf" );
    this.montserratLight = Typeface.createFromAsset( context.getAssets(), "fonts/Montserrat-Light.ttf" );
    this.keepCalmMedium = Typeface.createFromAsset( context.getAssets(), "fonts/KeepCalmMedium.ttf" );
}

public synchronized static FontManager getInstance(Context context) {
    if ( Instance == null )
        Instance = new FontManager( context );

    return Instance;
}

public Typeface getByType(int type) {
    switch ( type ) {
        case 0:
            return FontManager.getInstance( context ).getRobotoCondensedBold();
        case 1:
            return FontManager.getInstance( context ).getRobotoLight();
        case 2:
            return FontManager.getInstance( context ).getKronica();
        case 3:
            return FontManager.getInstance( context ).getRobotoCondensed();
        case 4:
            return FontManager.getInstance( context ).getMontserrat();
        case 5:
            return FontManager.getInstance( context ).getMontserratLight();
        case 6:
            return FontManager.getInstance( context ).getKeepCalmMedium();
        default:
            return Typeface.DEFAULT;
    }
}

public Typeface getRobotoCondensedBold() {
    return robotoCondensedBold;
}

public Typeface getKronica() {
    return kronica;
}

public Typeface getRobotoCondensed() {
    return robotoCondensed;
}

public Typeface getRobotoLight() {
    return robotoLight;
}

public Typeface getMontserrat() {
    return montserrat;
}

public Typeface getMontserratLight() {
    return montserratLight;
}

public Typeface getKeepCalmMedium() {
    return keepCalmMedium;
}

Zusätzlich einen font_attrs.xml in Ihrem res-Ordner:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <declare-styleable name="Fonts">
        <attr name="font" format="enum">
            <enum name="robotoCondensedBold" value="0"/>
            <enum name="robotoLight" value="1"/>
            <enum name="kronica" value="2"/>
            <enum name="robotoCondensed" value="3"/>
            <enum name="montserrat" value="4"/>
            <enum name="montserratLight" value="5"/>
            <enum name="keepCalmMedium" value="6"/>
        </attr>
    </declare-styleable>
</resources> 

Beachten Sie, dass Sie lediglich FontManager und font_attrs.xml ändern müssen, um Ihre Schriftarten anzupassen.

0
Rafa0809