/Users/awniemel/Notepad-SVN/svn/trunk/CatNiP/CatNiP/UIDocumentView.m

Go to the documentation of this file.

#import "UIDocumentView.h"

@implementation UIDocumentView

@synthesize preloadFactor;
@synthesize placeholder;
@synthesize delegate;

- (void)setDocument:(UIDocument *)value
{
    // Safely set the new value and release the old one
    [value retain];
    [document release];
    document = value;
    
    // Remove all old UIImageViews
    for(UIView *view in container.subviews)
        [view removeFromSuperview];
    
    // Create new UIImageViews for the pages
    CGPoint pageOrigin = CGPointZero;
    for(int i = 1; i <= document.numberOfPages; ++i)
    {
        // Calculate the frame of the current page: horizontally centered and
        // vertically directly below the last one
        CGSize pageSize = [document getSizeOfPage:i];
        pageOrigin.x = (document.size.width - pageSize.width) / 2;
        CGRect pageRect = CGRectMake(pageOrigin.x, pageOrigin.y, pageSize.width, pageSize.height);
        pageOrigin.y += pageSize.height;
        
        // Create an UIImageView object for the page and add it to the container
        UIImageView *page = [[UIImageView alloc] initWithImage:placeholder];
        page.contentMode = UIViewContentModeCenter;
        page.frame = pageRect;        
        [container addSubview:page];
        [page release];
    }
    
    // Back up zoom scale range
    float minimumZoomScale = self.minimumZoomScale;
    self.minimumZoomScale = 1.0;
    
    float maximumZoomScale = self.maximumZoomScale;
    self.maximumZoomScale = 1.0;
    
    // Reset zoom and offset for a clean container resizing experience
    self.zoomScale = 1.0;
    self.contentOffset = CGPointZero;
    
    container.frame = CGRectMake(0, 0, document.size.width, document.size.height);
    self.contentSize = container.frame.size;
    
    // Restore zoom scale range
    self.minimumZoomScale = minimumZoomScale;
    self.maximumZoomScale = maximumZoomScale;
    
    // Set zoom scale as close to fit-to-width as possible, reset content
    // offset for good measure
    self.zoomScale = self.bounds.size.width / self.document.size.width;
    self.contentOffset = CGPointZero;
}

- (UIDocument *)document
{
    return document;
}

- (id)init
{
    placeholder = nil;
    preloadFactor = 0.0;
    container = [[UIView alloc] init];
    operationQueue = [[NSOperationQueue alloc] init];
    // Fast deceleration is best
    [self setDecelerationRate:UIScrollViewDecelerationRateFast];
    [self addSubview:container];
    [super setDelegate:self];
    return self;
}

- (id)initWithDocument:(UIDocument *)uiDocument
{
    if((self = [super init])) {
        self = [self init];
        self.document = uiDocument;
    }
    return self;
}

- (id)initWithCoder:(NSCoder *)aDecoder
{
    if((self = [super initWithCoder:aDecoder]))
        return [self init];
    else
        return nil;
}

- (id)initWithFrame:(CGRect)frame
{
    if((self = [super initWithFrame:frame]))
        return [self init];
    else
        return nil;
}

- (void)refresh
{
        // Cancel all operations so we don't accidentally load the same page twice
        // (this happens anyway at times thanks to parallelism, but this makes it
        // less bad.)
    [operationQueue cancelAllOperations];
    
    // Calculate the area the pages intersecting with which are loaded into
    // memory
    CGRect cacheView = CGRectMake(
                                 (self.contentOffset.x - self.bounds.size.width  * preloadFactor) / self.zoomScale,
                                 (self.contentOffset.y - self.bounds.size.height * preloadFactor) / self.zoomScale,
                                 (self.bounds.size.width  * (2 * preloadFactor + 1)) / self.zoomScale,
                                 (self.bounds.size.height * (2 * preloadFactor + 1)) / self.zoomScale
                                 );
    CGPoint pageOrigin = CGPointZero;
    
    // Loop through the document's pages
    for(int i = 1; i <= document.numberOfPages; ++i) {
        // Calculate the frame of the page: horizontally centered and vertically
        // directly below the last one
        CGSize pageSize = [document getSizeOfPage:i];
        pageOrigin.x = (document.size.width - pageSize.width) / 2;
        
        UIImageView *page = [container.subviews objectAtIndex:i - 1];
        CGRect pageRect = CGRectMake(pageOrigin.x, pageOrigin.y, pageSize.width, pageSize.height);
        
        // Check if the frame of the page intersects with the area to be loaded
        // into memory
        if(CGRectIntersectsRect(cacheView, pageRect)) {
            // Make sure the page image hasn't been loaded already;
            // if it hasn't, add a load operation to the queue
            if(page.image == placeholder) {
                // Make sure the page image STILL hasn't been loaded into// memory while this operation was sitting in the queue// Load an image into memory and set it as the// page-UIImageView's new image; the setting has to be// done on the main thread so that the OS doesn't// decide to delay it[operationQueue addOperationWithBlock:^{
                        
                        
                    if(page.image == placeholder) {
                        
                        
                        
                        
                        UIImage *image = [document getImageOfPage:i];
                        [page performSelectorOnMainThread:@selector(setImage:) withObject:image waitUntilDone:NO];
                    }
                }];
            }
        }
        else {
                // If the image hasn't been unloaded, do it now. Kind of a
                // redundant check, but it's in place for debugging reasons.
            if(page.image != placeholder) {
                page.image = placeholder;
            }
        }
        
        // Increment the y coordinate of the origin so that the frame of the
        // next page is calculated correctly
        pageOrigin.y += pageSize.height;
    }
}

- (void)centerContent
{
    // Using container.center didn't work for whatever reason, so this had to
    // be done by manually manipulating its frame.
    
    CGFloat x = 0.0;
    if(self.contentSize.width < self.bounds.size.width)
        x = (self.bounds.size.width - self.contentSize.width) / 2;
    
    CGFloat y = 0.0;
    if(self.contentSize.height < self.bounds.size.height)
        y = (self.bounds.size.height - self.contentSize.height) / 2;
    
    container.frame = CGRectMake(x, y, container.frame.size.width, container.frame.size.height);
}

#pragma mark - UIScrollViewDelegate methods for zooming and lazy load.
// These methods are mostly here just to conform to the UIScrollViewDelegate
// protocol and to make the overridden delegate property work properly

- (void)scrollViewDidScroll:(UIScrollView *)scrollView
{
    [self refresh];
    
        if([delegate respondsToSelector:@selector(scrollViewDidScroll:)])
                [delegate scrollViewDidScroll:scrollView];
}

- (UIView *)viewForZoomingInScrollView:(UIScrollView *)scrollView
{
    if([delegate respondsToSelector:@selector(viewForZoomingInScrollView:)])
        return [delegate viewForZoomingInScrollView:scrollView];
    // Zooming only applies to one view object, so it needs to be the container
    return container;
}

- (void)scrollViewDidZoom:(UIScrollView *)scrollView
{
    [self centerContent];
    
    if([delegate respondsToSelector:@selector(scrollViewDidZoom:)])
                [delegate scrollViewDidZoom:scrollView];
}

- (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView
{
        if([delegate respondsToSelector:@selector(scrollViewWillBeginDragging:)])
                        [delegate scrollViewWillBeginDragging:scrollView];
}

- (void)scrollViewDidEndDragging:(UIScrollView *)scrollView willDecelerate:(BOOL)decelerate
{
        if([delegate respondsToSelector:@selector(scrollViewWillEndDragging:)])
                        [delegate scrollViewDidEndDragging:scrollView willDecelerate:decelerate];
}

- (BOOL)scrollViewShouldScrollToTop:(UIScrollView *)scrollView
{
        if([delegate respondsToSelector:@selector(scrollViewShouldScrollToTop:)])
                        return [delegate scrollViewShouldScrollToTop:scrollView];
    return YES;
}

- (void)scrollViewDidScrollToTop:(UIScrollView *)scrollView
{
        if([delegate respondsToSelector:@selector(scrollViewDidScrollToTop:)])
                        [delegate scrollViewDidScrollToTop:scrollView];
}

- (void)scrollViewWillBeginDecelerating:(UIScrollView *)scrollView
{
        if([delegate respondsToSelector:@selector(scrollViewWillBeginDecelerating:)])
                        [delegate scrollViewWillBeginDecelerating:scrollView];
}

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView
{
        if([delegate respondsToSelector:@selector(scrollViewDidEndDecelerating:)])
                        [delegate scrollViewDidEndDecelerating:scrollView];
}

- (void)scrollViewWillBeginZooming:(UIScrollView *)scrollView withView:(UIView *)view
{
        if([delegate respondsToSelector:@selector(scrollViewWillBeginZooming:)])
                        [delegate scrollViewWillBeginZooming:scrollView withView:view];
}

- (void)scrollViewDidEndZooming:(UIScrollView *)scrollView withView:(UIView *)view atScale:(float)scale
{
        if([delegate respondsToSelector:@selector(scrollViewDidEndZooming:)])
                        [delegate scrollViewDidEndZooming:scrollView withView:view atScale:scale];
}

- (void)scrollViewDidEndScrollingAnimation:(UIScrollView *)scrollView
{
        if([delegate respondsToSelector:@selector(scrollViewDidEndScrollingAnimation:)])
                        [delegate scrollViewDidEndScrollingAnimation:scrollView];
}

- (void)dealloc
{
    [placeholder release];
    [container release];
    [document release];
    [super dealloc];
}

@end