Comment changer la couleur du texte de L'élément de Menu dans Android?
25 réponses
une ligne simple dans votre thème:)
<item name="android:actionMenuTextColor">@color/your_color</item>
il semble qu'un
<item name="android:itemTextAppearance">@style/myCustomMenuTextApearance</item>
dans mon thème et
<style name="myCustomMenuTextApearance" parent="@android:style/TextAppearance.Widget.IconMenu.Item">
<item name="android:textColor">@android:color/primary_text_dark</item>
</style>
dans styles.xml pour modifier le style de la liste des articles mais pas des éléments de menu.
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);
}
si vous utilisez la nouvelle barre d'outils, avec le thème Theme.AppCompat.Light.NoActionBar , vous pouvez le style 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 que j'ai eu,
android:textColorPrimary est la couleur du texte affichant le nom de votre activité, qui est le texte primaire de la barre d'outils.
android:textColorSecondary est la couleur du texte pour le sous-titre et plus d'options (3 points) bouton. (Oui, il a changé de couleur selon pour cette propriété!)
android:textColor est la couleur de tous les autres textes, y compris le menu.
Enfin le thème de 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"/>
si vous utilisez le menu comme <android.support.design.widget.NavigationView /> alors il suffit d'Ajouter sous la ligne NavigationView :
app:itemTextColor="your color"
également disponible colorTint pour l'icône, Il outrepassera la couleur pour votre icône ainsi. Pour cela, vous devez ajouter sous la ligne:
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 ça vous aidera.
Je l'ai fait programmatiquement 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;
}
comme vous pouvez le voir dans cette question vous devriez:
<item name="android:textColorPrimary">yourColor</item>
code ci-dessus change la couleur du texte des éléments d'action de menu pour API >= v21.
<item name="actionMenuTextColor">@android:color/holo_green_light</item>
ci-dessus est le code pour API < v21
la réponse courte est oui. vous avez de la chance!
Pour ce faire, vous devez outrepasser certains styles des styles par défaut Android:
tout d'abord, regardez 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>
donc maintenant nous avons le nom de la couleur en question, si vous regardez dans le dossier couleur 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 :
Override " TextAppearance.Widget.IconMenu.Article" et créer votre propre style. Puis liez - le à votre propre sélecteur pour le faire comme vous voulez. Espérons que cela vous aide. Bonne chance!
menu Options dans android peut être personnalisé pour définir l'arrière-plan ou de modifier l'apparence du texte. Le fond et la couleur du texte dans le menu ne pouvaient pas être changés en utilisant des thèmes et des styles. Le code source android (data\res\layout\icon_menu_item_layout.xml)utilise un élément personnalisé de la classe "com.Android.interne.vue.menu.IconMenuItem"Afficher le menu de configuration. Nous pouvons faire des changements dans la classe ci-dessus pour personnaliser le menu. Pour obtenir le même, utiliser LayoutInflater classe de l'usine et de mettre fond et couleur du texte pour 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);
}
Merci pour l'exemple de code. J'ai dû le modifier pour le faire fonctionner avec un menu contextuel. C'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.
j'ai utilisé la balise html pour changer la couleur du texte d'un article lorsque l'article du menu est gonflé. Espérons qu'il 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;
}
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>
Cheers ;)
Merci max.musterman, c'est la solution que j'ai eu pour travailler 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 code dur Color.BLACK pourrait devenir un paramètre additionnel à la méthode setMenuTextColor . De plus, Je ne l'ai utilisé que pour les éléments de menu qui étaient android:showAsAction="never" .
la façon la plus simple de faire la couleur de menu personnalisé pour la barre d'outils simple, 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 Toolbar style personnalisé
<style name="AppTheme.AppBarOverlay.MenuBlue">
<item name="actionMenuTextColor">@color/blue</item>
</style>
@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
vous pouvez régler 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);
}
}
});
}
Ma situation était la couleur de texte de paramètres dans le menu d'options (le menu de l'application principale a montré sur le bouton de menu presser).
testé dans API 16 avec appcompat-v7-27.0.2 bibliothèque, AppCompatActivity pour MainActivity et AppCompat thème pour l'application dans AndroidManifest.xml .
les 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 ce textColorSecondary affecte d'autres éléments mais il contrôle la couleur du texte du menu.
j'ai cherché quelques exemples sur le sujet, mais tous les extraits prêts à l'emploi n'ont pas fonctionné.
J'ai donc voulu l'étudier avec le code source de la bibliothèque appcompat-v7 (spécifiquement avec le dossier res du .AAR package).
bien que dans mon cas J'ai utilisé Eclipse avec explosée .AAR dépendances. Donc je pourrais changer les styles par défaut et vérifier les résultats. Je ne sais pas comment faire exploser les bibliothèques à utiliser avec Gradle ou Android Studio directement. Il mérite un autre fil d'investigation.
donc mon but était de trouver quelle couleur dans le res/values/values.le fichier xml est utilisé pour le texte du menu (j'étais presque sûr que la couleur était là).
- j'ai ouvert ce fichier, puis j'ai dupliqué toutes les couleurs, les ai placés sous les couleurs par défaut pour les surcharger et leur ai assigné la valeur
#f00. - Démarrer l'application.
- de nombreux éléments avaient un fond rouge ou une couleur de texte. Et les éléments du menu aussi. C'était ce dont j'avais besoin.
- enlever mes couleurs ajoutées par des blocs de 5-10 lignes j'ai fini avec la couleur
secondary_text_default_material_light. - cherchant ce nom dans les fichiers du dossier res (ou mieux dans res/colors ) Je n'ai trouvé qu'une occurrence dans le dossier color/abc_secondary_text_material_light.fichier xml (J'ai utilisé du texte Sublime pour ces opérations afin qu'il soit plus facile de trouver ce dont j'ai besoin).
- retour aux valeurs .xml 8 utilisations ont été trouvées pour le
@color/abc_secondary_text_material_light. - c'était un Light thème donc 4 gauche en 2 thèmes:
Base.ThemeOverlay.AppCompat.LightetPlatform.AppCompat.Light. - le premier thème était un enfant du deuxième donc il n'y avait que 2 attributs avec cette ressource de couleur:
android:textColorSecondaryetandroid:textColorTertiarydans leBase.ThemeOverlay.AppCompat.Light. - modifiant leurs valeurs directement dans les valeurs .xml et l'exécution de l'application j'ai trouvé que la finale correcte l'attribut était
android:textColorSecondary. - ensuite j'ai eu besoin d'un thème ou d'un autre attribut pour pouvoir le changer dans le style de mon application .xml (parce que mon thème avait comme parent le
Theme.AppCompat.Lightet non leThemeOverlay.AppCompat.Light). - j'ai cherché dans le même fichier le
Base.ThemeOverlay.AppCompat.Light. Il a eu un enfantThemeOverlay.AppCompat.Light. - cherchant le
ThemeOverlay.AppCompat.Lightj'ai trouvé son usage dans le thèmeBase.Theme.AppCompat.Light.DarkActionBarcomme leactionBarPopupThemela valeur de l'attribut. - le thème de mon application
Theme.AppCompat.Light.DarkActionBarétait un enfant duBase.Theme.AppCompat.Light.DarkActionBartrouvé pour que je puisse utiliser cet attribut dans Mes styles.xml sans problème. - comme il est vu dans le code d'exemple ci-dessus, j'ai créé un thème enfant à partir du mentionné
ThemeOverlay.AppCompat.Lightet changé l'attributandroid:textColorSecondary.
dans 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)
la solution de Sephy ne fonctionne pas. Il est possible de modifier l'apparence du texte de l'élément du menu 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 façons:
- Comment changer la couleur de fond du menu options?
- Ecrivez votre propre vue pour afficher et outrepasser onreateoptionsmenu et onPrepareOptionsMenu pour obtenir les résultats vous vouloir. Je l'affirme généralement parce que vous pouvez généralement faire tout ce que vous voulez dans ces méthodes, mais vous ne voudrez probablement pas appeler dans super().
- Copiez le code du SDK open-source et personnalisez votre comportement. L'implémentation du menu par défaut utilisé par Activité ne s'appliquera plus.
Voir 4441: Les Options de Menu à Thème pour plus d'informations.
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);
}
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
ajoutant ceci à mes styles.xml a fonctionné pour moi
<item name="android:textColorPrimary">?android:attr/textColorPrimaryInverse</item>
C'est comment vous pouvez colorier un élément de menu spécifique avec la couleur, fonctionne pour tous les niveaux de L'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 que vous perdez l'effet de sélecteur d'arrière-plan, donc voici le code pour appliquer un sélecteur d'arrière-plan personnalisé à tous les enfants de l'élément 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 helper aussi:
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);
}
pour changer la couleur du texte, vous pouvez simplement définir une vue personnalisée pour le MenuItem, puis vous pouvez définir la couleur pour le texte.
Code Échantillon : MenuItem.setActionView ()
pour changer la couleur du texte de l'élément de menu utiliser 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>