Not for human consumption. Yet.

The incompatibility with the File Tagging plugin hasn’t yet been worked out as the source isn’t available. If you’re using the download from B5X, be sure to disable this plugin until the conflict is resolved.

Note that some features (such as the “smart replace” pictured above) require setting the feature level to “developer”. You can do this by running the following two commands, then relaunching:

defaults write com.blacktree.Quicksilver "Cutting Edge Features" -bool yes
defaults write com.blacktree.Quicksilver "Feature Level" 3

A few new features and general stability improvements, but mostly a very thorough cleanup of the source code, so you can actually compile it now.

Compilation Instructions

Open Xcode preferences, scroll across to Source Trees and add one with a Setting Name of “QSFrameworks” and path of /Applications/Quicksilver.app/Contents/Frameworks/.

Then unzip Quicksilver.xcodeproj.zip, and open the Quicksilver.xcodeproj project in Xcode. Make sure you set the Active Build Configuration to “Release”. Click the Build button and you’re away.

Note: This build appears to be incompatible with the File Tagging plugin.

Bug fixes

A lot of features were buried in the source, available only by setting some preferences to allow them. Mostly it was due to buggy implementation or pending improvements. I managed to resurrect a few of these nifty ones and fix a few old bugs that have annoyed me for ages.

Color handling

Color handling was commented out in the Quicksilver source; probably because it resulted in errors. A simple change in the source allowed correct handling of color values, and the code for drawing the icon was already there. I added functionality to allow dropping colors from the Quicksilver object pane into color wells and the like - which is what makes this useful.

Uninstalled plugins

Added a plugin set to the plugins preference pane to list plugins that you haven’t yet installed or downloaded. Not sure why this was commented out; I didn’t have to add any new code here.

Triggers

There was a very annoying bug in the triggers preference pane that haunted me from the day I started using Quicksilver. Switching to the iTunes trigger set resulted in errors, and often froze or messed up Quicksilver. Finally, it’s fixed, and we can see and use these triggers.

Speaking of plugins; I think I heard mention of a “plugin check bug” fixed somewhere, but it wasn’t working for me so I’ve also fixed the issue where the plugin list would be blank until you hit refresh.

Miscellaneous bug fixes

Other things like crashing when you try to relaunch with the “Customize” preference pane open, and with the source, hundreds of warnings when trying to compile, errors in the shell scripts when working in a path with non-alphanumeric characters, etc. have also been fixed.

Tidy up

[I wonder] how long it’ll take people to notice the Frankensteinian nature of the source and respond - appropriately - with pitchforks. Alcor

I’ll have to agree with Alcor - to say the source is a mess would be an understatement. There are hundreds of compiler warnings, unused or unimplemented features, classes, objects, code, structures, nibs, etc. Hundreds. I’ve tried to remove as much of the redundant or test code as possible and I’ve yet to reach the end. Mind you, I’ve been doing this for hours a day for the past week. The formatting and indentation is almost as bad. I’m cleaning that up too, with some good old regular expressions and elbow grease. As I go, I’m also trying to improve the logic where I see potential for improvement. Already the application is feeling more responsive but I want to also reduce the memory footprint.

Why go to all this trouble? Mainly, to

• Make the source more readable; make it easier for people to understand what’s going on.
• Improve the performance of the application in both speed and memory usage.
• Fix existing bugs and add new features.

In the meantime, I’ll continue my clean up of the Quicksilver source and when it’s lookin’ fine perhaps post it up (the QS license doesn’t really say much about the source, so I might have to ask Alcor first. Perhaps he’d like to add it to the subversion repository after reviewing?).

Lastly, let me just say, I’ve learnt a lot from looking at the source code to Quicksilver. There are some very neat tricks in there, and great little snippets that could be very useful elsewhere. So thank you Mr. Jitkoff; thank you for writing the application, and thank you for the releasing the source code. It is highly appreciated.

One thing I disagree with, though, is the excessive use of the “do shell script” AppleScript. I like the “Run Command in Shell” action just fine. But if you want an icon, writing an Obj-C wrapper isn’t too much work. Especially since you have this source code.

I’ve also got a bit more on Quicksilver coming up shortly.

If you’re interested in this sort of thing, you can download the Quicksilver Smoke Actions plugin here.

It couldn’t be easier. Just drop the file or folder that you want the icon from onto IconGrabber, and choose a place to save it. The extension you choose determines the format, otherwise it defaults to tiff. That’s it!

If you’re a Quicksilver user, you can use the IconGrabber Quicksilver plugin. (It doesn’t require the IconGrabber application.) Once installed, you’ll get a “Save Icon To…” action. Not only can you save the icons of files and directories, you can save the icon of whatever appears in the first “object” pane. This is extremely handy.

Enjoy!

Update:

The Quicksilver plugin is now at version 0.95. Notable changes include:

• Forcing direct object to load icon.
• Indirect object for “Save Icon To…” starts at IconGrabberSaveTo defaults key. Format used is set by the IconGrabberFormat defaults key. Uses png by default.
• “Save Icon As…” action added. Indirect objects have different image formats. Images are saved to the IconGrabberSaveTo defaults key.
• Image files have the IconGrabberAppend key appended to the filename (”-icon” by default).

For example, if you want to use the tiff format for the “Save Icon To…” action, run defaults write com.blacktree.Quicksilver IconGrabberFormat tiff.

If you want to change the directory the images are generated in by “Save Icon As…”, run defaults write com.blacktree.Quicksilver IconGrabberSaveTo "~/NewDirectory".

Addressed some crashes related to switching applications Fixes for Leopard

If you’re developing plugins for Quicksilver and running Leopard, you may want to download this new release.

There’s absolutely no documentation on how to write an internal command for Quicksilver anywhere and figuring out the internal workings of the application can be frustrating at best. This tutorial aims to fill that void and, like some of my other Quicksilver-related articles, provide you with the knowledge and resources to make a working internal command.

Prerequisites

An internal command is written much like a standard Quicksilver action, so the only thing required is the Xcode project template for creating Quicksilver plugins. (However, if you really need another project template for writing internal commands, just ask)

It would also be a good idea to familiarize yourself with writing a Quicksilver action before going on.

Info.plist keys

Somewhere in the plist, you need to set QSLoadImmediately to true for Quicksilver to load your internal command properly. That’s simply:

<key>QSLoadImmediately</key>
<true/>

To register our internal command with Quicksilver, we need to add QSInternalMessages to the QSRegistration key. So, find the QSRegistrationTemplate key, rename it to QSRegistration, and configure the command in the following manner:

<key>QSRegistration</key>
<dict>
    <key>QSInternalMessages</key>
    <dict>
        <key>testInternalCommand</key>
        <dict>
            <key>target</key>
            <string>testCommand</string>
            <key>action</key>
            <string>doTestCommand:</string>
            <key>name</key>
            <string>Just a Test</string>
            <key>icon</key>
            <string></string>
        </dict>
        ...

What do the keys mean?

target

The class that will be running the internal command. This needs to be a singleton. More on that later.

action

An instance method that the target class responds to; this is the command.

name

A brief and meaningful name for your internal command.

icon

An icon for your command. You can use an identifier like com.blacktree.Quicksilver or com.apple.AddressBook and Quicksilver will load up the appropriate icon for you.

The class

As I mentioned earlier, the class that runs the command should be a singleton - that means only one copy of the class is instantiated and used (Apple’s documentation on singletons). The internal command will be called like: [[targetClass sharedInstance] doActionMethod:nil] where targetClass is the class you specified under target and doActionMethod: is the method for the key action in the Info.plist.

From the example Info.plist excerpt given above, the class that would be written would look something like this:

// testCommand.h

#import <QSCore/QSActionProvider.h>

@interface testCommand : QSActionProvider
{
}
+ (id)sharedInstance;
-(IBAction)doTestCommand:(id)sender;
@end

// testCommand.m

#import "testCommand.h"

@implementation testCommand

// Following few methods to make this class a singleton

static testCommand *sharedTestCommandManager = nil;

+ (id)sharedInstance {
    if (sharedTestCommandManager == nil) {
        [[self alloc] init]; // assignment not done here
    }
    return sharedTestCommandManager;
}
+ (id)allocWithZone:(NSZone *)zone{
    //    @synchronized(self) {
    if (sharedTestCommandManager == nil) {
        sharedTestCommandManager = [super allocWithZone:zone];
        return sharedTestCommandManager;  // assignment and return on first allocation
    }
    //      }
    return nil; //on subsequent allocation attempts return nil
}
- (id)copyWithZone:(NSZone *)zone{
    return self;
}
- (id)retain{
    return self;
}
- (unsigned)retainCount{
    return UINT_MAX;  //denotes an object that cannot be released
}
- (void)release{
    //do nothing
}
- (id)autorelease{
    return self;
}

// Method to perform the internal command

-(IBAction)doTestCommand:(id)sender
{
    NSLog(@"Running test internal command...");
    // do something useful
}

@end

And that’s it. Possibly the shortest ever Quicksilver development tutorial you’re going to see in a while.

I thought I’d drive home the usefulness of internal commands by showing off a little something I’ve been playing with for a while.

A simple internal command allows any interface to smoke

Yeah, it’s the cube interface. Smoking.

In fact, with this internal command, I can make anything smoke.

Summary

• Add QSLoadImmediately key, set to true
• Add QSInternalMessages to the QSRegistration key
• Write singleton class that runs the command

As always, I’ll be thrilled to see what you come up with.

Standard Animation Effects

Quicksilver adds a category to the NSWindow class to allow for some pretty cool effects. The following should be pretty self-explanatory:

-(void)pulse:(id)sender;
-(void)flare:(id)sender;
-(void)shrink:(id)sender;
-(void)fold:(id)sender;

What these methods essentially mean, is that you can pulse, flare, shrink or fold any window you have a reference to in a plugin - whether it’s an interface or dialog or something completely different. Eg, just call [window shrink:nil] and watch that NSWindow shrink down to nothing, or [window flare:nil] to make it burst away!

Private Core Graphics Animations

Quicksilver also adds methods to use private Core Graphics transitions for instances of NSWindow or its subclasses. The main method is defined something like:

- (void) displayWithTransition:(CGSTransitionType)type option:(CGSTransitionOption)option duration:(float)duration;

The transitions you have access to are fade, zoom, reveal, slide, warp-fade, swap, warp-switch and the famous cube animation. You can use them on any window, for example:

[window displayWithTransition:CGSCube option:CGSLeft duration:1.3];

To learn more about Core Graphics transitions, see the Core Graphics ebook, or play around with the Core Transitions Framework.

Quicksilver’s CGSPrivate.h file is missing CGSFlip, but you can run the Dashboard-style flip effect by using the integer 9.

Quicksilver’s own animations

Alcor has used various techniques to write several very interesting animation effects into Quicksilver. You’ll be familiar with some of these (just watch the Primer interface activate and deactivate) but for whatever reason, many of these bizarre animations never made into an interface. They’re really very clever. I’ve played around with some of these:

• QSGrowEffect
• QSShrinkEffect
• QSSlightGrowEffect
• QSSlightShrinkEffect
• QSBingeEffect
• QSPurgeEffect
• QSExplodeEffect
• QSExtraExtraEffect
• QSShakeItLikeAPolaroidPictureEffect
• QSBoobTubeEffect
• QSVExpandEffect
• QSVillainousKryptonianEffect
• QSMMBlowEffect
• QSLudicrousSpeedEffect

Very interesting to look at, but how does one use these effects?

As we are dealing with Quicksilver, the solution is (as expected) very elegant. There are very simple methods to set a show, hide or execute effect for a window. These methods don’t even require an explanation; they’re so simple:

// Effect for showing the QSWindow
[window setShowEffect:[NSDictionary dictionaryWithObjectsAndKeys:@"QSSlightGrowEffect",@"transformFn",@"show",@"type",[NSNumber numberWithFloat:2.0],@"duration",nil]];

// Effect for hiding the QSWindow
[window setHideEffect:[NSDictionary dictionaryWithObjectsAndKeys:@"QSSlightShrinkEffect",@"transformFn",@"hide",@"type",[NSNumber numberWithFloat:2.0],@"duration",nil]];

// The "execute" effect is slightly different:
[window setWindowProperty:[NSDictionary dictionaryWithObjectsAndKeys:@"QSExplodeEffect",@"transformFn",@"hide",@"type",[NSNumber numberWithFloat:1.5],@"duration",nil] forKey:kQSWindowExecEffect];

Easy!

Sample plugin

I don’t dare mention all this private goodness and not even provide a demonstration. I’ve created an “Effects” plugin that will allow you to change the activate, deactivate and execute effects for any Quicksilver interface temporarily to play around with the effects. Just for good measure, I’ve also thrown in an action that lets you explore Core Graphics transitions as well.

This is not really a bona fide Quicksilver plugin; while it does let you have some fun with the effects, it’s not very user-friendly and doesn’t save your configuration. If these animations prove to be popular, then I’ll write a proper plugin to let you configure the effects more easily (probably through a preference pane) and remembers your settings.

Download Quicksilver Effects Plugin

Usage

Type in the name of the effect you want, then use “Set Hide Effect”, “Set Show Effect” or the “Set Exec Effect” action. The list of effects is given above; just type one in and run the relevant action.

To run a Core Graphics transition, type in the name of the transition, and use the “Run CoreGraphics Transition” action. You can optionally specify a direction in the indirect selector. (You can enter text in the direct and indirect selectors by pressing the period “.” key)

For example

• “QSBingeEffect” -> Set Show Effect
• “QSPurgeEffect” -> Set Hide Effect
• “QSExplodeEffect” -> Set Exec Effect
• “flip” -> Run CoreGraphics Transition
• “slide” -> Run CoreGraphics Transition -> “up”
• “swap” -> Run CoreGraphics Transition -> “inout”

Pictures show how to use the effects plugin. Actual animations are not shown.

Quicksilver has many such hidden surprises and nifty time-saving methods; it’s so well thought out and full of these amazing gems!

What do you think about these animations? Be sure to let me know if you’d like a proper, more user-friendly plugin to use these effects.