Je veux modifier le anchorPoint, mais garder la vue au même endroit. J'ai essayé NSLog-ing self.layer.positionet self.centerils restent tous les deux les mêmes, quelles que soient les modifications apportées à anchorPoint. Pourtant ma vue bouge!

Aucune astuce sur comment le faire?

self.layer.anchorPoint = CGPointMake(0.5, 0.5);
NSLog(@"center point: %f %f", self.layer.position.x, self.layer.position.y);
self.layer.anchorPoint = CGPointMake(1, 1);
NSLog(@"center point: %f %f", self.layer.position.x, self.layer.position.y);

La sortie est:

2009-12-27 20:43:24.161 Type[11289:207] center point: 272.500000 242.500000
2009-12-27 20:43:24.162 Type[11289:207] center point: 272.500000 242.500000

La section Layer Geometry and Transforms du Guide de programmation d'animation de base explique la relation entre la position d'un CALayer et les propriétés anchorPoint. Fondamentalement, la position d'un calque est spécifiée en fonction de l'emplacement du point d'ancrage du calque. Par défaut, le point d'ancrage d'un calque est (0,5, 0,5), qui se trouve au centre du calque. Lorsque vous définissez la position du calque, vous définissez alors l'emplacement du centre du calque dans le système de coordonnées de son super-calque.

La position étant relative au point d'ancrage du calque, modifier ce point d'ancrage tout en conservant la même position déplace le calque. Afin d'éviter ce mouvement, vous devrez ajuster la position du calque pour tenir compte du nouveau point d'ancrage. Une façon de procéder consiste à saisir les limites du calque, à multiplier la largeur et la hauteur des limites par les valeurs normalisées de l'ancien et du nouveau anchorPoint, à prendre la différence des deux anchorPoints et à appliquer cette différence à la position du calque.

Vous pourriez même être en mesure de rendre compte de la rotation de cette façon en utilisant CGPointApplyAffineTransform()avec CGAffineTransform de votre UIView.

J'ai eu le même problème. La solution de Brad Larson a très bien fonctionné même lorsque la vue est tournée. Voici sa solution traduite en code.

-(void)setAnchorPoint:(CGPoint)anchorPoint forView:(UIView *)view
{
    CGPoint newPoint = CGPointMake(view.bounds.size.width * anchorPoint.x, 
                                   view.bounds.size.height * anchorPoint.y);
    CGPoint oldPoint = CGPointMake(view.bounds.size.width * view.layer.anchorPoint.x, 
                                   view.bounds.size.height * view.layer.anchorPoint.y);

    newPoint = CGPointApplyAffineTransform(newPoint, view.transform);
    oldPoint = CGPointApplyAffineTransform(oldPoint, view.transform);

    CGPoint position = view.layer.position;

    position.x -= oldPoint.x;
    position.x += newPoint.x;

    position.y -= oldPoint.y;
    position.y += newPoint.y;

    view.layer.position = position;
    view.layer.anchorPoint = anchorPoint;
}

Et l'équivalent rapide:

func setAnchorPoint(anchorPoint: CGPoint, forView view: UIView) {
    var newPoint = CGPointMake(view.bounds.size.width * anchorPoint.x, view.bounds.size.height * anchorPoint.y)
    var oldPoint = CGPointMake(view.bounds.size.width * view.layer.anchorPoint.x, view.bounds.size.height * view.layer.anchorPoint.y)

    newPoint = CGPointApplyAffineTransform(newPoint, view.transform)
    oldPoint = CGPointApplyAffineTransform(oldPoint, view.transform)

    var position = view.layer.position
    position.x -= oldPoint.x
    position.x += newPoint.x

    position.y -= oldPoint.y
    position.y += newPoint.y

    view.layer.position = position
    view.layer.anchorPoint = anchorPoint
}

SWIFT 4.x

func setAnchorPoint(anchorPoint: CGPoint, forView view: UIView) {
    var newPoint = CGPoint(x: view.bounds.size.width * anchorPoint.x,
                           y: view.bounds.size.height * anchorPoint.y)


    var oldPoint = CGPoint(x: view.bounds.size.width * view.layer.anchorPoint.x,
                           y: view.bounds.size.height * view.layer.anchorPoint.y)

    newPoint = newPoint.applying(view.transform)
    oldPoint = oldPoint.applying(view.transform)

    var position = view.layer.position
    position.x -= oldPoint.x
    position.x += newPoint.x

    position.y -= oldPoint.y
    position.y += newPoint.y

    view.layer.position = position
    view.layer.anchorPoint = anchorPoint
}

La clé pour résoudre ce problème était d'utiliser la propriété frame, qui est étrangement la seule chose qui change.

Swift 2

let oldFrame = self.frame
self.layer.anchorPoint = CGPointMake(1, 1)
self.frame = oldFrame

Swift 3

let oldFrame = self.frame
self.layer.anchorPoint = CGPoint(x: 1, y: 1)
self.frame = oldFrame

Ensuite, je fais mon redimensionnement, où il se met à l'échelle du point d'ancrage. Ensuite, je dois restaurer l'ancien point d'ancrage;

Swift 2

let oldFrame = self.frame
self.layer.anchorPoint = CGPointMake(0.5,0.5)
self.frame = oldFrame

Swift 3

let oldFrame = self.frame
self.layer.anchorPoint = CGPoint(x: 0.5, y: 0.5)
self.frame = oldFrame

EDIT: cela s'efface si la vue est tournée, car la propriété frame n'est pas définie si un CGAffineTransform a été appliqué.

Pour moi, comprendre positionet anchorPointc'était plus facile quand j'ai commencé à le comparer avec ma compréhension de frame.origin dans UIView. Un UIView avec frame.origin = (20,30) signifie que l'UIView est à 20 points de la gauche et à 30 points du haut de sa vue parent. Cette distance est calculée à partir de quel point d'un UIView? Il est calculé à partir du coin supérieur gauche d'un UIView.

Dans le calque anchorPointmarque le point (sous forme normalisée, c'est-à-dire de 0 à 1) à partir duquel cette distance est calculée, par exemple layer.position = (20, 30) signifie que le calque anchorPointest à 20 points de gauche et 30 points du haut de son calque parent. Par défaut, le point d'ancrage d'un calque est (0,5, 0,5), de sorte que le point de calcul de distance se trouve juste au centre du calque. La figure suivante aidera à clarifier mon point:

anchorPoint se trouve également être le point autour duquel la rotation se produira si vous appliquez une transformation au calque.

Il existe une solution si simple. Ceci est basé sur la réponse de Kenny. Mais au lieu d'appliquer l'ancien cadre, utilisez son origine et le nouveau pour calculer la traduction, puis appliquez cette traduction au centre. Cela fonctionne aussi avec la vue pivotée! Voici le code, beaucoup plus simple que les autres solutions:

func setAnchorPoint(anchorPoint: CGPoint, view: UIView) {
   let oldOrigin = view.frame.origin
   view.layer.anchorPoint = anchorPoint
   let newOrigin = view.frame.origin

   let translation = CGPoint(x: newOrigin.x - oldOrigin.x, y: newOrigin.y - oldOrigin.y)

   view.center = CGPoint(x: view.center.x - translation.x, y: view.center.y - translation.y)
}

Pour ceux qui en ont besoin, voici la solution de Magnus dans Swift:

func setAnchorPoint(anchorPoint: CGPoint, view: UIView) {
    var newPoint: CGPoint = CGPointMake(view.bounds.size.width * anchorPoint.x, view.bounds.size.height * anchorPoint.y)
    var oldPoint: CGPoint = CGPointMake(view.bounds.size.width * view.layer.anchorPoint.x, view.bounds.size.height * view.layer.anchorPoint.y)

    newPoint = CGPointApplyAffineTransform(newPoint, view.transform)
    oldPoint = CGPointApplyAffineTransform(oldPoint, view.transform)

    var position: CGPoint = view.layer.position

    position.x -= oldPoint.x
    position.x += newPoint.x

    position.y -= oldPoint.y
    position.y += newPoint.y

    view.setTranslatesAutoresizingMaskIntoConstraints(true)     // Added to deal with auto layout constraints
    view.layer.anchorPoint = anchorPoint
    view.layer.position = position
}

Voici la réponse de user945711 ajustée pour NSView sur OS X. Outre que NSView n'a pas de .centerpropriété, le cadre de NSView ne change pas (probablement parce que NSViews n'est pas fourni avec un CALayer par défaut) mais l'origine du cadre CALayer change lorsque le point d'ancrage est modifié.

func setAnchorPoint(anchorPoint: NSPoint, view: NSView) {
    guard let layer = view.layer else { return }

    let oldOrigin = layer.frame.origin
    layer.anchorPoint = anchorPoint
    let newOrigin = layer.frame.origin

    let transition = NSMakePoint(newOrigin.x - oldOrigin.x, newOrigin.y - oldOrigin.y)
    layer.frame.origin = NSMakePoint(layer.frame.origin.x - transition.x, layer.frame.origin.y - transition.y)
}

Si vous changez anchorPoint, sa position changera également, À MOINS QUE votre origine ne soit le point zéro CGPointZero.

position.x == origin.x + anchorPoint.x;
position.y == origin.y + anchorPoint.y;

Modifier et voir le point d'ancrage d'UIView à droite sur Storyboard (Swift 3)

Il s'agit d'une solution alternative qui vous permet de modifier le point d'ancrage via l'inspecteur d'attributs et qui possède une autre propriété pour afficher le point d'ancrage pour confirmation.

Créez un nouveau fichier à inclure dans votre projet

import UIKit

@IBDesignable
class UIViewAnchorPoint: UIView {

    @IBInspectable var showAnchorPoint: Bool = false
    @IBInspectable var anchorPoint: CGPoint = CGPoint(x: 0.5, y: 0.5) {
        didSet {
            setAnchorPoint(anchorPoint: anchorPoint)
        }
    }

    override func draw(_ rect: CGRect) {
        if showAnchorPoint {
            let anchorPointlayer = CALayer()
            anchorPointlayer.backgroundColor = UIColor.red.cgColor
            anchorPointlayer.bounds = CGRect(x: 0, y: 0, width: 6, height: 6)
            anchorPointlayer.cornerRadius = 3

            let anchor = layer.anchorPoint
            let size = layer.bounds.size

            anchorPointlayer.position = CGPoint(x: anchor.x * size.width, y: anchor.y * size.height)
            layer.addSublayer(anchorPointlayer)
        }
    }

    func setAnchorPoint(anchorPoint: CGPoint) {
        var newPoint = CGPoint(x: bounds.size.width * anchorPoint.x, y: bounds.size.height * anchorPoint.y)
        var oldPoint = CGPoint(x: bounds.size.width * layer.anchorPoint.x, y: bounds.size.height * layer.anchorPoint.y)

        newPoint = newPoint.applying(transform)
        oldPoint = oldPoint.applying(transform)

        var position = layer.position
        position.x -= oldPoint.x
        position.x += newPoint.x

        position.y -= oldPoint.y
        position.y += newPoint.y

        layer.position = position
        layer.anchorPoint = anchorPoint
    }
}

Ajouter une vue au storyboard et définir la classe personnalisée

Maintenant, définissez le nouveau point d'ancrage pour l'UIView

L'activation de Afficher le point d'ancrage affichera un point rouge afin que vous puissiez mieux voir où le point d'ancrage sera visuellement. Vous pouvez toujours le désactiver plus tard.

Cela m'a vraiment aidé lors de la planification des transformations sur UIViews.

Pour Swift 3:

func setAnchorPoint(_ anchorPoint: CGPoint, forView view: UIView) {
    var newPoint = CGPoint(x: view.bounds.size.width * anchorPoint.x, y: view.bounds.size.height * anchorPoint.y)
    var oldPoint = CGPoint(x: view.bounds.size.width * view.layer.anchorPoint.x, y: view.bounds.size.height * view.layer.anchorPoint.y)

    newPoint = newPoint.applying(view.transform)
    oldPoint = oldPoint.applying(view.transform)

    var position = view.layer.position
    position.x -= oldPoint.x
    position.x += newPoint.x

    position.y -= oldPoint.y
    position.y += newPoint.y

    view.layer.position = position
    view.layer.anchorPoint = anchorPoint
}

En développant la réponse excellente et approfondie de Magnus, j'ai créé une version qui fonctionne sur les sous-couches:

-(void)setAnchorPoint:(CGPoint)anchorPoint forLayer:(CALayer *)layer
{
    CGPoint newPoint = CGPointMake(layer.bounds.size.width * anchorPoint.x, layer.bounds.size.height * anchorPoint.y);
    CGPoint oldPoint = CGPointMake(layer.bounds.size.width * layer.anchorPoint.x, layer.bounds.size.height * layer.anchorPoint.y);
    CGPoint position = layer.position;
    position.x -= oldPoint.x;
    position.x += newPoint.x;
    position.y -= oldPoint.y;
    position.y += newPoint.y;
    layer.position = position;
    layer.anchorPoint = anchorPoint;
}