Now we’re going to start moving much faster.

When we approach Cocoa with Interface Builder, we have to do everything stepwise (pardon the pun). A Cocoa tutorial usually involves performing many steps in Interface Builder and occasionally digressing into code, as if code was a bad thing (although Objective-C source code is kind of ugly). But after a while, my short-term memory gets overloaded. “Did I just set that menu action?”, I wonder, then “have I told Interface Builder about my new class?” and “did I remember to connect that button?” This doesn’t just lead to mistakes for the reader; it’s also a frequent source of errors in Cocoa books (as I unhappily experienced with the first one I used).

Also, stepwise presentations of Cocoa sometimes require that important elements of a project appear ahead of their context, which has left me confused more than once, and leafing back and forth through a long sequence of interface building instructions is not happy programming.

But now, because I can present everything in Ruby, I can place much more of our examples in front of you at once. I think you’ll find them surprisingly self-explanatory. So in general, I’ll let the code talk more than me and refer you to the searchable online Cocoa documentation in Xcode. If you want to know about any of the “NS” classes you see here, look there first.

Finally, I’ve noticed that occasionally someone posts to a Cocoa message board asking how they can use Cocoa without Interface Builder. The answer they usually get goes something like this: “Don’t do it. You’ll write too much code, and you’ll probably get it wrong.” I’ll show you a way to do it; you can then decide for yourself.

In the next chapter, we will embed an IRB console in a text view. As a preliminary step, let’s display a text view inside a window. Put the code below in a file called “console.rb”. Save it in your project directory and run your application.

class ConsoleWindowController < OSX::NSObject
  attr_accessor :window, :textview, :console

  def initWithFrame(frame)
    init
    styleMask = OSX::NSTitledWindowMask + OSX::NSClosableWindowMask +
    OSX::NSMiniaturizableWindowMask + OSX::NSResizableWindowMask
    @window = OSX::NSWindow.alloc.initWithContentRect_styleMask_backing_defer(
    frame, styleMask, OSX::NSBackingStoreBuffered, false)
    @textview = OSX::NSTextView.alloc.initWithFrame(frame)
    @console = nil # to be completed later...
    with @window do |w|
      w.setContentView scrollableView(@textview)
      w.setTitle "RubyCocoa Console"
      w.setDelegate self
      w.center
      w.makeKeyAndOrderFront(self)
    end
    self
  end

  def run
    # to be completed later...
  end

  def windowWillClose(notification)
    OSX::NSApplication.sharedApplication.terminate(self)
  end

  def windowShouldClose(notification)
    @alert = OSX::NSAlert.alloc.init
    with @alert do |a|
      a.setMessageText(
        "Do you really want to close the console?\nYour application will exit.")
      a.setAlertStyle(OSX::NSCriticalAlertStyle)
      a.addButtonWithTitle("OK")
      a.addButtonWithTitle("Cancel")
      a.beginSheetModalForWindow_modalDelegate_didEndSelector_contextInfo(
        window, self, "alertDidEnd:returnCode:contextInfo:", nil)
    end
    false
  end

  def alertDidEnd_returnCode_contextInfo(alert, code, contextInfo)
    window.close if (code == 1000)
  end
end

def with(x)
  yield x if block_given?; x
end if not defined? with

def scrollableView(content)
  scrollview = OSX::NSScrollView.alloc.initWithFrame(content.frame)
  clipview = OSX::NSClipView.alloc.initWithFrame(scrollview.frame)
  scrollview.setContentView(clipview)
  scrollview.setDocumentView(content)
  clipview.setDocumentView(content)
  content.setFrame(clipview.frame)
  scrollview.setHasVerticalScroller(1)
  scrollview.setHasHorizontalScroller(1)
  scrollview.setAutohidesScrollers(1)
  resizingMask = OSX::NSViewWidthSizable + OSX::NSViewHeightSizable
  content.setAutoresizingMask(resizingMask)
  clipview.setAutoresizingMask(resizingMask)
  scrollview.setAutoresizingMask(resizingMask)
  scrollview
end

class ApplicationDelegate < OSX::NSObject
  def applicationDidFinishLaunching(sender)
    $consoleWindowController = ConsoleWindowController.alloc.initWithFrame(
    [30,20,600,300])
    $consoleWindowController.run
  end
end

# set up the application delegate
$delegate = ApplicationDelegate.alloc.init
OSX::NSApplication.sharedApplication.setDelegate($delegate)

Whenever I look at the above code, I can’t help but think “so much functionality, so little code!”

You can probably understand everything in the code above with no further explanation. But if you’d like a guided tour, let’s begin at the end of the file, where we set the application delegate. Cocoa has a special singleton object that represents the currently-running application. You can get it from Ruby by calling OSX::NSApplication.sharedApplication. We get it and set its delegate to an instance of the ApplicationDelegate class that we defined above. That class is responsible for creating our console window when the application has finished launching. That’s how we can create objects on startup without using a nib file.

Our ConsoleWindowController class is a subclass of NSObject (there’s also a special class called NSWindowController, but it’s mainly useful for loading windows defined in nib files). It has an instance variable called @window that we set to the NSWindow object that we create (look up the initialization function if you want to know more about it). Then it creates the NSTextView that we will put in our window using the window’s setContentView method.

Now, perhaps you already know this, but it’s not so easy to put a text view in a window if you want it to scroll. Instead of directly inserting the text view, you have to put it in an NSScrollView and make the scroll view the window’s content view. But you can’t just do that, either. In between the NSTextView and the NSScrollView, you need an NSClipView to help manage things. Interface Builder hides this dirty laundry from us. But I believe I’ve worked out everything that we need to do and put it in a little reusable function that I called scrollableView in the code shown. It takes a view as an argument (typically an NSTextView) and returns a scroll view that encloses it. See the Cocoa documentation for details on individual pieces.

Back in our window’s initialization function, we set a few properties of our window and then display the window on screen. The “with” call is something that I added for appearance only; it’s defined a few lines later in the file.

That’s enough to get our window on the screen. Move it around, resize it, and type enough in it to get it to scroll. You’ll notice that no keyboard shortcuts work (except to quit) because we’re running with a stripped-down menu. We’ll fix that later.

There are a few more functions on our window controller that we haven’t discussed yet. Because we set our controller to be the window’s delegate, we can use these functions to detect significant events involving the window. For example, when the window closes, our windowWillClose method will get called, and it in turn will tell the application to exit by sending it the terminate message. More interestingly, when a person clicks on the window’s close button (the red one in the top left corner), we’ll get a windowShouldClose message that we can use to present the user with an alert sheet for confirmation. That in turn will call alertDidEnd_returnCode_contextInfo when the sheet is closed. Again, the Cocoa documentation will tell you more about this, and again, when have you had so much fun with so few lines of code?