online hexadecimal custom color ios uiview uicolor

ios - hexadecimal - Crea programáticamente una UIView con degradado de color



uicolor swift (19)

C objetivo:

UIView *view = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 320, 50)]; CAGradientLayer *gradient = [CAGradientLayer layer]; gradient.frame = view.bounds; gradient.colors = @[(id)[UIColor whiteColor].CGColor, (id)[UIColor blackColor].CGColor]; [view.layer insertSublayer:gradient atIndex:0];

Rápido:

let view = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 50)) let gradient = CAGradientLayer() gradient.frame = view.bounds gradient.colors = [UIColor.white.cgColor, UIColor.black.cgColor] view.layer.insertSublayer(gradient, at: 0)

Información : use startPoint y endPoint para cambiar la dirección del gradiente .

Si hay otras vistas agregadas a esta UIView (como una UILabel ), puede considerar establecer el color de fondo de esas UIView en [UIColor clearColor] para que se presente la vista de gradiente en lugar del color de fondo para las sub vistas . El uso de clearColor tiene un golpe de rendimiento leve.

Estoy tratando de generar una vista con un fondo de color degradado (Un color sólido a transparente) en tiempo de ejecución. ¿Hay una manera de hacer eso?


Como solo necesitaba un tipo de gradiente en mi aplicación, creé una subclase de UIView y preconfiguré la capa de gradiente en la inicialización con colores fijos. Los inicializadores de UIView llaman a configureGradientLayer -method, que configura CAGradientLayer:

DDGradientView.h:

#import <UIKit/UIKit.h> @interface DDGradientView : UIView { } @end

DDGradientView.m:

#import "DDGradientView.h" @implementation DDGradientView // Change the views layer class to CAGradientLayer class + (Class)layerClass { return [CAGradientLayer class]; } - (instancetype)initWithCoder:(NSCoder *)aDecoder { self = [super initWithCoder:aDecoder]; if(self) { [self configureGradientLayer]; } return self; } - (instancetype)initWithFrame:(CGRect)frame { self = [super initWithFrame:frame]; if(self) { [self configureGradientLayer]; } return self; } // Make custom configuration of your gradient here - (void)configureGradientLayer { CAGradientLayer *gLayer = (CAGradientLayer *)self.layer; gLayer.colors = [NSArray arrayWithObjects:(id)[[UIColor whiteColor] CGColor], (id)[[UIColor lightGrayColor] CGColor], nil]; } @end


En Swift 3.1 he añadido esta extensión a UIView

import Foundation import UIKit import CoreGraphics extension UIView { func gradientOfView(withColours: UIColor...) { var cgColours = [CGColor]() for colour in withColours { cgColours.append(colour.cgColor) } let grad = CAGradientLayer() grad.frame = self.bounds grad.colors = cgColours self.layer.insertSublayer(grad, at: 0) } }

que luego llamo con

class OverviewVC: UIViewController { override func viewDidLoad() { super.viewDidLoad() self.view.gradientOfView(withColours: UIColor.red,UIColor.green, UIColor.blue) } }


Es una buena idea llamar a las soluciones anteriores para actualizar la capa en el

viewDidLayoutSubviews 

para obtener las vistas actualizadas correctamente


Este es mi enfoque recomendado.

Para promover la reutilización, diría que cree una categoría de CAGradientLayer y agregue los gradientes que desee como métodos de clase. Especifíquelos en el archivo de header así:

#import <QuartzCore/QuartzCore.h> @interface CAGradientLayer (SJSGradients) + (CAGradientLayer *)redGradientLayer; + (CAGradientLayer *)blueGradientLayer; + (CAGradientLayer *)turquoiseGradientLayer; + (CAGradientLayer *)flavescentGradientLayer; + (CAGradientLayer *)whiteGradientLayer; + (CAGradientLayer *)chocolateGradientLayer; + (CAGradientLayer *)tangerineGradientLayer; + (CAGradientLayer *)pastelBlueGradientLayer; + (CAGradientLayer *)yellowGradientLayer; + (CAGradientLayer *)purpleGradientLayer; + (CAGradientLayer *)greenGradientLayer; @end

Luego, en su archivo de implementación, especifique cada gradiente con esta sintaxis:

+ (CAGradientLayer *)flavescentGradientLayer { UIColor *topColor = [UIColor colorWithRed:1 green:0.92 blue:0.56 alpha:1]; UIColor *bottomColor = [UIColor colorWithRed:0.18 green:0.18 blue:0.18 alpha:1]; NSArray *gradientColors = [NSArray arrayWithObjects:(id)topColor.CGColor, (id)bottomColor.CGColor, nil]; NSArray *gradientLocations = [NSArray arrayWithObjects:[NSNumber numberWithInt:0.0],[NSNumber numberWithInt:1.0], nil]; CAGradientLayer *gradientLayer = [CAGradientLayer layer]; gradientLayer.colors = gradientColors; gradientLayer.locations = gradientLocations; return gradientLayer; }

Luego simplemente importe esta categoría en su ViewController o en cualquier otra subclass requerida, y úsela así:

CAGradientLayer *backgroundLayer = [CAGradientLayer purpleGradientLayer]; backgroundLayer.frame = self.view.frame; [self.view.layer insertSublayer:backgroundLayer atIndex:0];


He extendido un poco la respuesta aceptada utilizando la funcionalidad de extensión de Swift, así como una enumeración.

Ah, y si está utilizando Storyboard como yo, asegúrese de llamar a gradientBackground(from:to:direction:) en viewDidLayoutSubviews() o posterior.

Swift 3

enum GradientDirection { case leftToRight case rightToLeft case topToBottom case bottomToTop } extension UIView { func gradientBackground(from color1: UIColor, to color2: UIColor, direction: GradientDirection) { let gradient = CAGradientLayer() gradient.frame = self.bounds gradient.colors = [color1.cgColor, color2.cgColor] switch direction { case .leftToRight: gradient.startPoint = CGPoint(x: 0.0, y: 0.5) gradient.endPoint = CGPoint(x: 1.0, y: 0.5) case .rightToLeft: gradient.startPoint = CGPoint(x: 1.0, y: 0.5) gradient.endPoint = CGPoint(x: 0.0, y: 0.5) case .bottomToTop: gradient.startPoint = CGPoint(x: 0.5, y: 1.0) gradient.endPoint = CGPoint(x: 0.5, y: 0.0) default: break } self.layer.insertSublayer(gradient, at: 0) } }


He implementado esto de forma rápida con una extensión:

Swift 3

extension UIView { func addGradientWithColor(color: UIColor) { let gradient = CAGradientLayer() gradient.frame = self.bounds gradient.colors = [UIColor.clear.cgColor, color.cgColor] self.layer.insertSublayer(gradient, at: 0) } }

Swift 2.2

extension UIView { func addGradientWithColor(color: UIColor) { let gradient = CAGradientLayer() gradient.frame = self.bounds gradient.colors = [UIColor.clearColor().CGColor, color.CGColor] self.layer.insertSublayer(gradient, atIndex: 0) } }

No puedo establecer un gradiente en cada vista como esta:

myImageView.addGradientWithColor(UIColor.blue)


He implementado esto en mi código.

UIView *view1 = [[UIView alloc] initWithFrame:CGRectMake(0.0f, 0.0f, self.view.frame.size.width, 31.0f)]; view1.backgroundColor = [UIColor clearColor]; CAGradientLayer *gradient = [CAGradientLayer layer]; gradient.frame = view1.bounds; UIColor *topColor = [UIColor colorWithRed:132.0/255.0 green:222.0/255.0 blue:109.0/255.0 alpha:1.0]; UIColor *bottomColor = [UIColor colorWithRed:31.0/255.0 green:150.0/255.0 blue:99.0/255.0 alpha:1.0]; gradient.colors = [NSArray arrayWithObjects:(id)[topColor CGColor], (id)[bottomColor CGColor], nil]; [view1.layer insertSublayer:gradient atIndex:0];

Ahora puedo ver un gradiente en mi vista.


Intenta esto funcionó como un encanto para mí,

C objetivo

He establecido el color de fondo degradado RGB en UIview

UIView *view = [[UIView alloc] initWithFrame:CGRectMake(0,0,320,35)]; CAGradientLayer *gradient = [CAGradientLayer layer]; gradient.frame = view.bounds; gradient.startPoint = CGPointZero; gradient.endPoint = CGPointMake(1, 1); gradient.colors = [NSArray arrayWithObjects:(id)[[UIColor colorWithRed:34.0/255.0 green:211/255.0 blue:198/255.0 alpha:1.0] CGColor],(id)[[UIColor colorWithRed:145/255.0 green:72.0/255.0 blue:203/255.0 alpha:1.0] CGColor], nil]; [view.layer addSublayer:gradient];

ACTUALIZADO: - Swift3 +

Código : -

var gradientView = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 35)) let gradientLayer:CAGradientLayer = CAGradientLayer() gradientLayer.frame.size = self.gradientView.frame.size gradientLayer.colors = [UIColor.white.cgColor,UIColor.red.withAlphaComponent(1).cgColor] //Use diffrent colors gradientView.layer.addSublayer(gradientLayer)

Puede agregar el punto de inicio y final del color degradado.

gradientLayer.startPoint = CGPoint(x: 0.0, y: 1.0) gradientLayer.endPoint = CGPoint(x: 1.0, y: 1.0)

Para una descripción más detallada, consulte el documento CAGradientLayer

Espero que esto sea de ayuda para alguien.


Lo que estás buscando es CAGradientLayer . Cada UIView tiene una capa: en esa capa puede agregar subcapas, al igual que puede agregar subvistas. Un tipo específico es CAGradientLayer , donde le CAGradientLayer una variedad de colores para que se gradúe entre ellos.

Un ejemplo es este simple envoltorio para una vista de degradado:

http://oleb.net/blog/2010/04/obgradientview-a-simple-uiview-wrapper-for-cagradientlayer/

Tenga en cuenta que debe incluir el marco de QuartZCore para acceder a todas las partes de la capa de una vista UIV.


Mi solución es crear UIView subclase CAGradientLayer con CAGradientLayer accesible como una propiedad de solo lectura. Esto le permitirá personalizar su gradiente como desee y no necesita manejar los cambios de diseño usted mismo. Implementación de subclases:

@interface GradientView : UIView @property (nonatomic, readonly) CAGradientLayer *gradientLayer; @end @implementation GradientView + (Class)layerClass { return [CAGradientLayer class]; } - (CAGradientLayer *)gradientLayer { return (CAGradientLayer *)self.layer; } @end

Uso:

self.iconBackground = [GradientView new]; [self.background addSubview:self.iconBackground]; self.iconBackground.gradientLayer.colors = @[(id)[UIColor blackColor].CGColor, (id)[UIColor whiteColor].CGColor]; self.iconBackground.gradientLayer.startPoint = CGPointMake(1.0f, 1.0f); self.iconBackground.gradientLayer.endPoint = CGPointMake(0.0f, 0.0f);


Puede crear una clase personalizada GradientView :

Swift 4, Swift 3

class GradientView: UIView { override open class var layerClass: AnyClass { return CAGradientLayer.classForCoder() } required init?(coder aDecoder: NSCoder) { super.init(coder: aDecoder) let gradientLayer = layer as! CAGradientLayer gradientLayer.colors = [UIColor.white.cgColor, UIColor.black.cgColor] } }

En el guión gráfico, establezca el tipo de clase en cualquier vista que desee tener fondo degradado:

Esto es mejor de las siguientes maneras:

  • No es necesario configurar el marco de CLayer
  • Utilice NSConstraint como de costumbre en UIView
  • No es necesario crear subcapas (menos uso de memoria)

Vista rápida y sencilla basada en la versión de Yuchen.

class GradientView: UIView { override class func layerClass() -> AnyClass { return CAGradientLayer.self } lazy var gradientLayer: CAGradientLayer = { return self.layer as! CAGradientLayer }() override init(frame: CGRect) { super.init(frame: frame) } required init?(coder aDecoder: NSCoder) { super.init(coder: aDecoder) } }

Luego puedes usar gradientLayer después de la inicialización de esta manera ...

someView.gradientLayer.colors = [UIColor.whiteColor().CGColor, UIColor.blackColor().CGColor]


Implementación rápida:

var gradientLayerView: UIView = UIView(frame: CGRectMake(0, 0, view.bounds.width, 50)) var gradient: CAGradientLayer = CAGradientLayer() gradient.frame = gradientLayerView.bounds gradient.colors = [UIColor.grayColor().CGColor, UIColor.clearColor().CGColor] gradientLayerView.layer.insertSublayer(gradient, atIndex: 0) self.view.layer.insertSublayer(gradientLayerView.layer, atIndex: 0)


Para dar color degradado a UIView (swift 4.2)

func makeGradientLayer(`for` object : UIView, startPoint : CGPoint, endPoint : CGPoint, gradientColors : [Any]) -> CAGradientLayer { let gradient: CAGradientLayer = CAGradientLayer() gradient.colors = gradientColors gradient.locations = [0.0 , 1.0] gradient.startPoint = startPoint gradient.endPoint = endPoint gradient.frame = CGRect(x: 0, y: 0, w: object.frame.size.width, h: object.frame.size.height) return gradient }

Cómo utilizar

let start : CGPoint = CGPoint(x: 0.0, y: 1.0) let end : CGPoint = CGPoint(x: 1.0, y: 1.0) let gradient: CAGradientLayer = makeGradientLayer(for: cell, startPoint: start, endPoint: end, gradientColors: [ UIColor(red:0.92, green:0.07, blue:0.4, alpha:1).cgColor, UIColor(red:0.93, green:0.11, blue:0.14, alpha:1).cgColor ]) self.vwTemp.layer.insertSublayer(gradient, at: 0)


SWIFT 3

Para agregar una capa de degradado en su vista

  • Enlace su punto de vista

    @IBOutlet var YOURVIEW : UIView!

  • Definir el CAGradientLayer ()

    var gradient = CAGradientLayer()

  • Aquí está el código que tienes que escribir en tu viewDidLoad

    YOURVIEW.layoutIfNeeded()

    gradient.startPoint = CGPoint(x: CGFloat(0), y: CGFloat(1)) gradient.endPoint = CGPoint(x: CGFloat(1), y: CGFloat(0)) gradient.frame = YOURVIEW.bounds gradient.colors = [UIColor.red.cgColor, UIColor.green.cgColor] gradient.colors = [ UIColor(red: 255.0/255.0, green: 56.0/255.0, blue: 224.0/255.0, alpha: 1.0).cgColor,UIColor(red: 86.0/255.0, green: 13.0/255.0, blue: 232.0/255.0, alpha: 1.0).cgColor,UIColor(red: 16.0/255.0, green: 173.0/255.0, blue: 245.0/255.0, alpha: 1.0).cgColor] gradient.locations = [0.0 ,0.6 ,1.0] YOURVIEW.layer.insertSublayer(gradient, at: 0)


Swift 4:

Muestra gradiente en IB correctamente:

@IBDesignable public class GradientView: UIView { override open class var layerClass: AnyClass { return CAGradientLayer.classForCoder() } required public init?(coder aDecoder: NSCoder) { super.init(coder: aDecoder) configureGradientLayer() } public override init(frame: CGRect) { super.init(frame: frame) configureGradientLayer() } func configureGradientLayer() { let gradientLayer = layer as! CAGradientLayer gradientLayer.colors = [UIColor(hex: 0x003399).cgColor, UIColor(hex: 0x00297b).cgColor] } }


Un enfoque rápido

Esta respuesta se basa en las respuestas anteriores y proporciona una implementación para tratar el problema del gradiente que no se aplica correctamente durante la rotación. Satisface este problema cambiando la capa de degradado a un cuadrado para que la rotación en todas las direcciones resulte en un degradado correcto. La firma de la función incluye un argumento variado de Swift que permite pasar tantos CGColorRef (CGColor) como sea necesario (consulte el ejemplo de uso). También se proporciona un ejemplo como una extensión Swift para que uno pueda aplicar un gradiente a cualquier UIView.

func configureGradientBackground(colors:CGColorRef...){ let gradient: CAGradientLayer = CAGradientLayer() let maxWidth = max(self.view.bounds.size.height,self.view.bounds.size.width) let squareFrame = CGRect(origin: self.view.bounds.origin, size: CGSizeMake(maxWidth, maxWidth)) gradient.frame = squareFrame gradient.colors = colors view.layer.insertSublayer(gradient, atIndex: 0) }

Usar:

en viewDidLoad ...

override func viewDidLoad() { super.viewDidLoad() configureGradientBackground(UIColor.redColor().CGColor, UIColor.whiteColor().CGColor) }

Implementación de la extensión

extension CALayer { func configureGradientBackground(colors:CGColorRef...){ let gradient = CAGradientLayer() let maxWidth = max(self.bounds.size.height,self.bounds.size.width) let squareFrame = CGRect(origin: self.bounds.origin, size: CGSizeMake(maxWidth, maxWidth)) gradient.frame = squareFrame gradient.colors = colors self.insertSublayer(gradient, atIndex: 0) } }

Ejemplo de caso de uso de extensión:

override func viewDidLoad() { super.viewDidLoad() self.view.layer.configureGradientBackground(UIColor.purpleColor().CGColor, UIColor.blueColor().CGColor, UIColor.whiteColor().CGColor) }

Lo que significa que el fondo degradado ahora se puede aplicar a cualquier UIControl ya que todos los controles son UIViews (o una subclase) y todas las UIViews tienen CALayers.

Swift 4

Implementación de la extensión

extension CALayer { public func configureGradientBackground(_ colors:CGColor...){ let gradient = CAGradientLayer() let maxWidth = max(self.bounds.size.height,self.bounds.size.width) let squareFrame = CGRect(origin: self.bounds.origin, size: CGSize(width: maxWidth, height: maxWidth)) gradient.frame = squareFrame gradient.colors = colors self.insertSublayer(gradient, at: 0) } }

Ejemplo de caso de uso de extensión:

override func viewDidLoad() { super.viewDidLoad() self.view.layer.configureGradientBackground(UIColor.purple.cgColor, UIColor.blue.cgColor, UIColor.white.cgColor) }


extension UIView { func applyGradient(isTopBottom: Bool, colorArray: [UIColor]) { if let sublayers = layer.sublayers { let _ = sublayers.filter({ $0 is CAGradientLayer }).map({ $0.removeFromSuperlayer() }) } let gradientLayer = CAGradientLayer() gradientLayer.colors = colorArray.map({ $0.cgColor }) if isTopBottom { gradientLayer.locations = [0.0, 1.0] } else { //leftRight gradientLayer.startPoint = CGPoint(x: 0.0, y: 0.5) gradientLayer.endPoint = CGPoint(x: 1.0, y: 0.5) } backgroundColor = .clear gradientLayer.frame = bounds layer.insertSublayer(gradientLayer, at: 0) } }

USO

someView.applyGradient(isTopBottom: true, colorArray: [.green, .blue])