#import "ASDisplayNode.h"

#import "ASDisplayNode+Subclasses.h"

#import "ASDisplayNodeInternal.h"

#import "ASLayoutOptionsPrivate.h"

#import <objc/runtime.h>

#import "_ASAsyncTransaction.h"

#import "_ASAsyncTransactionContainer+Private.h"

#import "_ASPendingState.h"

#import "_ASDisplayView.h"

#import "_ASScopeTimer.h"

#import "ASDisplayNodeExtras.h"

#import "ASEqualityHelpers.h"

#import "ASInternalHelpers.h"

#import "ASLayout.h"

#import "ASLayoutSpec.h"

@interface ASDisplayNode () <UIGestureRecognizerDelegate>

- (void)_staticInitialize;

#if TIME_DISPLAYNODE_OPS

#define TIME_SCOPED(outVar) ASDN::ScopeTimer t(outVar)

#else

#define TIME_SCOPED(outVar)

#endif

@implementation ASDisplayNode

@dynamic spacingAfter, spacingBefore, flexGrow, flexShrink, flexBasis, alignSelf, ascender, descender, sizeRange, layoutPosition, layoutOptions;

@synthesize name = _name;

@synthesize preferredFrameSize = _preferredFrameSize;

@synthesize isFinalLayoutable = _isFinalLayoutable;

BOOL ASDisplayNodeSubclassOverridesSelector(Class subclass, SEL selector)

{

return ASSubclassOverridesSelector([ASDisplayNode class], subclass, selector);

}

void ASDisplayNodePerformBlockOnMainThread(void (^block)())

{

if ([NSThread isMainThread]) {

block();

} else {

dispatch_async(dispatch_get_main_queue(), ^{

block();

});

}

}

void ASDisplayNodeRespectThreadAffinityOfNode(ASDisplayNode *node, void (^block)())

{

ASDisplayNodeCAssertNotNil(block, @"block is required");

if (!block) {

return;

}

{

// Hold the lock to avoid a race where the node gets loaded while the block is in-flight.

ASDN::MutexLocker l(node->_propertyLock);

if (node.nodeLoaded) {

ASDisplayNodePerformBlockOnMainThread(^{

block();

});

} else {

block();

}

}

}

static struct ASDisplayNodeFlags GetASDisplayNodeFlags(Class c, ASDisplayNode *instance)

{

ASDisplayNodeCAssertNotNil(c, @"class is required");

struct ASDisplayNodeFlags flags = {0};

flags.isInHierarchy = NO;

flags.displaysAsynchronously = YES;

flags.implementsDrawRect = ([c respondsToSelector:@selector(drawRect:withParameters:isCancelled:isRasterizing:)] ? 1 : 0);

flags.implementsImageDisplay = ([c respondsToSelector:@selector(displayWithParameters:isCancelled:)] ? 1 : 0);

if (instance) {

flags.implementsDrawParameters = ([instance respondsToSelector:@selector(drawParametersForAsyncLayer:)] ? 1 : 0);

} else {

flags.implementsDrawParameters = ([c instancesRespondToSelector:@selector(drawParametersForAsyncLayer:)] ? 1 : 0);

}

return flags;

}

static ASDisplayNodeMethodOverrides GetASDisplayNodeMethodOverrides(Class c)

{

ASDisplayNodeCAssertNotNil(c, @"class is required");

ASDisplayNodeMethodOverrides overrides = ASDisplayNodeMethodOverrideNone;

if (ASDisplayNodeSubclassOverridesSelector(c, @selector(touchesBegan:withEvent:))) {

overrides |= ASDisplayNodeMethodOverrideTouchesBegan;

}

if (ASDisplayNodeSubclassOverridesSelector(c, @selector(touchesMoved:withEvent:))) {

overrides |= ASDisplayNodeMethodOverrideTouchesMoved;

}

if (ASDisplayNodeSubclassOverridesSelector(c, @selector(touchesCancelled:withEvent:))) {

overrides |= ASDisplayNodeMethodOverrideTouchesCancelled;

}

if (ASDisplayNodeSubclassOverridesSelector(c, @selector(touchesEnded:withEvent:))) {

overrides |= ASDisplayNodeMethodOverrideTouchesEnded;

}

if (ASDisplayNodeSubclassOverridesSelector(c, @selector(layoutSpecThatFits:))) {

overrides |= ASDisplayNodeMethodOverrideLayoutSpecThatFits;

}

return overrides;

}

+ (void)initialize

{

if (self != [ASDisplayNode class]) {

// Subclasses should never override these

ASDisplayNodeAssert(!ASDisplayNodeSubclassOverridesSelector(self, @selector(calculatedSize)), @"Subclass %@ must not override calculatedSize method", NSStringFromClass(self));

ASDisplayNodeAssert(!ASDisplayNodeSubclassOverridesSelector(self, @selector(calculatedLayout)), @"Subclass %@ must not override calculatedLayout method", NSStringFromClass(self));

ASDisplayNodeAssert(!ASDisplayNodeSubclassOverridesSelector(self, @selector(measure:)), @"Subclass %@ must not override measure method", NSStringFromClass(self));

ASDisplayNodeAssert(!ASDisplayNodeSubclassOverridesSelector(self, @selector(measureWithSizeRange:)), @"Subclass %@ must not override measureWithSizeRange method", NSStringFromClass(self));

ASDisplayNodeAssert(!ASDisplayNodeSubclassOverridesSelector(self, @selector(recursivelyClearContents)), @"Subclass %@ must not override recursivelyClearContents method", NSStringFromClass(self));

ASDisplayNodeAssert(!ASDisplayNodeSubclassOverridesSelector(self, @selector(recursivelyClearFetchedData)), @"Subclass %@ must not override recursivelyClearFetchedData method", NSStringFromClass(self));

// At most one of the three layout methods is overridden

ASDisplayNodeAssert((ASDisplayNodeSubclassOverridesSelector(self, @selector(calculateSizeThatFits:)) ? 1 : 0)

+ (ASDisplayNodeSubclassOverridesSelector(self, @selector(layoutSpecThatFits:)) ? 1 : 0)

+ (ASDisplayNodeSubclassOverridesSelector(self, @selector(calculateLayoutThatFits:)) ? 1 : 0) <= 1,

@"Subclass %@ must override at most one of the three layout methods: calculateLayoutThatFits, layoutSpecThatFits or calculateSizeThatFits", NSStringFromClass(self));

}

// Below we are pre-calculating values per-class and dynamically adding a method (_staticInitialize) to populate these values

// when each instance is constructed. These values don't change for each class, so there is significant performance benefit

// in doing it here. +initialize is guaranteed to be called before any instance method so it is safe to add this method here.

// Note that we take care to detect if the class overrides +respondsToSelector: or -respondsToSelector and take the slow path

// (recalculating for each instance) to make sure we are always correct.

BOOL classOverridesRespondsToSelector = ASSubclassOverridesClassSelector([NSObject class], self, @selector(respondsToSelector:));

BOOL instancesOverrideRespondsToSelector = ASSubclassOverridesSelector([NSObject class], self, @selector(respondsToSelector:));

struct ASDisplayNodeFlags flags = GetASDisplayNodeFlags(self, nil);

ASDisplayNodeMethodOverrides methodOverrides = GetASDisplayNodeMethodOverrides(self);

IMP staticInitialize = imp_implementationWithBlock(^(ASDisplayNode *node) {

node->_flags = (classOverridesRespondsToSelector || instancesOverrideRespondsToSelector) ? GetASDisplayNodeFlags(node.class, node) : flags;

node->_methodOverrides = (classOverridesRespondsToSelector) ? GetASDisplayNodeMethodOverrides(node.class) : methodOverrides;

});

class_replaceMethod(self, @selector(_staticInitialize), staticInitialize, "v:@");

}

+ (BOOL)layerBackedNodesEnabled

{

return YES;

}

+ (Class)viewClass

{

return [_ASDisplayView class];

}

+ (Class)layerClass

{

return [_ASDisplayLayer class];

}

#pragma mark - Lifecycle

- (void)_staticInitialize

{

ASDisplayNodeAssert(NO, @"_staticInitialize must be overridden");

}

- (void)_initializeInstance

{

[self _staticInitialize];

_contentsScaleForDisplay = ASScreenScale();

_displaySentinel = [[ASSentinel alloc] init];

_preferredFrameSize = CGSizeZero;

}

- (id)init

{

if (!(self = [super init]))

return nil;

[self _initializeInstance];

return self;

}

- (id)initWithViewClass:(Class)viewClass

{

if (!(self = [super init]))

return nil;

ASDisplayNodeAssert([viewClass isSubclassOfClass:[UIView class]], @"should initialize with a subclass of UIView");

[self _initializeInstance];

_viewClass = viewClass;

_flags.synchronous = ![viewClass isSubclassOfClass:[_ASDisplayView class]];

return self;

}

- (id)initWithLayerClass:(Class)layerClass

{

if (!(self = [super init]))

return nil;

ASDisplayNodeAssert([layerClass isSubclassOfClass:[CALayer class]], @"should initialize with a subclass of CALayer");

[self _initializeInstance];

_layerClass = layerClass;

_flags.synchronous = ![layerClass isSubclassOfClass:[_ASDisplayLayer class]];

_flags.layerBacked = YES;

return self;

}

- (id)initWithViewBlock:(ASDisplayNodeViewBlock)viewBlock

{

return [self initWithViewBlock:viewBlock didLoadBlock:nil];

}

- (id)initWithViewBlock:(ASDisplayNodeViewBlock)viewBlock didLoadBlock:(ASDisplayNodeDidLoadBlock)didLoadBlock

{

if (!(self = [super init]))

return nil;

ASDisplayNodeAssertNotNil(viewBlock, @"should initialize with a valid block that returns a UIView");

[self _initializeInstance];

_viewBlock = viewBlock;

_nodeLoadedBlock = didLoadBlock;

_flags.synchronous = YES;

return self;

}

- (id)initWithLayerBlock:(ASDisplayNodeLayerBlock)layerBlock

{

return [self initWithLayerBlock:layerBlock didLoadBlock:nil];

}

- (id)initWithLayerBlock:(ASDisplayNodeLayerBlock)layerBlock didLoadBlock:(ASDisplayNodeDidLoadBlock)didLoadBlock

{

if (!(self = [super init]))

return nil;

ASDisplayNodeAssertNotNil(layerBlock, @"should initialize with a valid block that returns a CALayer");

[self _initializeInstance];

_layerBlock = layerBlock;

_nodeLoadedBlock = didLoadBlock;

_flags.synchronous = YES;

_flags.layerBacked = YES;

return self;

}

- (void)dealloc

{

ASDisplayNodeAssertMainThread();

self.asyncLayer.asyncDelegate = nil;

_view.asyncdisplaykit_node = nil;

_layer.asyncdisplaykit_node = nil;

// Remove any subnodes so they lose their connection to the now deallocated parent. This can happen

// because subnodes do not retain their supernode, but subnodes can legitimately remain alive if another

// thing outside the view hierarchy system (e.g. async display, controller code, etc). keeps a retained

// reference to subnodes.

for (ASDisplayNode *subnode in _subnodes)

[subnode __setSupernode:nil];

_view = nil;

_subnodes = nil;

if (_flags.layerBacked)

_layer.delegate = nil;

_layer = nil;

[self __setSupernode:nil];

_pendingViewState = nil;

_replaceAsyncSentinel = nil;

_displaySentinel = nil;

_pendingDisplayNodes = nil;

}

#pragma mark - Core

- (void)__tearDown:(BOOL)tearDown subnodesOfNode:(ASDisplayNode *)node

{

for (ASDisplayNode *subnode in node.subnodes) {

if (tearDown) {

[subnode __unloadNode];

} else {

[subnode __loadNode];

}

}

}

- (void)__unloadNode

{

ASDisplayNodeAssertThreadAffinity(self);

ASDN::MutexLocker l(_propertyLock);

if (_flags.layerBacked)

_pendingViewState = [_ASPendingState pendingViewStateFromLayer:_layer];

else

_pendingViewState = [_ASPendingState pendingViewStateFromView:_view];

[_view removeFromSuperview];

_view = nil;

if (_flags.layerBacked)

_layer.delegate = nil;

[_layer removeFromSuperlayer];

_layer = nil;

}

- (void)__loadNode

{

[self layer];

}

- (ASDisplayNode *)__rasterizedContainerNode

{

ASDisplayNode *node = self.supernode;

while (node) {

if (node.shouldRasterizeDescendants) {

return node;

}

node = node.supernode;

}

return nil;

}

- (BOOL)__shouldLoadViewOrLayer

{

return ![self __rasterizedContainerNode];

}

- (BOOL)__shouldSize

{

return YES;

}

- (void)__exitedHierarchy

{

}

- (UIView *)_viewToLoad

{

UIView *view;

ASDN::MutexLocker l(_propertyLock);

if (_viewBlock) {

view = _viewBlock();

ASDisplayNodeAssertNotNil(view, @"View block returned nil");

ASDisplayNodeAssert(![view isKindOfClass:[_ASDisplayView class]], @"View block should return a synchronously displayed view");

_viewBlock = nil;

_viewClass = [view class];

} else {

if (!_viewClass) {

_viewClass = [self.class viewClass];

}

view = [[_viewClass alloc] init];

}

return view;

}

- (CALayer *)_layerToLoad

{

CALayer *layer;

ASDN::MutexLocker l(_propertyLock);

if (_layerBlock) {

layer = _layerBlock();

ASDisplayNodeAssertNotNil(layer, @"Layer block returned nil");

ASDisplayNodeAssert(![layer isKindOfClass:[_ASDisplayLayer class]], @"Layer block should return a synchronously displayed layer");

_layerBlock = nil;

_layerClass = [layer class];

} else {

if (!_layerClass) {

_layerClass = [self.class layerClass];

}

layer = [[_layerClass alloc] init];

}

return layer;

}

- (void)_loadViewOrLayerIsLayerBacked:(BOOL)isLayerBacked

{

ASDN::MutexLocker l(_propertyLock);

if (self._isDeallocating) {

return;

}

if (![self __shouldLoadViewOrLayer]) {

return;

}

if (isLayerBacked) {

TIME_SCOPED(_debugTimeToCreateView);

_layer = [self _layerToLoad];

_layer.delegate = self;

} else {

TIME_SCOPED(_debugTimeToCreateView);

_view = [self _viewToLoad];

_view.asyncdisplaykit_node = self;

_layer = _view.layer;

}

_layer.asyncdisplaykit_node = self;

self.asyncLayer.asyncDelegate = self;

{

TIME_SCOPED(_debugTimeToApplyPendingState);

[self _applyPendingStateToViewOrLayer];

}

{

TIME_SCOPED(_debugTimeToAddSubnodeViews);

[self _addSubnodeViewsAndLayers];

}

{

TIME_SCOPED(_debugTimeForDidLoad);

[self __didLoad];

}

if (self.placeholderEnabled) {

[self _setupPlaceholderLayer];

}

}

- (UIView *)view

{

ASDisplayNodeAssert(!_flags.layerBacked, @"Call to -view undefined on layer-backed nodes");

if (_flags.layerBacked) {

return nil;

}

if (!_view) {

ASDisplayNodeAssertMainThread();

[self _loadViewOrLayerIsLayerBacked:NO];

}

return _view;

}

- (CALayer *)layer

{

if (!_layer) {

ASDisplayNodeAssertMainThread();

if (!_flags.layerBacked) {

return self.view.layer;

}

[self _loadViewOrLayerIsLayerBacked:YES];

}

return _layer;

}

- (_ASDisplayView *)ensureAsyncView

{

return _flags.synchronous ? nil : (_ASDisplayView *)self.view;

}

- (_ASDisplayLayer *)asyncLayer

{

ASDN::MutexLocker l(_propertyLock);

return [_layer isKindOfClass:[_ASDisplayLayer class]] ? (_ASDisplayLayer *)_layer : nil;

}

- (BOOL)isNodeLoaded

{

ASDN::MutexLocker l(_propertyLock);

return (_view != nil || (_flags.layerBacked && _layer != nil));

}

- (NSString *)name

{

ASDN::MutexLocker l(_propertyLock);

return _name;

}

- (void)setName:(NSString *)name

{

ASDN::MutexLocker l(_propertyLock);

if (!ASObjectIsEqual(_name, name)) {

_name = [name copy];

}

}

- (BOOL)isSynchronous

{

return _flags.synchronous;

}

- (void)setSynchronous:(BOOL)flag

{

_flags.synchronous = flag;

}

- (void)setLayerBacked:(BOOL)isLayerBacked

{

if (![self.class layerBackedNodesEnabled]) return;

ASDN::MutexLocker l(_propertyLock);

ASDisplayNodeAssert(!_view && !_layer, @"Cannot change isLayerBacked after layer or view has loaded");

ASDisplayNodeAssert(!_viewBlock && !_layerBlock, @"Cannot change isLayerBacked when a layer or view block is provided");

ASDisplayNodeAssert(!_viewClass && !_layerClass, @"Cannot change isLayerBacked when a layer or view class is provided");

if (isLayerBacked != _flags.layerBacked && !_view && !_layer) {

_flags.layerBacked = isLayerBacked;

}

}

- (BOOL)isLayerBacked

{

ASDN::MutexLocker l(_propertyLock);

return _flags.layerBacked;

}

#pragma mark -

- (CGSize)measure:(CGSize)constrainedSize

{

return [self measureWithSizeRange:ASSizeRangeMake(CGSizeZero, constrainedSize)].size;

}

- (ASLayout *)measureWithSizeRange:(ASSizeRange)constrainedSize

{

ASDN::MutexLocker l(_propertyLock);

return [self __measureWithSizeRange:constrainedSize];

}

- (ASLayout *)__measureWithSizeRange:(ASSizeRange)constrainedSize

{

ASDisplayNodeAssertThreadAffinity(self);

if (![self __shouldSize])

return nil;

// only calculate the size if

// - we haven't already

// - the constrained size range is different

if (!_flags.isMeasured || !ASSizeRangeEqualToSizeRange(constrainedSize, _constrainedSize)) {

_layout = [self calculateLayoutThatFits:constrainedSize];

_constrainedSize = constrainedSize;

_flags.isMeasured = YES;

}

ASDisplayNodeAssertTrue(_layout.layoutableObject == self);

ASDisplayNodeAssertTrue(_layout.size.width >= 0.0);

ASDisplayNodeAssertTrue(_layout.size.height >= 0.0);

// we generate placeholders at measureWithSizeRange: time so that a node is guaranteed to have a placeholder ready to go

// also if a node has no size, it should not have a placeholder

if (self.placeholderEnabled && [self _displaysAsynchronously] && _layout.size.width > 0.0 && _layout.size.height > 0.0) {

if (!_placeholderImage) {

_placeholderImage = [self placeholderImage];

}

if (_placeholderLayer) {

_placeholderLayer.contents = (id)_placeholderImage.CGImage;

}

}

return _layout;

}

- (BOOL)displaysAsynchronously

{

ASDN::MutexLocker l(_propertyLock);

return [self _displaysAsynchronously];

}

- (BOOL)_displaysAsynchronously

{

ASDisplayNodeAssertThreadAffinity(self);

if (self.isSynchronous) {

return NO;

} else {

return _flags.displaysAsynchronously;

}

}

- (void)setDisplaysAsynchronously:(BOOL)displaysAsynchronously

{

ASDisplayNodeAssertThreadAffinity(self);

// Can't do this for synchronous nodes (using layers that are not _ASDisplayLayer and so we can't control display prevention/cancel)

if (_flags.synchronous)

return;

ASDN::MutexLocker l(_propertyLock);

if (_flags.displaysAsynchronously == displaysAsynchronously)

return;

_flags.displaysAsynchronously = displaysAsynchronously;

self.asyncLayer.displaysAsynchronously = displaysAsynchronously;

}

- (BOOL)shouldRasterizeDescendants

{

ASDisplayNodeAssertThreadAffinity(self);

ASDN::MutexLocker l(_propertyLock);

return _flags.shouldRasterizeDescendants;

}

- (void)setShouldRasterizeDescendants:(BOOL)flag

{

ASDisplayNodeAssertThreadAffinity(self);

ASDN::MutexLocker l(_propertyLock);

if (_flags.shouldRasterizeDescendants == flag)

return;

_flags.shouldRasterizeDescendants = flag;

if (self.isNodeLoaded) {

//recursively tear down or build up subnodes

[self recursivelyClearContents];

[self __tearDown:flag subnodesOfNode:self];

if (flag == NO) {

[self _addSubnodeViewsAndLayers];

}

[self recursivelyDisplayImmediately];

}

}

- (CGFloat)contentsScaleForDisplay

{

ASDisplayNodeAssertThreadAffinity(self);

ASDN::MutexLocker l(_propertyLock);

return _contentsScaleForDisplay;

}

- (void)setContentsScaleForDisplay:(CGFloat)contentsScaleForDisplay

{

ASDisplayNodeAssertThreadAffinity(self);

ASDN::MutexLocker l(_propertyLock);

if (_contentsScaleForDisplay == contentsScaleForDisplay)

return;

_contentsScaleForDisplay = contentsScaleForDisplay;

}

- (void)displayImmediately

{

ASDisplayNodeAssertMainThread();

ASDisplayNodeAssert(!_flags.synchronous, @"this method is designed for asynchronous mode only");

[[self asyncLayer] displayImmediately];

}

- (void)recursivelyDisplayImmediately

{

ASDN::MutexLocker l(_propertyLock);

for (ASDisplayNode *child in _subnodes) {

[child recursivelyDisplayImmediately];

}

[self displayImmediately];

}

- (void)__setNeedsLayout

{

ASDisplayNodeAssertThreadAffinity(self);

ASDN::MutexLocker l(_propertyLock);

if (!_flags.isMeasured) {

return;

}

ASSizeRange oldConstrainedSize = _constrainedSize;

[self invalidateCalculatedLayout];

if (_supernode) {

// Cause supernode's layout to be invalidated

[_supernode setNeedsLayout];

} else {

// This is the root node. Trigger a full measurement pass on *current* thread. Old constrained size is re-used.

[self measureWithSizeRange:oldConstrainedSize];

CGRect oldBounds = self.bounds;

CGSize oldSize = oldBounds.size;

CGSize newSize = _layout.size;

if (! CGSizeEqualToSize(oldSize, newSize)) {

self.bounds = (CGRect){ oldBounds.origin, newSize };

// Frame's origin must be preserved. Since it is computed from bounds size, anchorPoint

// and position (see frame setter in ASDisplayNode+UIViewBridge), position needs to be adjusted.

CGPoint anchorPoint = self.anchorPoint;

CGPoint oldPosition = self.position;

CGFloat xDelta = (newSize.width - oldSize.width) * anchorPoint.x;

CGFloat yDelta = (newSize.height - oldSize.height) * anchorPoint.y;

self.position = CGPointMake(oldPosition.x + xDelta, oldPosition.y + yDelta);

}

}

}

- (void)__setSafeFrame:(CGRect)rect

{

ASDisplayNodeAssertThreadAffinity(self);

ASDN::MutexLocker l(_propertyLock);

BOOL useLayer = (_layer && ASDisplayNodeThreadIsMain());

CGPoint origin = (useLayer ? _layer.bounds.origin : self.bounds.origin);

CGPoint anchorPoint = (useLayer ? _layer.anchorPoint : self.anchorPoint);

CGRect bounds = (CGRect){ origin, rect.size };

CGPoint position = CGPointMake(rect.origin.x + rect.size.width * anchorPoint.x,

rect.origin.y + rect.size.height * anchorPoint.y);

if (useLayer) {

_layer.bounds = bounds;

_layer.position = position;

} else {

self.bounds = bounds;

self.position = position;

}

}

- (void)__layout

{

ASDisplayNodeAssertMainThread();

ASDN::MutexLocker l(_propertyLock);

if (CGRectEqualToRect(self.bounds, CGRectZero)) {

return; // Performing layout on a zero-bounds view often results in frame calculations with negative sizes after applying margins, which will cause measureWithSizeRange: on subnodes to assert.

}

_placeholderLayer.frame = self.bounds;

[self layout];

[self layoutDidFinish];

}

- (void)layoutDidFinish

{

}

- (CATransform3D)_transformToAncestor:(ASDisplayNode *)ancestor

{

CATransform3D transform = CATransform3DIdentity;

ASDisplayNode *currentNode = self;

while (currentNode.supernode) {

if (currentNode == ancestor) {

return transform;

}

CGPoint anchorPoint = currentNode.anchorPoint;

CGRect bounds = currentNode.bounds;

CGPoint position = currentNode.position;

CGPoint origin = CGPointMake(position.x - bounds.size.width * anchorPoint.x,

position.y - bounds.size.height * anchorPoint.y);

transform = CATransform3DTranslate(transform, origin.x, origin.y, 0);

transform = CATransform3DTranslate(transform, -bounds.origin.x, -bounds.origin.y, 0);

currentNode = currentNode.supernode;

}

return transform;

}

static inline BOOL _ASDisplayNodeIsAncestorOfDisplayNode(ASDisplayNode *possibleAncestor, ASDisplayNode *possibleDescendent)

{

ASDisplayNode *supernode = possibleDescendent;

while (supernode) {

if (supernode == possibleAncestor) {

return YES;

}

supernode = supernode.supernode;

}

return NO;

}

static inline ASDisplayNode *_ASDisplayNodeFindClosestCommonAncestor(ASDisplayNode *node1, ASDisplayNode *node2)

{

ASDisplayNode *possibleAncestor = node1;

while (possibleAncestor) {

if (_ASDisplayNodeIsAncestorOfDisplayNode(possibleAncestor, node2)) {

break;

}

possibleAncestor = possibleAncestor.supernode;

}

ASDisplayNodeCAssertNotNil(possibleAncestor, @"Could not find a common ancestor between node1: %@ and node2: %@", node1, node2);

return possibleAncestor;

}

static inline ASDisplayNode *_getRootNode(ASDisplayNode *node)

{

// node <- supernode on each loop

// previous <- node on each loop where node is not nil

// previous is the final non-nil value of supernode, i.e. the root node

ASDisplayNode *previousNode = node;

while ((node = [node supernode])) {

previousNode = node;

}

return previousNode;

}

static inline CATransform3D _calculateTransformFromReferenceToTarget(ASDisplayNode *referenceNode, ASDisplayNode *targetNode)

{

ASDisplayNode *ancestor = _ASDisplayNodeFindClosestCommonAncestor(referenceNode, targetNode);

// Transform into global (away from reference coordinate space)

CATransform3D transformToGlobal = [referenceNode _transformToAncestor:ancestor];

// Transform into local (via inverse transform from target to ancestor)

CATransform3D transformToLocal = CATransform3DInvert([targetNode _transformToAncestor:ancestor]);

return CATransform3DConcat(transformToGlobal, transformToLocal);

}

- (CGPoint)convertPoint:(CGPoint)point fromNode:(ASDisplayNode *)node

{

ASDisplayNodeAssertThreadAffinity(self);

// Get root node of the accessible node hierarchy, if node not specified

node = node ? node : _getRootNode(self);

// Calculate transform to map points between coordinate spaces

CATransform3D nodeTransform = _calculateTransformFromReferenceToTarget(node, self);

CGAffineTransform flattenedTransform = CATransform3DGetAffineTransform(nodeTransform);

ASDisplayNodeAssertTrue(CATransform3DIsAffine(nodeTransform));

// Apply to point

return CGPointApplyAffineTransform(point, flattenedTransform);

}

- (CGPoint)convertPoint:(CGPoint)point toNode:(ASDisplayNode *)node

{

ASDisplayNodeAssertThreadAffinity(self);

// Get root node of the accessible node hierarchy, if node not specified

node = node ? node : _getRootNode(self);

// Calculate transform to map points between coordinate spaces

CATransform3D nodeTransform = _calculateTransformFromReferenceToTarget(self, node);

CGAffineTransform flattenedTransform = CATransform3DGetAffineTransform(nodeTransform);

ASDisplayNodeAssertTrue(CATransform3DIsAffine(nodeTransform));

// Apply to point

return CGPointApplyAffineTransform(point, flattenedTransform);

}

- (CGRect)convertRect:(CGRect)rect fromNode:(ASDisplayNode *)node

{

ASDisplayNodeAssertThreadAffinity(self);

// Get root node of the accessible node hierarchy, if node not specified

node = node ? node : _getRootNode(self);

// Calculate transform to map points between coordinate spaces

CATransform3D nodeTransform = _calculateTransformFromReferenceToTarget(node, self);

CGAffineTransform flattenedTransform = CATransform3DGetAffineTransform(nodeTransform);

ASDisplayNodeAssertTrue(CATransform3DIsAffine(nodeTransform));

// Apply to rect

return CGRectApplyAffineTransform(rect, flattenedTransform);

}

- (CGRect)convertRect:(CGRect)rect toNode:(ASDisplayNode *)node

{

ASDisplayNodeAssertThreadAffinity(self);

// Get root node of the accessible node hierarchy, if node not specified

node = node ? node : _getRootNode(self);

// Calculate transform to map points between coordinate spaces

CATransform3D nodeTransform = _calculateTransformFromReferenceToTarget(self, node);

CGAffineTransform flattenedTransform = CATransform3DGetAffineTransform(nodeTransform);

ASDisplayNodeAssertTrue(CATransform3DIsAffine(nodeTransform));

// Apply to rect

return CGRectApplyAffineTransform(rect, flattenedTransform);

}

#pragma mark - _ASDisplayLayerDelegate

- (void)willDisplayAsyncLayer:(_ASDisplayLayer *)layer

{

// Subclass hook.

[self displayWillStart];

}

- (void)didDisplayAsyncLayer:(_ASDisplayLayer *)layer

{

// Subclass hook.

[self displayDidFinish];

}

#pragma mark - CALayerDelegate

- (id<CAAction>)actionForLayer:(CALayer *)layer forKey:(NSString *)event

{

if (event == kCAOnOrderIn) {

[self __enterHierarchy];

} else if (event == kCAOnOrderOut) {

[self __exitHierarchy];

}

ASDisplayNodeAssert(_flags.layerBacked, @"We shouldn't get called back here if there is no layer");

return (id<CAAction>)[NSNull null];

}

#pragma mark -

static bool disableNotificationsForMovingBetweenParents(ASDisplayNode *from, ASDisplayNode *to)

{

if (!from || !to) return NO;

if (from->_flags.synchronous) return NO;

if (to->_flags.synchronous) return NO;

if (from->_flags.isInHierarchy != to->_flags.isInHierarchy) return NO;

return YES;

}

- (void)addSubnode:(ASDisplayNode *)subnode

{

ASDisplayNodeAssertThreadAffinity(self);

ASDN::MutexLocker l(_propertyLock);

ASDisplayNode *oldParent = subnode.supernode;

if (!subnode || subnode == self || oldParent == self)

return;

// Disable appearance methods during move between supernodes, but make sure we restore their state after we do our thing

BOOL isMovingEquivalentParents = disableNotificationsForMovingBetweenParents(oldParent, self);

if (isMovingEquivalentParents) {

[subnode __incrementVisibilityNotificationsDisabled];

}

[subnode removeFromSupernode];

if (!_subnodes)

_subnodes = [[NSMutableArray alloc] init];