Changeset 4725

Show
Ignore:
Timestamp:
04/26/07 13:11:32 (1 year ago)
Author:
morris
Message:

Add a progress indicator for asynchronously loading files off the net

Extract thumbnail data from loaded files off the net

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • Footagehead/trunk/English.lproj/Browser.nib/classes.nib

    r4716 r4725  
    6262        },  
    6363        { 
     64            ACTIONS = { 
     65                firstFile = id;  
     66                lastFile = id;  
     67                nextImage = id;  
     68                nextPage = id;  
     69                previousImage = id;  
     70                previousPage = id;  
     71                rotateLeft = id;  
     72                rotateRight = id;  
     73                zoomMode = id;  
     74            };  
    6475            CLASS = FHWindowController;  
    6576            LANGUAGE = ObjC;  
    66             OUTLETS = {"_imageView" = FHImageView; };  
     77            OUTLETS = {"_imageView" = FHImageView; "_progressIndicator" = NSProgressIndicator; };  
    6778            SUPERCLASS = WIWindowController;  
    6879        },  

  • Footagehead/trunk/English.lproj/Browser.nib/info.nib

    r4721 r4725  
    99        <key>IBOpenObjects</key> 
    1010        <array> 
     11                <integer>82</integer> 
    1112                <integer>7</integer> 
    1213                <integer>65</integer> 
    1314                <integer>52</integer> 
    14                 <integer>82</integer> 
    1515        </array> 
    1616        <key>IBSystem Version</key> 

  • Footagehead/trunk/English.lproj/Slideshow.nib/classes.nib

    r4716 r4725  
    1414        {CLASS = FHSlideshowWindow; LANGUAGE = ObjC; SUPERCLASS = NSWindow; },  
    1515        { 
     16            ACTIONS = { 
     17                firstFile = id;  
     18                lastFile = id;  
     19                nextImage = id;  
     20                nextPage = id;  
     21                previousImage = id;  
     22                previousPage = id;  
     23                rotateLeft = id;  
     24                rotateRight = id;  
     25                zoomMode = id;  
     26            };  
    1627            CLASS = FHWindowController;  
    1728            LANGUAGE = ObjC;  
    18             OUTLETS = {"_imageView" = FHImageView; };  
     29            OUTLETS = {"_imageView" = FHImageView; "_progressIndicator" = NSProgressIndicator; };  
    1930            SUPERCLASS = WIWindowController;  
    2031        },  

  • Footagehead/trunk/FHBrowserController.m

    r4723 r4725  
    425425        [[_imageLoader notificationCenter] 
    426426                addObserver:self 
     427                   selector:@selector(imageLoaderReceivedImageData:) 
     428                           name:FHImageLoaderReceivedImageData]; 
     429         
     430        [[_imageLoader notificationCenter] 
     431                addObserver:self 
    427432                   selector:@selector(imageLoaderDidLoadImage:) 
    428433                           name:FHImageLoaderDidLoadImage]; 
    …… 
    564569 
    565570- (void)handlerDidFinishLoading:(FHHandler *)handler { 
     571} 
     572 
     573 
     574 
     575- (void)imageLoaderReceivedImageData:(NSNotification *)notification { 
     576        FHFile          *file; 
     577         
     578        file = [notification object]; 
     579         
     580        if(file == [self selectedFile]) { 
     581                if([_progressIndicator isHidden]) { 
     582                        [_progressIndicator setIndeterminate:!([file percentReceived] > 0.0)]; 
     583                        [_progressIndicator setHidden:NO]; 
     584                } 
     585                 
     586                [_progressIndicator setDoubleValue:[file percentReceived]]; 
     587                [_progressIndicator animate:self]; 
     588        } 
    566589} 
    567590 
    …… 
    10731096        class = [FHHandler handlerForURL:url]; 
    10741097         
    1075         if([class handlesURLAsDirectory:url]) { 
    1076                 [self _loadURL:url]; 
    1077         } else { 
     1098        if([url isFileURL] && ![class handlesURLAsDirectory:url]) { 
    10781099                file    = [[url path] lastPathComponent]; 
    10791100                url             = [WIURL fileURLWithPath:[[url path] stringByDeletingLastPathComponent]]; 
    …… 
    10831104 
    10841105                [self _loadURL:url selectFile:file]; 
     1106        } else { 
     1107                [self _loadURL:url]; 
    10851108        } 
    10861109} 

  • Footagehead/trunk/FHCache.h

    r4706 r4725  
    4141- (NSImage *)directoryIcon; 
    4242 
    43 - (void)setFileIcon:(NSImage *)icon forURL:(WIURL *)url; 
    4443- (NSImage *)fileIconForURL:(WIURL *)url; 
    45  
    46 - (void)setLargeFileIcon:(NSImage *)icon forExtension:(NSString *)extension; 
    4744- (NSImage *)largeFileIconForExtension:(NSString *)extension; 
    48  
    49 - (void)setLargeFileIcon:(NSImage *)icon forURL:(WIURL *)url; 
    5045- (NSImage *)largeFileIconForURL:(WIURL *)url; 
    5146 
    52 - (void)setThumbnail:(FHImage *)image forURL:(WIURL *)url; 
    5347- (FHImage *)thumbnailForURL:(WIURL *)url; 
     48- (FHImage *)thumbnailForURL:(WIURL *)url withData:(NSData *)data; 
    5449- (void)dropThumbnailsForURL:(WIURL *)url; 
    5550 

  • Footagehead/trunk/FHCache.m

    r4723 r4725  
    7979#pragma mark - 
    8080 
    81 - (void)setFileIcon:(NSImage *)icon forURL:(WIURL *)url { 
    82         if([_fileIcons count] > 1000) 
    83                 [_fileIcons removeObjectForKey:[[_fileIcons allKeys] objectAtIndex:0]]; 
    84          
    85         [_fileIcons setObject:icon forKey:[url string]]; 
    86 } 
    87  
    88  
    89  
    9081- (NSImage *)fileIconForURL:(WIURL *)url { 
    91         return [_fileIcons objectForKey:[url string]]; 
     82        NSImage         *image; 
     83        WIURL           *faviconURL; 
     84         
     85        image = [_fileIcons objectForKey:[url string]]; 
     86         
     87        if(!image) { 
     88                if([url isFileURL]) { 
     89                        image = [[NSWorkspace sharedWorkspace] iconForFile:[url path]]; 
     90                } else { 
     91                        faviconURL = [[url copy] autorelease]; 
     92                        [faviconURL setPath:@"/favicon.ico"]; 
     93                         
     94                        image = [[[NSImage alloc] initWithContentsOfURL:[faviconURL URL]] autorelease]; 
     95                         
     96                        if(!image) 
     97                                image = [NSImage imageNamed:@"URL"]; 
     98                } 
     99                 
     100                if(image) { 
     101                        if([_fileIcons count] > 1000) 
     102                                [_fileIcons removeObjectForKey:[[_fileIcons allKeys] objectAtIndex:0]]; 
     103                         
     104                        [_fileIcons setObject:image forKey:[url string]]; 
     105                } 
     106        } 
     107                 
     108        return image; 
     109} 
     110 
     111 
     112 
     113- (NSImage *)largeFileIconForExtension:(NSString *)extension { 
     114        NSImage         *image; 
     115         
     116        image = [_largeFileIcons objectForKey:extension]; 
     117                 
     118        if(!image) { 
     119                image = [[NSWorkspace sharedWorkspace] iconForFileType:extension]; 
     120                 
     121                if(image) { 
     122                        [image setSize:NSMakeSize(128.0, 128.0)]; 
     123                 
     124                        if([_largeFileIcons count] > 1000) 
     125                                [_largeFileIcons removeObjectForKey:[[_largeFileIcons allKeys] objectAtIndex:0]]; 
     126                         
     127                        [_largeFileIcons setObject:image forKey:extension]; 
     128                } 
     129        } 
     130         
     131        return image; 
     132} 
     133 
     134 
     135 
     136- (NSImage *)largeFileIconForURL:(WIURL *)url { 
     137        NSImage         *image; 
     138         
     139        image = [_largeFileIcons objectForKey:[url string]]; 
     140                         
     141        if(!image) { 
     142                image = [[NSWorkspace sharedWorkspace] iconForFile:[url path]]; 
     143                 
     144                if(image) { 
     145                        [image setSize:NSMakeSize(128.0, 128.0)]; 
     146                 
     147                        if([_largeFileIcons count] > 1000) 
     148                                [_largeFileIcons removeObjectForKey:[[_largeFileIcons allKeys] objectAtIndex:0]]; 
     149                         
     150                        [_largeFileIcons setObject:image forKey:[url string]]; 
     151                } 
     152        } 
     153         
     154        return image; 
    92155} 
    93156 
    …… 
    96159#pragma mark - 
    97160 
    98 - (void)setLargeFileIcon:(NSImage *)icon forExtension:(NSString *)extension { 
    99         if([_largeFileIcons count] > 1000) 
    100                 [_largeFileIcons removeObjectForKey:[[_largeFileIcons allKeys] objectAtIndex:0]]; 
    101          
    102         [_largeFileIcons setObject:icon forKey:extension]; 
    103 } 
    104  
    105  
    106  
    107 - (NSImage *)largeFileIconForExtension:(NSString *)extension { 
    108         return [_largeFileIcons objectForKey:extension]; 
    109 } 
    110  
    111  
    112  
    113 #pragma mark - 
    114  
    115 - (void)setLargeFileIcon:(NSImage *)icon forURL:(WIURL *)url { 
    116         if([_largeFileIcons count] > 1000) 
    117                 [_largeFileIcons removeObjectForKey:[[_largeFileIcons allKeys] objectAtIndex:0]]; 
    118          
    119         [_largeFileIcons setObject:icon forKey:[url string]]; 
    120 } 
    121  
    122  
    123  
    124 - (NSImage *)largeFileIconForURL:(WIURL *)url { 
    125         return [_largeFileIcons objectForKey:[url string]]; 
    126 } 
    127  
    128  
    129  
    130 #pragma mark - 
    131  
    132 - (void)setThumbnail:(FHImage *)image forURL:(WIURL *)url { 
    133         if([_thumbnails count] > 500) 
    134                 [_thumbnails removeObjectForKey:[[_thumbnails allKeys] objectAtIndex:0]]; 
    135          
    136         [_thumbnails setObject:image forKey:[url string]]; 
    137 } 
    138  
    139  
    140  
    141161- (FHImage *)thumbnailForURL:(WIURL *)url { 
    142         return [_thumbnails objectForKey:[url string]]; 
     162        return [self thumbnailForURL:url withData:NULL]; 
     163} 
     164 
     165 
     166 
     167- (FHImage *)thumbnailForURL:(WIURL *)url withData:(NSData *)data { 
     168        FHImage         *image; 
     169         
     170        image = [_thumbnails objectForKey:[url string]]; 
     171 
     172        if(!image) { 
     173                if(data) 
     174                        image = [[[FHImage alloc] initThumbnailWithData:data preferredSize:NSMakeSize(128.0, 128.0)] autorelease]; 
     175                else 
     176                        image = [[[FHImage alloc] initThumbnailWithURL:url preferredSize:NSMakeSize(128.0, 128.0)] autorelease]; 
     177                         
     178                if(image) { 
     179                        if([_thumbnails count] > 500) 
     180                                [_thumbnails removeObjectForKey:[[_thumbnails allKeys] objectAtIndex:0]]; 
     181                         
     182                        [_thumbnails setObject:image forKey:[url string]]; 
     183                } 
     184        } 
     185         
     186        return image; 
    143187} 
    144188 

  • Footagehead/trunk/FHFile.h

    r4709 r4725  
    3838        FHImage                                 *_thumbnail; 
    3939        BOOL                                    _loaded; 
     40        double                                  _percentReceived; 
    4041        BOOL                                    _directory; 
    4142        NSUInteger                              _index; 
    …… 
    5253- (void)setLoaded:(BOOL)loaded; 
    5354- (BOOL)isLoaded; 
     55- (void)setPercentReceived:(double)percent; 
     56- (double)percentReceived; 
    5457 
    5558- (NSString *)name; 

  • Footagehead/trunk/FHFile.m

    r4709 r4725  
    5252         
    5353        if(!_directory) { 
    54                 // --- get icon for extension 
    5554                icon = [[FHCache cache] largeFileIconForExtension:_extension]; 
    56                  
    57                 if(!icon) { 
    58                         icon = [[NSWorkspace sharedWorkspace] iconForFileType:_extension]; 
    59                         [icon setSize:NSMakeSize(128.0, 128.0)]; 
    60                          
    61                         [[FHCache cache] setLargeFileIcon:icon forExtension:_extension]; 
    62                 } 
    6355                 
    6456                _icon = [[FHImage alloc] initImageWithImage:icon]; 
    6557        } else { 
    66                 if(![_url isFileURL]) { 
    67                         // --- get icon for generic remote directory 
     58                if(![_url isFileURL]) 
    6859                        icon = [[FHCache cache] directoryIcon]; 
    69                 } else { 
    70                         // --- get icon for local directory path 
     60                else 
    7161                        icon = [[FHCache cache] largeFileIconForURL:url]; 
    72                          
    73                         if(!icon) { 
    74                                 icon = [[NSWorkspace sharedWorkspace] iconForFile:_path]; 
    75                                 [icon setSize:NSMakeSize(128.0, 128.0)]; 
    76                                  
    77                                 [[FHCache cache] setLargeFileIcon:icon forURL:_url]; 
    78                         } 
    79                 } 
    8062                 
    8163                _icon = [[FHImage alloc] initImageWithImage:icon]; 
    …… 
    144126 
    145127 
     128- (void)setPercentReceived:(double)percentReceived { 
     129        _percentReceived = percentReceived; 
     130} 
     131 
     132 
     133 
     134- (double)percentReceived { 
     135        return _percentReceived; 
     136} 
     137 
     138 
     139 
    146140#pragma mark - 
    147141 

  • Footagehead/trunk/FHFutabaHandler.h

    r4724 r4725  
    2929#import "FHHTMLHandler.h" 
    3030 
    31 enum _FHFutabaType { 
    32         FHFutaba4chan 
    33 }; 
    34 typedef enum _FHFutabaType              FHFutabaType; 
    35  
    36  
    37 @interface FHFutabaHandler : FHHTMLHandler { 
    38         FHFutabaType                            _type; 
    39 } 
     31@interface FHFutabaHandler : FHHTMLHandler 
    4032 
    4133@end 

  • Footagehead/trunk/FHFutabaHandler.m

    r4724 r4725  
    3434@implementation FHFutabaHandler 
    3535 
    36 - (id)initHandlerWithURL:(WIURL *)url HTML:(NSString *)html { 
    37         NSString        *host; 
    38          
    39         self = [super initHandlerWithURL:url HTML:html]; 
    40          
    41         host = [url host]; 
    42          
    43         if([host hasSuffix:@"4chan.org"]) 
    44                 _type = FHFutaba4chan; 
    45          
    46         return self; 
    47 } 
    48  
    49  
    50  
    51 #pragma mark - 
    52  
    5336- (NSArray *)files { 
    5437        NSArray                 *links; 
    …… 
    6649                        url = [links objectAtIndex:i]; 
    6750                         
    68                         switch(_type) { 
    69                                 case FHFutaba4chan: 
    70                                         if([[url path] containsSubstring:@"src.cgi"]) 
    71                                                 continue; 
    72                                         break; 
    73                         } 
     51                        if([[url path] containsSubstring:@"src.cgi"]) 
     52                                continue; 
    7453                         
    7554                        file = [[FHFile alloc] initWithURL:[links objectAtIndex:i] isDirectory:NO index:index++]; 

  • Footagehead/trunk/FHHandler.m

    r4723 r4725  
    288288 
    289289- (NSImage *)iconForURL:(WIURL *)url { 
    290         NSImage         *icon; 
    291         WIURL           *faviconURL; 
    292          
    293         icon = [[FHCache cache] fileIconForURL:url]; 
    294          
    295         if(!icon) { 
    296                 if([url isFileURL]) { 
    297                         icon = [[NSWorkspace sharedWorkspace] iconForFile:[url path]]; 
    298                 } else { 
    299                         faviconURL = [[url copy] autorelease]; 
    300                         [faviconURL setPath:@"/favicon.ico"]; 
    301                          
    302                         icon = [[[NSImage alloc] initWithContentsOfURL:[faviconURL URL]] autorelease]; 
    303                          
    304                         if(!icon) 
    305                                 icon = [NSImage imageNamed:@"URL"]; 
    306                 } 
    307                  
    308                 [[FHCache cache] setFileIcon:icon forURL:url]; 
    309         } 
    310                  
    311         return icon; 
     290        return [[FHCache cache] fileIconForURL:url]; 
    312291} 
    313292 

  • Footagehead/trunk/FHImage.h

    r4706 r4725  
    3131        CGImageRef                                      _CGImage; 
    3232         
     33        CGImageSourceRef                        _imageSource; 
     34         
    3335        WIURL                                           *_url; 
    3436         
    …… 
    4446- (id)initImageWithData:(NSData *)data; 
    4547- (id)initThumbnailWithURL:(WIURL *)url preferredSize:(NSSize)size; 
     48- (id)initThumbnailWithData:(NSData *)data preferredSize:(NSSize)size; 
    4649 
    4750- (void)setFlipped:(BOOL)flipped; 

  • Footagehead/trunk/FHImage.m

    r4714 r4725  
    2727 */ 
    2828 
    29 #import "NSData-FHAdditions.h" 
    3029#import "NSImage-FHAdditions.h" 
    3130#import "FHImage.h" 
    …… 
    3332@interface FHImage(Private) 
    3433 
    35 - (BOOL)_initImageWithData:(NSData *)data; 
     34- (BOOL)_initImage; 
     35- (BOOL)_initThumbnailWithPreferredSize:(NSSize)size; 
    3636 
    3737@end 
    …… 
    4040@implementation FHImage(Private) 
    4141 
    42 - (BOOL)_initImageWithData:(NSData *)data { 
     42- (BOOL)_initImage { 
    4343        NSDictionary            *options; 
    44         CGImageSourceRef        imageSource; 
    45          
    46         imageSource = CGImageSourceCreateWithData((CFDataRef) data, NULL); 
    47          
    48         if(!imageSource) 
    49                 return NO; 
    5044 
    5145        options = [NSDictionary dictionaryWithObjectsAndKeys: 
    …… 
    5448                NULL]; 
    5549         
    56         _CGImage = CGImageSourceCreateImageAtIndex(imageSource, 0, (CFDictionaryRef) options); 
    57          
    58         if(!_CGImage) { 
    59                 CFRelease(imageSource); 
    60                  
     50        _CGImage = CGImageSourceCreateImageAtIndex(_imageSource, 0, (CFDictionaryRef) options); 
     51         
     52        if(!_CGImage) 
    6153                return NO; 
    62         } 
    6354         
    6455        _size = NSMakeSize(CGImageGetWidth(_CGImage), CGImageGetHeight(_CGImage)); 
    65  
    66         CFRelease(imageSource); 
    6756         
    6857        return YES; 
    6958} 
    7059 
    71 @end 
    72  
    73  
    74 @implementation FHImage 
    75  
    76 + (id)imageNamed:(NSString *)name { 
    77         NSImage         *image; 
    78  
    79         image = [NSImage imageNamed:name]; 
    80  
    81         if(!image) 
    82                 return NULL; 
    83          
    84         return [[[self alloc] initImageWithImage:image] autorelease]; 
    85 } 
    86  
    87  
    88  
    89 #pragma mark - 
    90  
    91 - (id)initImageWithImage:(NSImage *)image { 
    92         self = [super init]; 
    93          
    94         _NSImage        = [image retain]; 
    95         _size           = [_NSImage size]; 
    96          
    97         return self; 
    98 } 
    99  
    100  
    101  
    102 - (id)initImageWithURL:(WIURL *)url { 
    103         NSData          *data; 
    104          
    105         self = [super init]; 
    106          
    107         data = [NSData dataWithContentsOfURL:url returningResponse:NULL]; 
    108          
    109         if(!data) { 
    110                 [self release]; 
    111                  
    112                 return NULL; 
    113         } 
    114          
    115         if(![self _initImageWithData:data]) { 
    116                 [self release]; 
    117                  
    118                 return NULL; 
    119         } 
    120          
    121         return self; 
    122 } 
    123  
    124  
    125  
    126 - (id)initImageWithData:(NSData *)data { 
    127         self = [super init]; 
    128          
    129         if(![self _initImageWithData:data]) { 
    130                 [self release]; 
    131                  
    132                 return NULL; 
    133         } 
    134          
    135         return self; 
    136 } 
    137  
    138  
    139  
    140 - (id)initThumbnailWithURL:(WIURL *)url preferredSize:(NSSize)size { 
     60 
     61 
     62- (BOOL)_initThumbnailWithPreferredSize:(NSSize)size { 
    14163        NSDictionary            *options; 
    142         CGImageSourceRef        imageSource; 
    14364        CFNumberRef                     number; 
    144          
    145         self = [super init]; 
    146          
    147         imageSource = CGImageSourceCreateWithURL((CFURLRef) [url URL], NULL); 
    148          
    149         if(!imageSource) { 
    150                 [self release]; 
    151                  
    152                 return NULL; 
    153         } 
    15465         
    15566        number = CFNumberCreate(NULL, kCFNumberFloatType, &size.width); 
    …… 
    16071                NULL]; 
    16172         
    162         _CGImage = CGImageSourceCreateThumbnailAtIndex(imageSource, 0, (CFDictionaryRef) options); 
    163          
    164         if(!_CGImage) { 
    165                 [self release]; 
    166                 CFRelease(imageSource); 
    167                  
    168                 return NULL; 
    169         } 
     73        _CGImage = CGImageSourceCreateThumbnailAtIndex(_imageSource, 0, (CFDictionaryRef) options); 
     74         
     75        if(!_CGImage) 
     76                return NO; 
    17077         
    17178        _size = NSMakeSize(CGImageGetWidth(_CGImage), CGImageGetHeight(_CGImage)); 
    17279         
    173         CFRelease(imageSource); 
     80        return YES; 
     81} 
     82 
     83@end 
     84 
     85 
     86@implementation FHImage 
     87 
     88+ (id)imageNamed:(NSString *)name { 
     89        NSImage         *image; 
     90 
     91        image = [NSImage imageNamed:name]; 
     92 
     93        if(!image) 
     94                return NULL; 
     95         
     96        return [[[self alloc] initImageWithImage:image] autorelease]; 
     97} 
     98 
     99 
     100 
     101#pragma mark - 
     102 
     103- (id)initImageWithImage:(NSImage *)image { 
     104        self = [super init]; 
     105         
     106        _NSImage        = [image retain]; 
     107        _size           = [_NSImage size]; 
     108         
     109        return self; 
     110} 
     111 
     112 
     113 
     114- (id)initImageWithURL:(WIURL *)url { 
     115        self = [super init]; 
     116         
     117        _imageSource = CGImageSourceCreateWithURL((CFURLRef) [url URL], NULL); 
     118         
     119        if(!_imageSource) { 
     120                [self release]; 
     121                 
     122                return NULL; 
     123        } 
     124 
     125        if(![self _initImage]) { 
     126                [self release]; 
     127                 
     128                return NULL; 
     129        } 
     130         
     131        return self; 
     132} 
     133 
     134 
     135 
     136- (id)initImageWithData:(NSData *)data { 
     137        self = [super init]; 
     138         
     139        _imageSource = CGImageSourceCreateWithData((CFDataRef) data, NULL); 
     140         
     141        if(!_imageSource) { 
     142                [self release]; 
     143                 
     144                return NULL; 
     145        } 
     146 
     147        if(![self _initImage]) { 
     148                [self release]; 
     149                 
     150                return NULL; 
     151        } 
     152         
     153        return self; 
     154} 
     155 
     156 
     157 
     158- (id)initThumbnailWithURL:(WIURL *)url preferredSize:(NSSize)size { 
     159        self = [super init]; 
     160         
     161        _imageSource = CGImageSourceCreateWithURL((CFURLRef) [url URL], NULL); 
     162         
     163        if(!_imageSource) { 
     164                [self release]; 
     165                 
     166                return NULL; 
     167        } 
     168 
     169        if(![self _initThumbnailWithPreferredSize:size]) { 
     170                [self release]; 
     171                 
     172                return NULL; 
     173        } 
     174         
     175        return self; 
     176} 
     177 
     178 
     179 
     180- (id)initThumbnailWithData:(NSData *)data preferredSize:(NSSize)size { 
     181        self = [super init]; 
     182         
     183        _imageSource = CGImageSourceCreateWithData((CFDataRef) data, NULL); 
     184         
     185        if(!_imageSource) { 
     186                [self release]; 
     187                 
     188                return NULL; 
     189        } 
     190 
     191        if(![self _initThumbnailWithPreferredSize:size]) { 
     192                [self release]; 
     193                 
     194                return NULL; 
     195        } 
    174196         
    175197        return self; 
    …… 
    184206         
    185207        [_NSImage release]; 
    186          
     208 
     209        if(_imageSource) 
     210                CFRelease(_imageSource); 
     211 
    187212        [super dealloc]; 
    188213} 

  • Footagehead/trunk/FHImageLoader.h

    r4717 r4725  
    3838        NSUInteger                              _thumbnailCounter; 
    3939         
     40        NSMutableData                   *_asynchronousData; 
     41        FHFile                                  *_asynchronousFile; 
     42        long long                               _asynchronousLength; 
     43        BOOL                                    _asynchronousDone; 
     44         
    4045        BOOL                                    _imageStop; 
    4146        BOOL                                    _thumbnailStop; 
    …… 
    4752 
    4853 
    49 #define FHImageLoaderDidLoadImage               @"FHImageLoaderDidLoadImage" 
    50 #define FHImageLoaderDidLoadThumbnail   @"FHImageLoaderDidLoadThumbnail" 
     54#define FHImageLoaderReceivedImageData                          @"FHImageLoaderReceivedImageData" 
     55 
     56#define FHImageLoaderDidLoadImage                                       @"FHImageLoaderDidLoadImage" 
     57#define FHImageLoaderDidLoadThumbnail                           @"FHImageLoaderDidLoadThumbnail" 
    5158 
    5259 

  • Footagehead/trunk/FHImageLoader.m

    r4717 r4725  
    4444        _thumbnailLock          = [[NSConditionLock alloc] initWithCondition:0]; 
    4545 
     46        _asynchronousData       = [[NSMutableData alloc] init]; 
     47 
    4648        [NSThread detachNewThreadSelector:@selector(imageThread:) toTarget:self withObject:NULL]; 
    4749        [NSThread detachNewThreadSelector:@selector(thumbnailsThread:) toTarget:self withObject:NULL]; 
    …… 
    6264        [_thumbnailLock release]; 
    6365         
     66        [_asynchronousData release]; 
     67         
    6468        [super dealloc]; 
    6569} 
    …… 
    6973#pragma mark - 
    7074 
     75- (void)connection:(NSURLConnection *)connection didReceiveResponse:(NSURLResponse *)response { 
     76        _asynchronousLength = [response expectedContentLength]; 
     77} 
     78 
     79 
     80 
     81- (void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data { 
     82        double          percent; 
     83         
     84        [_asynchronousData appendData:data]; 
     85 
     86        if(_asynchronousLength > 0) { 
     87                percent = (double) [_asynchronousData length] / (double) _asynchronousLength; 
     88                 
     89                if(percent > [_asynchronousFile percentReceived] + 0.1 || [_asynchronousFile percentReceived] == 0.0) { 
     90                        [_asynchronousFile setPercentReceived:percent]; 
     91         
     92                        [_notificationCenter mainThreadPostNotificationName:FHImageLoaderReceivedImageData 
     93                                                                                                                 object:_asynchronousFile]; 
     94                } 
     95        } else { 
     96                [_notificationCenter mainThreadPostNotificationName:FHImageLoaderReceivedImageData 
     97                                                                                                         object:_asynchronousFile]; 
     98        } 
     99} 
     100 
     101 
     102 
     103- (void)connectionDidFinishLoading:(NSURLConnection *)connection { 
     104        _asynchronousDone = YES; 
     105} 
     106 
     107 
     108 
     109- (void)connection:(NSURLConnection *)connection didFailWithError:(NSError *)error { 
     110        _asynchronousDone = YES; 
     111} 
     112 
     113 
     114 
     115#pragma mark - 
     116 
    71117- (void)imageThread:(id)object { 
    72         NSAutoreleasePool   *pool; 
    73         NSArray                         *files; 
    74         FHImage                         *image; 
    75         FHFile                          *file; 
    76         NSUInteger                      i, count, index; 
    77         NSUInteger                      counter, lastCounter = 0; 
    78         BOOL                            stop; 
     118        NSAutoreleasePool               *pool; 
     119        NSArray                                 *files; 
     120        NSData                                  *data; 
     121        NSURLConnection                 *connection; 
     122        NSMutableURLRequest             *request; 
     123        WIURL                                   *url; 
     124        FHImage                                 *image; 
     125        FHFile                                  *file; 
     126        NSUInteger                              i, count, index; 
     127        NSUInteger                              counter, lastCounter = 0; 
     128        BOOL                                    stop; 
    79129         
    80130        [NSThread setThreadPriority:0.5]; 
     131         
     132        pool = [[NSAutoreleasePool alloc] init]; 
     133        request = [[NSMutableURLRequest alloc] init]; 
    81134 
    82135        while(YES) { 
    83                 pool = [[NSAutoreleasePool alloc] init]; 
     136                if(!pool) 
     137                        pool = [[NSAutoreleasePool alloc] init]; 
    84138 
    85139                [_imageLock lockWhenCondition:1]; 
    …… 
    128182                                        goto next; 
    129183                                 
    130                                 image = [[FHImage alloc] initImageWithURL:[file URL]]; 
     184                                url = [file URL]; 
     185                                 
     186                                if([url isFileURL]) { 
     187                                        data = [NSData dataWithContentsOfFile:[url path]]; 
     188                                } else { 
     189                                        [request setURL:[url URL]]; 
     190                                        [request setValue:[[url URLByDeletingLastPathComponent] string] forHTTPHeaderField:@"Referer"]; 
     191 
     192                                        connection = [NSURLConnection connectionWithRequest:request delegate:self]; 
     193                                         
     194                                        _asynchronousDone = NO; 
     195                                        _asynchronousFile = file; 
     196                                        [_asynch