Comment définir une police particulière pour le texte d'un bouton sous Android?
Je veux que le texte de mon bouton soit dans la police Copperplate Gothic Light et je n’ai pas encore trouvé de code propre et clair pour une fonction aussi simple que celle-ci. Aidez-moi!
PS: Étant donné qu'Android vient avec Ariel et quelques autres polices, nous devons importer ((excuses pour le manque d'un meilleur mot car je suis nouveau dans ce domaine) la police que nous souhaitons utiliser. C’est tout ce que j’ai pu rassembler jusqu’à présent et c’est là que le chemin se termine pour moi.
Si vous envisagez d'ajouter la même police à plusieurs boutons, je vous suggère d'aller jusqu'au bout et de l'implémenter en tant que bouton de style et de sous-classe:
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);
}
}
Il s'agit d'une classe auxiliaire permettant de définir une police sur un TextView (rappelez-vous, Button est une sous-classe de TextView) basée sur l'attribut com.my.package: font:
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);
}
}
}
Et voici FontCache pour réduire l'utilisation de la mémoire sur les appareils plus anciens :
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;
}
}
Dans res/values / attrs.xml, nous définissons l'attribut styleable personnalisé.
<?xml version="1.0" encoding="utf-8"?>
<resources>
<declare-styleable name="CustomFont">
<attr name="font" format="string"/>
</declare-styleable>
</resources>
Et enfin un exemple d'utilisation dans une mise en page:
<com.my.package.buttons.ButtonPlus
style="@style/button"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:text="@string/button_sometext"/>
Et dans 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>
Cela peut sembler une charge de travail énorme, mais vous me remercierez lorsque vous aurez quelques poignées de boutons et de champs de texte sur lesquels vous souhaitez modifier la police.
1) Obtenez la police dont vous avez besoin sous forme de fichier .ttf (CopperplateGothicLight.ttf, par exemple) et placez-la dans le répertoire/assets/de votre projet.
2) Utilisez ce code pour faire référence à la police et réglez-le sur votre bouton:
Typeface copperplateGothicLight = Typeface.createFromAsset(getAppContext().getAssets(), "CopperplateGothicLight.ttf");
yourButton.setTypeface(copperplateGothicLight);
Après plusieurs recherches, ma meilleure option était:
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);
}
}
then Utilisation de fontCache à partir de la première réponse: Fuites de mémoire avec la police personnalisée pour définir la police personnalisée
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;
}
}
Moins de code et plus d'utilisation des normes Android!
MainActivity.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" />
Lien de téléchargement de la police de votre choix: copperplate_gothic_light
placez-le dans votre dossier de ressources.
Capture d'écran:
J'espère que ça vous sera utile !!
Vous pouvez utiliser la classe de boutons personnalisée comme indiqué ci-dessous. Placez votre police dans le dossier actifs/polices.
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);
}
}
Maintenant, vous pouvez utiliser le bouton en XML comme indiqué ci-dessous.
<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" />
Vous pouvez utiliser le code ci-dessous. Il suffit de remplacer le nom de la police dans la méthode mTextFont () selon vos besoins.
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);
}
Commencez par télécharger le fichier TTF pour le style de police, puis placez-le dans le dossier assets de votre projet.
Vous pouvez le définir par programme de la manière suivante:
Typeface font_style = Typeface.createFromAsset(getAssets(), "yourcystomfontstyle.ttf");
yourbutton.setTypeface(font_style);
Essaye ça. Aussi utile pour EditTextViews, TextViews .. peu importe!
<your.namespace.app.FontButton
app:font="montserrat"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"/>
Qui est possible? Par ce moyen!
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;
}
De plus, un font_attrs.xml dans votre dossier res:
<?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>
Notez qu'il vous suffit de modifier les variables
FontManageretfont_attrs.xmlpour personnaliser vos polices!