Ich möchte das ändern anchorPoint, aber die Ansicht an der gleichen Stelle behalten. Ich habe versucht , NSLog-ing self.layer.positionund self.centerund sie beide gleich bleiben , unabhängig von Änderungen an der anchor. Doch meine Sicht bewegt sich!

Irgendwelche Tipps dazu?

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

Die Ausgabe ist:

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

Im Abschnitt Ebenengeometrie und Transformationen des Programmierhandbuchs für Kernanimationen wird die Beziehung zwischen der Position eines CALayers und den Eigenschaften von anchorPoint erläutert. Grundsätzlich wird die Position einer Ebene in Bezug auf die Position des Ankerpunkts der Ebene angegeben. Standardmäßig ist der Ankerpunkt einer Ebene (0,5, 0,5), der in der Mitte der Ebene liegt. Wenn Sie die Position der Ebene festlegen, legen Sie die Position der Mitte der Ebene im Koordinatensystem der Überlagerung fest.

Da die Position relativ zum Ankerpunkt der Ebene ist, wird die Ebene durch Ändern dieses Ankerpunkts unter Beibehaltung derselben Position verschoben. Um diese Bewegung zu verhindern, müssten Sie die Position der Ebene anpassen, um den neuen Ankerpunkt zu berücksichtigen. Eine Möglichkeit, dies zu tun, besteht darin, die Grenzen der Ebene zu erfassen, die Breite und Höhe der Grenzen mit den normalisierten Werten des alten und neuen Ankerpunkts zu multiplizieren, die Differenz der beiden Ankerpunkte zu nehmen und diese Differenz auf die Position der Ebene anzuwenden.

Auf diese Weise können Sie möglicherweise sogar die Rotation berücksichtigen, indem CGPointApplyAffineTransform()Sie die CGAffineTransform Ihres UIView verwenden.

Ich hatte das gleiche Problem. Die Lösung von Brad Larson hat auch bei gedrehter Ansicht hervorragend funktioniert. Hier ist seine Lösung in Code übersetzt.

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

Und das schnelle Äquivalent:

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
}

Der Schlüssel zur Lösung dieses Problems war die Verwendung der Frame-Eigenschaft, die sich seltsamerweise nur ändert.

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

Dann mache ich meine Größenänderung, wo sie vom anchorPoint skaliert wird. Dann muss ich den alten anchorPoint wiederherstellen;

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

BEARBEITEN: Dies wird ausgeblendet, wenn die Ansicht gedreht wird, da die Frame-Eigenschaft undefiniert ist, wenn eine CGAffineTransform angewendet wurde.

Für mich verständlich positionund anchorPointam einfachsten, als ich anfing, es mit meinem Verständnis von frame.origin in UIView zu vergleichen. Eine UIView mit frame.origin = (20,30) bedeutet, dass die UIView 20 Punkte von links und 30 Punkte von oben in der übergeordneten Ansicht entfernt ist. Diese Entfernung wird von welchem ​​Punkt eines UIView berechnet? Es wird aus der oberen linken Ecke eines UIView berechnet.

In Ebenenmarkierungen anchorPointbedeutet der Punkt (in normalisierter Form, dh 0 bis 1), von dem aus dieser Abstand berechnet wird, z. B. Ebene. Position = (20, 30) bedeutet, dass die Ebene anchorPoint20 Punkte von links und 30 Punkte von der Oberseite ihrer übergeordneten Ebene entfernt ist. Standardmäßig ist ein Ebenenankerpunkt (0,5, 0,5), sodass der Entfernungsberechnungspunkt genau in der Mitte der Ebene liegt. Die folgende Abbildung hilft mir, meinen Standpunkt zu verdeutlichen:

anchorPoint Dies ist auch der Punkt, um den die Drehung erfolgt, wenn Sie eine Transformation auf die Ebene anwenden.

Es gibt so eine einfache Lösung. Dies basiert auf Kennys Antwort. Anstatt den alten Rahmen anzuwenden, verwenden Sie seinen Ursprung und den neuen, um die Übersetzung zu berechnen, und wenden Sie diese Übersetzung dann auf die Mitte an. Es funktioniert auch mit gedrehter Ansicht! Hier ist der Code, viel einfacher als andere Lösungen:

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

Für diejenigen, die es brauchen, ist hier Magnus 'Lösung in 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
}

Hier ist die Antwort von Benutzer 945711, die für NSView unter OS X angepasst wurde. Abgesehen davon, dass NSView keine .centerEigenschaft hat, ändert sich der Frame von NSView nicht (wahrscheinlich, weil NSViews standardmäßig nicht mit einem CALayer geliefert werden), aber der Ursprung des CALayer-Frames ändert sich, wenn der Ankerpunkt geändert wird.

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

Wenn Sie anchorPoint ändern, ändert sich auch seine Position, es sei denn, Ihr Ursprung ist Nullpunkt CGPointZero.

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

Bearbeiten und sehen Sie den Ankerpunkt von UIView direkt im Storyboard (Swift 3)

Dies ist eine alternative Lösung, mit der Sie den Ankerpunkt über den Attributinspektor ändern können und die über eine andere Eigenschaft verfügt, um den Ankerpunkt zur Bestätigung anzuzeigen.

Erstellen Sie eine neue Datei, die Sie in Ihr Projekt aufnehmen möchten

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

Fügen Sie dem Storyboard die Ansicht hinzu und legen Sie die benutzerdefinierte Klasse fest

Stellen Sie nun den neuen Ankerpunkt für die UIView ein

Wenn Sie den Show-Ankerpunkt aktivieren, wird ein roter Punkt angezeigt, damit Sie besser sehen können, wo sich der Ankerpunkt visuell befindet. Sie können es später jederzeit ausschalten.

Dies hat mir bei der Planung von Transformationen in UIViews sehr geholfen.

Für 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
}

Ausgehend von Magnus 'großartiger und gründlicher Antwort habe ich eine Version erstellt, die auf Unterebenen funktioniert:

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