Botão UIB desativado não desbotado ou cinza

No meu aplicativo para iPhone, tenho um UIButton que criei no Interface Builder. Posso habilitá-lo e desativá-lo com êxito no meu código ...

sendButton.enabled = YES;

ou

sendButton.enabled = NO;

No entanto, a aparência visual do botão é sempre a mesma! Não está desbotado ou cinza. Se eu tentar clicar nele, ele estará ativado ou desativado conforme o esperado. Estou esquecendo de algo? Não deveria parecer desbotado ou cinza?

Você pode usar o seguinte código:

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

or

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

basta alterar a configuração do estado para desativar e escolher o que deseja, imagem de fundo para o estado desativado

Outra opção é alterar a cor do texto (para cinza claro, por exemplo) para o estado desativado.

No editor de storyboard, escolha Disabledno State Configbotão pop - up. Use o Text Colorbotão pop - up para alterar a cor do texto.

No código, use a -setTitleColor:forState:mensagem

Tente definir as diferentes imagens para UIControlStateDisabled(imagem cinza desativada) e UIControlStateNormal(imagem normal) para que o botão gere o estado desativado para você.

Para tornar o botão desbotado quando desativado, você pode definir alfa para ele. Existem duas opções para você:

Primeira maneira : se você deseja solicitar todos os botões do seu aplicativo, pode escrever extensionpara o UIButton assim:

extension UIButton {

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

}

Segunda maneira : se você apenas deseja solicitar alguns botões em seu aplicativo, pode escrever uma classe personalizada no UIButton como abaixo e usar esta classe para a qual deseja aplicar:

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

Se você usar um botão de texto, poderá colocar em viewDidLoad o método da instância

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

exemplo:

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

Você pode usar o adjustsImageWhenDisabledque é propriedade deUIButton
(@property (nonatomic) BOOL adjustsImageWhenDisabled)

Ex:

 Button.adjustsImageWhenDisabled = false

Esta é uma pergunta bastante antiga, mas há uma maneira muito simples de conseguir isso.

myButton.userInteractionEnabled = false

Isso desativará apenas os gestos de toque sem alterar a aparência do botão

Em Swift :

previousCustomButton.enabled = false
previousCustomButton.alpha = 0.5

ou

nextCustomButton.enabled = true
nextCustomButton.alpha = 1.0

Definido title colorpara diferentes estados:

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

Uso: (a cor do texto será alterada automaticamente)

loginButton.isEnabled = false

Crie uma extensão no Swift> 3.0 em vez de cada botão sozinho

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

Você pode usar as duas primeiras respostas e será um resultado melhor.

No inspetor de atributos (ao selecionar o botão), altere a Configuração do estado para Desativado para definir a nova imagem que será exibida quando for desativada (remova o marcador na verificação Conteúdo-> Ativado para desativá-lo) .

E quando você altera o estado para ativado, a imagem carrega a desse estado.

Adicionar a lógica alfa a isso é um bom detalhe.

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

Como usar

myButton.isEnabled = false

Estou preso no mesmo problema. Definir alfa não é o que eu quero.

UIButtontem " imagem de fundo " e " cor de fundo ". Para imagem, UIButtontem uma propriedade como

@property (nonatomic) BOOL adjustsImageWhenDisabled

E a imagem de fundo é mais clara quando o botão está desativado. Para a cor de fundo, a configuração de alfa, solução de Ravin, funciona bem.

Primeiro, você deve verificar se desmarcou a caixa "desativado ajusta imagem" em Utilitários-Atributos.
Em seguida, verifique a cor de fundo desse botão.

(Espero que seja útil. Este é um post antigo; as coisas podem ter mudado no Xcode).

Parece que o código a seguir funciona bem. Mas, em alguns casos, isso não funciona.

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

Se o código acima não funcionar, envolva-o no Main Thread. tão

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

se você for rápido, assim

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

Além disso, se você personalizou o UIButton, adicione isso à classe Button.

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

Obrigado e aproveite a codificação !!!

Se o UIButtonestá no estado combinado de selectede disabled, seu estado é UIControlStateSelected | UIControlStateDisabled.

Portanto, seu estado precisa ser ajustado assim:

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

Uma abordagem é a subclasse da UIButtonseguinte maneira:

@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

Esta pergunta tem muitas respostas, mas todas elas não parecem muito úteis, se você realmente quiser usar backgroundColor para estilizar seus botões. O UIButton tem uma boa opção para definir imagens diferentes para diferentes estados de controle, mas não há o mesmo recurso para cores de fundo. Portanto, uma das soluções é adicionar uma extensão que gere imagens em cores e as aplique no botão.

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

Apenas um problema com esta solução - essa alteração não será aplicada aos botões criados no storyboard. Quanto a mim, não é um problema, porque eu prefiro estilizar a interface do usuário a partir do código. Se você quiser usar storyboards, use um pouco de mágica adicional @IBInspectable.

A segunda opção é a subclasse, mas eu prefiro evitar isso.

Talvez você possa subclassificar seu botão e substituir sua variável isEnabled. A vantagem é que você pode reutilizar em vários lugares.

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