Subclase NSWindowController en Swift e init (windowNibName)

En lugar de sobrescribir cualquiera de los métodos init, simplemente puede sobrescribir la propiedad windowNibName y devolver una cadena codificada. Esto le permite llamar al método básico vanilla init para crear el controlador de ventana.

class WindowController: NSWindowController {

    override var windowNibName: String! {
        return "NameOfNib"
    }
}

let windowController = WindowController()

Prefiero esto a llamar a let windowController = WindowController(windowNibName: "NameOfNib") ya que el nombre del nib es un detalle de implementación que debe estar completamente encapsulado dentro de la clase window controller y nunca expuesto fuera (y es simplemente más fácil llamar a WindowController()).

Si desea agregar los parámetros adicionales al método init hacen lo siguiente:

• En su método init personalizado llame a super.init(window: nil). Esto hará que NSWindowController se inicie con la propiedad windowNibName.
• Invalida el método requerido init(coder: NSCoder) para configurar tu objeto o simplemente llamar a fatalError() para prohibir su uso (albiet en tiempo de ejecución).

class WindowController: NSWindowController {

    var test: Bool

    override var windowNibName: String! {
        return "NameOfNib"
    }

    init(test: Bool) {
        self.test = test
        super.init(window: nil) // Call this to get NSWindowController to init with the windowNibName property
    }

    // Override this as required per the class spec
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented. Use init()")

        // OR

        self.test = false
        super.init(coder: coder)
    }
}

let windowController = WindowController(test: true)

Pude solucionar esto simplemente teniendo un método de clase que llama al inicializador de conveniencia, modifica las variables personalizadas y luego devuelve el nuevo objeto.

Así que un método de Objective C init se vería así:

//Class.h
@class PPPlugInInfo;

@interface PPPlugInInfoController : NSWindowController
//...
- (id)initWithPlugInInfo:(PPPlugInInfo *)plugInfo;
//...
@end

//Class.m
#include "Class.h"

@interface PPPlugInInfoController ()
@property (strong) PPPlugInInfo *info;
@end

@implementation PPPlugInInfoController

- (id)initWithPlugInInfo:(PPPlugInInfo *)plugInfo;
{
    if (self = [self initWithWindowNibName:@"PPPlugInInfoController"]) {
        self.info = plugInfo;
    }
    return self;
}

@end

Así es como hice la versión Swift:

class PPPluginInfoController: NSWindowController {
    private var info: PPPlugInInfo!
    class func windowControllerFromInfo(plugInfo: PPPlugInInfo) -> Self {
        var toRet = self(windowNibName:"PPPlugInInfoController")
        toRet.info = plugInfo

        return toRet
    }
}

El golpe de genio en la respuesta de @hamstergene es anular init() también, que se hereda de NSResponder. Ahora se puede introducir un nuevo inicializador y delegar en self.init(windowNibName: NoteWindowName), que a su vez se hereda una vez que los tres inicializadores designados se anulan:

class WindowController: NSWindowController {

    var note: Document! // must be optional because self is not available before delegating to designated init

    convenience init(note: Document) {
        self.init(windowNibName: NoteWindowName)
        self.document = document
    }

    override init(window: NSWindow?) {
        super.init(window: window)
    }

    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    override init() {
        fatalError("init() has not been implemented")
    }
}

Ahora ya no es necesario decirle al controlador de ventanas personalizado desde qué archivo nib cargar. En su lugar, se puede especializar para lo que motivó a la subclase en primer lugar (como participar en algunos jerarquía de documentos, por ejemplo)...

Una actualización de la respuesta de hamstergene.

Esto funciona bien en Xcode Versión 6.1 (6A1052d)

//
//  MainWindowController.swift
//  VHDA Editor
//
//  Created by Holyfield on 20/11/14.
//  Copyright (c) 2014 Holyfield. All rights reserved.
//

import Cocoa

class MainWindowController: NSWindowController {

    //override func windowDidLoad() {
    //    super.windowDidLoad()

        // Implement this method to handle any initialization after your window controller's window has been loaded from its nib file.
   // }

    override init()
    {
        super.init()
        println(__FILE__, __FUNCTION__)
    }

    override init(window: NSWindow!)
    {
        super.init(window: window)
        println(__FILE__, __FUNCTION__)
    }

    required init?(coder: (NSCoder!))
    {
        super.init(coder: coder)
        println(__FILE__, __FUNCTION__)
    }

    override func windowDidLoad() {
        super.windowDidLoad()
        println(__FILE__, __FUNCTION__)
    }

}

Salida de consola:

(…/MainWindowController.swift, init(coder:))
(…/MainWindowController.swift, windowDidLoad())