Lap Cat Software Blog

I know, I’ve been neglecting my blog again. My excuse is that I’ve been working on a secret project, so secret that if I told you, I’d have to buy you a pitcher of margaritas and hope you forgot. It’s not quite Top Secret: more like Middle Secret. (No, it wasn’t TomKat’s wedding.)

As promised, I’ll talk about Cocoa programming, specifically, WebKit programming. (Technically, WebKit is not Cocoa — at least, it’s not included by Cocoa.h — but you can use it in your Cocoa projects, sopleasedonotsueme!) As usual, the story begins with a bug report from a Vienna user. I swear, Vienna is no more buggy than your average app, or ant hill. At any rate, I don’t think that this bug was really our fault. The user reported that after a lost internet connection was restored, Vienna’s web browser couldn’t reload a page that had initially failed to load. However, Vienna’s reload button just uses the WebKit action -[WebView reload:], and Safari, which also uses WebKit, can reload a page once the internet connection is restored.

The class reference for WebView says that its reload: method Reloads the current page. That’s helpful. Luckily, WebKit is open source. In the file WebView.m, we find the implementation for the action:

- (IBAction)reload:(id)sender
{
    [[self mainFrame] reload];
}

Ok, that makes sense. Yet the class reference for WebFrame, which is slightly more helpful, says that its reload method Reloads the initial request passed as an argument to loadRequest:. Vienna does pass an NSURLRequest as an argument when calling loadRequest: on the mainFrame of the WebView. Why doesn’t the page get reloaded? Returning to the source, the file WebFrame.m contains the implementation:

- (void)reload
{
    [_private->frameLoader reload];
}

In WebFrame.h, we see that _private is an instance variable:

@interface WebFrame : NSObject
{
@private
    WebFramePrivate *_private;
}

Back in WebFrame.h, we can see that frameLoader is, in turn, an ivar of the class WebFramePrivate:

@interface WebFramePrivate : NSObject
{
@public
    WebFrameView *webFrameView;
    WebFrameLoader *frameLoader;

Finally, in WebFrameLoader.m we see the problem:

- (void)reload
{
    WebDataSource *ds = [self dataSource];
    if (ds == nil)
        return;

    NSMutableURLRequest *initialRequest = [ds request];

The WebFrame does not keep a reference to the NSURLRequest! The initial request comes from the data source, but the documentation for -[WebFrame loadRequest:] indicates that that there is no (committed) data source until data has been received. Obviously, no data has been received if there was no internet connection. When there is no data source, reloading the page does, well, nothing. In other words, the description of -[WebFrame reload] should be amended with, Now, where did I put that initial request? I thought I had it around here somewhere. Check under the bed.

The solution to this problem is to keep your own reference to the NSURLRequest and override -[WebView reload:], as follows.

-(IBAction)reload:(id)sender {
    if ([[self mainFrame] dataSource] == nil) {
        [[self mainFrame] loadRequest:myRequest];
    } else {
        [super reload:sender];
    }
}

I’ve created a demonstration project that contrasts this with the default reload: method. To see how they work (or don’t, as the case may be), build and run the application, turn off your net connection, press the Load button, turn your connection back on, and then experiment with the Reload buttons. You can see in the run log that both dataSource and provisionalDataSource are nil.

Die Sauerkraut ist in mein Lederhosen.

This is the first of a series of posts (two) on the method -[NSWorkspace openURLs: withAppBundleIdentifier: options: additionalEventParamDescriptor: launchIdentifiers:], described in the NSWorkspace Class Reference. The first post will consist entirely of naming the method, because just typing it has given me carpal tunnel syndrome.

My cat graciously offered to type, so we’ll press ahead. Vienna has a built-in WebKit browser that allows you to follow links in a feed without switching to another app. There is a preference to choose whether to open links in Vienna or in your default web browser (in my case, Safari). Opening an array of URLs in your default web browser can be accomplished by calling the above mentioned method with the parameter withAppBundleIdentifier: set to nil.

Occasionally I want to override Vienna’s link opening preference. For example, I might want to bookmark some pages in Safari while still doing most of my web browsing in Vienna. (Note to self: implement feature in Vienna to add page to bookmarks.) My very first contribution to the Vienna project was a patch to override the preferred link opening behavior with a keyboard shortcut. I used the shift key, because at that point the option key was reserved for another purpose. The patch would do the opposite of your preference when you shift-clicked a link in the article pane or typed shift-return in the articles list. In other words, it would give you chicken salad, on rye, untoasted, and a cup of tea.

Using the shift key for this feature was a mistake, I later discovered. I received a bug report in the forum from a user who had minimized a Safari window to the Dock. When the user pressed the shift key in Vienna to open a link, the page did indeed open in Safari … extremely … slowly. My new Vienna feature had inadvertently activated the Mac OS X super-slow-motion effect for opening minimized windows. (The only purpose of this effect, as far as I can tell, is to mildly impress Windows users.) I faced another apparent example of relativistic weirdness, as if the shift key created time dilation by accelerating the rest of the system to near light speed, leaving Safari to lumber along like a gorilla. You maniacs! You blew it up! Super slowly!

To make a long story even longer, I fixed the bug in Vienna by switching the modifier key from shift to option. All recent builds of Vienna use the option key to override the browsing preference. My advice to you is to avoid using the shift key in your application as a modifier to open external links. Thank you very little.

How do you call among you the little mouse, the mouse that jumps? Oh, that’s right, we call that one Mighty Mouse. Actually, my cat prefers the keyboard. He must be a hacker at heart. (A hacker and a slicer.)

In the post Single-click renaming in NSTableView, I mentioned that Cocoa gives the appearance of being able to see into the future. Now I’ll describe another example of this phenomenon. Strange things are afoot at the Circle K! Our story begins with a Vienna bug: mouse-clicking in another browser tab didn’t always bring the other tab forward. The bug seemed to occur at random, and that, as you know, is the worst kind of bug. (Though yellow jackets are pretty bad too, I’ve discovered.) So how do we debug de, err, the bug?

Here I come to save the day! Perhaps I’m old school (the Academy), but I find old school methods to be useful, and this looks like the perfect situation for NSLog(). (It’s a little known fact, however, that NS stands for New School.) I’ve uploaded a simple demo application project, TrackingRects, that simulates mouse tracking for Vienna browser tabs with close buttons. The application presents a window containing two larger boxes, or ‘tabs’, each of which contains a smaller box, or ‘close button’. Every box has a mouse-tracking rectangle, or ‘cat’, within its borders, and all of the resulting mouseEntered: and mouseExited: messages are logged.

If you move the mouse in and out of the boxes slowly, then everything works as expected. Weirdness begins to happen, though, if you zip the mouse through the boxes. According to the logs, the mouse has entered the second box before it exited the first box. You can’t be serious! You cannot be serious! Yet logs don’t lie, folks. (Although they do sometimes commit sins of omission.) Apparently, Cocoa likes to send mouseEntered: messages before mouseExited: messages when they’re close enough together. It’s almost as if your mouse were approaching the speed of light, and events that appear in sequence from the mouse’s perspective appear simultaneous from the perspective of the stationary window, because of the principles of special relativity. Wow, you didn’t think you needed to be a rocket scientist to write Cocoa apps, did you?

Moral of the story: Do not rely on the runtime to send event messages to your code in a particular order. And most important, do not do your homework without wearing headphones.

The post is over, thought I’d something more to say.

Greetings, programs! Welcome to another installment of…um…this blog. I’m going to talk about the very important topic of renaming, because nobody is happy with their given name. Can you imagine Eleanor Gow wearing a Ralph Lifschitz dress? When I was born, I was destined to become Kid Dyn-O-Mite!

In earlier versions of Vienna, double-clicking a feed in the folders list started editing the feed’s name. The folders list is an NSOutlineView, which is a subclass of NSTableView and inherits much of the superclass behavior, including the default behavior of editing when a table cell is double-clicked. Daniel Jalkut suggested to me that double-clicking should open a feed’s home page, because the user will probably want to do that much more often than rename the feed. I agreed, but in order to follow his suggestion, I had to override the default behavior of NSOutlineView. It took me six revisions to finally get this right. (svn commit -m "D'oh!") The same technique works for both NSOutlineView and NSTableView, so I’ll examine the more general case.

According to the class reference for NSTableView, you need to do four things to override the default double-clicking behavior.

1. Make the table cell uneditable. One way of doing this would be with the delegate method tableView:shouldEditTableColumn:row:.
2. Set the double action for the table (setDoubleAction:).
3. Set the action for the table (setAction:).
4. Set the target for the table (setTarget:).

However, getting the single-click and double-click behaviors you desire is not as simple as setting the action and double action. The catch is that the table’s action method gets called for many different reasons. For example, the action method gets called as a result of the first click of a double-click. (Ted: No way! Bill: Yes way!) The action method also gets called when you click to make the table the first responder or to change the selection in the table. The irony is—isn’t it ironic, don’t you think?—that the change in table selection or first responder status is a result of your click, but the action method gets called after tableViewSelectionDidChange: or becomeFirstResponder. It’s like the runtime is prescient! There must be some spice in that Cocoa.

What you want is for a single-click to trigger editing only when the table is already the first responder and not when changing the cell selection or double-clicking the cell, but you need to take into account that the selection can change via mouse or keyboard, and the table can become first responder in any number of ways:

1. As the initialFirstResponder of the window
2. As the recipient of a mouse click
3. As the nextKeyView of the first responder
4. As the recipient of a makeFirstResponder: message

Are you exhausted yet? Never fear, because I’ve done the rest of the work for you. The trick to weeding out those ‘retrospective’ single-clicks is to set a short timer that prevents single-click renaming after your non-renaming events.

The following code is adapted from Vienna’s FoldersTree and FoldersView classes. I know it’s bad form to combine your model, view, and controller in one class, but JJTableView does have the virtues of brevity, which is appreciated on the web, and full functionality, when applied to a table in Interface Builder. This code is released under the SHAG license: if you use it in your app and become rich and famous while I linger in poverty and obscurity, I will Silently Hold A Grudge.

#import <Cocoa/Cocoa.h>

@interface JJTableView : NSTableView {
    NSMutableArray * array;
    BOOL canRename;
    IBOutlet NSTextField * textField;
    NSTimer * timer;
}
-(void)doClick:(id)sender;
-(void)doDoubleClick:(id)sender;
-(void)enableClickToRenameAfterDelay;
-(void)enableClickToRenameByTimer:(id)sender;
-(void)renameByTimer:(id)sender;
-(void)startTimerWithTimeInterval:(NSTimeInterval)seconds selector:(SEL)selector;
-(void)stopTimer;
@end

@implementation JJTableView

// NSNibAwaking
-(void)awakeFromNib {
    NSLog(@"awakeFromNib");
    array = [[NSMutableArray alloc] initWithObjects:
        @"1", @"2", @"3", @"4", @"5", nil];
    canRename = NO;
    timer = nil;
    [self setDataSource:self];
    [self setDelegate:self];
    [self setAction:@selector(doClick:)];
    [self setDoubleAction:@selector(doDoubleClick:)];
    [self setTarget:self];
    [self setNextKeyView:textField];
    [textField setNextKeyView:self];
}

// NSResponder (super)
-(BOOL)becomeFirstResponder {
    NSLog(@"becomeFirstResponder");
    BOOL flag = [super becomeFirstResponder];
    if (flag) {
        [self enableClickToRenameAfterDelay];
    }
    return flag;
}

// NSObject (super)
-(void)dealloc {
    [self stopTimer];
    [array release];
    [super dealloc];
}

// Action
-(void)doClick:(id)sender {
    NSLog(@"doClick:");
    if (canRename) {
        int row = [self clickedRow];
        if (row >= 0) {
            [self startTimerWithTimeInterval:0.5 selector:@selector(renameByTimer:)];
        }
    }
}

// DoubleAction
-(void)doDoubleClick:(id)sender {
    NSLog(@"doDoubleClick:");
    [self enableClickToRenameAfterDelay];
}

-(void)enableClickToRenameAfterDelay {
    canRename = NO;
    [self startTimerWithTimeInterval:0.2
        selector:@selector(enableClickToRenameByTimer:)];
}

-(void)enableClickToRenameByTimer:(id)sender {
    NSLog(@"enableClickToRenameByTimer:");
    canRename = YES;
}

-(void)renameByTimer:(id)sender {
    if (canRename) {
        int row = [self selectedRow];
        if (row != -1) {
            [self editColumn:0 row:row withEvent:nil select:YES];
        }
    }
}

-(void)startTimerWithTimeInterval:(NSTimeInterval)seconds selector:(SEL)selector {
    [self stopTimer];
    timer = [[NSTimer scheduledTimerWithTimeInterval:seconds
        target:self
        selector:selector
        userInfo:nil
        repeats:NO] retain];
}

-(void)stopTimer {
    if (timer != nil) {
        if ([timer isValid]) {
            [timer invalidate];
        }
        [timer release];
    }
}

// NSTableDataSource
-(int)numberOfRowsInTableView:(NSTableView *)tableView {
    return (int)[array count];
}

// NSTableDataSource
-(id)tableView:(NSTableView *)tableView
        objectValueForTableColumn:(NSTableColumn *)tableColumn row:(int)rowIndex {
    id value = nil;
    if ((rowIndex >= 0) && ((unsigned int)rowIndex < [array count])) {
        value = [array objectAtIndex:(unsigned int)rowIndex];
    }
    return value;
}

// NSTableDataSource
-(void)tableView:(NSTableView *)tableView
        setObjectValue:(id)object forTableColumn:(NSTableColumn *)tableColumn
        row:(int)rowIndex {
    if ((object != nil) && (rowIndex >= 0) && ((unsigned int)rowIndex < [array count])) {
        [array replaceObjectAtIndex:(unsigned int)rowIndex withObject:object];
    }
}

// NSTableView delegate
-(BOOL)tableView:(NSTableView *)tableView
        shouldEditTableColumn:(NSTableColumn *)tableColumn row:(int)rowIndex {
    return NO;
}

// NSTableView delegate
-(void)tableViewSelectionDidChange:(NSNotification *)notification {
    NSLog(@"tableViewSelectionDidChange:");
    [self enableClickToRenameAfterDelay];
}

@end