Changer la couleur des boutons en AlertDialog

voilà ce que j'ai fait.

AlertDialog.Builder customBuilder = new AlertDialog.Builder(new ContextThemeWrapper(this,android.R.style.Theme_Dialog));

customBuilder.setTitle(R.string.popup_error_title);
customBuilder.setNegativeButton("Exit application", new DialogInterface.OnClickListener() {  
    public void onClick(DialogInterface dialog, int which) {  
        MyActivity.this.finish();
    }  
});

AlertDialog dialog = customBuilder.create();
dialog.show();

Button b = dialog.getButton(DialogInterface.BUTTON_NEGATIVE);

if(b != null) {
    b.setBackgroundDrawable(getResources().getDrawable(R.drawable.my_button));
}

je trouve le drawable ici

puisque la plupart des gens utilisent probablement un DialogFragment maintenant j'ai rencontré quelques problèmes et cliqué mon chemin à travers plusieurs réponses ainsi pour résoudre ceux. Permettez-moi de poster ma solution actuelle.

j'ai fini par régler le bouton-arrière-plan avec des tirables personnalisés comme déjà suggéré plusieurs fois. Toutefois, cela n'était pas encore possible avec la méthode onCreateDialog . Vous pouvez le faire par exemple dans onStart() , ou (ce qui est ce que je preferred) dans le onShow -auditeur du dialogue! Gardez à l'esprit cependant, vous devez invalider vos boutons après les changements alors.

comme pour les marges: simple supprimer le rembourrage dans votre Drawable-XML pour les boutons.

#onreatedialog dans votre fragment de dialogue:

@Override
public Dialog onCreateDialog(final Bundle savedInstanceState) {
  AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());

  // setup your dialog here...

  builder.setNegativeButton(getString(R.string.cancel), new DialogInterface.OnClickListener() {
    @Override
    public void onClick(final DialogInterface dialog, final int which) {
      // do something
    }
  });

  builder.setPositiveButton(getString(R.string.ok), new DialogInterface.OnClickListener() {
    @Override
    public void onClick(final DialogInterface dialog, final int which) {
      // do something
    }
  });

  final AlertDialog dialog = builder.create();

  dialog.setOnShowListener(new DialogInterface.OnShowListener() {
    @Override
    public void onShow(final DialogInterface dialog) {
      Button negativeButton = ((AlertDialog)dialog).getButton(DialogInterface.BUTTON_NEGATIVE);
      Button positiveButton = ((AlertDialog)dialog).getButton(DialogInterface.BUTTON_POSITIVE);

      // this not working because multiplying white background (e.g. Holo Light) has no effect
      //negativeButton.getBackground().setColorFilter(0xFFFF0000, PorterDuff.Mode.MULTIPLY);

      final Drawable negativeButtonDrawable = getResources().getDrawable(R.drawable.alert_dialog_button_light_red);
      final Drawable positiveButtonDrawable = getResources().getDrawable(R.drawable.alert_dialog_button_light_green);
      if (Build.VERSION.SDK_INT >= 16) {
        negativeButton.setBackground(negativeButtonDrawable);
        positiveButton.setBackground(positiveButtonDrawable);
      } else {
        negativeButton.setBackgroundDrawable(negativeButtonDrawable);
        positiveButton.setBackgroundDrawable(positiveButtonDrawable);
      }

      negativeButton.invalidate();
      positiveButton.invalidate();
    }
  });

  return dialog;
}

tirable-exemple XML pour un bouton:

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

  <item android:state_pressed="true" >
    <shape>
      <gradient
        android:startColor="@color/alert_dialog_button_green_pressed1"
        android:endColor="@color/alert_dialog_button_green_pressed2"
        android:angle="270" />
    </shape>
  </item>

  <item android:state_focused="true" >
    <shape>
      <gradient
        android:endColor="@color/alert_dialog_button_green_focused1"
        android:startColor="@color/alert_dialog_button_green_focused2"
        android:angle="270" />
    </shape>
  </item>

  <item>
    <shape>
      <gradient
        android:endColor="@color/alert_dialog_button_green1"
        android:startColor="@color/alert_dialog_button_green2"
        android:angle="270" />
    </shape>
  </item>
</selector>

N'oubliez pas de définir votre couleurs dans le res\values\colors.xml , par exemple comme ceci (Je ne voulais pas d'un gradient, donc les couleurs 1 et 2 sont les mêmes):

<?xml version="1.0" encoding="utf-8"?>
<resources>
  <color name="alert_dialog_button_green1">#b4099930</color>
  <color name="alert_dialog_button_green2">#b4099930</color>
  <color name="alert_dialog_button_green_focused1">#96099930</color>
  <color name="alert_dialog_button_green_focused2">#96099930</color>
  <color name="alert_dialog_button_green_pressed1">#96099930</color>
  <color name="alert_dialog_button_green_pressed2">#96099930</color>
</resources>

voici un exemple:

AlertDialog.Builder b = new AlertDialog.Builder(all.this);

b.setMessage("r u wan't 2 exit");
b.setCancelable(false);

b.setNegativeButton("no", new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface dialog, int which) {
        dialog.cancel();    
    }
});

b.setPositiveButton("yes", new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface dialog, int which) {
        Intent i=new Intent(getBaseContext(), s.class);
        startActivity(i);
    }
});

AlertDialog a=b.create();

a.show();

Button bq = a.getButton(DialogInterface.BUTTON_NEGATIVE);  
bq.setBackgroundColor(Color.BLUE);

j'ai fait par ce code il pourrait vous aider:

AlertDialog.Builder builder1 = new AlertDialog.Builder(this); 
        builder1.setCancelable(true);
     builder1.setTitle("abc");
      builder1.setMessage("abcdefg");
      builder1.setInverseBackgroundForced(true);
     builder1.setPositiveButton("Yes",
             new DialogInterface.OnClickListener() {
         public void onClick(DialogInterface dialog, int id) {
             dialog.cancel();
         }
     }); 

     builder1.setNegativeButton("No",
             new DialogInterface.OnClickListener() {
         public void onClick(DialogInterface dialog, int id) {
             dialog.cancel();
         }
     });

     AlertDialog alert11 = builder1.create();
     alert11.show(); 

     Button buttonbackground = alert11.getButton(DialogInterface.BUTTON_NEGATIVE); 
     buttonbackground.setBackgroundColor(Color.BLUE); 

     Button buttonbackground1 = alert11.getButton(DialogInterface.BUTTON_POSITIVE); 
     buttonbackground1.setBackgroundColor(Color.BLUE);

j'ai voulu résoudre cela avec des thèmes plutôt que du code supplémentaire car il se sent plus propre pour moi d'avoir tous les trucs liés au style dans les styles.XML. Ce que j'ai fait était basé sur la réponse D'Arade et cette autre question :

<style name="AlertDialogDanger" parent="Theme.AppCompat.Light.Dialog.Alert">
    <item name="colorAccent">@color/error</item>
</style>

cela changera la couleur du texte du bouton de n'importe quelle boîte de dialogue d'alerte que vous créez avec le style AlertDialogDanger . Pour ce faire:

    new AlertDialog.Builder(new ContextThemeWrapper(this, R.style.AlertDialogDanger))
            .setMessage("Really delete?")
            .setPositiveButton("Delete", null)
            .setNegativeButton("Cancel", null)
            .create().show();

je pense qu'il y a des développeurs qui souhaitent étendre la classe AlertDialog et définir les couleurs des boutons avec la définition de classe. Pour ce faire, vous pouvez utiliser ce code:

class MyDialog extends AlertDialog {
    public MyDialog(final Context context) {
        super(context); 
        setOnShowListener(new OnShowListener() {
            @Override
            public void onShow(DialogInterface dialog) {
                Button negativeButton = getButton(DialogInterface.BUTTON_NEGATIVE);  
                Button positiveButton = getButton(DialogInterface.BUTTON_POSITIVE);

                negativeButton.setBackgroundColor(Color.GREEN);
                positiveButton.setBackgroundColor(Color.RED);
            }
        });
    }
}

nous pouvons changer la couleur du texte du bouton de dialogue d'alerte en utilisant le Style.

 AlertDialog.Builder dialog = new AlertDialog.Builder(context, R.style.yourDialog);
    dialog.setTitle(R.string.title);
    dialog.setNegativeButton(R.string.no, new DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialogInterface, int i) {
            //code here 
        }
    });
    dialog.setPositiveButton(R.string.yes, new DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialogInterface, int i) {
            //do here 
        }
    });

    dialog.show();

Style.xml

<style name="yourDialog" parent="Theme.AppCompat.Light.Dialog.Alert">

    <item name="android:colorAccent">@color/themeColor</item>
    <item name="android:colorPrimary">@color/themeColor</item>

</style>

pour changer la couleur des boutons de L'AlertDailog

Code:

// Initialize AlertDialog & AlertDialog Builder
AlertDialog.Builder builder = new AlertDialog.Builder(YourActivity.this);
builder.setTitle(R.String.AlertDialogTitle);
...........
......... 
//Build your AlertDialog 
AlertDialog Demo_alertDialog= builder.create();
Demo_alertDialog.show();

//For Positive Button:
Button b_pos; 
b_pos=Demo_alertDialog.getButton(DialogInterface.BUTTON_POSITIVE);
if(b_pos!=null){
   b_pos.setTextColor(getResources().getColor(R.color.YourColor));
   }    


//For Neutral Button:
Button b_neu;
b_neu=Demo_alertDialog.getButton(DialogInterface.BUTTON_NEUTRAL);
if(b_neu!=null){
   b_neu.setTextColor(getResources().getColor(R.color.YourColor));
   }

//For Negative Button:
Button b_neg;
b_neg=Demo_alertDialog.getButton(DialogInterface.BUTTON_NEGATIVE);
if(b_neg!=null){
   b_neg.setTextColor(getResources().getColor(R.color.YourColor));
   }

si vous utilisez DialogFragment ( android.App.DialogFragment) puis vous pouvez écraser la méthode onStart pour obtenir la poignée de tous les boutons (Positif, Négatif et neutre).

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    View eventEditDialogView = View.inflate(this.getActivity(), R.layout.event_edit_dialog,
                                            null);

    builder.setTitle(getLocalizedString("edit_event"))
            .setView(eventEditDialogView)
            .setPositiveButton(getLocalizedString("all_events"), new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int id) {
                }
            })
            .setNegativeButton(getLocalizedString("this_event"), new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int id) {
                }
            })
    return builder.create();
}

 @Override
    public void onStart() {
        super.onStart();
    Button positive = ((AlertDialog) getDialog()).getButton(AlertDialog.BUTTON_POSITIVE);
    positive.setTextColor(Color.BLACK);
    positive.setBackgroundColor(getResources().getColor(R.color.GrayBGColor));
}

toutes les solutions ci-dessus fonctionneront avec AlertDialog ou Dialog créé sur la même activité ou Fragment mais pas sur DialogFragment créé séparément.

    //el resto
    AlertDialog a=alertDialog.create();
    cambiar_color_texto_alertdialog(a);

}

public void cambiar_color_texto_alertdialog(AlertDialog a){
    a.show();
    Button BN = a.getButton(DialogInterface.BUTTON_NEGATIVE);
    BN.setTextColor(parseColor("#2E9AFE"));
    Button BA = a.getButton(DialogInterface.BUTTON_POSITIVE);
    BA.setTextColor(parseColor("#2E9AFE"));
}

Non vous ne pouvez pas changer la couleur ou les images ou le fond des boutons par défaut des boîtes d'alerte. Pour la personnalisation, vous devrez vous rendre sur la boîte de dialogue personnalisée comme ça.

public class TryAgainAlert extends Dialog implements OnClickListener
{
    @Override
 public boolean onKeyDown(int keyCode, KeyEvent event)
 {
  if (keyCode == KeyEvent.KEYCODE_BACK)
  {   

   Intent i = new Intent(getApplicationContext(), MainMenu.class);
   finish();
   startActivity(i);

   return true;
  }
  return super.onKeyDown(keyCode, event);
 }


    TextView scores;
    Button tryagain,mainmenu,submit;


     public TryAgainAlert(Context context) {
        super(context);

        setContentView(R.layout.tryagainalert);

        scores=(TextView)findViewById(R.id.text);



        tryagain= (Button) findViewById(R.id.trya);
        mainmenu= (Button) findViewById(R.id.submitscore);
        submit= (Button) findViewById(R.id.mainmenu);

    }


    @Override
    public void onClick(View v) {
        if(v == tryagain)
        {

        else if (v==mainmenu)
        {


        }
        else if (v == submit)
        {

        }
    }

}

vous pouvez faire ce que vous voulez avec le fichier XML. J'espère que ça aidera. Merci

la couleur des boutons et autres textes peuvent également être changés en utilisant appcompat:

<style name="AlertDialogCustom" parent="Theme.AppCompat.Light.Dialog.Alert">
    <item name="android:colorPrimary">@color/flexdrive_blue_1</item>
    <item name="android:textColorPrimary">@color/flexdrive_blue_6</item>
    <item name="android:colorAccent">@color/flexdrive_blue_1</item>
    <item name="colorPrimaryDark">@color/flexdrive_blue_4</item>
</style>

faites-vous référence aux boutons neutre, positif et négatif? Ou de boutons que vous avez inclus dans la présentation?

Si vous faites référence à l'ancien, alors oui vous pouvez. Consultez la section dans ce tutoriel . Vous avez essentiellement besoin d'un fichier XML qui indiquera à votre bouton quel dessin/couleur utiliser pour chaque changement d'état. Vous pouvez ensuite définir ce fichier XML comme étant l'arrière-plan de votre bouton.