Pulsante UIB disabilitato non sbiadito o grigio

Nella mia app per iPhone, ho un UIButton che ho creato in Interface Builder. Posso abilitarlo e disabilitarlo con successo in questo modo nel mio codice ...

sendButton.enabled = YES;

o

sendButton.enabled = NO;

Tuttavia, l'aspetto visivo del pulsante è sempre lo stesso! Non è sbiadito o grigio. Se provo a fare clic su di esso, tuttavia, è abilitato o disabilitato come previsto. Mi sto perdendo qualcosa? Non dovrebbe apparire sbiadito o grigio?

Puoi usare il seguente codice:

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

or

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

basta cambiare la configurazione dello stato per disabilitare e scegliere ciò che si desidera, immagine di sfondo per lo stato disabilitato

Un'altra opzione è quella di cambiare il colore del testo (ad esempio in grigio chiaro) per lo stato disabilitato.

Nell'editor dello storyboard, scegliere Disableddal State Configpulsante popup. Utilizzare il Text Colorpulsante popup per modificare il colore del testo.

Nel codice, usa il -setTitleColor:forState:messaggio.

Prova a impostare le diverse immagini per UIControlStateDisabled(immagine grigia disabilitata) e UIControlStateNormal(Immagine normale) in modo che il pulsante generi lo stato disabilitato per te.

Per rendere il pulsante sbiadito quando disabilitato, è possibile impostare alpha per esso. Ci sono due opzioni per te:

Primo modo : se vuoi richiedere tutti i pulsanti della tua app, puoi scrivere extensionper UIButton in questo modo:

extension UIButton {

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

}

Secondo modo : se desideri semplicemente applicare alcuni pulsanti nella tua app, puoi scrivere una classe personalizzata da UIButton come di seguito e utilizzare questa classe per la quale desideri applicare:

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

Se si utilizza un pulsante di testo, è possibile inserire viewDidCaricare il metodo dell'istanza

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

esempio:

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

È possibile utilizzare la adjustsImageWhenDisabledproprietà diUIButton
(@property (nonatomic) BOOL adjustsImageWhenDisabled)

Ex:

 Button.adjustsImageWhenDisabled = false

Questa è una domanda piuttosto vecchia ma c'è un modo molto semplice per raggiungere questo obiettivo.

myButton.userInteractionEnabled = false

Ciò disabiliterà solo i gesti tattili senza modificare l'aspetto del pulsante

In Swift :

previousCustomButton.enabled = false
previousCustomButton.alpha = 0.5

o

nextCustomButton.enabled = true
nextCustomButton.alpha = 1.0

Impostare title colorper stati diversi:

@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)
        }
    }

Utilizzo: (il colore del testo verrà modificato automaticamente)

loginButton.isEnabled = false

Crea un'estensione in Swift> 3.0 anziché ogni pulsante da solo

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

Puoi usare entrambe le prime risposte e sarà un risultato migliore.

Nella finestra di ispezione degli attributi (quando si seleziona il pulsante), modificare Config. Stato su Disabilitato per impostare la nuova immagine che verrà visualizzata quando è disabilitata (rimuovere l'indicatore nel controllo Contenuto-> Abilitato per renderlo disabilitato) .

E quando cambi lo stato in abilitato, l'immagine caricherà quello da questo stato.

L'aggiunta della logica alfa a questo è un buon dettaglio.

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
                }
            }
        }
    }
}

Come usare

myButton.isEnabled = false

Sono bloccato sullo stesso problema. Impostare alfa non è quello che voglio.

UIButtonha " immagine di sfondo " e " colore di sfondo ". Per l'immagine, UIButtonha una proprietà come

@property (nonatomic) BOOL adjustsImageWhenDisabled

E l'immagine di sfondo è più chiara quando il pulsante è disabilitato. Per il colore di sfondo, l'impostazione alpha, la soluzione di Ravin, funziona bene.

Innanzitutto, devi controllare se hai deselezionato la casella "disabilitato regola l'immagine" in Utilità-Attributi.
Quindi, controlla il colore di sfondo per questo pulsante.

(Spero sia utile. Questo è un vecchio post; le cose potrebbero essere cambiate in Xcode).

Sembra che il seguente codice funzioni bene. Ma in alcuni casi, questo non funziona.

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

Se il codice sopra non funziona, avvolgilo nella discussione principale. così

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

se vai con swift, in questo modo

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

Inoltre, se hai personalizzato UIButton, aggiungilo alla classe Button.

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

Grazie e buona codifica !!!

Se il UIButtonè nello stato combinato di selectede disabled, il suo stato è UIControlStateSelected | UIControlStateDisabled.

Quindi il suo stato deve essere modificato in questo modo:

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

Un approccio è la sottoclasse UIButtoncome segue:

@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

Questa domanda ha molte risposte ma tutte non sembrano molto utili nel caso in cui tu voglia davvero usare backgroundColor per dare uno stile ai tuoi pulsanti. UIButton ha una bella opzione per impostare immagini diverse per diversi stati di controllo ma non c'è la stessa funzione per i colori di sfondo. Quindi una delle soluzioni è aggiungere l'estensione che genererà immagini dal colore e applicarle al pulsante.

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)
  }
}

Solo un problema con questa soluzione: questa modifica non verrà applicata ai pulsanti creati nello storyboard. Per quanto mi riguarda non è un problema perché preferisco modellare l'interfaccia utente dal codice. Se vuoi usare gli storyboard, allora qualche magia aggiuntiva con@IBInspectable necessità.

La seconda opzione è la sottoclasse ma preferisco evitarlo.

Forse puoi sottoclassare il tuo pulsante e sovrascrivere la tua variabile isEnabled. Il vantaggio è che puoi riutilizzarlo in più punti.

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