Créer un rectangle avec deux coins arrondis en swift?

Dans Swift 2.3 vous pouvez le faire en

let maskPath = UIBezierPath(roundedRect: anyView.bounds,
            byRoundingCorners: [.BottomLeft, .BottomRight],
            cornerRadii: CGSize(width: 10.0, height: 10.0))

let shape = CAShapeLayer()
shape.path = maskPath.CGPath
view.layer.mask = shape

---

Dans Objective-C vous pouvez utiliser le UIBezierPath méthode de classe

bezierPathWithRoundedRect:byRoundingCorners:cornerRadii:

exemple de mise en œuvre-

//set the corner radius to the specified corners of the passed container
- (void)setMaskTo:(UIView*)view byRoundingCorners:(UIRectCorner)corners
{
    UIBezierPath *rounded = [UIBezierPath bezierPathWithRoundedRect:view.bounds
                                                  byRoundingCorners:corners
                                                        cornerRadii:CGSizeMake(10.0, 10.0)];
    CAShapeLayer *shape = [[CAShapeLayer alloc] init];
    [shape setPath:rounded.CGPath];
    view.layer.mask = shape;
}

et d'appeler la méthode ci-dessus comme-

[self setMaskTo:anyView byRoundingCorners:UIRectCornerBottomLeft | UIRectCornerBottomRight];

Swift 4+, iOS 11+

Si vous avez déjà un UIView nommé myView référencé comme un IBOutlet, essayez d'ajouter les deux lignes suivantes dans ViewDidLoad() ou partout où il est en cours de chargement:

myView.layer.cornerRadius = 10
myView.layer.maskedCorners = [.layerMinXMaxYCorner, .layerMaxXMaxYCorner]

Vous pouvez modifier le tableau [] à toute combinaison de MinX, MinY, MaxX, et MaxY sélectionnez l'un des coins. L'exemple ci-dessus des tours de la partie inférieure de deux coins.

C'est juste une autre approche, peut-être un peu plus simple en fonction de votre conception.

De construction sur le dessus de Sanjay excellente réponse, j'ai écrit un rapide CALayer extension pour Swift 2.3, dans le cas où vous avez besoin pour faire ce genre de "seulement autour de quelques coins" chose plus d'une fois.

extension CALayer {
func roundCorners(corners: UIRectCorner, radius: CGFloat) {
let maskPath = UIBezierPath(roundedRect: bounds,
byRoundingCorners: corners,
cornerRadii: CGSize(width: radius, height: radius))
let shape = CAShapeLayer()
shape.path = maskPath.CGPath
mask = shape
}
}

Utilisation:

myView.layer.roundCorners([.TopLeft, .TopRight], radius: myCornerRadius)

Swift 3.0 (Dans cet exemple, les limites sont venus de le point de vue non pas de la couche. En utilisant les limites de l'affichage de ce code pour travailler avec des vues dans un UITableViewCell.):

func roundCorners(corners: UIRectCorner, radius: CGFloat, viewBounds: CGRect) {
let maskPath = UIBezierPath(roundedRect: viewBounds,
byRoundingCorners: corners,
cornerRadii: CGSize(width: radius, height: radius))
let shape = CAShapeLayer()
shape.path = maskPath.cgPath
mask = shape
}

Utilisation:

myView.layer.roundCorners(corners: [.topLeft, .topRight], radius: myCornerRadius, viewBounds: bounds)

2017...

@IBDesignable
class RoundedEnds: UIView {
override func layoutSubviews() { setup() } //"layoutSubviews" is best

func setup() {
let r = self.bounds.size.height / 2
let path = UIBezierPath(roundedRect: self.bounds, cornerRadius:r)
let mask = CAShapeLayer()
mask.path = path.cgPath
self.layer.mask = mask
}
}

Pour seulement certains coins, il suffit de changer d':

roundedRect: self.bounds,
byRoundingCorners: [.topLeft, .topRight],
cornerRadii: CGSize(width: r, height: r)

Noter que comme d'habitude il y a eu beaucoup de petits changements dans Swift, par exemple, à la capitalisation de constantes, etc.

Mis à jour iWasRobbed la réponse de travailler avec la Swift 3.0 version GM:

import UIKit
extension UIView {
/**
Rounds the given set of corners to the specified radius
- parameter corners: Corners to round
- parameter radius:  Radius to round to
*/
func round(corners: UIRectCorner, radius: CGFloat) {
_round(corners: corners, radius: radius)
}
/**
Rounds the given set of corners to the specified radius with a border
- parameter corners:     Corners to round
- parameter radius:      Radius to round to
- parameter borderColor: The border color
- parameter borderWidth: The border width
*/
func round(corners: UIRectCorner, radius: CGFloat, borderColor: UIColor, borderWidth: CGFloat) {
let mask = _round(corners: corners, radius: radius)
addBorder(mask: mask, borderColor: borderColor, borderWidth: borderWidth)
}
/**
Fully rounds an autolayout view (e.g. one with no known frame) with the given diameter and border
- parameter diameter:    The view's diameter
- parameter borderColor: The border color
- parameter borderWidth: The border width
*/
func fullyRound(diameter: CGFloat, borderColor: UIColor, borderWidth: CGFloat) {
layer.masksToBounds = true
layer.cornerRadius = diameter / 2
layer.borderWidth = borderWidth
layer.borderColor = borderColor.cgColor;
}
}
private extension UIView {
@discardableResult func _round(corners: UIRectCorner, radius: CGFloat) -> CAShapeLayer {
let path = UIBezierPath(roundedRect: bounds, byRoundingCorners: corners, cornerRadii: CGSize(width: radius, height: radius))
let mask = CAShapeLayer()
mask.path = path.cgPath
self.layer.mask = mask
return mask
}
func addBorder(mask: CAShapeLayer, borderColor: UIColor, borderWidth: CGFloat) {
let borderLayer = CAShapeLayer()
borderLayer.path = mask.path
borderLayer.fillColor = UIColor.clear.cgColor
borderLayer.strokeColor = borderColor.cgColor
borderLayer.lineWidth = borderWidth
borderLayer.frame = bounds
layer.addSublayer(borderLayer)
}
}

iOS 11+ Seulement | Vous pouvez vérifier iOS statistiques d'utilisation ici

Explication

Depuis le CACornerMask rawValue est un UInt vous maintenant qu'un CACornerMask rawValue est la somme de chaque CACornerMask.Element rawValue

Plus précisément:

• TopLeft (layerMinXMinYCorner) = 1
• Haut (layerMaxXMinYCorner) = 2
• BottomLeft (layerMinXMaxYCorner) = 4
• BottomRight (layerMaxXMaxYCorner) = 8

Ainsi, par exemple, si vous voulez en haut à gauche et en haut à droite des coins, vous pouvez simplement taper CACornerMask(rawValue: 3).

---

 Exemple

Ci-dessous une simple extension d'un UIView

extension UIView {
enum Corner:Int {
case bottomRight = 0,
topRight,
bottomLeft,
topLeft
}
private func parseCorner(corner: Corner) -> CACornerMask.Element {
let corners: [CACornerMask.Element] = [.layerMaxXMaxYCorner, .layerMaxXMinYCorner, .layerMinXMaxYCorner, .layerMinXMinYCorner]
return corners[corner.rawValue]
}
private func createMask(corners: [Corner]) -> UInt {
return corners.reduce(0, { (a, b) -> UInt in
return a + parseCorner(corner: b).rawValue
})
}
func roundCorners(corners: [Corner], amount: CGFloat = 5) {
layer.cornerRadius = amount
let maskedCorners: CACornerMask = CACornerMask(rawValue: createMask(corners: corners))
layer.maskedCorners = maskedCorners
}
}

Vous pouvez l'utiliser comme:

let myRect = UIView(frame: CGRect(x: 0, y: 0, width: 200, height: 50))
myRect.roundCorners(corners: [.topRight, .topLeft])