Comment définir par programme un attribut de style dans une vue ?

Question

J'obtiens une vue du XML avec le code ci-dessous :

Button view = (Button) LayoutInflater.from(this).inflate(R.layout.section_button, null);

Je voudrais définir un "style" pour le bouton. Comment puis-je le faire en Java puisque je veux utiliser plusieurs styles pour chaque bouton que j'utiliserai.

Answer 1

En fonction des attributs de style que vous souhaitez modifier, vous pourrez peut-être utiliser la bibliothèque de Paris :

Button view = (Button) LayoutInflater.from(this).inflate(R.layout.section_button, null);
Paris.style(view).apply(R.style.YourStyle);

De nombreux attributs tels que background, padding, textSize, textColor, etc. sont pris en charge.

• Liste des attributs actuellement pris en charge
• Instructions d'installation

Clause de non-responsabilité : Je suis l'auteur de la bibliothèque.

Answer 2

La réponse de @Dayerman et @h_rules est juste. Pour donner un exemple élaboré avec du code, Dans le dossier drawable, créez un fichier xml appelé button_disabled.xml.

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
android:shape="rectangle" android:padding="10dp">   
 <solid android:color="@color/silver"/>
<corners
   android:bottomRightRadius="20dp"
   android:bottomLeftRadius="20dp"
   android:topLeftRadius="20dp"
   android:topRightRadius="20dp"/>
</shape>

Puis en Java,

((Button) findViewById(R.id.my_button)).setEnabled(false);
((Button) findViewById(R.id.my_button)).setBackgroundResource(R.drawable.button_disabled);

La propriété du bouton sera désactivée et la couleur sera argentée.

[La couleur est définie dans color.xml comme :

<resources>

    <color name="silver">#C0C0C0</color>

</resources>

Answer 3

Pour tous ceux qui cherchent une réponse matérielle, voir ce post de SO : Boutons à colorier dans Android avec Material Design et AppCompat

J'ai utilisé une combinaison de cette réponse pour définir la couleur du texte par défaut du bouton en blanc pour mon bouton : https://stackoverflow.com/a/32238489/3075340

Alors cette réponse https://stackoverflow.com/a/34355919/3075340 pour définir de manière programmatique la couleur d'arrière-plan. Le code pour cela est le suivant :

ViewCompat.setBackgroundTintList(your_colored_button,
 ContextCompat.getColorStateList(getContext(),R.color.your_custom_color));

your_colored_button peut être un simple Button ou un bouton AppCompat si vous le souhaitez - j'ai testé le code ci-dessus avec les deux types de boutons et cela fonctionne.

EDIT : J'ai découvert que les appareils pré-lollipop ne fonctionnent pas avec le code ci-dessus. Voir ce post sur la façon d'ajouter le support pour les appareils pré-lollipop : https://stackoverflow.com/a/30277424/3075340

En gros, faites ça :

Button b = (Button) findViewById(R.id.button);
ColorStateList c = ContextCompat.getColorStateList(mContext, R.color.your_custom_color;
Drawable d = b.getBackground();
if (b instanceof AppCompatButton) {
    // appcompat button replaces tint of its drawable background
    ((AppCompatButton)b).setSupportBackgroundTintList(c);
} else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    // Lollipop button replaces tint of its drawable background
    // however it is not equal to d.setTintList(c)
    b.setBackgroundTintList(c);
} else {
    // this should only happen if 
    // * manually creating a Button instead of AppCompatButton
    // * LayoutInflater did not translate a Button to AppCompatButton
    d = DrawableCompat.wrap(d);
    DrawableCompat.setTintList(d, c);
    b.setBackgroundDrawable(d);
}

Answer 4

Au moment de l'exécution, vous savez quel style vous voulez donner à votre bouton. Ainsi, à l'avance, dans le dossier layout, vous pouvez avoir tous les boutons prêts à l'emploi avec les styles dont vous avez besoin. Ainsi, dans le dossier layout, vous pouvez avoir un fichier nommé : button_style_1.xml. Le contenu de ce fichier pourrait ressembler à ceci

<?xml version="1.0" encoding="utf-8"?>
<Button
    android:id="@+id/styleOneButton"
    style="@style/FirstStyle" />

Si vous travaillez avec des fragments, alors dans onCreateView vous gonflez ce bouton, comme :

Button firstStyleBtn = (Button) inflater.inflate(R.layout.button_style_1, container, false);

où container est le conteneur ViewGroup associé à la méthode onCreateView que vous surchargez lors de la création de votre fragment.

Vous avez besoin de deux autres boutons de ce type ? Vous les créez comme ceci :

Button secondFirstStyleBtn = (Button) inflater.inflate(R.layout.button_style_1, container, false);
Button thirdFirstStyleBtn = (Button) inflater.inflate(R.layout.button_style_1, container, false);

Vous pouvez personnaliser ces boutons :

secondFirstStyleBtn.setText("My Second");
thirdFirstStyleBtn.setText("My Third");

Ensuite, vous ajoutez vos boutons personnalisés et stylisés au conteneur de mise en page que vous avez également gonflé dans la méthode onCreateView :

_stylizedButtonsContainer = (LinearLayout) rootView.findViewById(R.id.stylizedButtonsContainer);

_stylizedButtonsContainer.addView(firstStyleBtn);
_stylizedButtonsContainer.addView(secondFirstStyleBtn);
_stylizedButtonsContainer.addView(thirdFirstStyleBtn);

Et c'est ainsi que vous pouvez travailler dynamiquement avec des boutons stylisés.

Answer 5

J'ai fait une interface d'aide pour cela en utilisant le modèle de support.

public interface StyleHolder<V extends View> {
    void applyStyle(V view);
}

Maintenant, pour chaque style que vous voulez utiliser de manière pragmatique, il suffit d'implémenter l'interface, par exemple :

public class ButtonStyleHolder implements StyleHolder<Button> {

    private final Drawable background;
    private final ColorStateList textColor;
    private final int textSize;

    public ButtonStyleHolder(Context context) {
        TypedArray ta = context.obtainStyledAttributes(R.style.button, R.styleable.ButtonStyleHolder);

        Resources resources = context.getResources();

        background = ta.getDrawable(ta.getIndex(R.styleable.ButtonStyleHolder_android_background));

        textColor = ta.getColorStateList(ta.getIndex(R.styleable.ButtonStyleHolder_android_textColor));

        textSize = ta.getDimensionPixelSize(
                ta.getIndex(R.styleable.ButtonStyleHolder_android_textSize),
                resources.getDimensionPixelSize(R.dimen.standard_text_size)
        );

        // Don't forget to recycle!
        ta.recycle();
    }

    @Override
    public void applyStyle(Button btn) {
        btn.setBackground(background);
        btn.setTextColor(textColor);
        btn.setTextSize(TypedValue.COMPLEX_UNIT_PX, textSize);
    }
}

Déclarez un stylet dans votre attrs.xml le styleable pour cet exemple est :

<declare-styleable name="ButtonStyleHolder">
    <attr name="android:background" />
    <attr name="android:textSize" />
    <attr name="android:textColor" />
</declare-styleable>

Voici le style déclaré dans styles.xml :

<style name="button">
    <item name="android:background">@drawable/button</item>
    <item name="android:textColor">@color/light_text_color</item>
    <item name="android:textSize">@dimen/standard_text_size</item>
</style>

Et enfin l'implémentation du support de style :

Button btn = new Button(context);    
StyleHolder<Button> styleHolder = new ButtonStyleHolder(context);
styleHolder.applyStyle(btn);

J'ai trouvé cela très utile car il peut être facilement réutilisé et garde le code propre et verbeux, je recommanderais de l'utiliser seulement comme une variable locale afin de permettre au ramasseur de déchets de faire son travail une fois que nous avons fini de définir tous les styles.