#import <Foundation/Foundation.h>
#import <CoreFoundation/CoreFoundation.h>
#import <UIKit/UIKit.h>
#import <UIKit/UIApplication.h>
#import <UIKit/UIScroller.h>
#import <UIKit/UIView-Hierarchy.h>
#import <LayerKit/LayerKit.h>
#import <LayerKit/LKScrollLayer.h>
#import <GraphicsServices/GraphicsServices.h>

/* Number of pixels scrolled before next cover comes front */
#define SCROLL_PIXELS 60.0

/* Size of each cover */
#define COVER_WIDTH_HEIGHT 128.0

@interface CFView : UIScroller
{
    BOOL beating;
}
- (id) initWithFrame:(struct CGRect)frame;
- (void) mouseDragged:(GSEvent*)event;
- (void) heartbeatCallback;
@end

@interface CovertFlowApplication : UIApplication
{
    UIWindow *window;
    CFView *mainView;
    LKScrollLayer *cfIntLayer;
    NSMutableArray *pictures;
    int selected;
}
+ (CovertFlowApplication *)sharedInstance;
- (void) jumpToCover:(int)index;
- (void) layoutLayer:(LKScrollLayer *)layer;
@end

#import <CoreFoundation/CoreFoundation.h>
#import <Foundation/Foundation.h>
#import <UIKit/CDStructures.h>
#import <UIKit/UIWindow.h>
#import <UIKit/UIView.h>
#import <UIKit/UIView-Hierarchy.h>
#import <UIKit/UIHardware.h>
#import <UIKit/UIResponder.h>
#import <GraphicsServices/GraphicsServices.h>
#import <UIKit/UIView-Geometry.h>
#import <CoreGraphics/CGGeometry.h>
#import <UIKit/UIKit.h>
#import <LayerKit/LayerKit.h>
#import <LayerKit/LKLayer.h>
#import <LayerKit/LKScrollLayer.h>
#import <LayerKit/LKAnimation.h>
#import <LayerKit/LKTransition.h>
#import <LayerKit/LKTransaction.h>
#import <LayerKit/LKTimingFunction.h>
#import "CovertFlow.h"
#import "math.h"

static CovertFlowApplication *sharedInstance;

int main(int argc, char **argv)
{
    NSAutoreleasePool *autoreleasePool = [
        [ NSAutoreleasePool alloc ] init
    ];
    int returnCode = UIApplicationMain(argc, argv,
        [ CovertFlowApplication class ]);
    [ autoreleasePool release ];
    return returnCode;
}

@implementation CFView
-(id)initWithFrame:(struct CGRect)frame
{
    if ((self == [super initWithFrame: frame]) != nil) {
        [self setTapDelegate:self];
        [self setDelegate:self];
        beating = NO;
        [ self startHeartbeat: @selector(heartbeatCallback) inRunLoopMode:nil ];
    }
    return self;
}

- (void) mouseDragged:(GSEvent*)event
{
    if (beating == NO) {

       /* User started flicking through covers.
        * Start a heartbeat to update the coverflow
        */

        beating = YES;
        [ self startHeartbeat: @selector(heartbeatCallback) inRunLoopMode:nil ];
    }
    [ super mouseDragged: event ];
}

- (void)heartbeatCallback
{
    [ [ CovertFlowApplication sharedInstance ]
       jumpToCover:(int) roundf(([ self offset ].y/SCROLL_PIXELS))
    ];

    if (! [self isScrolling] )
    {
        /* Stop the heartbeat when scrolling stops */
        [ self stopHeartbeat: @selector(heartbeatCallback) ];
        beating = NO;
    }
}
@end

@implementation CovertFlowApplication
+ (CovertFlowApplication *)sharedInstance
{
    if (!sharedInstance) {
        sharedInstance = [ [ CovertFlowApplication alloc ] init ];
    }
    return sharedInstance;
}

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification
{
    UIImageView *background;
    CGRect rect;
    NSString *file, *path;
    NSDirectoryEnumerator *dirEnum;
    int i, j;

    /* Read the pictures directory */
    path = [ [ NSString alloc ] initWithString:
       @"/var/root/Media/DCIM/100APPLE" ];
    pictures = [ [ NSMutableArray alloc] init ];
    dirEnum = [ [ NSFileManager defaultManager ] enumeratorAtPath: path ];
    while ((file = [ dirEnum nextObject ])) {
        if ( [ [ file pathExtension ] isEqualToString: @"THM" ])
        {
            [ pictures addObject: [ [ NSString alloc ] initWithString:
                [ path stringByAppendingPathComponent: file ] ] ];
        }
    }
    j = [ pictures count ];

    window = [ [ UIWindow alloc ] initWithContentRect:
        [ UIHardware fullScreenApplicationContentRect ] ];

    rect = [ UIHardware fullScreenApplicationContentRect ];
    rect.origin.x = rect.origin.y = 0.0f;

    sharedInstance = self;
    mainView = [ [ CFView alloc ] initWithFrame: rect ];

    /* Set the # of pixels to drag before the scroller moves */
    [ mainView setScrollHysteresis: 64.0 ];

    /* Disable rubber banding */
    [ mainView setAllowsFourWayRubberBanding: NO ];

    /* Cause the scroller to become stiffer */
    [ mainView setScrollDecelerationFactor: 0.9999 ];

    /* Set the scroll view to snap to pixel boundaries */
    [ mainView setGridSize:CGSizeMake(SCROLL_PIXELS, SCROLL_PIXELS) ];

    [ window setContentView: mainView ];
    [ window orderFront: self ];
    [ window makeKey: self ];
    [ window _setHidden: NO ];

    /* Initialize the CovertFlow layer */
    cfIntLayer = [ [ LKScrollLayer alloc ] initWithBounds:
        CGRectMake(0, 0, rect.size.width, rect.size.height + 128)
    ];
    [ cfIntLayer setDelegate:self ];

    /* Position the CovertFlow layer in the middle of the scroll view */
    cfIntLayer.position = CGPointMake(160, 304);
    [ cfIntLayer setDelegate:self ];

    /* Load the album covers */
    for (i=0; i<j; i++) {
        NSString *filename = [ pictures objectAtIndex: i ];

        background = [ [ [ UIImageView alloc ] initWithFrame:
                CGRectMake(0, 0, COVER_WIDTH_HEIGHT, COVER_WIDTH_HEIGHT)
            ]
            autorelease
        ];
        [ background setImage: [ [ UIImage alloc ]
initWithContentsOfFile: filename ] ];
        [ cfIntLayer addSublayer: [ background _layer ] ];
    }

    /* Set the size of the scroll view proportionately to the # covers */
    [ mainView setContentSize:
        CGSizeMake(320, ( (rect.size.height) + (SCROLL_PIXELS*j) ) )
    ];

    /* Add the album layer to the main layer */
    selected = 0;
    [ [ mainView _layer ] addSublayer:cfIntLayer ];
    [ self layoutLayer: cfIntLayer ];
}

- (void) jumpToCover:(int)index
{
    if (index != selected) {
        selected = index;
        [ self layoutLayer:cfIntLayer ];
    }
}

-(void) layoutLayer:(LKScrollLayer *)layer
{
    LKLayer *sublayer;
    NSArray *array;
    size_t i, count;
    CGRect rect, cfImageRect;
    NSSize cellSize, spacing, margin;
    CGSize size;
    LKTransform leftTransform, rightTransform, sublayerTransform;
    float zCenterPosition, zSidePosition;
    float sideSpacingFactor, rowScaleFactor;
    float angle = 1.39;
    int x;

    size = [ layer bounds ].size;

    zCenterPosition = 60;      /* Z-Position of selected cover */
    zSidePosition = 0;         /* Default Z-Position for other covers */
    sideSpacingFactor = .85;   /* How close should slide covers be */
    rowScaleFactor = .55;      /* Distance between main cover and side covers */

    leftTransform = LKTransformMakeRotation(angle, −1, 0, 0);
    rightTransform = LKTransformMakeRotation(-angle, −1, 0, 0);

    margin   = NSMakeSize(5.0, 5.0);
    spacing  = NSMakeSize(5.0, 5.0);
    cellSize = NSMakeSize (COVER_WIDTH_HEIGHT, COVER_WIDTH_HEIGHT);

    margin.width += (size.width - cellSize.width * [ pictures count ]
                  -  spacing.width * ([ pictures count ] - 1)) * .5;
    margin.width = floor (margin.width);

    /* Build an array of covers */
    array = [ layer sublayers ];
    count = [ array count ];

    sublayerTransform = LKTransformIdentity;
    /* Set perspective */
    sublayerTransform.m34 = −0.006;

    /* Begin an LKTransaction so that all animations happen simultaneously */
    [ LKTransaction begin ];
    [ LKTransaction setValue: [ NSNumber numberWithFloat:0.3f ]
        forKey:@"animationDuration" ];

    for (i = 0; i < count; i++)
    {
        sublayer = [ array objectAtIndex:i ];
        x = i;

        rect.size = *(CGSize *)&cellSize;
        rect.origin = CGPointZero;
        cfImageRect = rect;

        /* Base position */
        rect.origin.x = size.width / 2 - cellSize.width / 2;
        rect.origin.y = margin.height + x * (cellSize.height + spacing.height);

        [ [ sublayer superlayer ] setSublayerTransform: sublayerTransform ];

        if (x < selected)        /* Left side */
        {
            rect.origin.y += cellSize.height * sideSpacingFactor
                           * (float) (selected - x - rowScaleFactor);
            sublayer.zPosition = zSidePosition - 2.0 * (selected - x);
            sublayer.transform = leftTransform;
        }
        else if (x > selected)   /* Right side */
        {
            rect.origin.y -= cellSize.height * sideSpacingFactor
                           * (float) (x - selected - rowScaleFactor);
            sublayer.zPosition = zSidePosition - 2.0 * (x - selected);
            sublayer.transform = rightTransform;
        }
        else                     /* Selected cover */
        {
            sublayer.transform = LKTransformIdentity;
            sublayer.zPosition = zCenterPosition;

            /* Position in the middle of the scroll layer */
            [ layer scrollToPoint: CGPointMake(0, rect.origin.y
                - (([ layer bounds ].size.height - cellSize.width)/2.0))
            ];

            /* Position the scroll layer in the center of the view */
            layer.position =
                CGPointMake(160.0f, 240.0f + (selected * SCROLL_PIXELS));
        }
        [ sublayer setFrame: rect ];

    }
    [ LKTransaction commit ];
}

@end