Comment définir par programmation de l'attribut style dans une vue

Je reçois une vue à partir du XML avec le code ci-dessous:

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

Je voudrais mettre un "style" pour le bouton comment puis-je le faire en java depuis un souhaitez utiliser plusieurs style pour chaque bouton que je vais utiliser.

InformationsquelleAutor Lint_ | 2010-01-06

android styles

49

En général, vous ne pouvez pas modifier les styles par programmation, vous pouvez définir l'apparence d'un écran ou d'une partie d'une mise en page ou de l'individu bouton dans votre XML de mise en page à l'aide de des thèmes ou des styles. Les thèmes peuvent, toutefois, être appliquée par programmation.

Il y a aussi une telle chose comme un StateListDrawable qui vous permet de définir différents un drawable pour chaque état de la votre Button peut-être, qu'il s'agisse d', sélectionné, pressé, les handicapés, et ainsi de suite.

Par exemple, pour obtenir votre bouton de changer de couleur lorsqu'il est pressé, vous pouvez définir un fichier XML appelé res/drawable/my_button.xml répertoire comme ceci:
```
<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
  <item
    android:state_pressed="true"
    android:drawable="@drawable/btn_pressed" />
  <item
    android:state_pressed="false"
    android:drawable="@drawable/btn_normal" />
</selector>
```
Vous pouvez ensuite appliquer ce sélecteur pour un Button par la définition de la propriété android:background="@drawable/my_button".
- Mon problème est que j'ai charger des données à partir d'un webservice qui décrivent mon bouton info. Les boutons doivent avoir un style différent basé sur une catégorie à laquelle ils appartiennent. C'est pourquoi je tiens à mettre en style dynamicly.
- Eh bien, vous ne pouvez pas changer le Android style attribut, mais vous pouvez définir par programmation le fond d'un Button comme vous le feriez avec tout autre point de vue, si cela suffira. Aussi, en tant que Button hérite de TextView, vous pouvez modifier les propriétés du texte. Il suffit de regarder la documentation de l'API pour ces articles... developer.android.com/reference/android/view/...
- Je viens de penser à le faire, juste avant de vérifier si j'ai eu de nouvelles réponses. Merci beaucoup.
- N'est-il pas possible de créer un style pour un bouton qui définit la taille du texte, les marges, etc etc, et ensuite l'appliquer à un bouton par programmation. Sûrement son possible dire si j'ai six boutons qui veulent avoir le même style?
- l'attribut on peut gonfler ? peut-on gonfler les marges , rembourrage ?
InformationsquelleAutor Christopher Orr
40

Tout d'abord, vous n'avez pas besoin d'utiliser une mise en page inflater pour créer un simple Bouton. Vous pouvez simplement utiliser:
```
button = new Button(context);
```
Si vous voulez le style, la touche, vous avez 2 choix: le plus simple est de spécifier tous les éléments dans le code, comme beaucoup d'autres réponses suggèrent:
```
button.setTextColor(Color.RED);
button.setTextSize(TypedValue.COMPLEX_UNIT_SP, 18);
```
L'autre option est de définir le style de XML, et de l'appliquer à la touche. Dans le cas général, vous pouvez utiliser un ContextThemeWrapper pour cela:
```
ContextThemeWrapper newContext = new ContextThemeWrapper(baseContext, R.style.MyStyle);
button = new Button(newContext);
```
De modifier le texte et les attributs liés à un TextView (ou de ses sous-classes comme le Bouton) il y a une méthode spéciale:
```
button.setTextAppearance(context, R.style.MyTextStyle);
```
Ce dernier ne peut pas être utilisé pour modifier tous les attributs; par exemple pour changer de rembourrage, vous devez utiliser un ContextThemeWrapper. Mais pour la couleur du texte, taille, etc. vous pouvez utiliser setTextAppearance.
- Il n'est pas du travail pour moi. 🙁
- Il ne fonctionne que pour certains attributs
- Tout simplement génial. ContextThemeWrapper - est ce que je cherchais depuis si longtemps.
- Cela fonctionne merveilleusement. Été à la recherche de cette solution pendant un certain temps.
InformationsquelleAutor beetstra
14

Oui, vous pouvez utiliser par exemple dans un bouton
```
Button b = new Button(this);
b.setBackgroundResource(R.drawable.selector_test);
```
- Qui va définir l'arrière-plan, mais d'un style peut spécifier plus qu'un simple arrière-plan. Beaucoup de points de Vue (y compris Bouton) semblent avoir un constructeur qui prend un style ID en paramètre. Cependant, je vais avoir des problèmes pour obtenir que cela fonctionne pour moi, le bouton s'affiche sous forme de texte avec pas de frontière ou de quoi que ce soit. Ce que je pourrais faire à la place est de créer une mise en page avec seulement un bouton (avec un style spécifié), gonfler cette mise en page, puis réglez le bouton de texte et autres joyeusetés.
InformationsquelleAutor Dayerman
9

Vous pouvez faire les attributs de style comme:
```
Button myButton = new Button(this, null,android.R.attr.buttonBarButtonStyle);
```
à la place de:
```
<Button
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:id="@+id/btn"
    style="?android:attr/buttonBarButtonStyle"

    />
```
- Bonne réponse en considérant un bouton doit être créé. Il serait bon de voir comment le faire que pour un bouton existant.
- Voir la réponse de cesards.
- c'est ce que je suis à la recherche d'
InformationsquelleAutor Kristy Welsh

Pour ceux qui recherchent un Matériau réponse de voir cette SI post: Coloriage les Boutons Android avec la Conception de Matériel et AppCompat

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

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

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

your_colored_button peut être juste un Button ou un AppCompat bouton si vous le désirez, j'ai testé le code ci-dessus avec les deux types de boutons et ça fonctionne.

EDIT: j'ai trouvé que la pré-sucette périphériques ne fonctionne pas avec le code ci-dessus. Voir ce post sur comment ajouter la prise en charge pré-sucette appareils: https://stackoverflow.com/a/30277424/3075340

Fondamentalement ce faire:

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);
}

InformationsquelleAutor Micro

6

Si vous utilisez la bibliothèque de prise en charge, vous pouvez simplement utiliser
```
TextViewCompat.setTextAppearance(getContext(), R.style.AppTheme_TextStyle_ButtonDefault_Whatever);
```
pour TextViews et des Boutons. Il existe des classes pour le reste des points de Vue 🙂

InformationsquelleAutor cesards

La réponse par @Dayerman et @h_rules est droit.
Pour donner un élaboré exemple avec code,
Dans drawable dossier, créer 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);

Cela va régler le bouton de la propriété pour les handicapés et définit la couleur de l'argent.

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

<resources>

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

</resources>

Le point de l'ensemble de cette question est pas pour utiliser le format xml.
la question ne dis pas ça du tout. C'est ambigu si le style est le XML ou en java. Il demande seulement comment définir le style de la programmation.

InformationsquelleAutor biniam

3

Au moment de l'exécution, vous savez quel style vous voulez que votre bouton. Donc, à l'avance, en xml, la mise en page de dossier, vous pouvez avoir tout prêt à aller boutons avec les styles dont vous avez besoin. Donc, dans la mise en page de dossier, vous pouvez avoir un fichier nommé: button_style_1.xml. Le contenu de ce fichier peut ressembler à:
```
<?xml version="1.0" encoding="utf-8"?>
<Button
    android:id="@+id/styleOneButton"
    style="@style/FirstStyle" />
```
Si vous travaillez avec des fragments, puis dans onCreateView vous gonflez le bouton, comme:
```
Button firstStyleBtn = (Button) inflater.inflate(R.layout.button_style_1, container, false);
```
où le conteneur est le ViewGroup container associés à la onCreateView méthode vous remplacer lors de la création de votre fragment.

Besoin de deux autres boutons? Vous créer 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");
```
Puis vous ajoutez votre personnalisé, stylisée des boutons à la disposition de conteneurs vous aussi gonflé dans le onCreateView méthode:
```
_stylizedButtonsContainer = (LinearLayout) rootView.findViewById(R.id.stylizedButtonsContainer);

_stylizedButtonsContainer.addView(firstStyleBtn);
_stylizedButtonsContainer.addView(secondFirstStyleBtn);
_stylizedButtonsContainer.addView(thirdFirstStyleBtn);
```
Et c'est comment vous pouvez dynamiquement travailler avec boutons stylisés.

InformationsquelleAutor Jerry Frost
3

En fonction de ce que les attributs de style que vous souhaitez changer, vous pourriez être en mesure d'utiliser le Paris de la bibliothèque:
```
Button view = (Button) LayoutInflater.from(this).inflate(R.layout.section_button, null);
Paris.style(view).apply(R.style.YourStyle);
```
De nombreux attributs comme arrière-plan, rembourrage, textSize, textColor, etc. sont pris en charge.
- Liste des attributs pris en charge
- Les instructions d'Installation
Avertissement: je l'auteur de la bibliothèque.

InformationsquelleAutor Nathanael

J'ai fait une aide de l'interface pour cela, utilisez le titulaire du modèle.

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

Maintenant, pour chaque style que vous souhaitez utiliser, de façon pragmatique, juste 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éclarer un styliser 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>

Ici le style est-il 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 la mise en œuvre de la style de support:

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 réutilisé facilement et conserve le code propre et commenté, je recommande l'utilisation de cette seule comme une variable locale afin que nous puissions permettre le garbage collector pour faire son travail une fois que nous en avons terminé avec le réglage de tous les styles.

InformationsquelleAutor Kostyantin2216

-1

J'ai connu le même problème récemment. voici comment je l'ai résolu.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent">

    <!-- This is the special two colors background START , after this LinearLayout, you can add all view that have it for main background-->
    <LinearLayout
    android:layout_width="match_parent"
    android:layout_height="match_parent"

    android:weightSum="2"

    android:background="#FFFFFF"
    android:orientation="horizontal"
    >

    <View
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_weight="1"
        android:background="#0000FF" />

    <View
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_weight="1"
        android:background="#F000F0" />
    </LinearLayout>
    <!-- This is the special two colors background END-->

   <TextView
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_centerInParent="true"
    android:gravity="center"
    android:text="This Text is centered with a special backgound,
    You can add as much elements as you want as child of this RelativeLayout"
    android:textColor="#FFFFFF"
    android:textSize="20sp" />
</RelativeLayout>

J'ai utilisé un LinearLayout android:weightSum="2"
J'ai donné les deux éléments enfants android:layout_weight="1"
(J'ai donné chacun 50% de l'espace parent(largeur & hauteur))
Et enfin, j'ai donné les deux enfants de l'élément de différentes couleurs d'arrière-plan pour avoir de l'effet final.

Merci !

InformationsquelleAutor steve111MV

Vous devez vous connecter pour publier un commentaire.