Swiftgram/AsyncDisplayKit/Layout/ASLayoutOptions.mm

/*
 *  Copyright (c) 2014-present, Facebook, Inc.
 *  All rights reserved.
 *
 *  This source code is licensed under the BSD-style license found in the
 *  LICENSE file in the root directory of this source tree. An additional grant
 *  of patent rights can be found in the PATENTS file in the same directory.
 *
 */

#import "ASLayoutOptions.h"

#import <AsyncDisplayKit/ASAssert.h>
#import <AsyncDisplayKit/ASThread.h>
#import <AsyncDisplayKit/ASTextNode.h>
#import "ASInternalHelpers.h"

@interface ASLayoutOptions()
{
  ASDN::RecursiveMutex _propertyLock;
}
@end

@implementation ASLayoutOptions

@synthesize spacingBefore = _spacingBefore;
@synthesize spacingAfter = _spacingAfter;
@synthesize flexGrow = _flexGrow;
@synthesize flexShrink = _flexShrink;
@synthesize flexBasis = _flexBasis;
@synthesize alignSelf = _alignSelf;

@synthesize ascender = _ascender;
@synthesize descender = _descender;

@synthesize sizeRange = _sizeRange;
@synthesize layoutPosition = _layoutPosition;

static Class gDefaultLayoutOptionsClass = nil;
+ (void)setDefaultLayoutOptionsClass:(Class)defaultLayoutOptionsClass
{
  gDefaultLayoutOptionsClass = defaultLayoutOptionsClass;
}

+ (Class)defaultLayoutOptionsClass
{
  static dispatch_once_t onceToken;
  dispatch_once(&onceToken, ^{
    if (gDefaultLayoutOptionsClass == nil) {
      // If someone is asking for this and it hasn't been customized yet, use the default.
      gDefaultLayoutOptionsClass = [ASLayoutOptions class];
    }
  });
  return gDefaultLayoutOptionsClass;
}

- (instancetype)init
{
  return nil;
}

- (instancetype)initWithLayoutable:(id<ASLayoutable>)layoutable
{
  self = [super init];
  if (self) {
    
    self.flexBasis = ASRelativeDimensionUnconstrained;
    self.sizeRange = ASRelativeSizeRangeMake(ASRelativeSizeMakeWithCGSize(CGSizeZero), ASRelativeSizeMakeWithCGSize(CGSizeZero));
    self.layoutPosition = CGPointZero;
    
    // The following properties use a default value of 0 which we do not need to assign.
    // self.spacingBefore = 0;
    // self.spacingAfter = 0;
    // self.flexGrow = NO;
    // self.flexShrink = NO;
    // self.alignSelf = ASStackLayoutAlignSelfAuto;
    // self.ascender = 0;
    // self.descender = 0;
    
    [self setValuesFromLayoutable:layoutable];
  }
  return self;
}

#pragma mark - NSCopying
- (id)copyWithZone:(NSZone *)zone
{
  ASLayoutOptions *copy = [[[self class] alloc] init];
  [copy copyFromOptions:self];
  return copy;
}

- (void)copyFromOptions:(ASLayoutOptions *)layoutOptions
{
  ASDN::MutexLocker l(_propertyLock);
  self.flexBasis = layoutOptions.flexBasis;
  self.spacingAfter = layoutOptions.spacingAfter;
  self.spacingBefore = layoutOptions.spacingBefore;
  self.flexGrow = layoutOptions.flexGrow;
  self.flexShrink = layoutOptions.flexShrink;
  self.alignSelf = layoutOptions.alignSelf;
  
  self.ascender = layoutOptions.ascender;
  self.descender = layoutOptions.descender;
  
  self.sizeRange = layoutOptions.sizeRange;
  self.layoutPosition = layoutOptions.layoutPosition;
}

/**
 *  Given an id<ASLayoutable>, set up layout options that are intrinsically defined by the layoutable.
 *
 *  While this could be done in the layoutable object itself, moving the logic into the ASLayoutOptions class 
 *  allows a custom spec to set up defaults without needing to alter the layoutable itself. For example,
 *  image you were creating a custom baseline spec that needed ascender/descender. To assign values automatically
 *  when a text node's attribute string is set, you would need to subclass ASTextNode and assign the values in the
 *  override of setAttributeString. However, assigning the defaults in an ASLayoutOptions subclass's
 *  setValuesFromLayoutable allows you to create a custom spec without the need to create a
 *  subclass of ASTextNode.
 *
 *  @param layoutable The layoutable object to inspect for default intrinsic layout option values
 */
- (void)setValuesFromLayoutable:(id<ASLayoutable>)layoutable
{
  ASDN::MutexLocker l(_propertyLock);
  if ([layoutable isKindOfClass:[ASDisplayNode class]]) {
    ASDisplayNode *displayNode = (ASDisplayNode *)layoutable;
    self.sizeRange = ASRelativeSizeRangeMake(ASRelativeSizeMakeWithCGSize(displayNode.preferredFrameSize), ASRelativeSizeMakeWithCGSize(displayNode.preferredFrameSize));
    
    if ([layoutable isKindOfClass:[ASTextNode class]]) {
      ASTextNode *textNode = (ASTextNode *)layoutable;
      NSAttributedString *attributedString = textNode.attributedString;
      if (attributedString.length > 0) {
        CGFloat screenScale = ASScreenScale();
        self.ascender = round([[attributedString attribute:NSFontAttributeName atIndex:0 effectiveRange:NULL] ascender] * screenScale)/screenScale;
        self.descender = round([[attributedString attribute:NSFontAttributeName atIndex:attributedString.length - 1 effectiveRange:NULL] descender] * screenScale)/screenScale;
      }
    }
    
  }
}

- (CGFloat)spacingAfter
{
  ASDN::MutexLocker l(_propertyLock);
  return _spacingAfter;
}

- (void)setSpacingAfter:(CGFloat)spacingAfter
{
  ASDN::MutexLocker l(_propertyLock);
  _spacingAfter = spacingAfter;
}

- (CGFloat)spacingBefore
{
  ASDN::MutexLocker l(_propertyLock);
  return _spacingBefore;
}

- (void)setSpacingBefore:(CGFloat)spacingBefore
{
  ASDN::MutexLocker l(_propertyLock);
  _spacingBefore = spacingBefore;
}

- (BOOL)flexGrow
{
  ASDN::MutexLocker l(_propertyLock);
  return _flexGrow;
}

- (void)setFlexGrow:(BOOL)flexGrow
{
  ASDN::MutexLocker l(_propertyLock);
  _flexGrow = flexGrow;
}

- (BOOL)flexShrink
{
  ASDN::MutexLocker l(_propertyLock);
  return _flexShrink;
}

- (void)setFlexShrink:(BOOL)flexShrink
{
  ASDN::MutexLocker l(_propertyLock);
  _flexShrink = flexShrink;
}

- (ASRelativeDimension)flexBasis
{
  ASDN::MutexLocker l(_propertyLock);
  return _flexBasis;
}

- (void)setFlexBasis:(ASRelativeDimension)flexBasis
{
  ASDN::MutexLocker l(_propertyLock);
  _flexBasis = flexBasis;
}

- (ASStackLayoutAlignSelf)alignSelf
{
  ASDN::MutexLocker l(_propertyLock);
  return _alignSelf;
}

- (void)setAlignSelf:(ASStackLayoutAlignSelf)alignSelf
{
  ASDN::MutexLocker l(_propertyLock);
  _alignSelf = alignSelf;
}

- (CGFloat)ascender
{
  ASDN::MutexLocker l(_propertyLock);
  return _ascender;
}

- (void)setAscender:(CGFloat)ascender
{
  ASDN::MutexLocker l(_propertyLock);
  _ascender = ascender;
}

- (CGFloat)descender
{
  ASDN::MutexLocker l(_propertyLock);
  return _descender;
}

- (void)setDescender:(CGFloat)descender
{
  ASDN::MutexLocker l(_propertyLock);
  _descender = descender;
}

- (ASRelativeSizeRange)sizeRange
{
  ASDN::MutexLocker l(_propertyLock);
  return _sizeRange;
}

- (void)setSizeRange:(ASRelativeSizeRange)sizeRange
{
  ASDN::MutexLocker l(_propertyLock);
  _sizeRange = sizeRange;
}

- (CGPoint)layoutPosition
{
  ASDN::MutexLocker l(_propertyLock);
  return _layoutPosition;
}

- (void)setLayoutPosition:(CGPoint)layoutPosition
{
  ASDN::MutexLocker l(_propertyLock);
  _layoutPosition = layoutPosition;
}

@end