#import "ASDisplayNode.h"

#import "ASDisplayNode+Subclasses.h"

#import "ASDisplayNodeInternal.h"

#import <objc/runtime.h>

#import "_ASAsyncTransaction.h"

#import "_ASPendingState.h"

#import "_ASDisplayView.h"

#import "_ASScopeTimer.h"

#import "ASDisplayNodeExtras.h"

@interface ASDisplayNode () <UIGestureRecognizerDelegate>

#if TIME_DISPLAYNODE_OPS

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

#else

#define TIME_SCOPED(outVar)

#endif

@implementation ASDisplayNode

BOOL ASDisplayNodeSubclassOverridesSelector(Class subclass, SEL selector)

{

Method superclassMethod = class_getInstanceMethod([ASDisplayNode class], selector);

Method subclassMethod = class_getInstanceMethod(subclass, selector);

IMP superclassIMP = superclassMethod ? method_getImplementation(superclassMethod) : NULL;

IMP subclassIMP = subclassMethod ? method_getImplementation(subclassMethod) : NULL;

return (superclassIMP != subclassIMP);

}

CGFloat ASDisplayNodeScreenScale()

{

static CGFloat screenScale = 0.0;

static dispatch_once_t onceToken;

dispatch_once(&onceToken, ^{

if ([NSThread isMainThread]) {

screenScale = [[UIScreen mainScreen] scale];

} else {

dispatch_sync(dispatch_get_main_queue(), ^{

screenScale = [[UIScreen mainScreen] scale];

});

}

});

return screenScale;

}

void ASDisplayNodePerformBlockOnMainThread(void (^block)())

{

if ([NSThread isMainThread]) {

block();

} else {

dispatch_async(dispatch_get_main_queue(), ^{

block();

});

}

}

+ (void)initialize

{

if (self == [ASDisplayNode class]) {

return;

}

// Subclasses should never override these

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

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

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

}

+ (BOOL)layerBackedNodesEnabled

{

return YES;

}

+ (Class)viewClass

{

return [_ASDisplayView class];

}

+ (Class)layerClass

{

return [_ASDisplayLayer class];

}

#pragma mark - Lifecycle

- (void)_initializeInstance

{

_contentsScaleForDisplay = ASDisplayNodeScreenScale();

_displaySentinel = [[ASSentinel alloc] init];

_flags.inWindow = NO;

_flags.displaysAsynchronously = YES;

// As an optimization, it may be worth a caching system that performs these checks once per class in +initialize (see above).

_flags.implementsDisplay = [[self class] respondsToSelector:@selector(drawRect:withParameters:isCancelled:isRasterizing:)] || [self.class respondsToSelector:@selector(displayWithParameters:isCancelled:)];

_flags.hasClassDisplay = ([[self class] respondsToSelector:@selector(displayWithParameters:isCancelled:)] ? 1 : 0);

_flags.hasWillDisplayAsyncLayer = ([self respondsToSelector:@selector(willDisplayAsyncLayer:)] ? 1 : 0);

_flags.hasDrawParametersForAsyncLayer = ([self respondsToSelector:@selector(drawParametersForAsyncLayer:)] ? 1 : 0);

}

- (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.isSynchronous = ![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.isSynchronous = ![layerClass isSubclassOfClass:[_ASDisplayLayer class]];

_flags.isLayerBacked = 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.isLayerBacked)

_layer.delegate = nil;

_layer = nil;

[self __setSupernode:nil];

_pendingViewState = nil;

_replaceAsyncSentinel = nil;

_displaySentinel = nil;

}

#pragma mark - UIResponder overrides

- (UIResponder *)nextResponder

{

return self.view.superview;

}

#pragma mark - Core

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

{

}

- (void)_loadViewOrLayerIsLayerBacked:(BOOL)isLayerBacked

{

ASDN::MutexLocker l(_propertyLock);

if (self._isDeallocating) {

return;

}

if (![self __shouldLoadViewOrLayer]) {

return;

}

if (isLayerBacked) {

TIME_SCOPED(_debugTimeToCreateView);

if (!_layerClass) {

_layerClass = [self.class layerClass];

}

_layer = [[_layerClass alloc] init];

_layer.delegate = self;

} else {

TIME_SCOPED(_debugTimeToCreateView);

if (!_viewClass) {

_viewClass = [self.class viewClass];

}

_view = [[_viewClass alloc] init];

_view.asyncdisplaykit_node = self;

_layer = _view.layer;

}

_layer.asyncdisplaykit_node = self;

#if DEBUG

_layer.name = self.description;

#endif

self.asyncLayer.asyncDelegate = self;

{

TIME_SCOPED(_debugTimeToApplyPendingState);

[self _applyPendingStateToViewOrLayer];

}

{

TIME_SCOPED(_debugTimeToAddSubnodeViews);

[self _addSubnodeViewsAndLayers];

}

{

TIME_SCOPED(_debugTimeForDidLoad);

[self didLoad];

}

}

- (UIView *)view

{

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

if (_flags.isLayerBacked) {

return nil;

}

if (!_view) {

ASDisplayNodeAssertMainThread();

[self _loadViewOrLayerIsLayerBacked:NO];

}

return _view;

}

- (CALayer *)layer

{

if (!_layer) {

ASDisplayNodeAssertMainThread();

if (!_flags.isLayerBacked) {

return self.view.layer;

}

[self _loadViewOrLayerIsLayerBacked:YES];

}

return _layer;

}

- (_ASDisplayView *)ensureAsyncView

{

return _flags.isSynchronous ? 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.isLayerBacked && _layer != nil));

}

- (BOOL)isSynchronous

{

return _flags.isSynchronous;

}

- (void)setSynchronous:(BOOL)flag

{

_flags.isSynchronous = 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");

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

_flags.isLayerBacked = isLayerBacked;

}

}

- (BOOL)isLayerBacked

{

ASDN::MutexLocker l(_propertyLock);

return _flags.isLayerBacked;

}

#pragma mark -

- (CGSize)measure:(CGSize)constrainedSize

{

ASDisplayNodeAssertThreadAffinity(self);

if (![self __shouldSize])

return CGSizeZero;

// only calculate the size if

// - we haven't already

// - the width is different from the last time

// - the height is different from the last time

if (!_flags.sizeCalculated || !CGSizeEqualToSize(constrainedSize, _constrainedSize)) {

_size = [self calculateSizeThatFits:constrainedSize];

_constrainedSize = constrainedSize;

_flags.sizeCalculated = YES;

}

ASDisplayNodeAssertTrue(_size.width >= 0.0);

ASDisplayNodeAssertTrue(_size.height >= 0.0);

return _size;

}

- (BOOL)displaysAsynchronously

{

ASDisplayNodeAssertThreadAffinity(self);

ASDN::MutexLocker l(_propertyLock);

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.isSynchronous)

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;

}

- (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.isSynchronous, @"this method is designed for asynchronous mode only");

[[self asyncLayer] displayImmediately];

}

- (void)__layout

{

ASDisplayNodeAssertMainThread();

ASDN::MutexLocker l(_propertyLock);

if (CGRectEqualToRect(_layer.bounds, CGRectZero))

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

[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(self, node);

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)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.isLayerBacked, @"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.isSynchronous) return NO;

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

if (from->_flags.inWindow != to->_flags.inWindow) 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];

[_subnodes addObject:subnode];

if (self.nodeLoaded) {

// If this node has a view or layer, force the subnode to also create its view or layer and add it to the hierarchy here.

// Otherwise there is no way for the subnode's view or layer to enter the hierarchy, except recursing down all

// subnodes on the main thread after the node tree has been created but before the first display (which

// could introduce performance problems).

if (ASDisplayNodeThreadIsMain()) {

[self _addSubnodeSubviewOrSublayer:subnode];

} else {

dispatch_async(dispatch_get_main_queue(), ^{

[self _addSubnodeSubviewOrSublayer:subnode];

});

}

}

ASDisplayNodeAssert(isMovingEquivalentParents == disableNotificationsForMovingBetweenParents(oldParent, self), @"Invariant violated");

if (isMovingEquivalentParents) {

[subnode __decrementVisibilityNotificationsDisabled];

}

[subnode __setSupernode:self];

}

- (void)_insertSubnode:(ASDisplayNode *)subnode atSubnodeIndex:(NSInteger)subnodeIndex sublayerIndex:(NSInteger)sublayerIndex andRemoveSubnode:(ASDisplayNode *)oldSubnode

{

if (subnodeIndex == NSNotFound)

return;

ASDisplayNode *oldParent = [subnode _deallocSafeSupernode];

// 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];

[oldSubnode removeFromSupernode];

[_subnodes insertObject:subnode atIndex:subnodeIndex];

// Don't bother inserting the view/layer if in a rasterized subtree, becuase there are no layers in the hierarchy and none of this could possibly work.

if (!_flags.shouldRasterizeDescendants && ![self __rasterizedContainerNode]) {

if (_layer) {

ASDisplayNodeCAssertMainThread();

ASDisplayNodeAssert(sublayerIndex != NSNotFound, @"Should pass either a valid sublayerIndex");

if (sublayerIndex != NSNotFound) {

BOOL canUseViewAPI = !subnode.isLayerBacked && !self.isLayerBacked;

// If we can use view API, do. Due to an apple bug, -insertSubview:atIndex: actually wants a LAYER index, which we pass in

if (canUseViewAPI && sublayerIndex != NSNotFound) {

[_view insertSubview:subnode.view atIndex:sublayerIndex];

} else if (sublayerIndex != NSNotFound) {

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wconversion"

[_layer insertSublayer:subnode.layer atIndex:sublayerIndex];

#pragma clang diagnostic pop

}

}

}

}

ASDisplayNodeAssert(isMovingEquivalentParents == disableNotificationsForMovingBetweenParents(oldParent, self), @"Invariant violated");

if (isMovingEquivalentParents) {

[subnode __decrementVisibilityNotificationsDisabled];

}

[subnode __setSupernode:self];

}

- (void)replaceSubnode:(ASDisplayNode *)oldSubnode withSubnode:(ASDisplayNode *)replacementSubnode

{

ASDisplayNodeAssertThreadAffinity(self);

ASDN::MutexLocker l(_propertyLock);

if (!replacementSubnode || [oldSubnode _deallocSafeSupernode] != self) {

ASDisplayNodeAssert(0, @"Bad use of api. Invalid subnode to replace async.");

return;

}

ASDisplayNodeAssert(!(self.nodeLoaded && !oldSubnode.nodeLoaded), @"ASDisplayNode corruption bug. We have view loaded, but child node does not.");

ASDisplayNodeAssert(_subnodes, @"You should have subnodes if you have a subnode");

NSInteger subnodeIndex = [_subnodes indexOfObjectIdenticalTo:oldSubnode];

NSInteger sublayerIndex = NSNotFound;

if (_layer) {

sublayerIndex = [_layer.sublayers indexOfObjectIdenticalTo:oldSubnode.layer];

ASDisplayNodeAssert(sublayerIndex != NSNotFound, @"Somehow oldSubnode's supernode is self, yet we could not find it in our layers to replace");

if (sublayerIndex == NSNotFound) return;

}

[self _insertSubnode:replacementSubnode atSubnodeIndex:subnodeIndex sublayerIndex:sublayerIndex andRemoveSubnode:oldSubnode];

}

static NSInteger incrementIfFound(NSInteger i) {

return i == NSNotFound ? NSNotFound : i + 1;

}

- (void)insertSubnode:(ASDisplayNode *)subnode belowSubnode:(ASDisplayNode *)below

{

ASDisplayNodeAssertThreadAffinity(self);

ASDN::MutexLocker l(_propertyLock);

ASDisplayNodeAssert(subnode, @"Cannot insert a nil subnode");

if (!subnode)

return;

ASDisplayNodeAssert([below _deallocSafeSupernode] == self, @"Node to insert below must be a subnode");

if ([below _deallocSafeSupernode] != self)

return;

ASDisplayNodeAssert(_subnodes, @"You should have subnodes if you have a subnode");

NSInteger belowSubnodeIndex = [_subnodes indexOfObjectIdenticalTo:below];

NSInteger belowSublayerIndex = NSNotFound;

if (_layer) {

belowSublayerIndex = [_layer.sublayers indexOfObjectIdenticalTo:below.layer];

ASDisplayNodeAssert(belowSublayerIndex != NSNotFound, @"Somehow below's supernode is self, yet we could not find it in our layers to reference");

if (belowSublayerIndex == NSNotFound)

return;

}

// If the subnode is already in the subnodes array / sublayers and it's before the below node, removing it to insert it will mess up our calculation

if ([subnode _deallocSafeSupernode] == self) {

NSInteger currentIndexInSubnodes = [_subnodes indexOfObjectIdenticalTo:subnode];

if (currentIndexInSubnodes < belowSubnodeIndex) {

belowSubnodeIndex--;

}

if (_layer) {

NSInteger currentIndexInSublayers = [_layer.sublayers indexOfObjectIdenticalTo:subnode.layer];

if (currentIndexInSublayers < belowSublayerIndex) {

belowSublayerIndex--;

}

}

}

ASDisplayNodeAssert(belowSubnodeIndex != NSNotFound, @"Couldn't find below in subnodes");

[self _insertSubnode:subnode atSubnodeIndex:belowSubnodeIndex sublayerIndex:belowSublayerIndex andRemoveSubnode:nil];

}

- (void)insertSubnode:(ASDisplayNode *)subnode aboveSubnode:(ASDisplayNode *)above

{

ASDisplayNodeAssertThreadAffinity(self);

ASDN::MutexLocker l(_propertyLock);

ASDisplayNodeAssert(subnode, @"Cannot insert a nil subnode");

if (!subnode)

return;

ASDisplayNodeAssert([above _deallocSafeSupernode] == self, @"Node to insert above must be a subnode");

if ([above _deallocSafeSupernode] != self)

return;

ASDisplayNodeAssert(_subnodes, @"You should have subnodes if you have a subnode");

NSInteger aboveSubnodeIndex = [_subnodes indexOfObjectIdenticalTo:above];

NSInteger aboveSublayerIndex = NSNotFound;

// Don't bother figuring out the sublayerIndex if in a rasterized subtree, becuase there are no layers in the hierarchy and none of this could possibly work.

if (!_flags.shouldRasterizeDescendants && ![self __rasterizedContainerNode]) {

if (_layer) {

aboveSublayerIndex = [_layer.sublayers indexOfObjectIdenticalTo:above.layer];

ASDisplayNodeAssert(aboveSublayerIndex != NSNotFound, @"Somehow above's supernode is self, yet we could not find it in our layers to replace");

if (aboveSublayerIndex == NSNotFound)

return;

}

ASDisplayNodeAssert(aboveSubnodeIndex != NSNotFound, @"Couldn't find above in subnodes");

// If the subnode is already in the subnodes array / sublayers and it's before the below node, removing it to insert it will mess up our calculation

if ([subnode _deallocSafeSupernode] == self) {

NSInteger currentIndexInSubnodes = [_subnodes indexOfObjectIdenticalTo:subnode];

if (currentIndexInSubnodes <= aboveSubnodeIndex) {

aboveSubnodeIndex--;

}

if (_layer) {

NSInteger currentIndexInSublayers = [_layer.sublayers indexOfObjectIdenticalTo:subnode.layer];

if (currentIndexInSublayers <= aboveSublayerIndex) {

aboveSublayerIndex--;

}

}

}

}

[self _insertSubnode:subnode atSubnodeIndex:incrementIfFound(aboveSubnodeIndex) sublayerIndex:incrementIfFound(aboveSublayerIndex) andRemoveSubnode:nil];

}

- (void)insertSubnode:(ASDisplayNode *)subnode atIndex:(NSInteger)idx

{

ASDisplayNodeAssertThreadAffinity(self);

ASDN::MutexLocker l(_propertyLock);

if (idx > _subnodes.count || idx < 0) {

NSString *reason = [NSString stringWithFormat:@"Cannot insert a subnode at index %zd. Count is %zd", idx, _subnodes.count];

@throw [NSException exceptionWithName:NSInvalidArgumentException reason:reason userInfo:nil];

}

NSInteger sublayerIndex = NSNotFound;

// Account for potentially having other subviews

if (_layer && idx == 0) {

sublayerIndex = 0;

} else if (_layer) {

ASDisplayNode *positionInRelationTo = (_subnodes.count > 0 && idx > 0) ? _subnodes[idx - 1] : nil;

if (positionInRelationTo) {

sublayerIndex = incrementIfFound([_layer.sublayers indexOfObjectIdenticalTo:positionInRelationTo.layer]);

}

}

[self _insertSubnode:subnode atSubnodeIndex:idx sublayerIndex:sublayerIndex andRemoveSubnode:nil];

}

- (void)_addSubnodeSubviewOrSublayer:(ASDisplayNode *)subnode

{

ASDisplayNodeAssertMainThread();

ASDisplayNodeAssert(self.nodeLoaded, @"_addSubnodeSubview: should never be called before our own view is created");

BOOL canUseViewAPI = !self.isLayerBacked && !subnode.isLayerBacked;

if (canUseViewAPI) {

[_view addSubview:subnode.view];

} else {

// Disallow subviews in a layer-backed node

ASDisplayNodeAssert(subnode.isLayerBacked, @"Cannot add a subview to a layer-backed node; only sublayers permitted.");

[_layer addSublayer:subnode.layer];

}

}

- (void)_addSubnodeViewsAndLayers

{

ASDisplayNodeAssertMainThread();

for (ASDisplayNode *node in [_subnodes copy]) {

[self _addSubnodeSubviewOrSublayer:node];

}

}

- (void)_removeSubnode:(ASDisplayNode *)subnode

{

ASDisplayNodeAssertThreadAffinity(self);

ASDN::MutexLocker l(_propertyLock);

// Don't call self.supernode here because that will retain/autorelease the supernode. This method -_removeSupernode: is often called while tearing down a node hierarchy, and the supernode in question might be in the middle of its -dealloc. The supernode is never messaged, only compared by value, so this is safe.

// The particular issue that triggers this edge case is when a node calls -removeFromSupernode on a subnode from within its own -dealloc method.

if (!subnode || [subnode _deallocSafeSupernode] != self)

return;

[_subnodes removeObjectIdenticalTo:subnode];

[subnode __setSupernode:nil];

}

- (void)removeFromSupernode

{

ASDisplayNodeAssertThreadAffinity(self);

ASDN::MutexLocker l(_propertyLock);

if (!_supernode)

return;

// Do this before removing the view from the hierarchy, as the node will clear its supernode pointer when its view is removed from the hierarchy.

[_supernode _removeSubnode:self];

if (ASDisplayNodeThreadIsMain()) {

if (_flags.isLayerBacked) {

[_layer removeFromSuperlayer];

} else {

[_view removeFromSuperview];

}

} else {

dispatch_async(dispatch_get_main_queue(), ^{

if (_flags.isLayerBacked) {

[_layer removeFromSuperlayer];

} else {

[_view removeFromSuperview];

}

});

}

}

- (BOOL)__visibilityNotificationsDisabled

{

ASDN::MutexLocker l(_propertyLock);

return _flags.visibilityNotificationsDisabled > 0;

}

- (void)__incrementVisibilityNotificationsDisabled

{

ASDN::MutexLocker l(_propertyLock);

const size_t maxVisibilityIncrement = (1ULL<<visibilityNotificationsDisabledBits) - 1ULL;

ASDisplayNodeAssert(_flags.visibilityNotificationsDisabled < maxVisibilityIncrement, @"Oops, too many increments of the visibility notifications API");

if (_flags.visibilityNotificationsDisabled < maxVisibilityIncrement)

_flags.visibilityNotificationsDisabled++;

}

- (void)__decrementVisibilityNotificationsDisabled

{

ASDN::MutexLocker l(_propertyLock);

ASDisplayNodeAssert(_flags.visibilityNotificationsDisabled > 0, @"Can't decrement past 0");

if (_flags.visibilityNotificationsDisabled > 0)

_flags.visibilityNotificationsDisabled--;

}

- (BOOL)__hasParentWithVisibilityNotificationsDisabled

{

CALayer *layer = _layer;

do {

ASDisplayNode *node = ASLayerToDisplayNode(layer);

if (node) {

if (node->_flags.visibilityNotificationsDisabled) {

return YES;

}

}

layer = layer.superlayer;

} while (layer);

return NO;

}

- (void)__enterHierarchy

{

ASDisplayNodeAssertMainThread();

ASDisplayNodeAssert(!_flags.isInEnterHierarchy, @"Should not cause recursive __enterHierarchy");

if (!self.inWindow && !_flags.visibilityNotificationsDisabled && ![self __hasParentWithVisibilityNotificationsDisabled]) {

self.inWindow = YES;

_flags.isInEnterHierarchy = YES;

if (self.shouldRasterizeDescendants) {

// Nodes that are descendants of a rasterized container do not have views or layers, and so cannot receive visibility notifications directly via orderIn/orderOut CALayer actions. Manually send visibility notifications to rasterized descendants.