- (void)drawRect:(NSRect)dirtyRect
{
    context = [[NSGraphicsContext currentContext] graphicsPort];
    CGContextAddRect(context, NSRectToCGRect(self.bounds));
	CGContextSetRGBStrokeColor(context, 1.0f, 0.0f, 0.0f, 1.0f);
	CGContextStrokePath(context);
    CGContextSetInterpolationQuality(context, kCGInterpolationNone);
    CGContextSetShouldAntialias(context, NO);
 
    if (image)
    {
 
        NSRect imageRect = NSZeroRect;
        imageRect.size = CGImageGetSize([image CGImage]);
        drawRect = [self bounds];
        NSRect viewRect = drawRect;
        CGFloat aspectRatio = imageRect.size.width / imageRect.size.height;
        if (viewRect.size.width / viewRect.size.height <= aspectRatio)
        {
            drawRect.size.width = viewRect.size.width;
            drawRect.size.height = imageRect.size.height * (viewRect.size.width / imageRect.size.width);
        }
        else
        {
            drawRect.size.height = viewRect.size.height;
            drawRect.size.width = imageRect.size.width * (viewRect.size.height / imageRect.size.height);
        }
 
        drawRect.origin.x += (viewRect.size.width - drawRect.size.width) / 2.0;
        drawRect.origin.y += (viewRect.size.height - drawRect.size.height) / 2.0;
 
        CGContextDrawImage(context, drawRect, [image CGImage]);
 
        if (showPixelGrid)
        {
            //Draw grid by creating start and end points for vertical and horizontal lines.
            //FIXME: Grid is uneven, especially at smaller sizes. 
            CGContextSetStrokeColorWithColor(context, CGColorGetConstantColor(kCGColorBlack));
            CGContextAddRect(context, drawRect);
            CGContextStrokePath(context);
            NSUInteger numXPoints = (NSUInteger)imageRect.size.width * 2;
            NSUInteger numYPoints = (NSUInteger)imageRect.size.height * 2;
            CGPoint xPoints[numXPoints];
            CGPoint yPoints[numYPoints];
            CGPoint startPoint;
            CGPoint endPoint;
            CGFloat widthRatio = drawRect.size.width / imageRect.size.width;
            CGFloat heightRatio = drawRect.size.height / imageRect.size.height;
            startPoint.x  = drawRect.origin.x;
            startPoint.y = drawRect.origin.y;
            endPoint.x = drawRect.origin.x;
            endPoint.y = drawRect.size.height + drawRect.origin.y;
            for (NSUInteger i = 0; i < numXPoints; i += 2)
            {
                startPoint.x += widthRatio;
                endPoint.x += widthRatio;
                xPoints[i] = startPoint;
                xPoints[i + 1] = endPoint;
            }
            startPoint.x  = drawRect.origin.x;
            startPoint.y = drawRect.origin.y;
            endPoint.x = drawRect.size.width + drawRect.origin.x;
            endPoint.y = drawRect.origin.y;
            for (NSUInteger i = 0; i < numYPoints; i += 2)
            {
                startPoint.y += heightRatio;
                endPoint.y += heightRatio;
                yPoints[i] = startPoint;
                yPoints[i + 1] = endPoint;
            }
            CGContextStrokeLineSegments(context, xPoints, numXPoints);
            CGContextStrokeLineSegments(context, yPoints, numYPoints);
        }
    }
 
}

OTHER_LDFLAGS_macosx_1070 = -Xlinker -objc_gc_compaction;

//
//  JSbdecoder.m
//  BitMaster
//
//  Created by Jon Shier on 4/9/07.
//  Copyright 2007 __MyCompanyName__. All rights reserved.
//
#import "JSbdecoder.h"
 
@implementation JSbdecoder
 
- (NSDictionary *) decodeTorrentFile: (NSString *) pathToTorrentFile {
    torrentData = [NSData dataWithContentsOfFile: pathToTorrentFile options: NSUncachedRead error: nil];
    rawTorrentData = [torrentData bytes];
    position = 0;
 
    return [self convertObjectDataToStrings:[[self bdecodeData] objectAtIndex: 0]];
}
 
- (NSArray *) bdecodeData {
    NSMutableArray *methodArray = [NSMutableArray array];
    do {
        if(rawTorrentData[position] == 'i') {
            position++;
            [methodArray addObject:[self decodeInt]];
        } else if(rawTorrentData[position] == 'l') {
            position++;
            [methodArray addObject:[self decodeList]];
        } else if(rawTorrentData[position] == 'd') {
            position++;
            [methodArray addObject:[self decodeDictionary]];
        } else if(isdigit(rawTorrentData[position])) {
            [methodArray addObject:[self decodeBytes]];
        } else if(rawTorrentData[position] == 'e') {
            position++;
            //Should only hit this when at the end of lists, dictionaries, or integers.
            break;
        } else {
            NSLog(@"Error decoding torrent. Unexpected character '%c' at position %d.", rawTorrentData[position], position);
            return methodArray;
        }
    } while (position < [torrentData length]);
 
    return methodArray;
}
 
- (NSNumber *) decodeInt {
    NSUInteger methodPosition = position;
    while(rawTorrentData[position] != 'e') {
       position++;
    }
    position++;
    return [NSNumber numberWithInteger: [[NSString stringWithUTF8String: [[torrentData subdataWithRange: NSMakeRange(methodPosition, (position - methodPosition))] bytes]] integerValue]];
}
 
- (NSData *) decodeBytes {
    NSUInteger methodPosition = position;
    while(rawTorrentData[position] != ':') {
        position++;
    }
    NSUInteger bytesLength = [[NSString stringWithUTF8String: [[torrentData subdataWithRange: NSMakeRange(methodPosition, (position - methodPosition))] bytes]] integerValue];
    position++;
    methodPosition = position;
    position += bytesLength;
 
    return [torrentData subdataWithRange: NSMakeRange(methodPosition, bytesLength)];
}
 
- (NSArray *) decodeList {
    return [self bdecodeData];
}
 
- (NSDictionary *) decodeDictionary {
    NSMutableDictionary *methodDictionary = [NSMutableDictionary dictionary];
    NSArray *methodArray = [NSArray arrayWithArray:[self bdecodeData]];
    for(NSUInteger i = 0; i < [methodArray count]; i += 2) {
        [methodDictionary setObject: [methodArray objectAtIndex: i + 1] forKey: [methodArray objectAtIndex: i]];
    }
 
    return methodDictionary;
}
 
- (id) convertObjectDataToStrings: (id) object {
    if ([object conformsToProtocol: @protocol(NSFastEnumeration)]) {
        NSMutableArray *valueArray = [NSMutableArray array];
        if ([object isKindOfClass: [NSArray class]]) {
            for (id enumeratedObject in object) {
                [valueArray addObject: [self convertObjectDataToStrings: enumeratedObject]];
            }
            return valueArray;
        } else if ([object isKindOfClass: [NSDictionary class]]) {
            valueArray = [[object allValues] mutableCopy];
            NSMutableArray *keyArray = [NSMutableArray arrayWithArray: [object allKeys]];
            for (NSUInteger i = 0; i < [keyArray count]; i++) {
                [keyArray replaceObjectAtIndex: i withObject: [self convertObjectDataToStrings: [keyArray objectAtIndex: i]]];
            }
            for (NSUInteger i = 0; i < [valueArray count]; i++) {
                if (![[keyArray objectAtIndex: i] isEqualToString: @"pieces"]) {
                    [valueArray replaceObjectAtIndex: i withObject: [self convertObjectDataToStrings: [valueArray objectAtIndex: i]]];
                }
            }
            return [NSDictionary dictionaryWithObjects: valueArray forKeys: keyArray];
        }
    } else if ([object isKindOfClass: [NSNumber class]]) {
        return object;
    } else if ([object isKindOfClass: [NSData class]]) {
        return [[NSString alloc] initWithBytes: [object bytes] length: [object length] encoding: NSUTF8StringEncoding];
    } else {
        NSLog(@"Unexpected object %@ of class %@", object, [object class]);
    }
    return object;
}
 
@end

//
//  JSbcoder.m
//
//  Created by Jon Shier on 3/4/05.
//</code>
 
<code>#import "JSbcoder.h"
 
@implementation JSbcoder
 
- (NSDictionary *) decodeTorrentFileData: (NSData *) torrentData {
 
//Need error checking. Check that the data starts with d.
 
const char *torrentFileBytes = [torrentData bytes];
 
[self setDataLength: [torrentData length]];
 
return [NSDictionary dictionaryWithDictionary: [self decodeDictionaryFromBytes: torrentFileBytes withRange: NSMakeRange(1, dataLength - 2)]];
}
 
- (NSDictionary *) convertDictionaryDataToStrings: (NSDictionary *) torrentDictionary {
NSMutableArray *keyArray = [NSMutableArray arrayWithArray: [torrentDictionary allKeys]];
NSMutableArray *valueArray = [NSMutableArray arrayWithArray: [torrentDictionary allValues]];
 
for (int i = 0; i &lt; [keyArray count]; i++) {
[keyArray replaceObjectAtIndex: i withObject: [NSString stringWithUTF8String: [[keyArray objectAtIndex: i] bytes]]];
}
 
for (int i = 0; i &lt; [valueArray count]; i++) {
if([[valueArray objectAtIndex: i] isKindOfClass: [NSData class]] &amp;&amp; ![[keyArray objectAtIndex: i] isEqualToString: @"pieces"]) {
if(IsEmpty([NSString stringWithUTF8String: [[valueArray objectAtIndex: i] bytes]])) NSLog(@"A value is nil, value array is: %@ nil value at index %i which is %@ string of which is %@\n", valueArray, i, [valueArray objectAtIndex: i], [NSString stringWithUTF8String: [[valueArray objectAtIndex: i] bytes]]);
[valueArray replaceObjectAtIndex: i withObject: [NSString stringWithUTF8String: [[valueArray objectAtIndex: i] bytes]]];
} else if([[valueArray objectAtIndex: i] isKindOfClass: [NSDictionary class]]) {
[valueArray replaceObjectAtIndex: i withObject: [self convertDictionaryDataToStrings: [valueArray objectAtIndex: i]]];
}
}
 
return [NSDictionary dictionaryWithObjects: valueArray forKeys: keyArray];
}
 
- (NSNumber *) decodeIntegerFromBytes: (const char*) torrentData withRange: (NSRange) range {
 
return [NSNumber numberWithInt: [[[[NSString alloc] initWithBytes:torrentData + range.location length:range.length encoding:NSUTF8StringEncoding] autorelease] intValue]];
}
 
- (NSData *) decodeStringAndReturnDataFromBytes: (const char*) torrentData withRange: (NSRange) range {
 
return [[NSData dataWithBytes: torrentData length: dataLength] subdataWithRange: range];
}
 
- (unsigned int) findBlockRangeAtIndex: (unsigned int) index inBytes: (const char *) torrentData {
int j = 0;
int blockLength = 1;
 
//Need error checking
 
while (index + blockLength &lt; dataLength) {
blockLength++;
if (torrentData[index + blockLength] == 'i') {
for (j = 1; j &lt; dataLength; j++) {
if (torrentData[index + j + blockLength] == 'e') break;
}
blockLength += j;
} else if (isdigit(torrentData[index + blockLength])) {
NSRange range;
for (j = 0; j &lt; dataLength; j++) {
if (isdigit(torrentData[j + index + blockLength]) &amp;&amp; torrentData[j + index + 1 + blockLength] == ':') {
range.location = index + blockLength;
range.length = j + 1;
break;
}
}
blockLength += j + 1;
j = [[[[NSString alloc] initWithBytes:torrentData + range.location length:range.length encoding:NSUTF8StringEncoding] autorelease] intValue];
blockLength += j;
} else if (torrentData[index + blockLength] == 'l') {
blockLength += [self findBlockRangeAtIndex: (index + blockLength) inBytes: torrentData] - 1;
} else if (torrentData[index + blockLength] == 'd') {
blockLength += [self findBlockRangeAtIndex: (index + blockLength) inBytes: torrentData] - 1;
} else if (torrentData[index + blockLength] == 'e') {
break;
}
}
 
return blockLength + 1;
}
 
- (NSArray *) decodeListFromBytes: (const char *) torrentData withRange: (NSRange) range {
 
//Insert error checking
 
return [NSArray arrayWithArray:[self createArrayFromData: torrentData withRange: range]];
}
 
- (NSDictionary *) decodeDictionaryFromBytes: (const char *) torrentData withRange: (NSRange) range {
 
//Need error checking
 
NSArray *methodArray = [NSArray arrayWithArray:[self createArrayFromData: torrentData withRange: range]];
 
NSMutableArray *keyArray = [NSMutableArray array];
NSMutableArray *valueArray = [NSMutableArray array];
for(int i = 0; i &lt; [methodArray count]; i += 2) {
if([[methodArray objectAtIndex: i] isKindOfClass: [NSData class]]) {
if(IsEmpty([NSString stringWithUTF8String:[[methodArray objectAtIndex: i] bytes]])) {
[keyArray addObject: [methodArray objectAtIndex: i]];
} else [keyArray addObject: [NSString stringWithUTF8String:[[methodArray objectAtIndex: i] bytes]]];
} else {
[keyArray addObject: [methodArray objectAtIndex: i]];
}
}
 
for(int i = 1; i &lt; [methodArray count]; i += 2) {
if([[methodArray objectAtIndex: i] isKindOfClass: [NSData class]] ) {
if(IsEmpty([NSString stringWithUTF8String:[[methodArray objectAtIndex: i] bytes]])) {
[valueArray addObject: [methodArray objectAtIndex: i]];
} else [valueArray addObject: [NSString stringWithUTF8String:[[methodArray objectAtIndex: i] bytes]]];
} else {
[valueArray addObject: [methodArray objectAtIndex: i]];
}
}
return [NSDictionary dictionaryWithObjects: valueArray forKeys: keyArray];
}
 
- (void) setDataLength: (unsigned int) torrentFileDataLength {
dataLength = torrentFileDataLength;
}
 
- (NSArray *) createArrayFromData: (const char *) torrentData withRange: (NSRange) range {
NSMutableArray *methodArray = [NSMutableArray array];
 
unsigned int j = 0;
unsigned int k = range.length + range.location;
for (int i = range.location; i &lt;= k; i++) {
if (torrentData[i] == 'i') {
for (j = 1; j &lt; dataLength; j++) {
if (torrentData[i + j] == 'e') break;
}
range.location = i + 1;
range.length = j - 1;
[methodArray addObject: [self decodeIntegerFromBytes: torrentData withRange: range]];
i += j;
} else if (isdigit(torrentData[i])) {
for (j = 0; j &lt; dataLength; j++) {
if (isdigit(torrentData[j + i]) &amp;&amp; torrentData[j + i + 1] == ':') {
range.location = i;
range.length = j + 1;
break;
}
}
i += range.length;
j = [[[[NSString alloc] initWithBytes:torrentData + range.location length:range.length encoding:NSUTF8StringEncoding] autorelease] intValue];
range.location += range.length + 1;
range.length = j;
[methodArray addObject: [self decodeStringAndReturnDataFromBytes: torrentData withRange: range]];
i += range.length;
} else if (torrentData[i] == 'l') {
range.location = i + 1;
range.length = [self findBlockRangeAtIndex: i inBytes: torrentData] - 2;
[methodArray addObject: [self decodeListFromBytes: torrentData withRange: range]];
i += range.length + 1;
} else if (torrentData[i] == 'd') {
range.location = i + 1;
range.length = [self findBlockRangeAtIndex: i inBytes: torrentData] - 2;
[methodArray addObject: [self decodeDictionaryFromBytes: torrentData withRange: range]];
i += range.length + 1;
}
}
return methodArray;
}
 
@end