This class is called CalStoreHelper and it provides you with two methods: one for getting events and the other for getting tasks. An example script shows you concretely how to generate different kinds of output. Below is a small excerpt that shows how to generate CSV output:

You can get the class by cloning the version control repository with Mercurial or by downloading an archive from the repository browser page (the bz2, zip and gz links at the top). Happy hacking.

Choose Between GeekTool and NerdTool

GeekTool and NerdTool are two programs that do the same thing: display stuff on your desktop. The choice between which one to use is up to you but allow me to give a few suggestions:

• If you want to change the text colors used in the display, choose NerdTool (as far as I know, GeekTool can only change the default text color but not the actual colors used for “red”, “blue background”, “bright green” etc.)
• If you want to hack on the program yourself, choose NerdTool (it’s open source).
• If you don’t care about any of the above, choose GeekTool.

Install the Apps

When you’ve chosen which one you’d like to use, download and install it. GeekTool is a preference pane so it lives in your System Preferences, while NerdTool is a regular application which you drag into your Applications folder.

In order to install icalBuddy, download the latest version and unzip the package by double-clicking on it. Open the unzipped folder, double-click on install.command and follow the instructions (you’ll have to press return, input your password and icalBuddy will be installed).

Figure out Your icalBuddy Configuration

So now you need to figure out what to put into the command field in Geek-/NerdTool. First you need to go to the icalBuddy Usage Examples page and browse through it — you might find the kind of output you’re looking for right there, in which case you can just get the command you see there (note that some of the examples require you to add something to the configuration file).

If you’d like to take some of the examples and modify the output a bit, you can fire up your Terminal.app and start experimenting with different arguments. In this case the documentation links will come in handy.

Add Your icalBuddy Command into GeekTool/NerdTool

Once you have your command, you can put it into the app by creating a new “shell” entry:

• GeekTool: Drag the “Shell” geeklet icon (see below) onto your desktop. The properties window for this entry should appear.



• NerdTool: Click the “plus” button (see below) and select “Shell” from the popup. A new entry is created into the list above.

You can then insert your icalBuddy command into the command field in whichever app you’re using (and set the refresh interval in order to specify how often the command should be run):

That’s it. You can then delve into the settings that both GeekTool and NerdTool offer you, like changing the colors and fonts used for the output.

I read somewhere that Safari (or the OS? or iTunes?) sometimes decides to “fix” the mappings of iTunes URL protocol handlers, forcing you to “play cat and mouse” if you decide to prevent iTunes from automagically opening up by removing it as the itms: protocol handler, so I decided that it would be best to try and fix this problem by messing with the iTunes website source via GlimmerBlocker, which I already was using for ad blocking.

I couldn’t find any straightforward directions on how to do this with GlimmerBlocker so I decided to post it here myself once I figured out how to do it. So this is how I prevented iTunes from automatically opening up whenever I open up a store link in my browser:

• Open the GlimmerBlocker “filters” tab and add a new filter, as well as a new rule for this filter.
• Select Whitelist URL, optionally modifying content as the action
• For the Host section, select is as the predicate and type in itunes.apple.com
• Select ignored for both Path and Query
• Switch to the transform tab and type in the following:
replace(/detectAndOpenItunes\(\);/g, "<!-- detectAndOpenItunes() zapped -->");
• Make sure the Only for content-type selection in the bottom-right corner of the dialog sheet is html
• Save

This seems to correctly prevent the iTunes app from opening up whenever a store website is opened, but it still allows for opening the viewed product in the stand-alone app via the “View in iTunes” link on the page.

It’s obvious we need a trash command that we can use instead of rm when we’re not 101% sure we need to actually remove these files, like, right now. Here are a couple of existing solutions I’ve found, my impressions of them, and then my version at the bottom:

osxutils’ trash by Sveinbjörn Þórðarson

This is what I’ve used up until now. It’s a small Perl script that simply manually moves the specified files into the trash folder under the current user’s home directory:

The biggest problem with this is that it moves all trashed files onto the same volume instead of using each volume’s own trash folders (this is not a good idea). It also deals with filename collisions manually, which is a bit volatile. The good thing about this is that it doesn’t follow “leaf” symbolic links, which is in my opinion the expected behaviour (what if I want to trash the link instead of its target?).

osx-trash by Dave Dribin

This one is a lot better. It’s a Ruby script that uses the Scripting Bridge to ask Finder to perform all the actual “heavy lifting” (e.g. moving the files to the trash) which means that each volume’s own trash folders are utilized properly and filename collisions are handled in a standard way:

It also allows you to list all the files that are currently in the trash and empty it (normally or securely). The few minor negative things are the fact that it follows leaf symbolic links and the fact that when you try to trash multiple files you don’t have access rights for, Finder will pop up an authentication dialog separately for each file.

my trash

Due to the few things that I wanted the trash command to do differently, I wrote my own. In order to make sure that filename collisions are handled in the standard manner and that each volume’s trash folders are properly used (just like with Dave Dribin’s script) this one first tries to use the standard system API for trashing files, and if that fails due to the user not having the correct access rights, then asks Finder to trash those files (Finder can authenticate the current user as an administrator and move the files into that user’s trash — if you simply run this program as root, the files will be moved to root’s trash, which is not what we want):

The difference is that this one doesn’t follow leaf symlinks, and when deleting multiple files that you don’t have access rights for, Finder will only show one authentication dialog (I had to implement this kind of “manually” because I couldn’t find any way to accomplish it with the Scripting Bridge). I also copied the idea and implementation of emptying the trash and listing its contents via the Scripting Bridge from Dave’s script. This trash is written in (Objective-)C, for all those extra milliseconds that are so goddamn important when waiting for files to be trashed.

You can go through my trash here.

The Application Kit additions to the NSAppleScript class provide an implementation of the syntax highlighting (which would be the hardest part in implementing something like this) and I already have the ANSIEscapeHelper class that provides the translation of an NSAttributedString to an ANSI-escaped NSString (which would be the second-hardest part in implementing something like this) so writing a command-line program around these two parts was quite simple in the end. The program is called asprint and it has its own page on this site where you can download it.

This is what using asprint looks like:

There was nothing on the horizon about any further additions to GeekTool (or any similar programs) that would provide the features I wanted (although version 3 of GeekTool seems to be in the making, and there’s also the GPL’d NerdTool project which aims to implement a clone of v2 with some changes and fixes), but luckily Yann Bizeul, the author of GeekTool, had released the source code to it, which enabled me to put this feature (and a few others) in. As you can see from the screenshot below, I also took the liberty to rearrange the GUI a bit:

I’ve been running this custom build for a few months now without any problems so I feel reasonably confident about releasing it. No open-source license has been specified for GeekTool 2.1.2 so I unfortunately won’t be releasing the source code for the changes I made. Sorry :(

Download link

First the most important part — here’s the download link:

GeekTool-2.2.1-unofficial-hasseg.org-build.zip (Latest version. Requires Leopard (Mac OS 10.5+)) (Sep 6, 2009: Recompiled the preference pane as 32/64-bit binary with support for garbage collection so that it would not force System Preferences to restart on Snow Leopard.)

GeekTool-2.2.0-unofficial-hasseg.org-build.zip (Requires Leopard. Based on source code from version 2.1.2)

Disclaimer: I will most probably *not* fix bugs in this version or develop it further in any way. This is simply a temporary solution until the next official version of GeekTool comes around (if it includes these features, which I don’t know if it does), or someone else releases something similar.

In order to install it, do the following:

1. Extract the files from the zip archive by double-clicking on it in Finder
2. Double-click on the GeekTool.prefPane file icon in Finder to install it
3. If you already had GeekTool installed, System Preferences will ask if you want to replace it. Select “Replace”, quit and restart System Preferences and open the GeekTool preference pane, verifying that the version label now says “unofficial hasseg.org build.”
4. Unselect the “Enable GeekTool” checkbox in order to kill the old version’s background process, and then select it again in order to run the updated one.

Added Features

ANSI Escape Sequence Support

As said, this version includes support for ANSI escape sequences, including all the supported foreground and background colors (each of which you can change yourself on an entry-by-entry basis in GeekTool’s preferences), intensity (bolding) and underlining (both single and double). Here’s an example of how my (customized) icalBuddy output looks in my GeekTool setup:

In order to learn how to customize icalBuddy’s ANSI-formatted output, please refer to the icalBuddyConfig man page. Also remember that you need to use the -f (or –formatOutput) argument to get formatted output in the first place.

Here’s what the new little preferences window that you can use to customize the actual colors used for displaying ANSI escape colors looks like:

You can specify different colors for each GeekTool entry you have.

UTF-8 Support

This version now supports UTF-8, which means that unicode characters (umlauts, arabic, hebrew etc.) will display correctly (version 2 only supported ASCII).

Text Writing Direction Setting

I had received word from one particular user of icalBuddy from a country where the language is written from right to left (arabic, to be precise,) who had issues with the bullet point sometimes shifting to the right side of the row instead of staying at the left. This was due to the OS X text layout algorithm trying to figure out if it should print characters in a string onto the screen from right to left or from left to right and sometimes failing due to mixtures of latin and arabic characters being on the same line. Now problems such as this can be fixed by explicitly specifying the text layout direction:

So I wrote a Quick Look plugin for just that. I call it ImageFolderQLGenerator and its results, when viewed within Finder, look like this:

Implementing the plugin itself wasn’t very difficult, even for someone as inexperienced in C as me, but the biggest headache has been something that I’ve yet to find a solution to: as you can see, Finder automatically wraps folder thumbnails into these “icon decors” with their page curls and drop shadows and whatnot — I haven’t found any way to prevent this from happening. As far as I know, Finder decides if it wants to do that based on the type of the content (in this case, folders) and there’s nothing you can do to influence its choice. If someone knows a cure for this, please let me know!

You can download ImageFolderQLGenerator here. I’ve released it under the Apache License version 2.0.

The answer, of course, is automating this process, which is very easy. You could do it with a shell script and the open command. You could do it with AppleScript. You could write an Automator workflow. You could train a monkey to do it for you. All of these are quick and easy to set up, copy (when you want to create new “launchers” for a different set of items) and modify (with the exception of the monkey, of course,) but what is a little bit more difficult is to make it possible to pick and choose at invocation time which items in the list you actually want to launch, without permanently modifying the list (so for example, if I want to launch my usual list of “work” items, but this time not the IM client, while still keeping the IM client as part of the permanent list.) This was a feature I really wanted to have, so a simple script wouldn’t suffice.

What I decided to do was to create an application bundle that would store the “launch list” in a file within itself (i.e. in its “Resources” folder) so that you could make copies of this application and each one would have their own list. I would also make it possible to edit this list and launch the items via simple GUI windows. This approach would allow me to display checkboxes next to each item so that the user could easily uncheck anything they didn’t want to launch at that time. The first version of this application, which I implemented with Python, Platypus and Pashua, looked like this:

This worked very well — I could just create copies of this application and give each of them their own names and lists of items to launch very quickly and easily through this simple GUI. And most important: when using any of these launchers, I could quickly uncheck anything I didn’t want to launch before pressing return. But of course, being the perfectionist I am, and wanting a new idea for a small Cocoa project (so that I could teach myself a little bit more Objective-C,) I recently re-implemented the whole thing as a native OS X application. So this is what it looks like now:

I call this new version LaunchList. It’s faster, it looks nicer (see the icons? I like icons.) and it is a lot easier to use. You can use the buttons or menus in the GUI as well as keyboard shortcuts for adding, removing and reordering items, and the application tries to automatically figure out if what you typed in is an application, a file or a web address, and display an appropriate icon (or Quick Look preview.) You can also drag and drop applications, files, folders and web addresses to the main window in order to add them to the list, and have the launcher remember its size and position for the next time you use it.

I have a separate page up for the application, where you can download the latest version and check out the changelog.

The good news is that Google provides a nice, standard POP3 interface for downloading emails from their service, and all of the software required for downloading messages via POP is already installed in Mac OS X Leopard by default. Below I’ll go through all of the steps it took me to set up periodical and automated GMail backups on my Macbook.

The following were my sources for most of the information presented here:

• LifeHacker: Geek to Live: Back up Gmail with fetchmail
• Logic Bound: Backup Gmail Data
• bronski.net: fetchmail & SSL
• Matthias Andree and Paul Elliott on [fetchmail-users]: What is a “local issuer certificate”?

Configure GMail for POP access

1. Go to GMail’s “Forwarding and POP/IMAP” settings
2. Set the “POP access” setting to “Enable POP for all mail (even mail that’s already been downloaded)”
3. Make sure that the “When messages are accessed with POP” setting says “keep Gmail’s copy in the inbox”

Configure fetchmail to Download the Messages

1. Create ~/.fetchmailrc with the following contents (replacing GMAIL_USERNAME, GMAIL_PASSWORD and LOCAL_USERNAME with their real values in your case):

poll pop.gmail.com with proto POP3 and options no dns
user 'GMAIL_USERNAME@gmail.com' there with password 'GMAIL_PASSWORD' is 'LOCAL_USERNAME' here and wants mda "/usr/bin/procmail -d %T"  options ssl keep sslcertck sslcertpath "/Users/LOCAL_USERNAME/.ssl/certs"

This configuration basically tells fetchmail to:

• Connect to the GMail POP server using the POP3 protocol,
• Map your GMail username to your localhost username,
• Deliver the downloaded mail into your local system mailbox (mail spool file),
• Connect using an encrypted SSL connection,
• Strictly check the SSL certificates of the server it connects to against local trusted certificates,
• Search for the local certificates in ~/.ssl/certs
2. Set the proper rights for ~/.fetchmailrc:
    chmod 710 ~/.fetchmailrc
3. Get the pop.gmail.com server’s SSL certificate from the POP port (note that this should be done using a secure, trusted internet connection — otherwise it kind of defeats the purpose):
    openssl s_client -connect pop.gmail.com:995 -showcerts

From the output of this command, copy the part that looks like this:

-----BEGIN CERTIFICATE-----
(a big bunch of characters here)
-----END CERTIFICATE-----

And save it into a file called ~/.ssl/certs/gmailpop.pem.

4. Download the certificate authority (Equifax) root certificate (for example from GeoTrust’s site here, where it says “Equifax Secure Certificate Authority (Base-64 encoded X.509)”), rename it to “equifax.pem” and move it to ~/.ssl/certs/equifax.pem (and just like the previous step, this should be done over a trusted internet connection as well).
5. Hash the certificates in this directory by running:
    c_rehash ~/.ssl/certs/

Optional: Specify the Location for Downloaded Messages

We’ve configured fetchmail to send messages to procmail, which will handle the storing of them in a mail spool file. By default this will be in /var/mail/LOCAL_USERNAME, but if you want to store it somewhere else, you can specify the location in the ~/.procmailrc configuration file. Below is an example (replace LOCAL_USERNAME with your username):

I prefer to exclude my mail spool file from Time Machine backups (because it’s a large file that changes very often which makes it take up a lot of disk space from my backup volume) so I have it located in ~/.mailspool/ like in the above example. This is because in OS X /var is actually a symbolic link to /private/var and Time Machine has a bug where it’s impossible to exclude anything from under that path from backups (for example, if I choose to exclude /private/var/mail in the GUI, it’ll replace this selection with /var/mail automatically, and even though /var/mail is then excluded, it’ll still back up /private/var/mail).

Download Messages with fetchmail

You can now download the mail by running this command (the -v argument is for verbose output):

Unless you only have a few mails in your Gmail box, this command will initially have to be run several times in a row in order to get all of the messages since it only downloads a few hundred messages at a time. The mail spool file containing all of the downloaded messages will then be found in /var/mail/LOCAL_USERNAME (or in whichever location you’ve specified in ~/.procmailrc).

It’s a good idea to set up a launchd job for running this command between regular intervals so that you wouldn’t have to remember to manually do it yourself. Lingon is an ideal GUI app for this purpose. My GMail backup launchd job doesn’t call fetchmail directly, though: it calls this helper Python script that I’ve written. The script does the following:

• Runs fetchmail,
• Displays Growl messages about the result (success or failure, number of messages downloaded if successful, etc.),
• Optionally saves fetchmail’s output into a log file when done.

Feel free to use it (remember to set the values in the “settings” section before running it, though).

Read Downloaded Messages with Thunderbird

In Mozilla Thunderbird, go to Tools > Account Settings… > Local Folders to get to the Local directory path. Go into this directory and create a symbolic link there that points to the mail spool file:

After this you’ll be able to find your backed up GMail messages in a folder called “GMailBackups” under “Local Folders” in Thunderbird.

I used dashboard widgets for a while for getting a quick overview of all of the events I have planned for the day plus any uncompleted tasks I might have, but soon noticed that I don’t actually go and see what’s up in the dashboard very often, which lead to me forgetting some things even though I had them set up as events or tasks in my calendars. The perfect place for displaying events for the day and any uncompleted tasks for me would thus be the desktop, which, even though it is most of the time obscured by a bunch of windows, I’ll occasionally glance at during the day. GeekTool is the solution for displaying any textual output from the shell on an OS X desktop, and I was using that already for some other things, so all that I needed was a CLI application or script that would get the events and tasks from the calendar store and output them in a nice readable way.

The only solution for this that I could find was made by some people over at macosxhints.com, who had come up with a Perl script for this purpose, but it didn’t seem very generic or reliable, so I started implementing my own version. I first tried to do it in Python, but soon ran into complexity issues with recurring events. Also, it wasn’t very fast. This was basically when I slapped myself in the head and realized that Apple has already provided a very nice API in Objective-C for getting calendar items from the database and working with them. With this, I started over and managed to come up with icalBuddy. Here’s an example of what its output might look like (this is a list of uncompleted tasks, separated by calendar:)

Here’s what it looks like on my desktop via GeekTool:

I have a separate page up on this site for the application itself, including download links, examples of use and documentation (read: HTML version of the man page,) so head on over there if you’re interested.