UIButton désactivé non décoloré ou gris

Dans mon application iPhone, j'ai un UIButton que j'ai créé dans Interface Builder. Je peux l'activer et le désactiver avec succès comme ceci dans mon code ...

sendButton.enabled = YES;

ou

sendButton.enabled = NO;

Cependant, l'aspect visuel du bouton est toujours le même! Il n'est ni fané ni gris. Si j'essaye de cliquer dessus, il est activé ou désactivé comme prévu. Est-ce que je manque quelque chose? Ne devrait-il pas avoir l'air fané ou gris?

Vous pouvez utiliser le code suivant:

sendButton.enabled = YES;
sendButton.alpha = 1.0;

or

sendButton.enabled = NO;
sendButton.alpha = 0.5;

changez simplement la configuration de l'état pour désactiver et choisissez ce que vous voulez, Image d'arrière-plan pour l'état désactivé

Une autre option consiste à changer la couleur du texte (en gris clair par exemple) pour l'état désactivé.

Dans l'éditeur de storyboard, choisissez Disableddans le State Configbouton contextuel. Utilisez le Text Colorbouton contextuel pour changer la couleur du texte.

Dans le code, utilisez le -setTitleColor:forState:message.

Essayez de définir les différentes images pour UIControlStateDisabled(image grise désactivée) et UIControlStateNormal(image normale) afin que le bouton génère l'état désactivé pour vous.

Pour rendre le bouton estompé lorsqu'il est désactivé, vous pouvez définir l'alpha pour celui-ci. Deux options s'offrent à vous:

Première manière : si vous souhaitez postuler pour tous vos boutons dans votre application, vous pouvez donc écrire extensionpour UIButton comme ceci:

extension UIButton {

    open override var isEnabled: Bool{
        didSet {
            alpha = isEnabled ? 1.0 : 0.5
        }
    }

}

Deuxième façon : si vous souhaitez simplement appliquer pour certains boutons dans votre application, vous pouvez donc écrire une classe personnalisée à partir d'UIButton comme ci-dessous et utiliser cette classe pour laquelle vous souhaitez appliquer:

class MyButton: UIButton {
    override var isEnabled: Bool {
        didSet {
            alpha = isEnabled ? 1.0 : 0.5
        }
    }
}

Si vous utilisez un bouton de texte, vous pouvez mettre dans viewDidLoad la méthode d'instance

- (void)setTitleColor:(UIColor *)color forState:(UIControlState)state

exemple:

[self.syncImagesButton setTitleColor:[UIColor grayColor] forState:UIControlStateDisabled];

Vous pouvez utiliser adjustsImageWhenDisabledce qui est la propriété deUIButton
(@property (nonatomic) BOOL adjustsImageWhenDisabled)

Ex:

 Button.adjustsImageWhenDisabled = false

C'est une question assez ancienne, mais il existe un moyen très simple d'y parvenir.

myButton.userInteractionEnabled = false

Cela désactivera uniquement les gestes tactiles sans changer l'apparence du bouton

Dans Swift :

previousCustomButton.enabled = false
previousCustomButton.alpha = 0.5

ou

nextCustomButton.enabled = true
nextCustomButton.alpha = 1.0

Défini title colorpour différents états:

@IBOutlet weak var loginButton: UIButton! {
        didSet {
            loginButton.setTitleColor(UIColor.init(white: 1, alpha: 0.3), for: .disabled)
            loginButton.setTitleColor(UIColor.init(white: 1, alpha: 1), for: .normal)
        }
    }

Utilisation: (la couleur du texte sera modifiée automatiquement)

loginButton.isEnabled = false

Créez une extension dans Swift> 3.0 plutôt que chaque bouton seul

extension UIButton {
    override open var isEnabled : Bool {
        willSet{
            if newValue == false {
                self.setTitleColor(UIColor.gray, for: UIControlState.disabled)
            }
        }
    }
}

Vous pouvez utiliser les deux premières réponses et vous obtiendrez un meilleur résultat.

Dans l'inspecteur d'attributs (lorsque vous sélectionnez le bouton), modifiez la configuration de l'état sur Désactivé pour définir la nouvelle image qui apparaîtra lorsqu'elle sera désactivée (supprimez le marqueur dans la case Contenu-> Activé pour la désactiver) .

Et lorsque vous changez l'état en activé, l'image chargera celui de cet état.

Ajouter la logique alpha à cela est un bon détail.

Swift 4+

extension UIButton {
    override open var isEnabled: Bool {
        didSet {
            DispatchQueue.main.async {
                if self.isEnabled {
                    self.alpha = 1.0
                }
                else {
                    self.alpha = 0.6
                }
            }
        }
    }
}

Comment utiliser

myButton.isEnabled = false

Je suis coincé sur le même problème. Mettre l'alpha n'est pas ce que je veux.

UIButtona " image d'arrière-plan " et " couleur d'arrière-plan ". Pour l'image, UIButtona une propriété comme

@property (nonatomic) BOOL adjustsImageWhenDisabled

Et l'image d'arrière-plan est plus claire lorsque le bouton est désactivé. Pour la couleur d'arrière-plan, le réglage alpha, la solution de Ravin, fonctionne très bien.

Tout d'abord, vous devez vérifier si vous avez décoché la case "désactivé ajuste l'image" sous Utilitaires-Attributs.
Vérifiez ensuite la couleur d'arrière-plan de ce bouton.

(J'espère que c'est utile. Ceci est un ancien message; les choses ont peut-être changé dans Xcode).

Il semble que le code suivant fonctionne correctement. Mais dans certains cas, cela ne fonctionne pas.

sendButton.enabled = NO;
sendButton.alpha = 0.5;

Si le code ci-dessus ne fonctionne pas, veuillez l'envelopper dans le fil principal. alors

dispatch_async(dispatch_get_main_queue(), ^{
    sendButton.enabled = NO;
    sendButton.alpha = 0.5
});

si tu y vas avec swift, comme ça

DispatchQueue.main.async {
    sendButton.isEnabled = false
    sendButton.alpha = 0.5
}

De plus, si vous avez personnalisé UIButton, ajoutez-le à la classe Button.

override var isEnabled: Bool {
    didSet {
        DispatchQueue.main.async {
            if self.isEnabled {
                self.alpha = 1.0
            }
            else {
                self.alpha = 0.5
            }
        }
    }
}

Merci et bonne programmation !!!

Si le UIButtonest dans l'état combiné de selectedet disabled, son état est UIControlStateSelected | UIControlStateDisabled.

Son état doit donc être ajusté comme ceci:

[button setTitleColor:color UIControlStateSelected | UIControlStateDisabled];
[button setImage:image forState:UIControlStateSelected | UIControlStateDisabled];

Une approche consiste à sous-classer UIButtoncomme suit:

@implementation TTButton
- (void)awakeFromNib {
   [super awakeFromNib];

    //! Fix behavior when `disabled && selected`
    //! Load settings in `xib` or `storyboard`, and apply it again.
    UIColor *color = [self titleColorForState:UIControlStateDisabled];
    [self setTitleColor:color forState:UIControlStateDisabled];

    UIImage *img = [self imageForState:UIControlStateDisabled];
    [self setImage:img forState:UIControlStateDisabled];
}

- (void)setTitleColor:(UIColor *)color forState:(UIControlState)state {
    [super setTitleColor:color forState:state];

    //
    if (UIControlStateDisabled == state) {
        [super setTitleColor:color forState:UIControlStateSelected | state];
        [super setTitleColor:color forState:UIControlStateHighlighted | state];
    }
}

- (void)setImage:(UIImage *)image forState:(UIControlState)state {
    [super setImage:image forState:state];

    if (UIControlStateDisabled == state) {
        [super setImage:image forState:UIControlStateSelected | state];
        [super setImage:image forState:UIControlStateHighlighted | state];
    }
}

@end

Cette question a beaucoup de réponses, mais elles ne semblent pas très utiles au cas où vous voudriez vraiment utiliser backgroundColor pour styliser vos boutons. UIButton a une option intéressante pour définir différentes images pour différents états de contrôle, mais il n'y a pas la même fonctionnalité pour les couleurs d'arrière-plan. L'une des solutions consiste donc à ajouter une extension qui générera des images à partir de la couleur et les appliquera au bouton.

extension UIButton {
  private func image(withColor color: UIColor) -> UIImage? {
    let rect = CGRect(x: 0.0, y: 0.0, width: 1.0, height: 1.0)
    UIGraphicsBeginImageContext(rect.size)
    let context = UIGraphicsGetCurrentContext()

    context?.setFillColor(color.cgColor)
    context?.fill(rect)

    let image = UIGraphicsGetImageFromCurrentImageContext()
    UIGraphicsEndImageContext()

    return image
  }

  func setBackgroundColor(_ color: UIColor, for state: UIControlState) {
    self.setBackgroundImage(image(withColor: color), for: state)
  }
}

Un seul problème avec cette solution - cette modification ne sera pas appliquée aux boutons créés dans le storyboard. Quant à moi, ce n'est pas un problème car je préfère styliser l'interface utilisateur à partir du code. Si vous souhaitez utiliser des storyboards, une magie supplémentaire est @IBInspectablenécessaire.

La deuxième option est le sous-classement, mais je préfère éviter cela.

Peut-être que vous pouvez sous-classer votre bouton et remplacer votre variable isEnabled. L'avantage est que vous pouvez réutiliser à plusieurs endroits.

override var isEnabled: Bool {
     didSet {
         if isEnabled {
             self.alpha = 1
         } else {
             self.alpha = 0.2
         }
     }
 }

#import "UIButton+My.h"
#import <QuartzCore/QuartzCore.h>
@implementation UIButton (My)


-(void)fade :(BOOL)enable{
    self.enabled=enable;//
    self.alpha=enable?1.0:0.5;
}

@end

.h:

#import <UIKit/UIKit.h>
@interface UIButton (My)

-(void)fade :(BOOL)enable;

@end