First, my Pixen fork is dead. I’m sorry but I found it rather difficult to spend time on a project I for which had no personal use. Luckily Pixen’s original creators have started updating the project once again. They released version 3.5.10b1 just a few weeks ago. It also looks like they’re taking the project commercial on the app store. Anyone looking for a good pixel editor should give it a try.

Second, I’ve recently started hacking on CoRD, an RDP client for OS X. I’m currently a windows server admin for my university and I needed a good RDP client. Microsoft’s official client just wasn’t cutting it for the number of servers I connect to on a daily basis and its stability was rather poor. So far I’ve modernized the code a bit, moved the minimum requirements to 64-bit on 10.6, and added one new feature, the ability to set a default username, password, and domain for new connections. I’ve also begun refactoring some of the more egregious metafiles (1000+ line AppController). Anyone interested can track my fork here and download my latest build here. I’m very interested in getting CoRD switched from rdesktop to FreeRDP but have hit a few obstacles along the way. But I have finally gotten FreeRDP playing nice with Xcode so I’ll be working on it more over my spring break next week.

Finally, I’ll be graduating with a degree in computer science at the end of April. In the mean time I’ll continue hacking away on CoRD and hope to make some sort of contribution by the time I find a job. Speaking of which, I should probably put my resume up here somewhere.

It can edit pixels, I swear!

This is where I’ve hit my first issue: my pixel grid is uneven. Here’s my current code:

- (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);
        }
    }
       
}

This method both resizes the image (currently stored as an NSBitmapImageRep) while maintaining the aspect ratio and draws the pixel grid when when it’s turned on. As you may be able to tell from the screenshot, the pixel grid is uneven, or at least appears to be. So my question is this, Mac developers: what would be a better way to draw the grid? As well, I currently access the image data by using NSBitmapImageReps’ setColor:atX:y: and it seems to work fine, but is it the best way? I ask you so I can code and not worry that what I’m writing is stupidly wrong. I look forward to your input.

P.S. Does anyone know a good, free, code-friendly WordPress theme? Carrington is just too damn narrow.

OTHER_LDFLAGS_macosx_1070 = -Xlinker -objc_gc_compaction;

Stunning, isn’t it? It may seem insignificant, but the addition of heap compaction to the Objective-C garbage collector is likely a prerequisite for its addition to the iOS SDK. You read about heap compaction in a great answer to this StackOverflow question. Why would it lead to garbage collection on iOS? Given that all iOS devices are vastly more memory constrained than their Mac OS X counterparts and lack on-disk virtual memory, anything can optimize memory use, especially for “free” from a developer’s perspective, is a big win. Reducing memory fragmentation, and more importantly, being able to reuse the same memory addresses during the common alloc/dealloc cycle that most objects go through will likely allow the Objective-C garbage collector to have the performance needed for Apple to enable it in iOS. As well, it’s continued evidence of Apple’s investment in Objective-C as the Mac OS X and iOS language of choice. It’s likely more details of this feature will be uncovered in the open source Objective-C runtime Apple produces, as well as the clang compiler project. A small but important feature we’ll see in Lion next year.

There is still hope however. Pixen: we can rebuild it, we have the technology. Over the coming weeks, time allowing, I’ll be adding a list of several major issues that need to be addressed for Pixen to move into 2010. These will be posted on my GitHub page, so feel free to comment with any suggestions. I always welcome additional insight into the Pixen code. Even if you don’t implement features or fix bugs, pointing me in the right direction so I can try to do so myself would be great. I’ll be focusing on any bugs that pop up (I already have at least one) and the transition to the 64-bit APIs. One of the biggest changes I’d like to see, even if I don’t do much with the foundation of the program, is a refreshed UI. I am not a designer by any stretch of the imagination, so if anyone is interested in submitting UI ideas or artwork, especially the UI icons, I would greatly appreciate it.

Thanks for reading.

So far my efforts have been limited to project cleanup, modernization, and house keeping. I expect this to be a great learning experience for me going forward and I’ll be posting code updates as I understand more of the Pixen code. Right now my priorities are fixing all of the warnings I created with new compiler options, updating the Obj-C syntax and Cocoa API’s used, and taking a look at the performance. Plus we’ll all be discussing exactly what new features to add for version 4.

Obviously, when I first sat down to develop BitMaster I had to determine what functionality I needed first. I chose torrent file parsing, since it seemed like a simple and ubiquitous part of torrent client development. You can see my first attempt a this code in my previous entry “Learning through doing…” which is quite rough. After feedback from various people online, it now looks like this:

//
//  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

This code is much faster, cleaner, and accurate than the previous attempt. But it’s still inelegant in a lot of ways. For example, I store the torrent file data within both an NSData object (for the subdata* methods) and a char array (so I can access individual characters to iterate over). Surely there must be a better way, I just haven’t found it. For a few of my methods, there must be a better way of converting to an NSNumber object than getting a subdata, making it a string, and making the string a number. Seems quite obtuse compared to the conversions I’ve seen in other languages.

Well, that’s all for now. I’ll try to get this post out and around so I can get feed back, so feel free to leave comments.