#import "iCarousel.h"

#import <objc/message.h>

#import <Availability.h>

#if !__has_feature(objc_arc)

#error This class requires automatic reference counting

#endif

#define MIN_TOGGLE_DURATION 0.2

#define MAX_TOGGLE_DURATION 0.4

#define SCROLL_DURATION 0.4

#define INSERT_DURATION 0.4

#define DECELERATE_THRESHOLD 0.1f

#define SCROLL_SPEED_THRESHOLD 2.0f

#define SCROLL_DISTANCE_THRESHOLD 0.1f

#define DECELERATION_MULTIPLIER 30.0f

#ifdef ICAROUSEL_MACOS

#define MAX_VISIBLE_ITEMS 50

#else

#define MAX_VISIBLE_ITEMS 30

#endif

@implementation NSObject (iCarousel)

- (NSUInteger)numberOfPlaceholdersInCarousel:(__unused iCarousel *)carousel { return 0; }

- (void)carouselWillBeginScrollingAnimation:(__unused iCarousel *)carousel {}

- (void)carouselDidEndScrollingAnimation:(__unused iCarousel *)carousel {}

- (void)carouselDidScroll:(__unused iCarousel *)carousel {}

- (void)carouselCurrentItemIndexDidChange:(__unused iCarousel *)carousel {}

- (void)carouselWillBeginDragging:(__unused iCarousel *)carousel {}

- (void)carouselDidEndDragging:(__unused iCarousel *)carousel willDecelerate:(__unused BOOL)decelerate {}

- (void)carouselWillBeginDecelerating:(__unused iCarousel *)carousel {}

- (void)carouselDidEndDecelerating:(__unused iCarousel *)carousel {}

- (BOOL)carousel:(__unused iCarousel *)carousel shouldSelectItemAtIndex:(__unused NSInteger)index { return YES; }

- (void)carousel:(__unused iCarousel *)carousel didSelectItemAtIndex:(__unused NSInteger)index {}

- (CGFloat)carouselItemWidth:(__unused iCarousel *)carousel { return 0; }

- (CATransform3D)carousel:(__unused iCarousel *)carousel

itemTransformForOffset:(__unused CGFloat)offset

baseTransform:(CATransform3D)transform { return transform; }

- (CGFloat)carousel:(__unused iCarousel *)carousel

valueForOption:(__unused iCarouselOption)option

withDefault:(CGFloat)value { return value; }

@interface iCarousel ()

@property (nonatomic, strong) UIView *contentView;

@property (nonatomic, strong) NSMutableDictionary *itemViews;

@property (nonatomic, strong) NSMutableSet *itemViewPool;

@property (nonatomic, strong) NSMutableSet *placeholderViewPool;

@property (nonatomic, assign) NSInteger previousItemIndex;

@property (nonatomic, assign) NSInteger numberOfPlaceholdersToShow;

@property (nonatomic, assign) NSInteger numberOfVisibleItems;

@property (nonatomic, assign) CGFloat itemWidth;

@property (nonatomic, assign) CGFloat offsetMultiplier;

@property (nonatomic, assign) CGFloat startOffset;

@property (nonatomic, assign) CGFloat endOffset;

@property (nonatomic, assign) NSTimeInterval scrollDuration;

@property (nonatomic, assign, getter = isScrolling) BOOL scrolling;

@property (nonatomic, assign) NSTimeInterval startTime;

@property (nonatomic, assign) NSTimeInterval lastTime;

@property (nonatomic, assign) CGFloat startVelocity;

@property (nonatomic, strong) NSTimer *timer;

@property (nonatomic, assign, getter = isDecelerating) BOOL decelerating;

@property (nonatomic, assign) CGFloat previousTranslation;

@property (nonatomic, assign, getter = isWrapEnabled) BOOL wrapEnabled;

@property (nonatomic, assign, getter = isDragging) BOOL dragging;

@property (nonatomic, assign) BOOL didDrag;

@property (nonatomic, assign) NSTimeInterval toggleTime;

NSComparisonResult compareViewDepth(UIView *view1, UIView *view2, iCarousel *self);

@implementation iCarousel

#pragma mark -

#pragma mark Initialisation

- (void)setUp

{

_decelerationRate = 0.95f;

_scrollEnabled = YES;

_bounces = YES;

_offsetMultiplier = 1.0f;

_perspective = -1.0f/500.0f;

_contentOffset = CGSizeZero;

_viewpointOffset = CGSizeZero;

_scrollSpeed = 1.0f;

_bounceDistance = 1.0f;

_stopAtItemBoundary = YES;

_scrollToItemBoundary = YES;

_ignorePerpendicularSwipes = YES;

_centerItemWhenSelected = YES;

_contentView = [[UIView alloc] initWithFrame:self.bounds];

#ifdef ICAROUSEL_IOS

_contentView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;

if (!_disableGesture) {

//add pan gesture recogniser

UIPanGestureRecognizer *panGesture = [[UIPanGestureRecognizer alloc] initWithTarget:self action:@selector(didPan:)];

panGesture.delegate = (id <UIGestureRecognizerDelegate>)self;

[_contentView addGestureRecognizer:panGesture];

//add tap gesture recogniser

UITapGestureRecognizer *tapGesture = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(didTap:)];

tapGesture.delegate = (id <UIGestureRecognizerDelegate>)self;

[_contentView addGestureRecognizer:tapGesture];

}

#else

[_contentView setWantsLayer:YES];

#endif

[self addSubview:_contentView];

if (_dataSource)

{

[self reloadData];

}

}

#ifndef USING_CHAMELEON

- (id)initWithCoder:(NSCoder *)aDecoder

{

if ((self = [super initWithCoder:aDecoder]))

{

[self setUp];

[self didMoveToSuperview];

}

return self;

}

#endif

#ifdef ICAROUSEL_IOS

- (id)initWithFrame:(CGRect)frame

{

if ((self = [super initWithFrame:frame]))

{

[self setUp];

}

return self;

}

#else

- (id)initWithFrame:(NSRect)frame

{

if ((self = [super initWithFrame:frame]))

{

[self setUp];

}

return self;

}

#endif

- (void)dealloc

{

[self stopAnimation];

}

- (void)setDataSource:(id<iCarouselDataSource>)dataSource

{

if (_dataSource != dataSource)

{

_dataSource = dataSource;

if (_dataSource)

{

[self reloadData];

}

}

}

- (void)setDelegate:(id<iCarouselDelegate>)delegate

{

if (_delegate != delegate)

{

_delegate = delegate;

if (_delegate && _dataSource)

{

[self setNeedsLayout];

}

}

}

- (void)setType:(iCarouselType)type

{

if (_type != type)

{

_type = type;

[self layOutItemViews];

}

}

- (void)setVertical:(BOOL)vertical

{

if (_vertical != vertical)

{

_vertical = vertical;

[self layOutItemViews];

}

}

- (void)setScrollOffset:(CGFloat)scrollOffset

{

_scrolling = NO;

_decelerating = NO;

_startOffset = scrollOffset;

_endOffset = scrollOffset;

if (_scrollOffset != scrollOffset)

{

_scrollOffset = scrollOffset;

[self depthSortViews];

[self didScroll];

}

}

- (void)setCurrentItemIndex:(NSInteger)currentItemIndex

{

[self setScrollOffset:currentItemIndex];

}

- (void)setPerspective:(CGFloat)perspective

{

if (_perspective != perspective)

{

_perspective = perspective;

[self transformItemViews];

}

}

- (void)setViewpointOffset:(CGSize)viewpointOffset

{

if (!CGSizeEqualToSize(_viewpointOffset, viewpointOffset))

{

_viewpointOffset = viewpointOffset;

[self transformItemViews];

}

}

- (void)setContentOffset:(CGSize)contentOffset

{

if (!CGSizeEqualToSize(_contentOffset, contentOffset))

{

_contentOffset = contentOffset;

[self layOutItemViews];

}

}

- (void)setAutoscroll:(CGFloat)autoscroll

{

if (_autoscroll != autoscroll)

{

_autoscroll = autoscroll;

if (autoscroll != 0.0f) [self startAnimation];

}

}

- (void)pushAnimationState:(BOOL)enabled

{

[CATransaction begin];

[CATransaction setDisableActions:!enabled];

}

- (void)popAnimationState

{

[CATransaction commit];

}

#pragma mark -

#pragma mark View management

- (NSArray *)indexesForVisibleItems

{

return [[_itemViews allKeys] sortedArrayUsingSelector:@selector(compare:)];

}

- (NSArray *)visibleItemViews

{

NSArray *indexes = [self indexesForVisibleItems];

return [_itemViews objectsForKeys:indexes notFoundMarker:[NSNull null]];

}

- (UIView *)itemViewAtIndex:(NSInteger)index

{

return _itemViews[@(index)];

}

- (UIView *)currentItemView

{

return [self itemViewAtIndex:self.currentItemIndex];

}

- (NSInteger)indexOfItemView:(UIView *)view

{

NSInteger index = [[_itemViews allValues] indexOfObject:view];

if (index != NSNotFound)

{

return [[_itemViews allKeys][index] integerValue];

}

return NSNotFound;

}

- (NSInteger)indexOfItemViewOrSubview:(UIView *)view

{

NSInteger index = [self indexOfItemView:view];

if (index == NSNotFound && view != nil && view != _contentView)

{

return [self indexOfItemViewOrSubview:view.superview];

}

return index;

}

- (UIView *)itemViewAtPoint:(CGPoint)point

{

for (UIView *view in [[[_itemViews allValues] sortedArrayUsingFunction:(NSInteger (*)(id, id, void *))compareViewDepth context:(__bridge void *)self] reverseObjectEnumerator])

{

if ([view.superview.layer hitTest:point])

{

return view;

}

}

return nil;

}

- (void)setItemView:(UIView *)view forIndex:(NSInteger)index

{

_itemViews[@(index)] = view;

}

- (void)removeViewAtIndex:(NSInteger)index

{

NSMutableDictionary *newItemViews = [NSMutableDictionary dictionaryWithCapacity:[_itemViews count] - 1];

for (NSNumber *number in [self indexesForVisibleItems])

{

NSInteger i = [number integerValue];

if (i < index)

{

newItemViews[number] = _itemViews[number];

}

else if (i > index)

{

newItemViews[@(i - 1)] = _itemViews[number];

}

}

self.itemViews = newItemViews;

}

- (void)insertView:(UIView *)view atIndex:(NSInteger)index

{

NSMutableDictionary *newItemViews = [NSMutableDictionary dictionaryWithCapacity:[_itemViews count] + 1];

for (NSNumber *number in [self indexesForVisibleItems])

{

NSInteger i = [number integerValue];

if (i < index)

{

newItemViews[number] = _itemViews[number];

}

else

{

newItemViews[@(i + 1)] = _itemViews[number];

}

}

if (view)

{

[self setItemView:view forIndex:index];

}

self.itemViews = newItemViews;

}

#pragma mark -

#pragma mark View layout

- (CGFloat)alphaForItemWithOffset:(CGFloat)offset

{

CGFloat fadeMin = -INFINITY;

CGFloat fadeMax = INFINITY;

CGFloat fadeRange = 1.0f;

CGFloat fadeMinAlpha = 0.0f;

switch (_type)

{

case iCarouselTypeTimeMachine:

{

fadeMax = 0.0f;

break;

}

case iCarouselTypeInvertedTimeMachine:

{

fadeMin = 0.0f;

break;

}

default:

{

//do nothing

}

}

fadeMin = [self valueForOption:iCarouselOptionFadeMin withDefault:fadeMin];

fadeMax = [self valueForOption:iCarouselOptionFadeMax withDefault:fadeMax];

fadeRange = [self valueForOption:iCarouselOptionFadeRange withDefault:fadeRange];

fadeMinAlpha = [self valueForOption:iCarouselOptionFadeMinAlpha withDefault:fadeMinAlpha];

#ifdef ICAROUSEL_MACOS

if (_vertical)

{

//invert

offset = -offset;

}

#endif

CGFloat factor = 0.0f;

if (offset > fadeMax)

{

factor = offset - fadeMax;

}

else if (offset < fadeMin)

{

factor = fadeMin - offset;

}

return 1.0f - fminf(factor, fadeRange) / fadeRange * (1.0f - fadeMinAlpha);

}

- (CGFloat)valueForOption:(iCarouselOption)option withDefault:(CGFloat)value

{

return _delegate? [_delegate carousel:self valueForOption:option withDefault:value]: value;

}

- (CATransform3D)transformForItemViewWithOffset:(CGFloat)offset

{

//set up base transform

CATransform3D transform = CATransform3DIdentity;

transform.m34 = _perspective;

transform = CATransform3DTranslate(transform, -_viewpointOffset.width, -_viewpointOffset.height, 0.0f);

//perform transform

switch (_type)

{

case iCarouselTypeCustom:

{

return [_delegate carousel:self itemTransformForOffset:offset baseTransform:transform];

}

case iCarouselTypeLinear:

{

CGFloat spacing = [self valueForOption:iCarouselOptionSpacing withDefault:1.0f];

if (_vertical)

{

return CATransform3DTranslate(transform, 0.0f, offset * _itemWidth * spacing, 0.0f);

}

else

{

return CATransform3DTranslate(transform, offset * _itemWidth * spacing, 0.0f, 0.0f);

}

}

case iCarouselTypeRotary:

case iCarouselTypeInvertedRotary:

{

CGFloat count = [self circularCarouselItemCount];

CGFloat spacing = [self valueForOption:iCarouselOptionSpacing withDefault:1.0f];

CGFloat arc = [self valueForOption:iCarouselOptionArc withDefault:M_PI * 2.0f];

CGFloat radius = [self valueForOption:iCarouselOptionRadius withDefault:fmaxf(_itemWidth * spacing / 2.0f, _itemWidth * spacing / 2.0f / tanf(arc/2.0f/count))];

CGFloat angle = [self valueForOption:iCarouselOptionAngle withDefault:offset / count * arc];

if (_type == iCarouselTypeInvertedRotary)

{

radius = -radius;

angle = -angle;

}

if (_vertical)

{

return CATransform3DTranslate(transform, 0.0f, radius * sin(angle), radius * cos(angle) - radius);

}

else

{

return CATransform3DTranslate(transform, radius * sin(angle), 0.0f, radius * cos(angle) - radius);

}

}

case iCarouselTypeCylinder:

case iCarouselTypeInvertedCylinder:

{

CGFloat count = [self circularCarouselItemCount];

CGFloat spacing = [self valueForOption:iCarouselOptionSpacing withDefault:1.0f];

CGFloat arc = [self valueForOption:iCarouselOptionArc withDefault:M_PI * 2.0f];

CGFloat radius = [self valueForOption:iCarouselOptionRadius withDefault:fmaxf(0.01f, _itemWidth * spacing / 2.0f / tanf(arc/2.0f/count))];

CGFloat angle = [self valueForOption:iCarouselOptionAngle withDefault:offset / count * arc];

if (_type == iCarouselTypeInvertedCylinder)

{

radius = -radius;

angle = -angle;

}

if (_vertical)

{

transform = CATransform3DTranslate(transform, 0.0f, 0.0f, -radius);

transform = CATransform3DRotate(transform, angle, -1.0f, 0.0f, 0.0f);

return CATransform3DTranslate(transform, 0.0f, 0.0f, radius + 0.01f);

}

else

{

transform = CATransform3DTranslate(transform, 0.0f, 0.0f, -radius);

transform = CATransform3DRotate(transform, angle, 0.0f, 1.0f, 0.0f);

return CATransform3DTranslate(transform, 0.0f, 0.0f, radius + 0.01f);

}

}

case iCarouselTypeWheel:

case iCarouselTypeInvertedWheel:

{

CGFloat count = [self circularCarouselItemCount];

CGFloat spacing = [self valueForOption:iCarouselOptionSpacing withDefault:1.0f];

CGFloat arc = [self valueForOption:iCarouselOptionArc withDefault:M_PI * 2.0f];

CGFloat radius = [self valueForOption:iCarouselOptionRadius withDefault:_itemWidth * spacing * count / arc];

CGFloat angle = [self valueForOption:iCarouselOptionAngle withDefault:arc / count];

if (_type == iCarouselTypeInvertedWheel)

{

radius = -radius;

angle = -angle;

}

if (_vertical)

{

transform = CATransform3DTranslate(transform, -radius, 0.0f, 0.0f);

transform = CATransform3DRotate(transform, angle * offset, 0.0f, 0.0f, 1.0f);

return CATransform3DTranslate(transform, radius, 0.0f, offset * 0.01f);

}

else

{

transform = CATransform3DTranslate(transform, 0.0f, radius, 0.0f);

transform = CATransform3DRotate(transform, angle * offset, 0.0f, 0.0f, 1.0f);

return CATransform3DTranslate(transform, 0.0f, -radius, offset * 0.01f);

}

}

case iCarouselTypeCoverFlow:

case iCarouselTypeCoverFlow2:

{

CGFloat tilt = [self valueForOption:iCarouselOptionTilt withDefault:0.9f];

CGFloat spacing = [self valueForOption:iCarouselOptionSpacing withDefault:0.25f];

CGFloat clampedOffset = fmaxf(-1.0f, fminf(1.0f, offset));

if (_type == iCarouselTypeCoverFlow2)

{

if (_toggle >= 0.0f)

{

if (offset <= -0.5f)

{

clampedOffset = -1.0f;

}

else if (offset <= 0.5f)

{

clampedOffset = -_toggle;

}

else if (offset <= 1.5f)

{

clampedOffset = 1.0f - _toggle;

}

}

else

{

if (offset > 0.5f)

{

clampedOffset = 1.0f;

}

else if (offset > -0.5f)

{

clampedOffset = -_toggle;

}

else if (offset > -1.5f)

{

clampedOffset = - 1.0f - _toggle;

}

}

}

CGFloat x = (clampedOffset * 0.5f * tilt + offset * spacing) * _itemWidth;

CGFloat z = fabs(clampedOffset) * -_itemWidth * 0.5f;

if (_vertical)

{

transform = CATransform3DTranslate(transform, 0.0f, x, z);

return CATransform3DRotate(transform, -clampedOffset * M_PI_2 * tilt, -1.0f, 0.0f, 0.0f);

}

else

{

transform = CATransform3DTranslate(transform, x, 0.0f, z);

return CATransform3DRotate(transform, -clampedOffset * M_PI_2 * tilt, 0.0f, 1.0f, 0.0f);

}

}

case iCarouselTypeTimeMachine:

case iCarouselTypeInvertedTimeMachine:

{

CGFloat tilt = [self valueForOption:iCarouselOptionTilt withDefault:0.3f];

CGFloat spacing = [self valueForOption:iCarouselOptionSpacing withDefault:1.0f];

if (_type == iCarouselTypeInvertedTimeMachine)

{

tilt = -tilt;

offset = -offset;

}

if (_vertical)

{

#ifdef ICAROUSEL_MACOS

//invert again

tilt = -tilt;

offset = -offset;

#endif

return CATransform3DTranslate(transform, 0.0f, offset * _itemWidth * tilt, offset * _itemWidth * spacing);

}

else

{

return CATransform3DTranslate(transform, offset * _itemWidth * tilt, 0.0f, offset * _itemWidth * spacing);

}

}

}

}

NSComparisonResult compareViewDepth(UIView *view1, UIView *view2, iCarousel *self)

{

//compare depths

CATransform3D t1 = view1.superview.layer.transform;

CATransform3D t2 = view2.superview.layer.transform;

CGFloat z1 = t1.m13 + t1.m23 + t1.m33 + t1.m43;

CGFloat z2 = t2.m13 + t2.m23 + t2.m33 + t2.m43;

CGFloat difference = z1 - z2;

//if depths are equal, compare distance from current view

if (difference == 0.0f)

{

CATransform3D t3 = [self currentItemView].superview.layer.transform;

if (self.vertical)

{

CGFloat y1 = t1.m12 + t1.m22 + t1.m32 + t1.m42;

CGFloat y2 = t2.m12 + t2.m22 + t2.m32 + t2.m42;

CGFloat y3 = t3.m12 + t3.m22 + t3.m32 + t3.m42;

difference = fabs(y2 - y3) - fabs(y1 - y3);

}

else

{

CGFloat x1 = t1.m11 + t1.m21 + t1.m31 + t1.m41;

CGFloat x2 = t2.m11 + t2.m21 + t2.m31 + t2.m41;

CGFloat x3 = t3.m11 + t3.m21 + t3.m31 + t3.m41;

difference = fabs(x2 - x3) - fabs(x1 - x3);

}

}

return (difference < 0.0f)? NSOrderedAscending: NSOrderedDescending;

}

#ifdef ICAROUSEL_IOS

- (void)depthSortViews

{

for (UIView *view in [[_itemViews allValues] sortedArrayUsingFunction:(NSInteger (*)(id, id, void *))compareViewDepth context:(__bridge void *)self])

{

[_contentView bringSubviewToFront:view.superview];

}

}

#else

- (void)setNeedsLayout

{

[self setNeedsLayout:YES];

}

- (void)depthSortViews

{

//does nothing on Mac OS

}

#endif

- (CGFloat)offsetForItemAtIndex:(NSInteger)index

{

//calculate relative position

CGFloat offset = index - _scrollOffset;

if (_wrapEnabled)

{

if (offset > _numberOfItems/2.0f)

{

offset -= _numberOfItems;

}

else if (offset < -_numberOfItems/2.0f)

{

offset += _numberOfItems;

}

}

//handle special case for one item

if (_numberOfItems + _numberOfPlaceholdersToShow == 1)

{

offset = 0.0f;

}

#ifdef ICAROUSEL_MACOS

if (_vertical)

{

//invert transform

offset = -offset;

}

#endif

return offset;

}

- (UIView *)containView:(UIView *)view

{

//set item width

if (!_itemWidth)

{

_itemWidth = _vertical? view.bounds.size.height: view.bounds.size.width;

}

//set container frame

CGRect frame = view.bounds;

frame.size.width = _vertical? frame.size.width: _itemWidth;

frame.size.height = _vertical? _itemWidth: frame.size.height;

UIView *containerView = [[UIView alloc] initWithFrame:frame];

#ifdef ICAROUSEL_MACOS

//clipping works differently on Mac OS

[containerView setBoundsSize:view.frame.size];

#endif

//set view frame

frame = view.frame;

frame.origin.x = (containerView.bounds.size.width - frame.size.width) / 2.0f;

frame.origin.y = (containerView.bounds.size.height - frame.size.height) / 2.0f;

view.frame = frame;

[containerView addSubview:view];

return containerView;

}

- (void)transformItemView:(UIView *)view atIndex:(NSInteger)index

{

//calculate offset

CGFloat offset = [self offsetForItemAtIndex:index];

#ifdef ICAROUSEL_IOS

//center view

view.superview.center = CGPointMake(self.bounds.size.width/2.0f + _contentOffset.width,

self.bounds.size.height/2.0f + _contentOffset.height);

//update alpha

view.superview.alpha = [self alphaForItemWithOffset:offset];

//enable/disable interaction

view.superview.userInteractionEnabled = (!_centerItemWhenSelected || index == self.currentItemIndex);

#else

//center view

[view.superview setFrameOrigin:NSMakePoint(self.bounds.size.width/2.0f + _contentOffset.width,

self.bounds.size.height/2.0f + _contentOffset.height)];

view.superview.layer.anchorPoint = CGPointMake(0.5f, 0.5f);

//update alpha

[view.superview setAlphaValue:[self alphaForItemWithOffset:offset]];

#endif

//special-case logic for iCarouselTypeCoverFlow2

CGFloat clampedOffset = fmaxf(-1.0f, fminf(1.0f, offset));

if (_decelerating || (_scrolling && !_didDrag) || (_scrollOffset - [self clampedOffset:_scrollOffset]) != 0.0f)

{

if (offset > 0)

{

_toggle = (offset <= 0.5f)? -clampedOffset: (1.0f - clampedOffset);

}

else

{

_toggle = (offset > -0.5f)? -clampedOffset: (- 1.0f - clampedOffset);

}

}

//calculate transform

CATransform3D transform = [self transformForItemViewWithOffset:offset];

//transform view

view.superview.layer.transform = transform;

//backface culling

BOOL showBackfaces = view.layer.doubleSided;

if (showBackfaces)

{

switch (_type)

{

case iCarouselTypeInvertedCylinder:

{

showBackfaces = NO;

break;

}

default:

{

showBackfaces = YES;

break;

}

}

}

showBackfaces = !![self valueForOption:iCarouselOptionShowBackfaces withDefault:showBackfaces];

//we can't just set the layer.doubleSided property because it doesn't block interaction

//instead we'll calculate if the view is front-facing based on the transform

view.superview.hidden = !(showBackfaces ?: (transform.m33 > 0.0f));

}

#ifdef ICAROUSEL_MACOS

- (void)resizeSubviewsWithOldSize:(NSSize)oldSize

{

[self pushAnimationState:NO];

_contentView.frame = self.bounds;

[self layOutItemViews];

[self popAnimationState];

}

#else

- (void)layoutSubviews

{

[super layoutSubviews];

_contentView.frame = self.bounds;

[self layOutItemViews];

}

#endif

- (void)transformItemViews

{

for (NSNumber *number in _itemViews)

{

NSInteger index = [number integerValue];

UIView *view = _itemViews[number];

[self transformItemView:view atIndex:index];

}

}

- (void)updateItemWidth

{

_itemWidth = [_delegate carouselItemWidth:self] ?: _itemWidth;

if (_numberOfItems > 0)

{

if ([_itemViews count] == 0)

{

[self loadViewAtIndex:0];

}

}

else if (_numberOfPlaceholders > 0)

{

if ([_itemViews count] == 0)

{

[self loadViewAtIndex:-1];

}

}

}

- (void)updateNumberOfVisibleItems

{

//get number of visible items

switch (_type)

{

case iCarouselTypeLinear:

{

//exact number required to fill screen

CGFloat spacing = [self valueForOption:iCarouselOptionSpacing withDefault:1.0f];

CGFloat width = _vertical ? self.bounds.size.height: self.bounds.size.width;

CGFloat itemWidth = _itemWidth * spacing;

_numberOfVisibleItems = ceilf(width / itemWidth) + 2;

break;

}

case iCarouselTypeCoverFlow:

case iCarouselTypeCoverFlow2:

{

//exact number required to fill screen

CGFloat spacing = [self valueForOption:iCarouselOptionSpacing withDefault:0.25f];

CGFloat width = _vertical ? self.bounds.size.height: self.bounds.size.width;

CGFloat itemWidth = _itemWidth * spacing;

_numberOfVisibleItems = ceilf(width / itemWidth) + 2;

break;

}

case iCarouselTypeRotary:

case iCarouselTypeCylinder:

{

//based on count value

_numberOfVisibleItems = [self circularCarouselItemCount];

break;

}

case iCarouselTypeInvertedRotary:

case iCarouselTypeInvertedCylinder:

{

//TODO: improve this

_numberOfVisibleItems = ceilf([self circularCarouselItemCount] / 2.0f);

break;

}

case iCarouselTypeWheel:

case iCarouselTypeInvertedWheel:

{

//TODO: improve this

CGFloat count = [self circularCarouselItemCount];

CGFloat spacing = [self valueForOption:iCarouselOptionSpacing withDefault:1.0f];

CGFloat arc = [self valueForOption:iCarouselOptionArc withDefault:M_PI * 2.0f];

CGFloat radius = [self valueForOption:iCarouselOptionRadius withDefault:_itemWidth * spacing * count / arc];

if (radius - _itemWidth / 2.0f < MIN(self.bounds.size.width, self.bounds.size.height) / 2.0f)

{

_numberOfVisibleItems = count;

}

else

{

_numberOfVisibleItems = ceilf(count / 2.0f) + 1;

}

break;

}

case iCarouselTypeTimeMachine:

case iCarouselTypeInvertedTimeMachine:

case iCarouselTypeCustom:

{

//slightly arbitrary number, chosen for performance reasons

_numberOfVisibleItems = MAX_VISIBLE_ITEMS;

break;

}

}

_numberOfVisibleItems = MIN(MAX_VISIBLE_ITEMS, _numberOfVisibleItems);

_numberOfVisibleItems = [self valueForOption:iCarouselOptionVisibleItems withDefault:_numberOfVisibleItems];

_numberOfVisibleItems = MAX(0, MIN(_numberOfVisibleItems, _numberOfItems + _numberOfPlaceholdersToShow));

}

- (NSInteger)circularCarouselItemCount

{

NSInteger count = 0;

switch (_type)

{

case iCarouselTypeRotary:

case iCarouselTypeInvertedRotary:

case iCarouselTypeCylinder: