There are two problems with using an eye-dropper tool. The first problem is that by sampling the on screen pixel value you can only get the composited red, green, blue values; you cannot get the alpha value at all. If the original colour had an alpha value then the final colour you might get will not much the original colour at all. The second problem is that you can’t easily be sure that a colour you sample directly off the screen uses the same colour profile as the original.

I decided instead to use Intruments to probe the application and find out exactly what RGBA colour was being used by UIKit. I modified my project to display the element I wanted to find out the colour of (in my case it was the colour of a UITableView’s section footer label) and then ran the application through Intruments.

After a little trial and error (and some help from Kevin Ballard to work out exactly how to output the RGBA values) I had an Instrument that would display all parameters passed to [UIColor initWithRed:green:blue:alpha] (Screenshot)

As you can see from the screenshot, this works almost too well, with Intruments displaying almost too much information. But it is actually quite easy to narrow down the data to exactly what you’re looking for (screenshot).

Note that you wont get all colours. Just those created via [UIColor initWithRed:green:blue:alpha:] but the same technique can easily be used to probe for colours created via other methods or even via CG functions. It’s also pretty easy to use gdb to break on the relevant symbol and print out the parameters – however once you have this instrument in place it’s really quick and easy to run through an application and capture all colours. You can even export the colours into CSV file for easy manipulation.

You can download the Instrument here, copy it to

~/Library/Application Support/Instruments/PlugIns/Instruments

Of course, if you want the best iOS developer money can buy, then please, hire Mike. Rest assured, you will get the best of the best. Don’t believe me? Just ask Mike.

#!/bin/sh

HOST=api.pinboard.in
read -p "Username: " USERNAME
read -p "Password: " -s PASSWORD
security add-internet-password -U -r http -s "$HOST" -a "$USERNAME" -w "$PASSWORD"

And the script also uses the BeautifulSoup 3rd party python module to extract the title of the webpage you’re linking to. You’ll need to install beautiful soup:

sudo easy_install beautifulsoup

If you’ve correctly installed the service you can enable/disable it and assign it a keyboard shortcut from the Keyboard preference pane:

When enabled you should be able to see an entry in the application’s service menu:

Eventually these clippings will get deleted or filed in a folder and forgotten. In the past I’ve written Spotlight importers to try and gather all these clippings and then export them in a format I could use in a bookmark manager application, such as WebNoteHappy. But most bookmark manager apps tend to be quite limited and I’ve found online services such as delicious, instapaper and now pinboard.in to be far superior to any desktop application.

But getting from an internet clipping on my desktop to an entry in an online bookmark manager usually involves a lot of manual labour.

I’ve found a great solution using Hazel and a custom Python script. I have a Hazel rule that finds files with a “.webloc” file extension on my desktop. The rule then runs a single python script to add the URL to my pinboard.in account and then moves the file into the trash. Usually Hazel notices the clipping, adds it to pinboard.in and trashes the file within a couple of seconds.

The python script is where all the magic happens:

#!/usr/bin/python

import sys
import urllib
import urllib2
import re
import subprocess
import Foundation
from Carbon import File, Files, Res

def infoForWebloc(inPath):
    theDisplayName = Foundation.NSFileManager.defaultManager().displayNameAtPath_(inPath)
    resNum = Res.FSOpenResourceFile(inPath, File.FSGetResourceForkName(), Files.fsRdPerm)
    Res.UseResFile(resNum)
    theResource = Res.Get1Resource('url ', 256)
    theURLFromResource = theResource.data
    Res.CloseResFile(resNum)
    theData = Foundation.NSData.dataWithContentsOfFile_(inPath)
    thePropertyList = Foundation.NSPropertyListSerialization.propertyListWithData_options_format_error_(theData, 0, None, None)
    theURLFromData = thePropertyList['URL'] 
    return theDisplayName, theURLFromResource

def getAccount(inServer):
    theArguments = ['security', 'find-internet-password', '-s', inServer, '-g']
    thePipe = subprocess.Popen(theArguments, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    theOutput = thePipe.stdout.read()
    theMatch = re.search(r'"acct"<blob>="(.+)"', theOutput)
    theUsername = theMatch.groups()[0]
    theOutput = thePipe.stderr.read()
    theMatch = re.match(r'^password: "(.+)"$', theOutput)
    thePassword = theMatch.groups()[0]
    return theUsername, thePassword

def upload(inURL, inDescription):
    password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
    top_level_url = "https://api.pinboard.in/v1"
    theUsername, thePassword = getAccount('api.pinboard.in')
    password_mgr.add_password(None, top_level_url, theUsername, thePassword)
    handler = urllib2.HTTPBasicAuthHandler(password_mgr)
    opener = urllib2.build_opener(handler)
    inURL = urllib.quote(inURL)
    inDescription = urllib.quote(inDescription)
    theURL = 'https://api.pinboard.in/v1/posts/add?url=%s&shared=no&replace=yes&description=%s' % (inURL, inDescription)
    theResult = opener.open(theURL)

def main(args):
    for thePath in args:
        theDescription, theURL = infoForWebloc(thePath)
        upload(theURL, theDescription)

if __name__ == '__main__':
    main(sys.argv[1:])

This script reads the .webloc file to extract the URL (.webloc files store the URL in both the Carbon resource fork and in the data fork in a property list format, this script extracts the URL from both locations but only uses the URL from the resource fork.

Then script uploads the URL to pinboard.in via pinboard.in’s delicious style API. The script gets your pinboard.in username and password from your keychain. To add the username and password to your keychain you’ll want to run this little shell script.

#!/bin/sh

HOST=api.pinboard.in
read -p "Username: " USERNAME
read -p "Password: " -s PASSWORD
security add-internet-password -U -r http -s "$HOST" -a "$USERNAME" -w "$PASSWORD"

You can download the Hazel rule here, but do remember to set up your pinboard.in keychain item before installing it.

Instead of using the entire desktop as a sort of a dropbox for URLs you could easily adapt the script and put it into a automator action or perhaps a system service.

When I started development on MOO I knew I wanted the project to use Mike’s code but I also wanted to take advantage of Cocoa’s Garbage Collection and Snow Leopard’s blocks. I originally tried to retrofit MAKVONotificationCenter to work with GC and with blocks but it rapidly become a very difficult task. So I wrote my own KVO Notification class that was fully GC compatible and worked purely with blocks (no delegate methods at all).

Jumping as quickly into the code as I can, here is an example showing a KVO block that modifies a CoreAnimation layer’s position in responses to changes in the application’s model (example code adapted from MOO’s CGameMapView.m):

void *theBlock = ^(NSString *keyPath, CALayer *self, NSDictionary *change, id identifier)
    {
    self.position = CGPointMake(self.viewPoint.scale * self.modelObject.position.x, self.viewPoint.scale * self.modelObject.position.y);
    };

CALayer *theLayer = ...;
[theLayer addKVOBlock:theBlock forKeyPath:@"modelObject.position" options:0 identifier:@"KVO_IDENTIFIER_1"];
[theLayer addKVOBlock:theBlock forKeyPath:@"viewPoint.scale" options:0 identifier:@"KVO_IDENTIFIER_2"];

I find this, blocks based, style of KVO handling much cleaner and easier to both code and maintain. No worrying about selectors and targets and passing whatever data you need into the delegate method. You just declare your block and register it with the KVO Notification Center.

Clean-up (unregistration) is also straight-forward, although with Garbage Collection enabled applications this isn’t usually even necessary.

If you’re sharp-eyed you might notice that I’ve called one of the block parameters “self”. By providing my own ‘self’ parameter I am obscuring and prevent access to the parent method’s ‘self’ parameter. The reason I am doing this is because I’ve found it is very common to register for notifications for “self” and unless you’re very careful you can end up with a horrible retain cycle caused memory leak. By providing my own self parameter I obscure the parent method’s self and make sure these kind of retains cycles don’t happen.

The code is released under the BSD License on bitbucket (mercurial): http://bitbucket.org/schwa/kvoblocknotificationcenter/. You’ll obviously need use this on Snow Leopard or possibly with Landon Fuller’s plblocks toolchain (although I haven’t tried that myself).

(Update: I’ve posted a movie on flickr of KVO Block Observing in action) (update 2: Joachim Bengtsson has posted a great HOWTO guide for blocks. It also goes into some detail about the “self” problem I mentioned and a better solution (__block variables)

That’s all I have for now. More coming.

I would like to continue improving and adding to TouchCode, but my time is finite and I’m unable to work on it as much as I would like. So when I do work on TouchCode, I appreciate that other people rely on the code and as such I make it a priority to fix bugs before adding new features or components. Other contributors to TouchCode have helped a lot. A lot of bugs and memory leaks have been found and fixed. This is all great. But it is obvious that TouchCode needs more work, it especially needs more unit tests and documentation. To help make time available to improve this I’ve decided to ask TouchCode users for donations via PayPal.

• You do NOT need to donate to use TouchCode (the code is still Open Source under very permissive licenses).
• TouchCode will always remain Open Source. Donations will not change that.
• Donations will be set aside and will allow me to spend more time working on TouchCode – especially the less sexy fun of TouchCode. I will not be using the funds to buy a new MacBook Pro (however tempting that may be).
• Donations will be made with no strings attached. I will not be adding feature X to component Y just because you’ve donated to the project. However if you have an urgent need for something in TouchCode (output support in NSXMLDocument perhaps?) contact me and we can talk.
• No donation too small, no donation too big. Every donation appreciated.

And here’s the PayPal donate button:

I make my living by writing iPhone and Mac OS X for hire. I’ve been doing this for a while with some level of success. But ever since the iPhone SDK was announced earlier this year I’ve been getting many, many more work enquiries than I could possibly handle. I’ve often referred enquiries to friends who I have either worked with in the past or whose work I respect. But this ad-hoc system doesn’t scale very well.

The Solution:

To try and make this informal referral approach work I’ve set up a private invite only Google Group called “iPhone Software Professionals”. Currently this group is made up of a handful (more than 10 less than 1000) software developers who specialise in iPhone development (although I’d say all are equally capable on Mac OS X). The group is made up of either people I have worked with personally (and would love to work with again) or people whose work has generated such a reputation that I would have no problem recommending them to a potential client.

The list is currently made up of software developers but I would like to open it open it up to any independent professional involved in the production of iPhone software. This includes, but is not limited to usability experts, graphic designers, quality assurance experts and so on.

The group will probably remain quite small, with new members invited and referred only by current members. There is no commission or finder’s fee involved, the group is just an informal group of professionals forwarding work that would otherwise be rejected.

Looking for an iPhone Software Professional?

So if you have some iPhone software that needs to be written then I think I might be able to find someone to help you out. I might be able to help you myself, but if I have more work than I can handle (which currently is very likely) I’ll forward your request to the group. Either way contact me directly at iphoneswpro@toxicsoftware.com and I’ll try make sure your software gets written.

Update

Please do not request an invite directly via Google Groups. See http://toxicsoftware.com/iphoneswpro/ for information on how to join the group. Essentially it helps if you or your work is known and respected by myself or other members of the group. You can use the email address to send a request directly to me.

If you’re not invited into the group please do not take it personally. I’m trying to keep a good balance between job leads posted to the group and freelancers able to consume the job leads. If the balance is good (or there are too few job leads) we will not be adding new developers to the group.