Comment désactiver / activer les boutons positifs négatifs de dialogue?
Veuillez consulter la boîte de dialogue personnalisée ci-dessous. J'ai un champ edittext sur la boîte de dialogue et si le champ de texte est vide, je voudrais désactiver le positiveButton
. Je peux obtenir un charListener pour le champ de texte mais je ne suis pas sûr de savoir comment je vais définir le positivebutton
pour désactiver ou activer à partir de cet écouteur? Quelle est la référence pour les boutons positifs et négatifs?
case DIALOG_TEXT_ENTRY:
// This example shows how to add a custom layout to an AlertDialog
LayoutInflater factory = LayoutInflater.from(this);
final View textEntryView = factory.inflate(R.layout.alert_dialog_text_entry, null);
return new AlertDialog.Builder(AlertDialogSamples.this)
.setIconAttribute(android.R.attr.alertDialogIcon)
.setTitle(R.string.alert_dialog_text_entry)
.setView(textEntryView)
.setPositiveButton(R.string.alert_dialog_ok, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int whichButton) {
/* User clicked OK so do some stuff */
}
})
.setNegativeButton(R.string.alert_dialog_cancel, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int whichButton) {
/* User clicked cancel so do some stuff */
}
})
.create();
}
6 réponses
Modifier pour la solution complète...
AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);
builder.setIcon(android.R.drawable.ic_dialog_info);
builder.setTitle("Alert dialog title");
builder.setMessage("This is the example code snippet to disable button if edittext attached to dialog is empty.");
builder.setPositiveButton("PositiveButton",
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface arg0, int arg1) {
// DO TASK
}
});
builder.setNegativeButton("NegativeButton",
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface arg0, int arg1) {
// DO TASK
}
});
// Set `EditText` to `dialog`. You can add `EditText` from `xml` too.
final EditText input = new EditText(MainActivity.this);
LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(
LinearLayout.LayoutParams.MATCH_PARENT,
LinearLayout.LayoutParams.MATCH_PARENT);
input.setLayoutParams(lp);
builder.setView(input);
final AlertDialog dialog = builder.create();
dialog.show();
// Initially disable the button
((AlertDialog) dialog).getButton(AlertDialog.BUTTON_POSITIVE)
.setEnabled(false);
// OR you can use here setOnShowListener to disable button at first
// time.
// Now set the textchange listener for edittext
input.addTextChangedListener(new TextWatcher() {
@Override
public void onTextChanged(CharSequence s, int start, int before,
int count) {
}
@Override
public void beforeTextChanged(CharSequence s, int start, int count,
int after) {
}
@Override
public void afterTextChanged(Editable s) {
// Check if edittext is empty
if (TextUtils.isEmpty(s)) {
// Disable ok button
((AlertDialog) dialog).getButton(
AlertDialog.BUTTON_POSITIVE).setEnabled(false);
} else {
// Something into edit text. Enable the button.
((AlertDialog) dialog).getButton(
AlertDialog.BUTTON_POSITIVE).setEnabled(true);
}
}
});
Ci-dessous sont l'historique édité, qui peut être référencé comme plus de détails
Voici un exemple de code, essayez ceci
AlertDialog.Builder builder = new AlertDialog.Builder(AddSchedule.this);
builder.setIcon(android.R.drawable.ic_dialog_info);
builder.setTitle("Alert dialog title");
builder.setMessage("Dialog message");
builder.setPositiveButton("Button1", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface arg0, int arg1) {
//DO TASK
}
});
builder.setNegativeButton("Button2", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface arg0, int arg1) {
//DO TASK
}
});
AlertDialog dialog = builder.create();
dialog.show();
//After calling show method, you need to check your condition and
//enable/ disable buttons of dialog
if(your_condition_true)
dialog.getButton(AlertDialog.BUTTON1).setEnabled(false); //BUTTON1 is positive button
Pour le négatif bouton
dialog.getButton(AlertDialog.BUTTON2).setEnabled(false); //BUTTON2 is negative button
Pour les boutons id : Référence alert_dialog.xml
Modifié :
et le setOnShowListener depuis L'API de niveau 8 (FroYo), fait la même chose,
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setPositiveButton(android.R.string.ok, null);
AlertDialog dialog = builder.create();
dialog.setOnShowListener(new OnShowListener() {
@Override
public void onShow(DialogInterface dialog) {
if(condition)
((AlertDialog)dialog).getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(false);
}
});
dialog.show();
Édité
new AlertDialog.Builder(this)
.setMessage("This may take a while")
.setPositiveButton("OK", new android.content.DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
((AlertDialog)dialog).getButton(which).setVisibility(View.INVISIBLE);
// the rest of your stuff
}
})
.show();
Aucune de ces réponses ne résout vraiment le problème.
Je réalise cela en utilisant une mise en page personnalisée avec un EditText et un TextWatcher sur cette vue.
final LinearLayout layout = (LinearLayout) inflator.inflate(R.layout.text_dialog, null);
final EditText text = (EditText) layout.findViewById(R.id.text_edit);
final AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setView(layout);
// Now add the buttons...
builder.setPositiveButton(R.string.ok, new AlertDialog.OnClickListener() {
// Left out for brevity...
}
builder.setNegativeButton(R.string.cancel, new AlertDialog.OnClickListener() {
// Left out for brevity...
}
// Create the dialog
final AlertDialog d = builder.create();
// Now add a TextWatcher that will handle enable/disable of save button
text.addTextChangedListener(new TextWatcher() {
private void handleText() {
// Grab the button
final Button okButton = d.getButton(AlertDialog.BUTTON_POSITIVE);
if(text.getText().length() == 0) {
okButton.setEnabled(false);
} else {
okButton.setEnabled(true);
}
}
@Override
public void afterTextChanged(Editable arg0) {
handleText();
}
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
// Nothing to do
}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
// Nothing to do
}
});
// show the dialog
d.show();
// and disable the button to start with
d.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(false);
Voici le code complet pour activer et désactiver le bouton positif de la boîte de dialogue
AlertDialog.Builder builder = new AlertDialog.Builder(this);
LayoutInflater layoutInflater = MainActivity.this.getLayoutInflater();
View view = layoutInflater.inflate(R.layout.dialog,null);
builder.setView(view);
builder.setTitle("Test");
builder.setPositiveButton("ok", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
Toast.makeText(MainActivity.this, "Ok clicked", Toast.LENGTH_SHORT).show();
dialog.dismiss();
}
});
builder.setNegativeButton("cancel", null);
final AlertDialog alertDialog = builder.create();
alertDialog.show();
EditText editText = (EditText)view.findViewById(R.id.mobile_number);
alertDialog.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(false);
editText.addTextChangedListener(new TextWatcher() {
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
}
@Override
public void afterTextChanged(Editable s) {
if(s.length()>=1)
{
alertDialog.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(true);
}
else {
alertDialog.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(false);
}
}
});
Pour supprimer l'enregistrement de la vue de liste de base de données en utilisant view holder, vous avez utilisé ce code dans votre méthode getview ()..
ViewHolder.btn.setOnClickListener(nouveau OnClickListener () {
@Override
public void onClick(View arg0) {
// TODO Auto-generated method stub
AlertDialog.Builder alertDialog2 = new AlertDialog.Builder(
Favorate.this.getParent());
// Setting Dialog Title
alertDialog2.setTitle("Confirm Delete...");
// Setting Dialog Message
alertDialog2
.setMessage("Are you sure you want delete ?");
// Setting Icon to Dialog
alertDialog2.setIcon(R.drawable.delete);
// Setting Positive "Yes" Btn
alertDialog2.setPositiveButton("YES",
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog,
int which) {
// Write your code here to execute after
// dialog
int id = _items.get(position).id;
db.deleterecord(id);
db.close();
}
});
// Setting Negative "NO" Btn
alertDialog2.setNegativeButton("NO",
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog,
int which) {
// Write your code here to execute after
// dialog
dialog.cancel();
}
});
// Showing Alert Dialog
alertDialog2.show();
}
});
Ce dialogFragment fera le travail pour vous. Notez que la boîte de dialogue restera ouverte après la rotation de l'écran en préservant tout texte que l'Utilisateur a déjà saisi. Si vous ne voulez pas que cela se produise, vous devez rejeter le fragment dans l'arrêt de votre activité. La signature de la méthode newInstance peut être modifiée pour tout ce dont vous avez besoin.
import android.app.Activity;
import android.app.Dialog;
import android.app.DialogFragment;
import android.content.DialogInterface;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v7.app.AlertDialog;
import android.text.Editable;
import android.text.TextWatcher;
import android.widget.EditText;
public class TextViewDialogFragment extends DialogFragment implements DialogInterface.OnClickListener, DialogInterface.OnShowListener, TextWatcher
{
final static private String TITLE = "title", MESSAGE = "message", IDENTIFIER = "identifier", INPUT_TYPE = "inputType", POSITIVE_TEXT = "pText", NEGATIVE_TEXT = "nText", CANCELABLE = "cancelable";
public TextViewDialogFragment()
{
super();
}
static public TextViewDialogFragment newInstance(int title, @Nullable String message, int identifier, int inputType, int positiveText, int negativeText, boolean cancelable)
{
TextViewDialogFragment fragement = new TextViewDialogFragment();
Bundle args = new Bundle();
args.putInt(TITLE, title);
args.putString(MESSAGE, message);
args.putInt(IDENTIFIER, identifier);
args.putInt(INPUT_TYPE, inputType);
args.putInt(POSITIVE_TEXT, positiveText);
args.putInt(NEGATIVE_TEXT, negativeText);
args.putBoolean(CANCELABLE, cancelable);
fragement.setArguments(args);
return fragement;
}
@Override
public Dialog onCreateDialog(Bundle savedInstanceState)
{
Activity activity = getActivity();
Bundle args = getArguments();
EditText input = new EditText(activity);
input.setInputType(args.getInt(INPUT_TYPE));
input.setId(R.id.dialog_edit_text);
input.addTextChangedListener(this);
AlertDialog.Builder alert = new AlertDialog.Builder(activity);
alert.setCancelable(args.getBoolean(CANCELABLE)).setTitle(args.getInt(TITLE)).setMessage(args.getString(MESSAGE)).setView(input).setPositiveButton(args.getInt(POSITIVE_TEXT), this);
int negativeText = args.getInt(NEGATIVE_TEXT);
if (negativeText != 0)
{
alert.setNegativeButton(negativeText, this);
}
AlertDialog dialog = alert.create();
dialog.setOnShowListener(this);
return dialog;
}
@Override
public void onShow(DialogInterface dialog)
{
// After device rotation there may be some text present.
if (((EditText)((AlertDialog) dialog).findViewById(R.id.dialog_edit_text)).length() == 0)
{
((AlertDialog) dialog).getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(false);
}
}
@Override
public void onClick(DialogInterface dialog, int which)
{
String text = ((EditText)((AlertDialog) dialog).findViewById(R.id.dialog_edit_text)).getText().toString();
((Callbacks) getActivity()).onTextViewDialogResult(which, getArguments().getInt(IDENTIFIER), text);
}
@Override
public void onCancel(DialogInterface dialog)
{
((Callbacks) getActivity()).onTextViewDialogActivityCancelled(getArguments().getInt(IDENTIFIER));
super.onCancel(dialog);
}
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after)
{
}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count)
{
}
@Override
public void afterTextChanged(Editable s)
{
((AlertDialog) getDialog()).getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(s.length() > 0);
}
void setMessage(String message)
{
Bundle args = getArguments();
args.putString(MESSAGE, message);
setArguments(args);
}
interface Callbacks
{
void onTextViewDialogResult(int which, int identity, String text);
void onTextViewDialogActivityCancelled(int identity);
}
}
Ajoutez des implémentations à votre activité (tout type D'activité est correct):
public class Myctivity extends AppCompatActivity implements TextViewDialogFragment.Callbacks
{
...
}
Créez le diaglogFragment dans votre activité comme ce:
final static int SOMETHING = 1;
myDF = TextViewDialogFragment.newInstance(R.string.my_title, "my message", SOMETHING, InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_CAP_WORDS | InputType.TYPE_TEXT_FLAG_CAP_SENTENCES, /* Whatever is best for your user. */ R.string.yay, android.R.string.cancel, true);
Gérez le résultat de votre activité comme ceci:
@Override
public void onTextViewDialogResult(int which, int identity, String text)
{
if (which == AlertDialog.BUTTON_NEGATIVE)
{
// User did not want to do anything.
return;
}
// text now holds the users answer.
// Identity can be used if you use the same fragment for more than one type of question.
}
@Override
public void onTextViewDialogActivityCancelled(int identity)
{
// This is invoked if you set cancelable to true and the user pressed the back button.
}
Vous devez créer l'identifiant de ressource afin d'ajouter cette ressource quelque part sous res / values
<?xml version="1.0" encoding="utf-8"?>
<resources>
<item name="dialog_edit_text" type="id"/>
</resources>
if(editTextEmailAddress.getText().toString().length()==0)
{
btnCancelCross.setEnabled(false);
}
else
{
btnCancelCross.setEnabled(true);
}
Cela pourrait vous aider merci.