Créer un personnalisé animables propriété

Sur UIView vous pouvez modifier la backgroundColour d'animation. Et sur un UISlideView vous pouvez modifier la valeur d'animation.

Pouvez-vous ajouter une propriété personnalisée à votre propre UIView sous-classe de sorte qu'il peut être animé?

Si j'ai un CGPath dans mon UIView alors je peux animer le dessin de celui-ci en modifiant le pourcentage de la voie.

Puis-je encapsuler que l'animation dans la sous-classe.

c'est à dire que j'ai un UIView avec un CGPath qui crée un cercle.

Si le cercle n'est pas là, il représente 0%. Si le cercle est complet il représente 100%. Je peux en tirer toute la valeur de modifier le pourcentage de la voie. Je peux également animer le changement (au sein de la sous-classe UIView) en animant le pourcentage de la CGPath et redessiner le chemin.

Puis-je définir une propriété (pourcentage) sur la UIView de sorte que je peux coller le changement dans un UIView animateWithDuration bloc et animer le changement de pourcentage de la chemin?

J'espère que j'ai expliqué ce que j'aimerais bien faire.

Essentiellement, tout ce que je veux faire, c'est quelque chose comme...

[UIView animateWithDuration:1.0
 animations:^{
     myCircleView.percentage = 0.7;
 }
 completion:nil];

et le chemin d'accès du cercle animer un pourcentage donné.

InformationsquelleAutor Fogmeister | 2013-01-07

23

Si vous étendez CALayer et de mettre en œuvre votre personnalisé
```
- (void) drawInContext:(CGContextRef) context
```
Vous pouvez faire un animables propriété en substituant needsDisplayForKey (dans votre personnalisé CALayer classe) comme ceci:
```
+ (BOOL) needsDisplayForKey:(NSString *) key {
    if ([key isEqualToString:@"percentage"]) {
        return YES;
    }
    return [super needsDisplayForKey:key];
}
```
Bien sûr, vous devez également avoir une @property appelé percentage. À partir de maintenant, vous pouvez animer le pourcentage de la propriété à l'aide de core animation. Je n'ai pas vérifier si il fonctionne en utilisant la [UIView animateWithDuration...] appeler ainsi. Cela pourrait fonctionner. Mais cela a fonctionné pour moi:
```
CABasicAnimation *animation = [CABasicAnimation animationWithKeyPath:@"percentage"];
animation.duration = 1.0;
animation.fromValue = [NSNumber numberWithDouble:0];
animation.toValue = [NSNumber numberWithDouble:100];

[myCustomLayer addAnimation:animation forKey:@"animatePercentage"];
```
Oh, et à utiliser yourCustomLayer avec myCircleView, faites ceci:
```
[myCircleView.layer addSublayer:myCustomLayer];
```
- Merci pour la réponse. Je vais jeter un oeil ce soir.
- Salut, je suis un peu en retard à la fête. Espérant demander: comment pourrait-on mettre en œuvre - (void) drawInContext:(CGContextRef) context? Est-ce là une nouvelle propriété personnalisée serait-il dessiné? Merci à l'avance.
- dans votre exemple, vous définissez la durée manuellement à 1... comment voulez-vous être en mesure de déterminer la durée/courbe/retard, ect... fournis par le UIViewAnimation bloc?
InformationsquelleAutor Tom van Zummeren

Complète Swift 3 exemple:

Créer un personnalisé animables propriété

public class CircularProgressView: UIView {
public dynamic var progress: CGFloat = 0 {
didSet {
progressLayer.progress = progress
}
}
fileprivate var progressLayer: CircularProgressLayer {
return layer as! CircularProgressLayer
}
override public class var layerClass: AnyClass {
return CircularProgressLayer.self
}
override public func action(for layer: CALayer, forKey event: String) -> CAAction? {
if event == #keyPath(CircularProgressLayer.progress),
let action = action(for: layer, forKey: #keyPath(backgroundColor)) as? CAAnimation, 
let animation: CABasicAnimation = (action.copy() as? CABasicAnimation) {
animation.keyPath = #keyPath(CircularProgressLayer.progress)
animation.fromValue = progressLayer.progress
animation.toValue = progress
self.layer.add(animation, forKey: #keyPath(CircularProgressLayer.progress))
return animation
}
return super.action(for: layer, forKey: event)
}
}
/*
* Concepts taken from:
* https://stackoverflow.com/a/37470079
*/
fileprivate class CircularProgressLayer: CALayer {
@NSManaged var progress: CGFloat
let startAngle: CGFloat = 1.5 * .pi
let twoPi: CGFloat = 2 * .pi
let halfPi: CGFloat = .pi / 2
override class func needsDisplay(forKey key: String) -> Bool {
if key == #keyPath(progress) {
return true
}
return super.needsDisplay(forKey: key)
}
override func draw(in ctx: CGContext) {
super.draw(in: ctx)
UIGraphicsPushContext(ctx)
//Light Grey
UIColor.lightGray.setStroke()
let center = CGPoint(x: bounds.midX, y: bounds.midY)
let strokeWidth: CGFloat = 4
let radius = (bounds.size.width / 2) - strokeWidth
let path = UIBezierPath(arcCenter: center, radius: radius, startAngle: 0, endAngle: twoPi, clockwise: true)
path.lineWidth = strokeWidth
path.stroke()
//Red
UIColor.red.setStroke()
let endAngle = (twoPi * progress) - halfPi
let pathProgress = UIBezierPath(arcCenter: center, radius: radius, startAngle: startAngle, endAngle: endAngle , clockwise: true)
pathProgress.lineWidth = strokeWidth
pathProgress.lineCapStyle = .round
pathProgress.stroke()
UIGraphicsPopContext()
}
}
let circularProgress = CircularProgressView(frame: CGRect(x: 0, y: 0, width: 80, height: 80))
UIView.animate(withDuration: 2, delay: 0, options: .curveEaseInOut, animations: {
circularProgress.progress = 0.76
}, completion: nil)

Il y a une grande objc article ici, qui va dans les détails au sujet de la façon dont cela fonctionne

Ainsi que d'un objc projet qui utilise les mêmes concepts ici:

Essentiellement une action(par couche:) sera appelée lorsqu'un objet est animé à partir d'un bloc d'animation, nous pouvons commencer nos propres animations avec les mêmes propriétés (vol de la propriété backgroundColor) et d'animer les changements.

Bonjour. Avez-vous essayé de mettre en œuvre @NSManaged avec CGAffineTransform?

InformationsquelleAutor David Rees

3

Pour ceux qui ont besoin de plus de détails sur ce comme je l'ai fait:

il est cool exemple d'Apple portant sur cette question.

E. g. grâce à lui j'ai constaté que vous n'avez pas besoin d'ajouter personnalisé de votre couche de sous-couche (comme @Tom van Zummeren l'indique). Au lieu de cela, il suffit d'ajouter une méthode de classe à votre point de Vue de classe:
```
+ (Class)layerClass
{
return [CustomLayer class];
}
```
Espère que cela aide quelqu'un.

InformationsquelleAutor makaron
0

vous aurez à mettre en œuvre le pourcentage de la partie de vous-même. vous pouvez remplacer la couche de dessin code pour dessiner votre cgpath, en fonction de l'ensemble de la valeur en pourcentage. la caisse de la core animation guide de programmation et types d'animation et le calendrier guide
- Merci pour la réponse. Je vais jeter un oeil ce soir.
- Aucune idée. Rien à voir avec moi.
InformationsquelleAutor Swapnil Luktuke

Vous devez vous connecter pour publier un commentaire.