UIButton deshabilitado no descolorido o gris

En mi aplicación para iPhone, tengo un UIButton que he creado en Interface Builder. Puedo habilitarlo y deshabilitarlo con éxito de esta manera en mi código ...

sendButton.enabled = YES;

o

sendButton.enabled = NO;

Sin embargo, ¡el aspecto visual del botón es siempre el mismo! No está descolorido ni gris. Sin embargo, si intento hacer clic en él, se activa o desactiva como se esperaba. ¿Me estoy perdiendo de algo? ¿No debería verse desvaído o gris?

Puedes usar el siguiente código:

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

or

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

simplemente cambie la configuración de estado para deshabilitar y elija lo que desee, Imagen de fondo para estado deshabilitado

Otra opción es cambiar el color del texto (a gris claro, por ejemplo) para el estado deshabilitado.

En el editor del guión gráfico, elija Disableddel State Configbotón emergente. Use el Text Colorbotón emergente para cambiar el color del texto.

En código, usa el -setTitleColor:forState:mensaje.

Intente configurar las diferentes imágenes para UIControlStateDisabled(imagen gris deshabilitada) y UIControlStateNormal(Imagen normal) para que el botón genere el estado deshabilitado por usted.

Para hacer que el botón se desvanezca cuando se deshabilita, puede configurar alfa para él. Hay dos opciones para ti:

Primera forma : si desea solicitar todos sus botones en su aplicación, puede escribir extensionpara UIButton de esta manera:

extension UIButton {

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

}

Segunda forma : si solo desea solicitar algunos botones en su aplicación, puede escribir una clase personalizada desde UIButton como se muestra a continuación y usar esta clase para la que desea aplicar:

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

Si usa un botón de texto, puede poner en viewDidLoad el método de instancia

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

ejemplo:

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

Puedes usar adjustsImageWhenDisabledcual es propiedad deUIButton
(@property (nonatomic) BOOL adjustsImageWhenDisabled)

Ex:

 Button.adjustsImageWhenDisabled = false

Esta es una pregunta bastante antigua, pero hay una forma muy simple de lograrlo.

myButton.userInteractionEnabled = false

Esto solo deshabilitará cualquier gesto táctil sin cambiar la apariencia del botón

En Swift :

previousCustomButton.enabled = false
previousCustomButton.alpha = 0.5

o

nextCustomButton.enabled = true
nextCustomButton.alpha = 1.0

Establecido 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: (el color del texto cambiará automáticamente)

loginButton.isEnabled = false

Cree una extensión en Swift> 3.0 en lugar de cada botón por sí mismo

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

Puede usar las dos primeras respuestas y será un mejor resultado.

En el inspector de atributos (cuando selecciona el botón), cambie la Configuración de estado a Desactivada para establecer la nueva imagen que aparecerá cuando esté desactivada (elimine el marcador en la verificación Contenido-> Activado para desactivarla) .

Y cuando cambia el estado a habilitado, la imagen cargará la de este estado.

Agregar la lógica alfa a esto es un buen detalle.

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

Cómo utilizar

myButton.isEnabled = false

Estoy atrapado en el mismo problema. Establecer alfa no es lo que quiero.

UIButtontiene " imagen de fondo " y " color de fondo ". Por imagen, UIButtontiene una propiedad como

@property (nonatomic) BOOL adjustsImageWhenDisabled

Y la imagen de fondo se dibuja más clara cuando el botón está desactivado. Para el color de fondo, la configuración alfa, la solución de Ravin, funciona bien.

Primero, debe verificar si ha desmarcado el cuadro "deshabilitar ajusta imagen" en Utilidades-Atributos.
Luego, verifique el color de fondo de este botón.

(Espero que sea útil. Esta es una publicación antigua; las cosas podrían haber cambiado en Xcode).

Parece que el siguiente código funciona bien. Pero en algunos casos, esto no funciona.

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

Si el código anterior no funciona, envuélvalo en Hilo principal. entonces

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

si vas con rapidez, así

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

Además, si personalizó UIButton, agréguelo a la clase Button.

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

Gracias y disfruta codificando !!!

Si el UIButtonestá en el estado combinado de selectedy disabled, su estado es UIControlStateSelected | UIControlStateDisabled.

Por lo tanto, su estado debe ajustarse así:

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

Un enfoque es subclasificar de la UIButtonsiguiente manera:

@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 pregunta tiene muchas respuestas, pero todas no parecen muy útiles en caso de que realmente quiera usar backgroundColor para diseñar sus botones. UIButton tiene una buena opción para configurar diferentes imágenes para diferentes estados de control, pero no hay la misma función para los colores de fondo. Entonces, una de las soluciones es agregar una extensión que generará imágenes a partir del color y aplicarlas al botón.

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 hay un problema con esta solución: este cambio no se aplicará a los botones creados en el guión gráfico. En cuanto a mí, no es un problema porque prefiero diseñar la interfaz de usuario desde el código. Si desea usar guiones gráficos, entonces @IBInspectablenecesita algo de magia adicional .

La segunda opción es la subclasificación, pero prefiero evitar esto.

Tal vez pueda subclasificar su botón y anular su variable isEnabled. La ventaja es que puede reutilizar en múltiples 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