CPApplication.j

Go to the documentation of this file.

/*
 * CPApplication.j
 * AppKit
 *
 * Created by Francisco Tolmasky.
 * Copyright 2008, 280 North, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */



@typedef CPModalSession

var CPMainCibFile               = @"CPMainCibFile",
    CPMainCibFileHumanFriendly  = @"Main cib file base name",
    CPEventModifierFlags = 0;


@protocol CPApplicationDelegate <CPObject>

@optional
- (CPApplicationTerminateReply)applicationShouldTerminate:(CPApplication)sender;
- (CPString)applicationShouldTerminateMessage:(CPApplication)sender;
- (void)applicationDidBecomeActive:(CPNotification)aNotification;
- (void)applicationDidChangeScreenParameters:(CPNotification)aNotification;
- (void)applicationDidFinishLaunching:(CPNotification)aNotification;
- (void)applicationDidResignActive:(CPNotification)aNotification;
- (void)applicationWillBecomeActive:(CPNotification)aNotification;
- (void)applicationWillFinishLaunching:(CPNotification)aNotification;
- (void)applicationWillResignActive:(CPNotification)aNotification;
- (void)applicationWillTerminate:(CPNotification)aNotification;

@end

var CPApplicationDelegate_applicationShouldTerminate_           = 1 << 0,
    CPApplicationDelegate_applicationShouldTerminateMessage_    = 1 << 1;

@implementation CPApplication : CPResponder
{
    CPArray                     _eventListeners;
    int                         _eventListenerInsertionIndex;

    CPEvent                     _currentEvent;
    CPWindow                    _lastMouseMoveWindow;

    CPArray                     _windows;
    CPWindow                    _keyWindow;
    CPWindow                    _mainWindow;
    CPWindow                    _previousKeyWindow;
    CPWindow                    _previousMainWindow;

    CPDocumentController        _documentController;

    CPModalSession              _currentSession;

    //
    id <CPApplicationDelegate>  _delegate;
    CPInteger                   _implementedDelegateMethods;

    BOOL                        _finishedLaunching;
    BOOL                        _isActive;

    CPDictionary                _namedArgs;
    CPArray                     _args;
    CPString                    _fullArgsString;

    CPImage                     _applicationIconImage;

    CPPanel                     _aboutPanel;

    CPThemeBlend                _themeBlend;
}

+ (CPApplication)sharedApplication
{
    if (!CPApp)
        CPApp = [[CPApplication alloc] init];

    return CPApp;
}

- (id)init
{
    self = [super init];

    CPApp = self;

    if (self)
    {
        _eventListeners = [];
        _eventListenerInsertionIndex = 0;

        _windows = [[CPNull null]];
    }

    return self;
}

// Configuring Applications

- (void)setDelegate:(id <CPApplicationDelegate>)aDelegate
{
    if (_delegate == aDelegate)
        return;

    _implementedDelegateMethods = 0;

    var defaultCenter = [CPNotificationCenter defaultCenter],
        delegateNotifications =
        [
            CPApplicationWillFinishLaunchingNotification, @selector(applicationWillFinishLaunching:),
            CPApplicationDidFinishLaunchingNotification, @selector(applicationDidFinishLaunching:),
            CPApplicationWillBecomeActiveNotification, @selector(applicationWillBecomeActive:),
            CPApplicationDidBecomeActiveNotification, @selector(applicationDidBecomeActive:),
            CPApplicationWillResignActiveNotification, @selector(applicationWillResignActive:),
            CPApplicationDidResignActiveNotification, @selector(applicationDidResignActive:),
            CPApplicationWillTerminateNotification, @selector(applicationWillTerminate:),
            CPApplicationDidChangeScreenParametersNotification, @selector(applicationDidChangeScreenParameters:)
        ],
        count = [delegateNotifications count];

    if (_delegate)
    {
        var index = 0;

        for (; index < count; index += 2)
        {
            var notificationName = delegateNotifications[index],
                selector = delegateNotifications[index + 1];

            if ([_delegate respondsToSelector:selector])
                [defaultCenter removeObserver:_delegate name:notificationName object:self];
        }
    }

    _delegate = aDelegate;

    var index = 0;

    for (; index < count; index += 2)
    {
        var notificationName = delegateNotifications[index],
            selector = delegateNotifications[index + 1];

        if ([_delegate respondsToSelector:selector])
            [defaultCenter addObserver:_delegate selector:selector name:notificationName object:self];
    }

    if ([_delegate respondsToSelector:@selector(applicationShouldTerminate:)])
        _implementedDelegateMethods |= CPApplicationDelegate_applicationShouldTerminate_;

    if ([_delegate respondsToSelector:@selector(applicationShouldTerminateMessage:)])
        _implementedDelegateMethods |= CPApplicationDelegate_applicationShouldTerminateMessage_
}

- (id)delegate
{
    return _delegate;
}

- (void)finishLaunching
{
    // At this point we clear the window.status to eliminate Safari's "Cancelled" error message
    // The message shouldn't be displayed, because only an XHR is cancelled, but it is a usability issue.
    // We do it here so that applications can change it in willFinish or didFinishLaunching
#if PLATFORM(DOM)
    window.status = " ";
#endif

    // We also want to set the default cursor on the body, so that buttons and things don't have an iBeam
    [[CPCursor arrowCursor] set];

    var bundle = [CPBundle mainBundle],
        delegateClassName = [bundle objectForInfoDictionaryKey:@"CPApplicationDelegateClass"];

    if (delegateClassName)
    {
        var delegateClass = objj_getClass(delegateClassName);

        if (delegateClass)
            [self setDelegate:[[delegateClass alloc] init]];
    }

    var defaultCenter = [CPNotificationCenter defaultCenter];

    [defaultCenter
        postNotificationName:CPApplicationWillFinishLaunchingNotification
        object:self];

    var types = [bundle objectForInfoDictionaryKey:@"CPBundleDocumentTypes"];

    if ([types count] > 0)
        _documentController = [CPDocumentController sharedDocumentController];

    var needsUntitled = !!_documentController,
        URLStrings = nil;

#if PLATFORM(DOM)
    URLStrings = window.cpOpeningURLStrings && window.cpOpeningURLStrings();
#endif

    var index = 0,
        count = [URLStrings count];

    for (; index < count; ++index)
        needsUntitled = ![self _openURL:[CPURL URLWithString:URLStrings[index]]] && needsUntitled;

    if (needsUntitled && [_delegate respondsToSelector:@selector(applicationShouldOpenUntitledFile:)])
        needsUntitled = [_delegate applicationShouldOpenUntitledFile:self];

    if (needsUntitled)
        [_documentController newDocument:self];

    [_documentController _updateRecentDocumentsMenu];

    [defaultCenter
        postNotificationName:CPApplicationDidFinishLaunchingNotification
        object:self];

    [[CPRunLoop currentRunLoop] limitDateForMode:CPDefaultRunLoopMode];

    _finishedLaunching = YES;
}

- (void)terminate:(id)aSender
{
    [[CPNotificationCenter defaultCenter]
        postNotificationName:CPApplicationWillTerminateNotification
                      object:self];

    if (![CPPlatform isBrowser])
    {
        [[CPDocumentController sharedDocumentController] closeAllDocumentsWithDelegate:self
                                                                  didCloseAllSelector:@selector(_documentController:didCloseAll:context:)
                                                                          contextInfo:nil];
    }
    else
    {
        [[[self keyWindow] platformWindow] _propagateCurrentDOMEvent:YES];
    }
}

- (void)setApplicationIconImage:(CPImage)anImage
{
    _applicationIconImage = anImage;
}

- (CPImage)applicationIconImage
{
    if (_applicationIconImage)
        return _applicationIconImage;

    var imagePath = [[CPBundle mainBundle] objectForInfoDictionaryKey:@"CPApplicationIcon"];
    if (imagePath)
        _applicationIconImage = [[CPImage alloc] initWithContentsOfFile:imagePath];

    return _applicationIconImage;
}

- (void)orderFrontStandardAboutPanel:(id)sender
{
    [self orderFrontStandardAboutPanelWithOptions:nil];
}

- (void)orderFrontStandardAboutPanelWithOptions:(CPDictionary)options
{
    if (!_aboutPanel)
    {
        var mainInfo = [[CPBundle mainBundle] infoDictionary],
            applicationTitle = [options objectForKey:"ApplicationName"] || [mainInfo objectForKey:@"CPBundleName"],
            applicationIcon = [options objectForKey:@"ApplicationIcon"] || [self applicationIconImage],
            version = [options objectForKey:@"Version"] || [mainInfo objectForKey:@"CPBundleVersion"],
            applicationVersion = [options objectForKey:@"ApplicationVersion"] || [mainInfo objectForKey:@"CPBundleShortVersionString"],
            copyright = [options objectForKey:@"Copyright"] || [mainInfo objectForKey:@"CPHumanReadableCopyright"];

        var windowWidth = 275,
            windowHeight = 223,
            imgWidth = 100,
            imgHeight = 100,
            interField = 8,
            aboutPanel = [[CPWindow alloc] initWithContentRect:CGRectMake(0, 0, windowWidth, windowHeight) styleMask:CPClosableWindowMask],
            imageView = [[CPImageView alloc] initWithFrame:CGRectMake((windowWidth / 2) - (imgWidth / 2), interField, imgWidth, imgHeight)],
            applicationLabel = [[CPTextField alloc] initWithFrame:CGRectMake(17, imgHeight + 16, windowWidth - 34, 24)],
            versionLabel = [[CPTextField alloc] initWithFrame:CGRectMake(17, imgHeight + 48, windowWidth - 34, 16)],
            copyrightLabel = [[CPTextField alloc] initWithFrame:CGRectMake(17, imgHeight + 72, windowWidth - 34, 32)],
            contentView = [aboutPanel contentView];

        [applicationLabel setFont:[CPFont boldSystemFontOfSize:[CPFont systemFontSize] + 2]];
        [applicationLabel setAlignment:CPCenterTextAlignment];
        [versionLabel setFont:[CPFont systemFontOfSize:[CPFont systemFontSize] - 1]];
        [versionLabel setAlignment:CPCenterTextAlignment];
        [copyrightLabel setFont:[CPFont systemFontOfSize:[CPFont systemFontSize] - 1]];
        [copyrightLabel setAlignment:CPCenterTextAlignment];
        [copyrightLabel setLineBreakMode:CPLineBreakByWordWrapping];

        [contentView addSubview:imageView];
        [contentView addSubview:applicationLabel];
        [contentView addSubview:versionLabel];
        [contentView addSubview:copyrightLabel];

        var standardPath = [[CPBundle bundleForClass:[self class]] pathForResource:@"standardApplicationIcon.png"];

        [imageView setImage:applicationIcon || [[CPImage alloc] initWithContentsOfFile:standardPath
                                                                                  size:CGSizeMake(256, 256)]];

        [applicationLabel setStringValue:applicationTitle || ""];

        if (applicationVersion && version)
            [versionLabel setStringValue:@"Version " + applicationVersion + " (" + version + ")"];
        else if (applicationVersion || version)
            [versionLabel setStringValue:@"Version " + (applicationVersion || version)];
        else
            [versionLabel setStringValue:@""];

        [copyrightLabel setStringValue:copyright || @""];
        [aboutPanel center];

        _aboutPanel = aboutPanel;
    }

    [_aboutPanel orderFront:self];
}


- (void)_documentController:(CPDocumentController)docController didCloseAll:(BOOL)didCloseAll context:(Object)info
{
    // callback method for terminate:
    if (didCloseAll)
        [self replyToApplicationShouldTerminate:[self _sendDelegateApplicationShouldTerminate]];
}

- (void)replyToApplicationShouldTerminate:(BOOL)terminate
{
    if (terminate == CPTerminateNow)
    {
        [[CPNotificationCenter defaultCenter] postNotificationName:CPApplicationWillTerminateNotification object:self];
        [CPPlatform terminateApplication];
    }
}

- (void)activateIgnoringOtherApps:(BOOL)shouldIgnoreOtherApps
{
    if (_isActive)
        return;

    [self _willBecomeActive];

    [CPPlatform activateIgnoringOtherApps:shouldIgnoreOtherApps];
    _isActive = YES;

    [self _didBecomeActive];
}

- (void)deactivate
{
    if (!_isActive)
        return;

    [self _willResignActive];

    [CPPlatform deactivate];
    _isActive = NO;

    [self _didResignActive];
}

- (void)isActive
{
    return _isActive;
}

- (void)hideOtherApplications:(id)aSender
{
    [CPPlatform hideOtherApplications:self];
}

- (void)run
{
    [self finishLaunching];
    [self sendEvent:[CPEvent otherEventWithType:CPAppKitDefined
                                       location:CGPointMakeZero()
                                  modifierFlags:0
                                      timestamp:[CPEvent currentTimestamp]
                                   windowNumber:[_keyWindow windowNumber]
                                        context:nil
                                        subtype:nil
                                          data1:nil
                                          data2:nil]];
}

// Managing the Event Loop
- (void)runModalForWindow:(CPWindow)aWindow
{
    [self runModalSession:[self beginModalSessionForWindow:aWindow]];
}

- (void)stopModalWithCode:(int)aCode
{
    if (!_currentSession)
    {
        return;
        // raise exception;
    }

    _currentSession._state = aCode;
    _currentSession = _currentSession._previous;

//    if (aCode == CPRunAbortedResponse)
        [self _removeRunModalLoop];
}

/* @ignore */
- (void)_removeRunModalLoop
{
    var count = _eventListeners.length;

    while (count--)
        if (_eventListeners[count]._callback === _CPRunModalLoop)
        {
            _eventListeners.splice(count, 1);
            if (count <= _eventListenerInsertionIndex)
                _eventListenerInsertionIndex--;

            return;
        }
}

- (void)stopModal
{
    [self stopModalWithCode:CPRunStoppedResponse]
}

- (void)abortModal
{
    [self stopModalWithCode:CPRunAbortedResponse];
}

- (CPModalSession)beginModalSessionForWindow:(CPWindow)aWindow
{
    return _CPModalSessionMake(aWindow, 0);
}

- (void)runModalSession:(CPModalSession)aModalSession
{
    aModalSession._previous = _currentSession;
    _currentSession = aModalSession;

    var theWindow = aModalSession._window;

    [theWindow center];
    [theWindow makeKeyWindow];
    [theWindow orderFront:self];

//    [theWindow._bridge _obscureWindowsBelowModalWindow];

    [CPApp setCallback:_CPRunModalLoop forNextEventMatchingMask:CPAnyEventMask untilDate:nil inMode:0 dequeue:YES];
}

- (CPWindow)modalWindow
{
    if (!_currentSession)
        return nil;

    return _currentSession._window;
}

/* @ignore */
- (BOOL)_handleKeyEquivalent:(CPEvent)anEvent
{
    return [[self keyWindow] performKeyEquivalent:anEvent] ||
           [[self mainMenu] performKeyEquivalent:anEvent];
}

- (void)sendEvent:(CPEvent)anEvent
{
    _currentEvent = anEvent;
    CPEventModifierFlags = [anEvent modifierFlags];

    var theWindow = [anEvent window];

    if ([anEvent type] == CPMouseMoved)
    {
        if (theWindow !== _lastMouseMoveWindow)
            [_lastMouseMoveWindow _mouseExitedResizeRect];

        _lastMouseMoveWindow = theWindow;
    }

    /*
        Event listeners are processed from back to front so that newer event listeners normally take
        precedence. If during the execution of a callback a new event listener is added, it should
        be inserted after the current callback but before any higher priority callbacks. This makes
        repeating event listeners (those that reinsert themselves) stable relative to each other.
    */
    for (var i = _eventListeners.length - 1; i >= 0; i--)
    {
        var listener = _eventListeners[i];

        if (listener._mask & (1 << [anEvent type]))
        {
            _eventListeners.splice(i, 1);
            // In case the callback wants to add more listeners.
            _eventListenerInsertionIndex = i;
            listener._callback(anEvent);

            if (listener._dequeue)
            {
                // Don't process the event normally and don't send it to any other listener.
                _eventListenerInsertionIndex = _eventListeners.length;
                return;
            }
        }
    }

    _eventListenerInsertionIndex = _eventListeners.length;

    // Check if this is a candidate for key equivalent...
    if ([anEvent _couldBeKeyEquivalent] && [self _handleKeyEquivalent:anEvent])
        // The key equivalent was handled.
        return;

    if (theWindow)
        [theWindow sendEvent:anEvent];
}

- (void)doCommandBySelector:(SEL)aSelector
{
    if ([_delegate respondsToSelector:aSelector])
        [_delegate performSelector:aSelector];
    else
        [super doCommandBySelector:aSelector];
}

- (CPWindow)keyWindow
{
    return _keyWindow;
}

- (CPWindow)mainWindow
{
    return _mainWindow;
}

- (CPWindow)windowWithWindowNumber:(int)aWindowNumber
{
    // Never allow _windows[0] to be returned - it's an internal CPNull placeholder.
    if (!aWindowNumber)
        return nil;

    return _windows[aWindowNumber];
}

- (CPArray)windows
{
    // Return all windows, but not the CPNull placeholder in _windows[0].
    return [_windows subarrayWithRange:CPMakeRange(1, [_windows count] - 1)];
}

- (CPArray)orderedWindows
{
#if PLATFORM(DOM)
    return CPWindowObjectList();
#else
    return [];
#endif
}

- (void)hide:(id)aSender
{
    [CPPlatform hide:self];
}

// Accessing the Main Menu
- (CPMenu)mainMenu
{
    return [self menu];
}

- (void)setMainMenu:(CPMenu)aMenu
{
    [self setMenu:aMenu];
}

- (void)setMenu:(CPMenu)aMenu
{
    if ([aMenu _menuName] === "CPMainMenu")
    {
        if ([self menu] === aMenu)
            return;

        [super setMenu:aMenu];

        if ([CPPlatform supportsNativeMainMenu])
            window.cpSetMainMenu([self menu]);
    }
    else
        [aMenu _setMenuName:@"CPMainMenu"];
}

- (void)orderFrontColorPanel:(id)aSender
{
    [[CPColorPanel sharedColorPanel] orderFront:self];
}

// Posting Actions
- (BOOL)tryToPerform:(SEL)anAction with:(id)anObject
{
    if (!anAction)
        return NO;

    if ([super tryToPerform:anAction with:anObject])
        return YES;

    if ([_delegate respondsToSelector:anAction])
    {
        [_delegate performSelector:anAction withObject:anObject];

        return YES;
    }

    return NO;
}

- (BOOL)sendAction:(SEL)anAction to:(id)aTarget from:(id)aSender
{
    var target = [self targetForAction:anAction to:aTarget from:aSender];

    if (!target)
        return NO;

    [target performSelector:anAction withObject:aSender];

    return YES;
}

- (id)targetForAction:(SEL)anAction to:(id)aTarget from:(id)aSender
{
    if (!anAction)
        return nil;

    if (aTarget)
        return aTarget;

    return [self targetForAction:anAction];
}

- (id)_targetForWindow:(CPWindow)aWindow action:(SEL)anAction
{
    var responder = [aWindow firstResponder],
        checkWindow = YES;

    while (responder)
    {
        if ([responder respondsToSelector:anAction])
            return responder;

        if (responder == aWindow)
            checkWindow = NO;

        responder = [responder nextResponder];
    }

    if (checkWindow && [aWindow respondsToSelector:anAction])
        return aWindow;

    var delegate = [aWindow delegate];

    if ([delegate respondsToSelector:anAction])
        return delegate;

    var windowController = [aWindow windowController];

    if ([windowController respondsToSelector:anAction])
        return windowController;

    var theDocument = [windowController document];
    if (theDocument !== delegate && [theDocument respondsToSelector:anAction])
        return theDocument;

    return nil;
}

- (id)targetForAction:(SEL)anAction
{
    if (!anAction)
        return nil;

    var target = [self _targetForWindow:[self keyWindow] action:anAction];

    if (target)
        return target;

    target = [self _targetForWindow:[self mainWindow] action:anAction];

    if (target)
        return target;

    if ([self respondsToSelector:anAction])
        return self;

    if ([_delegate respondsToSelector:anAction])
        return _delegate;

    if ([_documentController respondsToSelector:anAction])
        return _documentController;

    return nil;
}

- (void)setCallback:(Function)aCallback forNextEventMatchingMask:(unsigned int)aMask untilDate:(CPDate)anExpiration inMode:(CPString)aMode dequeue:(BOOL)shouldDequeue
{
    _eventListeners.splice(_eventListenerInsertionIndex++, 0, _CPEventListenerMake(aMask, aCallback, shouldDequeue));
}

- (void)setTarget:(id)aTarget selector:(SEL)aSelector forNextEventMatchingMask:(unsigned int)aMask untilDate:(CPDate)anExpiration inMode:(CPString)aMode dequeue:(BOOL)shouldDequeue
{
    _eventListeners.splice(_eventListenerInsertionIndex++, 0, _CPEventListenerMake(aMask, function (anEvent) { if (aTarget != null) aTarget.isa.objj_msgSend1(aTarget, aSelector, anEvent); }, shouldDequeue));
}

- (CPEvent)currentEvent
{
    return _currentEvent;
}

// Managing Sheets

- (void)beginSheet:(CPWindow)aSheet modalForWindow:(CPWindow)aWindow modalDelegate:(id)aModalDelegate didEndSelector:(SEL)didEndSelector contextInfo:(id)contextInfo
{
    if ([aWindow isSheet])
    {
        [CPException raise:CPInternalInconsistencyException reason:@"The target window of beginSheet: cannot be a sheet"];
        return;
    }

    if (![aWindow attachedSheet])
        [aSheet._windowView _enableSheet:YES inWindow:aWindow];

    [aWindow _attachSheet:aSheet modalDelegate:aModalDelegate didEndSelector:didEndSelector contextInfo:contextInfo];
}

- (void)endSheet:(CPWindow)sheet returnCode:(int)returnCode
{
    var count = [_windows count];

    while (--count >= 0)
    {
        var aWindow = [_windows objectAtIndex:count],
            context = aWindow._sheetContext;

        if (context && context["sheet"] === sheet)
        {
            context["returnCode"] = returnCode;
            [aWindow _endSheet];
            return;
        }
    }
}

- (void)endSheet:(CPWindow)sheet
{
    // FIX ME: this is wrong: by Cocoa this should be: CPRunStoppedResponse.
   [self endSheet:sheet returnCode:0];
}

- (CPArray)arguments
{
    // FIXME This should probably not access the window object #if !PLATFORM(DOM), but the unit tests rely on it.
    if (window && window.location && _fullArgsString !== window.location.hash)
        [self _reloadArguments];

    return _args;
}

- (void)setArguments:(CPArray)args
{
    if (!args || args.length == 0)
    {
        _args = [];
        // Don't use if PLATFORM(DOM) here - the unit test fakes window.location so we should play along.
        if (window && window.location)
            window.location.hash = @"#";
        return;
    }

    if (![args isKindOfClass:CPArray])
        args = [CPArray arrayWithObject:args];

    _args = args;

    var toEncode = [_args copy];
    for (var i = 0, count = toEncode.length; i < count; i++)
        toEncode[i] = encodeURIComponent(toEncode[i]);

    var hash = [toEncode componentsJoinedByString:@"/"];

    // Don't use if PLATFORM(DOM) here - the unit test fakes window.location so we should play along.
    if (window && window.location)
        window.location.hash = @"#" + hash;
}

- (void)_reloadArguments
{
    // FIXME This should probably not access the window object #if !PLATFORM(DOM), but the unit tests rely on it.
    _fullArgsString = (window && window.location) ? window.location.hash : "";

    if (_fullArgsString.length)
    {
        var args = _fullArgsString.substring(1).split("/");

        for (var i = 0, count = args.length; i < count; i++)
            args[i] = decodeURIComponent(args[i]);

        _args = args;
    }
    else
        _args = [];
}

- (CPDictionary)namedArguments
{
    return _namedArgs;
}

- (BOOL)_openURL:(CPURL)aURL
{
    if (_delegate && [_delegate respondsToSelector:@selector(application:openFile:)])
    {
        CPLog.warn("application:openFile: is deprecated, use application:openURL: instead.");
        return [_delegate application:self openFile:[aURL absoluteString]];
    }

    if (_delegate && [_delegate respondsToSelector:@selector(application:openURL:)])
        return [_delegate application:self openURL:aURL];

    return !![_documentController openDocumentWithContentsOfURL:aURL display:YES error:NULL];
}

- (void)_willBecomeActive
{
    [[CPNotificationCenter defaultCenter] postNotificationName:CPApplicationWillBecomeActiveNotification
                                                        object:self
                                                      userInfo:nil];
}

- (void)_didBecomeActive
{
    if (![self keyWindow] && _previousKeyWindow &&
        [[self windows] indexOfObjectIdenticalTo:_previousKeyWindow] !== CPNotFound)
        [_previousKeyWindow makeKeyWindow];

    if (![self mainWindow] && _previousMainWindow &&
        [[self windows] indexOfObjectIdenticalTo:_previousMainWindow] !== CPNotFound)
        [_previousMainWindow makeMainWindow];

    if ([self keyWindow])
        [[self keyWindow] orderFront:self];
    else if ([self mainWindow])
        [[self mainWindow] makeKeyAndOrderFront:self];
    else if ([self mainMenu])
        [[self mainMenu]._menuWindow makeKeyWindow]; //FIXME this may not actually work

    _previousKeyWindow = nil;
    _previousMainWindow = nil;

    [[CPNotificationCenter defaultCenter] postNotificationName:CPApplicationDidBecomeActiveNotification
                                                        object:self
                                                      userInfo:nil];
}

- (void)_willResignActive
{
    [[CPNotificationCenter defaultCenter] postNotificationName:CPApplicationWillResignActiveNotification
                                                        object:self
                                                      userInfo:nil];
}

- (BOOL)_sendDelegateApplicationShouldTerminate
{
    if (!(_implementedDelegateMethods & CPApplicationDelegate_applicationShouldTerminate_))
        return YES;

    return [_delegate applicationShouldTerminate:self];
}

- (CPString)_sendDelegateApplicationShouldTerminateMessage
{
    if (!(_implementedDelegateMethods & CPApplicationDelegate_applicationShouldTerminateMessage_))
        return @"You have attempted to leave this page. Are you sure you want to exit this page?";

    return [_delegate applicationShouldTerminateMessage:self];
}

- (void)_didResignActive
{
    if (self._activeMenu)
        [self._activeMenu cancelTracking];

    if ([self keyWindow])
    {
        _previousKeyWindow = [self keyWindow];
        [_previousKeyWindow resignKeyWindow];
    }

    if ([self mainWindow])
    {
        _previousMainWindow = [self mainWindow];
        [_previousMainWindow resignMainWindow];
    }

    [[CPNotificationCenter defaultCenter] postNotificationName:CPApplicationDidResignActiveNotification
                                                        object:self
                                                      userInfo:nil];
}

+ (CPString)defaultThemeName
{
    return ([[CPBundle mainBundle] objectForInfoDictionaryKey:"CPDefaultTheme"] || @"Aristo2");
}

@end

var _CPModalSessionMake = function(aWindow, aStopCode)
{
    return { _window:aWindow, _state:CPRunContinuesResponse , _previous:nil };
};

var _CPEventListenerMake = function(anEventMask, aCallback, shouldDequeue)
{
    return { _mask:anEventMask, _callback:aCallback, _dequeue:shouldDequeue };
};

// Make this a global for use in CPPlatformWindow+DOM.j.
_CPRunModalLoop = function(anEvent)
{
    [CPApp setCallback:_CPRunModalLoop forNextEventMatchingMask:CPAnyEventMask untilDate:nil inMode:0 dequeue:YES];

    var theWindow = [anEvent window],
        modalSession = CPApp._currentSession;

    /*
        The special case for popovers here is not clear. In Cocoa the popover window does not respond YES to worksWhenModal, yet it works when there is a modal window. Maybe it starts its own modal session, but interaction with the original modal window seems to continue working as well. Regardless of correctness, this solution beats popovers not working at all from sheets.
    */
    if (theWindow == modalSession._window ||
        [theWindow worksWhenModal] ||
        [theWindow attachedSheet] == modalSession._window || // -dw- allow modal parent of sheet to be repositioned
        ([theWindow isKindOfClass:_CPPopoverWindow] && [[theWindow targetView] window] === modalSession._window))
    {
        [theWindow sendEvent:anEvent];
    }
};

function CPApplicationMain(args, namedArgs)
{

#if PLATFORM(DOM)
    // hook to allow recorder, etc to manipulate things before starting AppKit
    if (window.parent !== window && typeof window.parent._childAppIsStarting === "function")
    {
        try
        {
            window.parent._childAppIsStarting(window);
        }
        catch(err)
        {
            // This could happen if we're in an iframe without access to the parent frame.
            CPLog.warn("Failed to call parent frame's _childAppIsStarting().");
        }
    }
#endif

    var mainBundle = [CPBundle mainBundle],
        principalClass = [mainBundle principalClass];

    if (!principalClass)
        principalClass = [CPApplication class];

    [principalClass sharedApplication];

    if ([args containsObject:"debug"])
        CPLogRegister(CPLogPopup);

    CPApp._args = args;
    CPApp._namedArgs = namedArgs;

    [_CPAppBootstrapper performActions];
}

var _CPAppBootstrapperActions = nil;
@implementation _CPAppBootstrapper : CPObject
{
    id __doxygen__;
}

+ (CPArray)actions
{
    return [@selector(bootstrapPlatform), @selector(loadDefaultTheme), @selector(loadMainCibFile)];
}

+ (void)performActions
{
    if (!_CPAppBootstrapperActions)
        _CPAppBootstrapperActions = [self actions];

    while (_CPAppBootstrapperActions.length)
    {
        var action = _CPAppBootstrapperActions.shift();

        if (self.isa.objj_msgSend0(self, action))
            return;
    }

    [CPApp run];
}

+ (BOOL)bootstrapPlatform
{
    return [CPPlatform bootstrap];
}

+ (BOOL)loadDefaultTheme
{
    var defaultThemeName = [CPApplication defaultThemeName],
        themeURL = nil;

    if (defaultThemeName === @"Aristo" || defaultThemeName === @"Aristo2")
        themeURL = [[CPBundle bundleForClass:[CPApplication class]] pathForResource:defaultThemeName + @".blend"];
    else
        themeURL = [[CPBundle mainBundle] pathForResource:defaultThemeName + @".blend"];

    var blend = [[CPThemeBlend alloc] initWithContentsOfURL:themeURL];
    [blend loadWithDelegate:self];

    return YES;
}

+ (void)blendDidFinishLoading:(CPThemeBlend)aThemeBlend
{
    [[CPApplication sharedApplication] setThemeBlend:aThemeBlend];
    [CPTheme setDefaultTheme:[CPTheme themeNamed:[CPApplication defaultThemeName]]];

    [self performActions];
}

+ (BOOL)loadMainCibFile
{
    var mainBundle = [CPBundle mainBundle],
        mainCibFile = [mainBundle objectForInfoDictionaryKey:CPMainCibFile] || [mainBundle objectForInfoDictionaryKey:CPMainCibFileHumanFriendly];

    if (mainCibFile)
    {
        [mainBundle loadCibFile:mainCibFile
              externalNameTable:@{ CPCibOwner: CPApp }
                   loadDelegate:self];

        return YES;
    }
    else
        [self loadCiblessBrowserMainMenu];

    return NO;
}

+ (void)loadCiblessBrowserMainMenu
{
    var mainMenu = [[CPMenu alloc] initWithTitle:@"MainMenu"];

    // FIXME: We should implement autoenabling.
    [mainMenu setAutoenablesItems:NO];

    var newMenuItem = [[CPMenuItem alloc] initWithTitle:@"New" action:@selector(newDocument:) keyEquivalent:@"n"];

    [newMenuItem setImage:[[CPTheme defaultTheme] valueForAttributeWithName:@"menu-general-icon-new" forClass:_CPMenuView]];
    [newMenuItem setAlternateImage:[[CPTheme defaultTheme] valueForAttributeWithName:@"menu-general-icon-new" inState:CPThemeStateHighlighted forClass:_CPMenuView]];

    [mainMenu addItem:newMenuItem];

    var openMenuItem = [[CPMenuItem alloc] initWithTitle:@"Open" action:@selector(openDocument:) keyEquivalent:@"o"];

    [openMenuItem setImage:[[CPTheme defaultTheme] valueForAttributeWithName:@"menu-general-icon-open" forClass:_CPMenuView]];
    [openMenuItem setAlternateImage:[[CPTheme defaultTheme] valueForAttributeWithName:@"menu-general-icon-open" inState:CPThemeStateHighlighted forClass:_CPMenuView]];

    [mainMenu addItem:openMenuItem];

    var saveMenu = [[CPMenu alloc] initWithTitle:@"Save"],
        saveMenuItem = [[CPMenuItem alloc] initWithTitle:@"Save" action:@selector(saveDocument:) keyEquivalent:nil];

    [saveMenuItem setImage:[[CPTheme defaultTheme] valueForAttributeWithName:@"menu-general-icon-save" forClass:_CPMenuView]];
    [saveMenuItem setAlternateImage:[[CPTheme defaultTheme] valueForAttributeWithName:@"menu-general-icon-save" inState:CPThemeStateHighlighted forClass:_CPMenuView]];

    [saveMenu addItem:[[CPMenuItem alloc] initWithTitle:@"Save" action:@selector(saveDocument:) keyEquivalent:@"s"]];
    [saveMenu addItem:[[CPMenuItem alloc] initWithTitle:@"Save As" action:@selector(saveDocumentAs:) keyEquivalent:nil]];

    [saveMenuItem setSubmenu:saveMenu];

    [mainMenu addItem:saveMenuItem];

    var editMenuItem = [[CPMenuItem alloc] initWithTitle:@"Edit" action:nil keyEquivalent:nil],
        editMenu = [[CPMenu alloc] initWithTitle:@"Edit"],

        undoMenuItem = [[CPMenuItem alloc] initWithTitle:@"Undo" action:@selector(undo:) keyEquivalent:CPUndoKeyEquivalent],
        redoMenuItem = [[CPMenuItem alloc] initWithTitle:@"Redo" action:@selector(redo:) keyEquivalent:CPRedoKeyEquivalent];

    [undoMenuItem setKeyEquivalentModifierMask:CPUndoKeyEquivalentModifierMask];
    [redoMenuItem setKeyEquivalentModifierMask:CPRedoKeyEquivalentModifierMask];

    [editMenu addItem:undoMenuItem];
    [editMenu addItem:redoMenuItem];

    [editMenu addItem:[[CPMenuItem alloc] initWithTitle:@"Cut" action:@selector(cut:) keyEquivalent:@"x"]];
    [editMenu addItem:[[CPMenuItem alloc] initWithTitle:@"Copy" action:@selector(copy:) keyEquivalent:@"c"]];
    [editMenu addItem:[[CPMenuItem alloc] initWithTitle:@"Paste" action:@selector(paste:) keyEquivalent:@"v"]];

    [editMenuItem setSubmenu:editMenu];
    [editMenuItem setHidden:YES];

    [mainMenu addItem:editMenuItem];

    [mainMenu addItem:[CPMenuItem separatorItem]];

    [CPApp setMainMenu:mainMenu];
}

+ (void)cibDidFinishLoading:(CPCib)aCib
{
    [self performActions];
}

+ (void)cibDidFailToLoad:(CPCib)aCib
{
    throw new Error("Could not load main cib file. Did you forget to nib2cib it?");
}

+ (void)reset
{
    _CPAppBootstrapperActions = nil;
}

@end


@implementation CPEvent (CPApplicationModifierFlags)

+ (unsigned)modifierFlags
{
    return CPEventModifierFlags;
}

@end

@implementation CPApplication (CPSynthesizedAccessors)

- (CPThemeBlend)themeBlend
{
    return _themeBlend;
}

- (void)setThemeBlend:(CPThemeBlend)aValue
{
    _themeBlend = aValue;
}

@end