web-dev-qa-db-fra.com

Comment changer la couleur du texte de l'élément de menu dans Android?

Puis-je changer la couleur de fond d'un élément de menu dans Android?

S'il vous plaît laissez-moi savoir si quelqu'un a une solution à cela. La dernière option sera évidemment de le personnaliser, mais existe-t-il un moyen de changer la couleur du texte sans le personnaliser?.

androidmenuitemtextcolorlayout-inflater
124
sunil

Une simple ligne dans votre thème :)

<item name="Android:actionMenuTextColor">@color/your_color</item>
279
Muhammad Alfaifi

Il semble qu'un

  <item name="Android:itemTextAppearance">@style/myCustomMenuTextAppearance</item>

dans mon thème et

   <style name="myCustomMenuTextAppearance" parent="@Android:style/TextAppearance.Widget.IconMenu.Item">
        <item name="Android:textColor">@Android:color/primary_text_dark</item>
    </style>

dans styles.xml change le style des éléments de liste mais pas des éléments de menu.

91
Marcus Wolschon

Vous pouvez facilement changer la couleur du texte MenuItem en utilisant SpannableString au lieu de String.

@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
    inflater.inflate(R.menu.your_menu, menu);

    int positionOfMenuItem = 0; // or whatever...
    MenuItem item = menu.getItem(positionOfMenuItem);
    SpannableString s = new SpannableString("My red MenuItem");
    s.setSpan(new ForegroundColorSpan(Color.RED), 0, s.length(), 0);
    item.setTitle(s);
}
70
max.mustermann

Si vous utilisez la nouvelle barre d’outils, avec le thème Theme.AppCompat.Light.NoActionBar, vous pouvez l’appeler de la manière suivante.

 <style name="ToolbarTheme" parent="Theme.AppCompat.Light.NoActionBar">
    <item name="Android:textColorPrimary">@color/my_color1</item>
    <item name="Android:textColorSecondary">@color/my_color2</item>
    <item name="Android:textColor">@color/my_color3</item>
 </style>`

D'après les résultats obtenus,
Android:textColorPrimary est la couleur du texte affichant le nom de votre activité, qui est le texte principal de la barre d’outils. 

Android:textColorSecondary est la couleur du texte pour le bouton de sous-titres et d’options supplémentaires (3 points). (Oui, sa couleur a changé en fonction de cette propriété!) 

Android:textColor est la couleur de tous les autres textes, y compris le menu .

Enfin, définissez le thème sur la barre d’outils

<Android.support.v7.widget.Toolbar xmlns:Android="http://schemas.Android.com/apk/res/Android"
    xmlns:app="http://schemas.Android.com/apk/res-auto"
    app:theme="@style/ToolbarTheme"
    Android:layout_height="wrap_content"
    Android:layout_width="match_parent"
    Android:minHeight="?attr/actionBarSize"/>
43
Sudara

Si vous utilisez menu en tant que <Android.support.design.widget.NavigationView />, ajoutez simplement la ligne ci-dessous dans NavigationView:

app:itemTextColor="your color"

Également disponible pour colorTint for icon, il remplacera également la couleur de votre icône. Pour cela, vous devez ajouter la ligne ci-dessous:

app:itemIconTint="your color"

Exemple: 

<Android.support.design.widget.NavigationView
        Android:id="@+id/nav_view"
        Android:layout_width="wrap_content"
        Android:layout_height="match_parent"
        Android:layout_gravity="start"

        app:itemTextColor="@color/color_white"
        app:itemIconTint="@color/color_white"

        Android:background="@color/colorPrimary"
        Android:fitsSystemWindows="true"
        app:headerLayout="@layout/nav_header_main"
        app:menu="@menu/activity_main_drawer"/>

J'espère que cela vous aidera.

24
Mihir Trivedi

Je suis allé à ce sujet par programme comme ceci:

public boolean onCreateOptionsMenu(Menu menu) {
    getMenuInflater().inflate(R.menu.changeip_card_menu, menu); 
    for(int i = 0; i < menu.size(); i++) {
        MenuItem item = menu.getItem(i);
        SpannableString spanString = new SpannableString(menu.getItem(i).getTitle().toString());
        spanString.setSpan(new ForegroundColorSpan(Color.BLACK), 0,     spanString.length(), 0); //fix the color to white
        item.setTitle(spanString);
    }
    return true;
}
23
Muralikrishna G S

comme vous pouvez le voir dans cette question vous devriez:

<item name="Android:textColorPrimary">yourColor</item>

Le code ci-dessus modifie la couleur du texte des actions du menu pour API> = v21.

<item name="actionMenuTextColor">@Android:color/holo_green_light</item>

Ci-dessus, le code de l’API <v21

14
pouya

J'ai utilisé la balise html pour changer la couleur du texte d'un seul élément lorsque l'élément de menu est gonflé. J'espère que ce serait utile.

public boolean onCreateOptionsMenu(Menu menu) {
    // Inflate the menu; this adds items to the action bar if it is present.
    getMenuInflater().inflate(R.menu.menu_main, menu);
    menu.findItem(R.id.main_settings).setTitle(Html.fromHtml("<font color='#ff3824'>Settings</font>"));
    return true;
}
8
alijandro

La reponse courte est oui. Quel chanceux êtes-vous!
Pour ce faire, vous devez remplacer certains styles des styles par défaut d'Android: 

Tout d’abord, regardons la définition des thèmes dans Android: 

<style name="Theme.IconMenu">
<!-- Menu/item attributes -->
<item name="Android:itemTextAppearance">@Android:style/TextAppearance.Widget.IconMenu.Item</item>
<item name="Android:itemBackground">@Android:drawable/menu_selector</item>
<item name="Android:itemIconDisabledAlpha">?android:attr/disabledAlpha</item>
<item name="Android:horizontalDivider">@Android:drawable/divider_horizontal_bright</item>
<item name="Android:verticalDivider">@Android:drawable/divider_vertical_bright</item>
<item name="Android:windowAnimationStyle">@Android:style/Animation.OptionsPanel</item>
<item name="Android:moreIcon">@Android:drawable/ic_menu_more</item>
<item name="Android:background">@null</item>
</style>

Ainsi, l’apparence du texte dans le menu est dans @Android:style/TextAppearance.Widget.IconMenu.Item
Maintenant, dans la définition de les styles : 

<style name="TextAppearance.Widget.IconMenu.Item" parent="TextAppearance.Small">
<item name="Android:textColor">?textColorPrimaryInverse</item>
</style>

Nous avons maintenant le nom de la couleur en question, si vous regardez dans le dossier de couleurs des ressources du système: 

<selector xmlns:Android="http://schemas.Android.com/apk/res/Android">
<item Android:state_enabled="false" Android:color="@Android:color/bright_foreground_light_disabled" /> 
<item Android:state_window_focused="false" Android:color="@Android:color/bright_foreground_light" /> 
<item Android:state_pressed="true" Android:color="@Android:color/bright_foreground_light" /> 
<item Android:state_selected="true" Android:color="@Android:color/bright_foreground_light" /> 
<item Android:color="@Android:color/bright_foreground_light" /> 
<!--  not selected --> 
</selector>

Enfin, voici ce que vous devez faire: 

Remplacez "TextAppearance.Widget.IconMenu.Item" et créez votre propre style. Ensuite, associez-le à votre propre sélecteur pour qu'il soit comme vous le souhaitez . J'espère que cela vous aidera . Bonne chance!

6
Sephy

Merci pour l'exemple de code . Je devais le modifier aller le faire fonctionner avec un menu contextuel . Ceci est ma solution.

    static final Class<?>[] constructorSignature = new Class[] {Context.class, AttributeSet.class};

class MenuColorFix implements LayoutInflater.Factory {
    public View onCreateView(String name, Context context, AttributeSet attrs) {
        if (name.equalsIgnoreCase("com.Android.internal.view.menu.ListMenuItemView")) {
            try {
                Class<? extends ViewGroup> clazz = context.getClassLoader().loadClass(name).asSubclass(ViewGroup.class);
                Constructor<? extends ViewGroup> constructor = clazz.getConstructor(constructorSignature);
                final ViewGroup view = constructor.newInstance(new Object[]{context,attrs});

                new Handler().post(new Runnable() {
                    public void run() {
                        try {
                            view.setBackgroundColor(Color.BLACK);
                            List<View> children = getAllChildren(view);
                            for(int i = 0; i< children.size(); i++) {
                                View child = children.get(i);
                                if ( child instanceof TextView ) {
                                    ((TextView)child).setTextColor(Color.WHITE);
                                }
                            }
                        }
                        catch (Exception e) {
                            Log.i(TAG, "Caught Exception!",e);
                        }

                    }
                });
                return view;
            }
            catch (Exception e) {
                Log.i(TAG, "Caught Exception!",e);
            }
        }
        return null;
    }       
}

public List<View> getAllChildren(ViewGroup vg) {
    ArrayList<View> result = new ArrayList<View>();
    for ( int i = 0; i < vg.getChildCount(); i++ ) {
        View child = vg.getChildAt(i);
        if ( child instanceof ViewGroup) {
            result.addAll(getAllChildren((ViewGroup)child));
        }
        else {
            result.add(child);
        }
    }
    return result;
}

@Override
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
    LayoutInflater lInflater = getLayoutInflater();
    if ( lInflater.getFactory() == null ) {
        lInflater.setFactory(new MenuColorFix());
    }
    super.onCreateContextMenu(menu, v, menuInfo);
    MenuInflater inflater = getMenuInflater();
    inflater.inflate(R.menu.myMenu, menu);
}

Pour moi, cela fonctionne avec Android 1.6, 2.03 et 4.03.

6
Michael Vogl

Le menu Options sous Android peut être personnalisé pour définir l’arrière-plan ou modifier l’apparence du texte. L’arrière-plan et la couleur du texte du menu ne peuvent pas être modifiés à l’aide de thèmes et de styles. Le code source Android (data\res\layout\icon_menu_item_layout.xml) utilise un élément personnalisé de la classe «com.Android.internal.view.menu.IconMenuItem» Voir pour la disposition du menu. Nous pouvons apporter des modifications dans la classe ci-dessus pour personnaliser le menu. Pour obtenir le même résultat, utilisez la classe d'usine LayoutInflater et définissez la couleur d'arrière-plan et du texte de la vue.


@Override
public boolean onCreateOptionsMenu(Menu menu) {
    MenuInflater inflater = getMenuInflater();
    inflater.inflate(R.menu.my_menu, menu);
    getLayoutInflater().setFactory(new Factory() {
        @Override
        public View onCreateView(String name, Context context, AttributeSet attrs) {
            if (name .equalsIgnoreCase(“com.Android.internal.view.menu.IconMenuItemView”)) {
                try{
                    LayoutInflater f = getLayoutInflater();
                    final View view = f.createView(name, null, attrs);
                    new Handler().post(new Runnable() {
                        public void run() {
                            // set the background drawable
                            view .setBackgroundResource(R.drawable.my_ac_menu_background);

                            // set the text color
                            ((TextView) view).setTextColor(Color.WHITE);
                        }
                    });
                    return view;
                } catch (InflateException e) {
                    } catch (ClassNotFoundException e) {}
            }
            return null;
        }
    });
    return super.onCreateOptionsMenu(menu);
}
6
Abhay Kumar

SIMPLEST moyen de créer une couleur de menu personnalisée pour une barre d'outils unique, pas pour AppTheme

    <Android.support.design.widget.AppBarLayout
        Android:layout_width="match_parent"
        Android:layout_height="wrap_content"
        Android:theme="@style/AppTheme.AppBarOverlay.MenuBlue">
        <Android.support.v7.widget.Toolbar
            Android:id="@+id/toolbar"
            Android:layout_width="match_parent"
            Android:layout_height="?attr/actionBarSize"/>
    </Android.support.design.widget.AppBarLayout>

barre d'outils habituelle sur styles.xml

<style name="AppTheme.AppBarOverlay" parent="ThemeOverlay.AppCompat.Dark.ActionBar"/>

notre style de barre d'outils personnalisé

<style name="AppTheme.AppBarOverlay.MenuBlue">
    <item name="actionMenuTextColor">@color/blue</item>
</style>
5
AndrewS

je l'ai trouvé Eureka !!

dans le thème de votre application:

<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
    <item name="Android:actionBarStyle">@style/ActionBarTheme</item>
    <!-- backward compatibility -->          
    <item name="actionBarStyle">@style/ActionBarTheme</item>        
</style>

voici le thème de votre barre d'action:

<style name="ActionBarTheme" parent="@style/Widget.AppCompat.Light.ActionBar.Solid.Inverse">
   <item name="Android:background">@color/actionbar_bg_color</item>
   <item name="popupTheme">@style/ActionBarPopupTheme</item
   <!-- backward compatibility -->
   <item name="background">@color/actionbar_bg_color</item>
</style>

et voici votre thème popup:

 <style name="ActionBarPopupTheme">
    <item name="Android:textColor">@color/menu_text_color</item>
    <item name="Android:background">@color/menu_bg_color</item>
 </style>

À votre santé ;)

5
Fareed Alnamrouti

Grâce à max.musterman, voici la solution sur laquelle j'ai travaillé au niveau 22:

public boolean onCreateOptionsMenu(Menu menu) {
    getMenuInflater().inflate(R.menu.menu_main, menu);
    SearchManager searchManager = (SearchManager) getSystemService(Context.SEARCH_SERVICE);
    MenuItem searchMenuItem = menu.findItem(R.id.search);
    SearchView searchView = (SearchView) searchMenuItem.getActionView();
    searchView.setSearchableInfo(searchManager.getSearchableInfo(getComponentName()));
    searchView.setSubmitButtonEnabled(true);
    searchView.setOnQueryTextListener(this);
    setMenuTextColor(menu, R.id.displaySummary, R.string.show_summary);
    setMenuTextColor(menu, R.id.about, R.string.text_about);
    setMenuTextColor(menu, R.id.importExport, R.string.import_export);
    setMenuTextColor(menu, R.id.preferences, R.string.settings);
    return true;
}

private void setMenuTextColor(Menu menu, int menuResource, int menuTextResource) {
    MenuItem item = menu.findItem(menuResource);
    SpannableString s = new SpannableString(getString(menuTextResource));
    s.setSpan(new ForegroundColorSpan(Color.BLACK), 0, s.length(), 0);
    item.setTitle(s);
}

Le Color.BLACK codé en dur pourrait devenir un paramètre supplémentaire de la méthode setMenuTextColor. De plus, je ne l'utilisais que pour les éléments de menu qui étaient Android:showAsAction="never".

4
lightkeeper

pour changer la couleur du texte d'un élément de menu, utilisez le code ci-dessous

<style name="AppToolbar" parent="Theme.AppCompat.Light.NoActionBar">
<item name="Android:itemTextAppearance">@style/menu_item_color</item>
</style>

où 

<style name="menu_item_color">
<item name="Android:textColor">@color/app_font_color</item>
</style>
2
Muhammad Abdullah

Vous pouvez définir la couleur par programmation.

private static void setMenuTextColor(final Context context, final Toolbar toolbar, final int menuResId, final int colorRes) {
    toolbar.post(new Runnable() {
        @Override
        public void run() {
            View settingsMenuItem =  toolbar.findViewById(menuResId);
            if (settingsMenuItem instanceof TextView) {
                if (DEBUG) {
                    Log.i(TAG, "setMenuTextColor textview");
                }
                TextView tv = (TextView) settingsMenuItem;
                tv.setTextColor(ContextCompat.getColor(context, colorRes));
            } else { // you can ignore this branch, because usually there is not the situation
                Menu menu = toolbar.getMenu();
                MenuItem item = menu.findItem(menuResId);
                SpannableString s = new SpannableString(item.getTitle());
                s.setSpan(new ForegroundColorSpan(ContextCompat.getColor(context, colorRes)), 0, s.length(), 0);
                item.setTitle(s);
            }

        }
    });
}
2
Victor Choy

Ma situation était la couleur du texte des paramètres dans le menu des options (le menu principal de l’application était affiché en appuyant sur le bouton du menu).

Testé dans API 16 avec la bibliothèque appcompat-v7-27.0.2, AppCompatActivity pour le thème MainActivity et AppCompat de l'application dans AndroidManifest.xml.

styles.xml:

<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
  <item name="actionBarPopupTheme">@style/PopupTheme</item>
</style>

<style name="PopupTheme" parent="@style/ThemeOverlay.AppCompat.Light">
  <item name="Android:textColorSecondary">#f00</item>
</style>

Je ne sais pas si cette textColorSecondary affecte d'autres éléments, mais elle contrôle la couleur du texte du menu.

J'ai cherché quelques exemples sur le sujet, mais tous les extraits prêts à l'emploi ne fonctionnaient pas.

Je voulais donc étudier le code source de la bibliothèque appcompat-v7 (en particulier le dossier res du paquetage .aar).

Bien que dans mon cas, j'ai utilisé Eclipse avec des dépendances éclatées .aar. Je pourrais donc changer les styles par défaut et vérifier les résultats. Je ne sais pas comment exploser les bibliothèques à utiliser avec Gradle ou Android Studio directement. Cela mérite un autre fil d'investigation.

Donc, mon but était de trouver quelle couleur dans le fichier res/values ​​/ values.xml est utilisée pour le texte du menu (j'étais presque sûr que la couleur était là).

  1. J'ai ouvert ce fichier, puis dupliqué toutes les couleurs, les ai placées sous les couleurs par défaut pour les écraser et attribué la valeur #f00 à toutes.
  2. Démarrer l'application.
  3. De nombreux éléments avaient un arrière-plan rouge ou une couleur de texte. Et les éléments de menu aussi. C'était ce dont j'avais besoin.
  4. En supprimant mes couleurs ajoutées par blocs de 5 à 10 lignes, je me suis retrouvé avec l’élément de couleur secondary_text_default_material_light.
  5. En recherchant ce nom dans les fichiers du dossier res (ou mieux dans le fichier res/colors), je n’ai trouvé qu’une occurrence dans le fichier color/abc_secondary_text_material_light.xml (j’ai utilisé Sublime Text pour ces fichiers). opérations, il est donc plus facile de trouver ce dont j'ai besoin).
  6. Retour à la values.xml 8 utilisations ont été trouvées pour le @color/abc_secondary_text_material_light.
  7. C'était un thème Light, donc 4 restants dans 2 thèmes: Base.ThemeOverlay.AppCompat.Light et Platform.AppCompat.Light.
  8. Le premier thème était un enfant du second, il n'y avait donc que 2 attributs avec cette ressource de couleur: Android:textColorSecondary et Android:textColorTertiarydans le Base.ThemeOverlay.AppCompat.Light.
  9. En modifiant leurs valeurs directement dans values.xml et en exécutant l'application, j'ai constaté que l'attribut correct final était Android:textColorSecondary.
  10. Ensuite, j'avais besoin d'un thème ou d'un autre attribut pour pouvoir le changer dans le style.xml de mon application (car mon thème avait pour parent le Theme.AppCompat.Light et non le ThemeOverlay.AppCompat.Light).
  11. J'ai cherché dans le même fichier pour le Base.ThemeOverlay.AppCompat.Light. Il avait un enfant ThemeOverlay.AppCompat.Light.
  12. En recherchant le ThemeOverlay.AppCompat.Light, j'ai trouvé son utilisation dans le thème Base.Theme.AppCompat.Light.DarkActionBar en tant que valeur d'attribut actionBarPopupTheme.
  13. Le thème de mon application, Theme.AppCompat.Light.DarkActionBar, était un enfant du Base.Theme.AppCompat.Light.DarkActionBar trouvé. Je pouvais donc utiliser cet attribut dans mon styles.xml sans problèmes.
  14. Comme indiqué dans l'exemple de code ci-dessus, j'ai créé un thème enfant à partir du ThemeOverlay.AppCompat.Light mentionné et modifié l'attribut Android:textColorSecondary.

 https://i.imgur.com/LNfKdzC.png

2
mortalis

à Kotlin, j'ai écrit ces extensions:

fun MenuItem.setTitleColor(color: Int) {
    val hexColor = Integer.toHexString(color).toUpperCase().substring(2)
    val html = "<font color='#$hexColor'>$title</font>"
    this.title = html.parseAsHtml()
}           



@Suppress("DEPRECATION")                                                                        
fun String.parseAsHtml(): Spanned {                                                             
    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {                                
        Html.fromHtml(this, Html.FROM_HTML_MODE_LEGACY)                                         
    } else {                                                                                    
        Html.fromHtml(this)                                                                     
    }                                                                                           
}

et utilisé comme ceci:

menu.findItem(R.id.main_settings).setTitleColor(Color.RED)
2
Amir Khorsandi
@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
    inflater.inflate(R.menu.search, menu);


    MenuItem myActionMenuItem = menu.findItem( R.id.action_search);
    SearchView searchView = (SearchView) myActionMenuItem.getActionView();

    EditText searchEditText = (EditText) searchView.findViewById(Android.support.v7.appcompat.R.id.search_src_text);
    searchEditText.setTextColor(Color.WHITE); //You color here
2
Bäda

Ajouter cela dans mon styles.xml a fonctionné pour moi 

<item name="Android:textColorPrimary">?android:attr/textColorPrimaryInverse</item>
1
Asim

La solution de Sephy ne fonctionne pas. Il est possible de remplacer l'apparence du texte d'un élément du menu d'options en utilisant la méthode décrite ci-dessus, mais pas l'élément ou le menu. Pour ce faire, il y a essentiellement 3 moyens:

  1. Comment changer la couleur de fond du menu d'options?
  2. Ecrivez votre propre vue pour afficher et remplacer onCreateOptionsMenu et onPrepareOptionsMenu pour obtenir les résultats souhaités. J'affirme cela généralement parce que vous pouvez généralement faire ce que vous voulez dans ces méthodes, mais vous ne voudrez probablement pas appeler super ().
  3. Copiez le code à partir du SDK Open Source et personnalisez-le en fonction de votre comportement. L'implémentation de menu par défaut utilisée par Activity ne s'appliquera plus.

Voir Numéro 4441: Thème du menu Options personnalisées pour plus d'indices.

1
Tenacious

essayez ce code ....

 @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        MenuInflater inflater = getMenuInflater();
         inflater.inflate(R.menu.my_menu, menu);

        getLayoutInflater().setFactory(new Factory() {
            @Override
            public View onCreateView(String name, Context context,
                    AttributeSet attrs) {

                if (name.equalsIgnoreCase("com.Android.internal.view.menu.IconMenuItemView")) {
                    try {
                        LayoutInflater f = getLayoutInflater();
                        final View view = f.createView(name, null, attrs);

                        new Handler().post(new Runnable() {
                            public void run() {

                                // set the background drawable
                                 view.setBackgroundResource(R.drawable.my_ac_menu_background);

                                // set the text color
                                ((TextView) view).setTextColor(Color.WHITE);
                            }
                        });
                        return view;
                    } catch (InflateException e) {
                    } catch (ClassNotFoundException e) {
                    }
                }
                return null;
            }
        });
        return super.onCreateOptionsMenu(menu);
    }
1
Anoop S S

Ajoutez simplement ceci à votre thème

<style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
        <item name="Android:itemTextAppearance">@style/AppTheme.ItemTextStyle</item>
</style>

<style name="AppTheme.ItemTextStyle" parent="@Android:style/TextAppearance.Widget.IconMenu.Item">
        <item name="Android:textColor">@color/orange_500</item>
</style>

Testé sur API 21

1
Pham Quan

Voici comment colorer un élément de menu spécifique avec une couleur, fonctionne pour tous les niveaux d'API:

public static void setToolbarMenuItemTextColor(final Toolbar toolbar,
                                               final @ColorRes int color,
                                               @IdRes final int resId) {
    if (toolbar != null) {
        for (int i = 0; i < toolbar.getChildCount(); i++) {
            final View view = toolbar.getChildAt(i);
            if (view instanceof ActionMenuView) {
                final ActionMenuView actionMenuView = (ActionMenuView) view;
                // view children are accessible only after layout-ing
                actionMenuView.post(new Runnable() {
                    @Override
                    public void run() {
                        for (int j = 0; j < actionMenuView.getChildCount(); j++) {
                            final View innerView = actionMenuView.getChildAt(j);
                            if (innerView instanceof ActionMenuItemView) {
                                final ActionMenuItemView itemView = (ActionMenuItemView) innerView;
                                if (resId == itemView.getId()) {
                                    itemView.setTextColor(ContextCompat.getColor(toolbar.getContext(), color));
                                }
                            }
                        }
                    }
                });
            }
        }
    }
}

En faisant cela, vous perdez l’effet sélecteur d’arrière-plan. Voici donc le code permettant d’appliquer un sélecteur d’arrière-plan personnalisé à tous les enfants d’éléments de menu.

public static void setToolbarMenuItemsBackgroundSelector(final Context context,
                                                         final Toolbar toolbar) {
    if (toolbar != null) {
        for (int i = 0; i < toolbar.getChildCount(); i++) {
            final View view = toolbar.getChildAt(i);
            if (view instanceof ImageButton) {
                // left toolbar icon (navigation, hamburger, ...)
                UiHelper.setViewBackgroundSelector(context, view);
            } else if (view instanceof ActionMenuView) {
                final ActionMenuView actionMenuView = (ActionMenuView) view;

                // view children are accessible only after layout-ing
                actionMenuView.post(new Runnable() {
                    @Override
                    public void run() {
                        for (int j = 0; j < actionMenuView.getChildCount(); j++) {
                            final View innerView = actionMenuView.getChildAt(j);
                            if (innerView instanceof ActionMenuItemView) {
                                // text item views
                                final ActionMenuItemView itemView = (ActionMenuItemView) innerView;
                                UiHelper.setViewBackgroundSelector(context, itemView);

                                // icon item views
                                for (int k = 0; k < itemView.getCompoundDrawables().length; k++) {
                                    if (itemView.getCompoundDrawables()[k] != null) {
                                        UiHelper.setViewBackgroundSelector(context, itemView);
                                    }
                                }
                            }
                        }
                    }
                });
            }
        }
    }
}

Voici la fonction d'assistance également:

public static void setViewBackgroundSelector(@NonNull Context context, @NonNull View itemView) {
    int[] attrs = new int[]{R.attr.selectableItemBackgroundBorderless};
    TypedArray ta = context.obtainStyledAttributes(attrs);
    Drawable drawable = ta.getDrawable(0);
    ta.recycle();

    ViewCompat.setBackground(itemView, drawable);
}
0
box

Pour changer la couleur du texte, vous pouvez simplement définir un affichage personnalisé pour MenuItem, puis vous pouvez définir la couleur du texte ..__

Exemple de code: MenuItem.setActionView ()

0
leisure