Every graphical GNUstep application has exactly one instance of
* NSApplication (or a subclass) instantiated. Usually this is
* created through the +sharedApplication method. Once created, this instance
* is always accessible through the global variable 'NSApp'.
The NSApplication instance manages the main run loop, dispatches * events, and manages resources. It sets up the connection to the window * server and provides special methods for putting up "modal" (always on top) * windows.
* *Typically, -run is called by an application's main method
* after the NSApplication instance is created, which never returns. However,
* applications needing to integrate other event loops may strategically call
* the -stop method, followed by -run later on.
To avoid most common needs for subclassing, NSApplication allows you to * specify a delegate that is messaged in particular situations. * See -delegate , -setDelegate: , and [(GSAppDelegateProtocol)].
* *Subclassing should be a last resort, and delegate * methods should be used in most cases. However, subclassing is most * frequently done to implement custom event loop management by overriding * -run when the method described above is not sufficient, or to intercept * events by overriding -sendEvent: .
*/ @implementation NSApplication /* * Class methods */ + (void) initialize { if (self == [NSApplication class]) { CREATE_AUTORELEASE_POOL(pool); /* * Dummy functions to fool linker into linking files that contain * only catagories - static libraries seem to have problems here. */ extern void GSStringDrawingDummyFunction(void); GSStringDrawingDummyFunction(); [self setVersion: 1]; /* Create the gui bundle we use to localize messages. */ guiBundle = [NSBundle bundleForLibrary: @"gnustep-gui"]; RETAIN(guiBundle); /* Save the base library exception handler */ defaultUncaughtExceptionHandler = NSGetUncaughtExceptionHandler (); /* Cache the NSAutoreleasePool class */ arpClass = [NSAutoreleasePool class]; nc = [NSNotificationCenter defaultCenter]; RELEASE(pool); } } // Helper method + (void) _invokeWithAutoreleasePool: (NSInvocation*) inv { CREATE_AUTORELEASE_POOL(pool); [inv invoke]; RELEASE(pool); } /** * Calls [NSThread+detachNewThreadSelector:toTarget:withObject:] with the * invocation wrapped by an autorelease pool. */ + (void) detachDrawingThread: (SEL)selector toTarget: (id)target withObject: (id)argument { NSInvocation *inv; // This uses a GNUstep extension on NSInvocation inv = [[NSInvocation alloc] initWithTarget: target selector: selector, argument]; [NSThread detachNewThreadSelector: @selector(_invokeWithAutoreleasePool:) toTarget: self withObject: inv]; RELEASE(inv); } /** *Return the shared application instance, creating one (of the
* receiver class) if needed. There is (and must always be) only a
* single shared application instance for each application. After the
* shared application instance has been created, you can access it
* directly via the global variable NSApp (but not before!). When
* the shared application instance is created, it is also automatically
* initialized (that is, its init method is called), which
* connects to the window server and prepares the gui library for actual
* operation. For this reason, you must always call [NSApplication
* sharedApplication] before using any functionality of the gui
* library - so, normally, this should be one of the first commands in
* your program (if you use NSApplicationMain(), this is
* automatically done).
The shared application instance is normally an instance of
* NSApplication; but you can subclass NSApplication, and have an
* instance of your own subclass be created and used as the shared
* application instance. If you want to get this result, you need to
* make sure the first time you call +sharedApplication is on your
* custom NSApplication subclass (rather than on NSApplication).
* Putting [MyApplicationClass sharedApplication]; as the first
* command in your program is the recommended way. :-) If you use
* NSApplicationMain(), it automatically creates the appropriate
* instance (which you can control by editing the info dictionary of
* the application).
It is not safe to call this method from multiple threads - it would * be useless anyway since the whole library is not thread safe: there * must always be at most one thread using the gui library at a time. * (If you absolutely need to have multiple threads in your * application, make sure only one of them uses the gui [the 'drawing' * thread], and the other ones do not).
*/ + (NSApplication *) sharedApplication { /* If the global application does not yet exist then create it. */ if (NSApp == nil) { /* -init sets NSApp. */ [[self alloc] init]; } return NSApp; } /* * Instance methods */ /** * The real gui initialisation ... called from -init */ - (void) _init { GSDisplayServer *srv; NSDictionary *attributes; /* Initialization must be enclosed in an autorelease pool. */ CREATE_AUTORELEASE_POOL (_app_init_pool); /* * Set NSApp as soon as possible, since other gui classes (which * we refer or use in this method) might be calling [NSApplication * sharedApplication] during their initialization, and we want * those calls to succeed. */ NSApp = self; /* Initialize the backend here. */ initialize_gnustep_backend(); /* Load user-defined bundles */ gsapp_user_bundles(); /* Connect to our window server. */ srv = [GSDisplayServer serverWithAttributes: nil]; RETAIN(srv); [GSDisplayServer setCurrentServer: srv]; /* Create a default context with the attributes of the main screen. */ attributes = [[NSScreen mainScreen] deviceDescription]; _default_context = [NSGraphicsContext graphicsContextWithAttributes: attributes]; RETAIN(_default_context); [NSGraphicsContext setCurrentContext: _default_context]; /* Initialize font manager. */ [NSFontManager sharedFontManager]; _hidden = [[NSMutableArray alloc] init]; _inactive = [[NSMutableArray alloc] init]; _unhide_on_activation = YES; _app_is_hidden = YES; /* Ivar already automatically initialized to NO when the app is created. */ //_app_is_active = NO; //_main_menu = nil; _windows_need_update = YES; /* Set a new exception handler for the gui library. */ NSSetUncaughtExceptionHandler (_NSAppKitUncaughtExceptionHandler); _listener = [GSServicesManager newWithApplication: self]; /* NSEvent doesn't use -init so we use +alloc instead of +new. */ _current_event = [NSEvent alloc]; // no current event null_event = [NSEvent alloc]; // create dummy event /* We are the end of responder chain. */ [self setNextResponder: nil]; RELEASE (_app_init_pool); } /** * This method initializes an NSApplication instance. It sets the * shared application instance to be the receiver, and then connects * to the window server and performs the actual gui library * initialization. * * If there is a already a shared application instance, calling this * method results in an assertion (and normally program abortion/crash). * * It is recommended that you /never/ call this method directly from * your code! It's called automatically (and only once) by * [NSApplication sharedApplication]. You might override this method * in subclasses (make sure to call super's :-), then your overridden * method will automatically be called (guaranteed once in the * lifetime of the application) when you call [MyApplicationClass * sharedApplication]. * * If you call this method from your code (which we discourage you * from doing), it is your responsibility to make sure it is called * only once (this is according to the openstep specification). Since * +sharedApplication automatically calls this method, making also * sure it calls it only once, you definitely want to use * +sharedApplication instead of calling -init directly. */ - (id) init { /* * As per openstep specification, calling -init twice is a bug in * the program. +sharedApplication automatically makes sure it * never calls -init more than once, and programmers should normally * use +sharedApplication in programs. * * Please refrain from trying to have this method work with multiple * calls (such as returning NSApp instead of raising an assertion). * No matter what you do, you can't protect subclass -init custom * code from multiple executions by changing the implementation here * - so it's just simpler and cleaner that multiple -init executions * are always forbidden, and subclasses inherit exactly the same * kind of multiple execution protection as the superclass has, and * initialization code behaves always in the same way for this class * and for subclasses. */ NSAssert (NSApp == nil, _(@"[NSApplication -init] called more than once")); /* * The appkit should run in the main thread ... so to be sure we perform * all the initialisation there. */ [self performSelectorOnMainThread: @selector(_init) withObject: self waitUntilDone: YES]; return NSApp; } /** *Activates the application, sets the application icon, loads the main
* Nib file if NSMainNibFile is set in the application
* property list, posts an
* NSApplicationWillFinishLaunchingNotification, and takes care
* of a few other startup tasks, then posts
* NSApplicationDidFinishLaunchingNotification.
* If you override this method, be sure to call super.
The -run method calls this the first time it is called, before starting * the event loop for the first time.
*/ - (void) finishLaunching { NSBundle *mainBundle = [NSBundle mainBundle]; NSDictionary *infoDict = [mainBundle infoDictionary]; NSString *mainModelFile; NSString *appIconFile; NSUserDefaults *defs = [NSUserDefaults standardUserDefaults]; NSString *filePath; NSArray *windows_list; unsigned count; unsigned i; BOOL hadDuplicates = NO; appIconFile = [infoDict objectForKey: @"NSIcon"]; if (appIconFile && ![appIconFile isEqual: @""]) { NSImage *image = [NSImage imageNamed: appIconFile]; if (image != nil) { [self setApplicationIconImage: image]; } } [self _appIconInit]; mainModelFile = [infoDict objectForKey: @"NSMainNibFile"]; if (mainModelFile != nil && [mainModelFile isEqual: @""] == NO) { if ([NSBundle loadNibNamed: mainModelFile owner: self] == NO) { NSLog (_(@"Cannot load the main model file '%@'"), mainModelFile); } } /* post notification that launch will finish */ [nc postNotificationName: NSApplicationWillFinishLaunchingNotification object: self]; /* Register our listener to incoming services requests etc. */ [_listener registerAsServiceProvider]; /* * Establish the current key and main windows. We need to do this in case * the windows were created and set to be key/main earlier - before the * app was active. */ windows_list = [self windows]; count = [windows_list count]; for (i = 0; i < count; i++) { NSWindow *win = [windows_list objectAtIndex: i]; if ([win isKeyWindow] == YES) { if (_key_window == nil) { _key_window = win; } else { hadDuplicates = YES; NSDebugLog(@"Duplicate keyWindow ignored"); [win resignKeyWindow]; } } if ([win isMainWindow] == YES) { if (_main_window == nil) { _main_window = win; } else { hadDuplicates = YES; NSDebugLog(@"Duplicate mainWindow ignored"); [win resignMainWindow]; } } } /* * If there was more than one window set as key or main, we must make sure * that the one we have recorded is the real one by making it become key/main * again. */ if (hadDuplicates) { [_main_window resignMainWindow]; [_main_window becomeMainWindow]; [_main_window orderFrontRegardless]; [_key_window resignKeyWindow]; [_key_window becomeKeyWindow]; [_key_window orderFrontRegardless]; } /* Register self as observer to window events. */ [nc addObserver: self selector: @selector(_windowWillClose:) name: NSWindowWillCloseNotification object: nil]; [nc addObserver: self selector: @selector(_windowDidBecomeKey:) name: NSWindowDidBecomeKeyNotification object: nil]; [nc addObserver: self selector: @selector(_windowDidBecomeMain:) name: NSWindowDidBecomeMainNotification object: nil]; [nc addObserver: self selector: @selector(_windowDidResignKey:) name: NSWindowDidResignKeyNotification object: nil]; [nc addObserver: self selector: @selector(_windowDidResignMain:) name: NSWindowDidResignMainNotification object: nil]; /* register as observer for hide/unhide notifications */ [[[NSWorkspace sharedWorkspace] notificationCenter] addObserver: self selector: @selector(_workspaceNotification:) name: GSHideOtherApplicationsNotification object: nil]; [[[NSWorkspace sharedWorkspace] notificationCenter] addObserver: self selector: @selector(_workspaceNotification:) name: GSUnhideAllApplicationsNotification object: nil]; [self activateIgnoringOtherApps: YES]; /* Instantiate the NSDocumentController if we are a doc-based app */ if ([NSDocumentController isDocumentBasedApplication]) [NSDocumentController sharedDocumentController]; /* * Now check to see if we were launched with arguments asking to * open a file. We permit some variations on the default name. */ if ((filePath = [defs stringForKey: @"GSFilePath"]) != nil || (filePath = [defs stringForKey: @"NSOpen"]) != nil) { [_listener application: self openFile: filePath]; } else if ((filePath = [defs stringForKey: @"GSTempPath"]) != nil) { [_listener application: self openTempFile: filePath]; } else if ((filePath = [defs stringForKey: @"NSPrint"]) != nil) { [_listener application: self printFile: filePath]; [self terminate: self]; } else if (![defs boolForKey: @"autolaunch"] && [_delegate respondsToSelector: @selector(applicationShouldOpenUntitledFile:)] && ([_delegate applicationShouldOpenUntitledFile: self]) && [_delegate respondsToSelector: @selector(applicationOpenUntitledFile:)]) { [_delegate applicationOpenUntitledFile: self]; } /* finish the launching post notification that launching has finished */ [nc postNotificationName: NSApplicationDidFinishLaunchingNotification object: self]; NS_DURING { [[[NSWorkspace sharedWorkspace] notificationCenter] postNotificationName: NSWorkspaceDidLaunchApplicationNotification object: [NSWorkspace sharedWorkspace] userInfo: [self _notificationUserInfo]]; } NS_HANDLER { NSLog (_(@"Problem during launch app notification: %@"), [localException reason]); [localException raise]; } NS_ENDHANDLER } - (void) dealloc { GSDisplayServer *srv = GSServerForWindow(_app_icon_window); [[[NSWorkspace sharedWorkspace] notificationCenter] removeObserver: self]; [nc removeObserver: self]; RELEASE(_hidden); RELEASE(_inactive); RELEASE(_listener); RELEASE(null_event); RELEASE(_current_event); /* We may need to tidy up nested modal session structures. */ while (_session != 0) { NSModalSession tmp = _session; _session = tmp->previous; NSZoneFree(NSDefaultMallocZone(), tmp); } /* Release the menus, then set them to nil so we don't try updating them after they have been deallocated. */ DESTROY(_main_menu); DESTROY(_windows_menu); TEST_RELEASE(_app_icon); TEST_RELEASE(_app_icon_window); TEST_RELEASE(_infoPanel); /* Destroy the default context */ [NSGraphicsContext setCurrentContext: nil]; DESTROY(_default_context); /* Close the server */ [srv closeServer]; DESTROY(srv); [super dealloc]; } /** * Activate app unconditionally if flag is YES, otherwise only if no other app * is active. (Note: this is currently not implemented * under GNUstep. The app is always activated unconditionally.) Usually * it is not necessary to manually call this method, except in some * circumstances of interapplication communication. */ - (void) activateIgnoringOtherApps: (BOOL)flag { // TODO: Currently the flag is ignored if (_app_is_active == NO) { unsigned count; unsigned i; NSDictionary *info; /* * Menus should observe this notification in order to make themselves * visible when the application is active. */ [nc postNotificationName: NSApplicationWillBecomeActiveNotification object: self]; _app_is_active = YES; /* Make sure to calculate count after the notification, since inactive status might be changed by a notifiee. */ count = [_inactive count]; for (i = 0; i < count; i++) { [[_inactive objectAtIndex: i] orderFrontRegardless]; } [_inactive removeAllObjects]; if ([self keyWindow] == nil && _hidden_key != nil && [[self windows] indexOfObjectIdenticalTo: _hidden_key] != NSNotFound) { [_hidden_key makeKeyWindow]; _hidden_key = nil; } if (_unhide_on_activation) { [self unhide: nil]; } if ([self keyWindow] != nil) { [[self keyWindow] orderFront: self]; } else if ([self mainWindow] != nil) { [[self mainWindow] makeKeyAndOrderFront: self]; } else { /* We need give input focus to some window otherwise we'll never get keyboard events. FIXME: doesn't work. */ NSWindow *menu_window= [[self mainMenu] window]; NSDebugLLog(@"Focus", @"No key on activation - make menu key"); [GSServerForWindow(menu_window) setinputfocus: [menu_window windowNumber]]; } info = [self _notificationUserInfo]; [nc postNotificationName: NSApplicationDidBecomeActiveNotification object: self userInfo: info]; [[[NSWorkspace sharedWorkspace] notificationCenter] postNotificationName: NSApplicationDidBecomeActiveNotification object: [NSWorkspace sharedWorkspace] userInfo: info]; } } /** * Forcefully deactivate the app, without activating another. It is rarely * necessary to use this method. */ - (void) deactivate { if (_app_is_active == YES) { NSArray *windows_list = [self windows]; unsigned count = [windows_list count]; unsigned i; NSDictionary *info; [nc postNotificationName: NSApplicationWillResignActiveNotification object: self]; _app_is_active = NO; if ([self keyWindow] != nil) { _hidden_key = [self keyWindow]; [_hidden_key resignKeyWindow]; } // FIXME: main window is not saved for when the app is activated again. // This is not a problem if it is also key, and I'm not sure if it // is a problem at all. May be annoying in the case of workspace switch. [[self mainWindow] resignMainWindow]; for (i = 0; i < count; i++) { NSModalSession theSession; NSWindow *win = [windows_list objectAtIndex: i]; if ([win isVisible] == NO) { continue; /* Already invisible */ } if ([win canHide] == NO) { continue; /* Can't be hidden */ } if (win == _app_icon_window) { continue; /* can't hide the app icon. */ } /* Don't order out modal windows */ theSession = _session; while (theSession != 0) { if (win == theSession->window) break; theSession = theSession->previous; } if (theSession) continue; if ([win hidesOnDeactivate] == YES) { [_inactive addObject: win]; [win orderOut: self]; } } info = [self _notificationUserInfo]; [nc postNotificationName: NSApplicationDidResignActiveNotification object: self userInfo: info]; [[[NSWorkspace sharedWorkspace] notificationCenter] postNotificationName: NSApplicationDidResignActiveNotification object: [NSWorkspace sharedWorkspace] userInfo: info]; } } /** * Returns whether this app is the currently active GNUstep application. * Note that on a GNUstep system, unlike OS X, it is possible for NO GNUstep * app to be active. */ - (BOOL) isActive { return _app_is_active; } /** * Cause all other apps to hide themselves. */ - (void) hideOtherApplications: (id)sender { [[[NSWorkspace sharedWorkspace] notificationCenter] postNotificationName: GSHideOtherApplicationsNotification object: [NSWorkspace sharedWorkspace] userInfo: [self _notificationUserInfo]]; } /** * Cause all apps including this one to unhide themselves. */ - (void) unhideAllApplications: (id)sender { [[[NSWorkspace sharedWorkspace] notificationCenter] postNotificationName: GSUnhideAllApplicationsNotification object: [NSWorkspace sharedWorkspace] userInfo: [self _notificationUserInfo]]; } /* * Running the main event loop */ /** *This method first calls -finishLaunching (if this is the first time -run) * has been called, then starts the main event loop of the application which * continues until -terminate: or -stop: is called.
* *At each iteration, at most one event is dispatched, the main and services * menus are sent [NSMenu-update] messages, and -updateWindows is possibly * called if this has been flagged as necessary.
*/ - (void) run { NSEvent *e; id distantFuture = [NSDate distantFuture]; /* Cache this, safe */ if (_runLoopPool != nil) { [NSException raise: NSInternalInconsistencyException format: @"NSApp's run called recursively"]; } /* * Set this flag here in case the application is actually terminated * inside -finishLaunching. */ _app_is_running = YES; if (_app_is_launched == NO) { _app_is_launched = YES; IF_NO_GC(_runLoopPool = [arpClass new]); [self finishLaunching]; [_listener updateServicesMenu]; [_main_menu update]; DESTROY(_runLoopPool); } while (_app_is_running) { IF_NO_GC(_runLoopPool = [arpClass new]); e = [self nextEventMatchingMask: NSAnyEventMask untilDate: distantFuture inMode: NSDefaultRunLoopMode dequeue: YES]; if (e != nil && e != null_event) { NSEventType type = [e type]; [self sendEvent: e]; // update (en/disable) the services menu's items if (type != NSPeriodic && type != NSMouseMoved) { [_listener updateServicesMenu]; [_main_menu update]; } } // send an update message to all visible windows if (_windows_need_update) { [self updateWindows]; } DESTROY (_runLoopPool); } /* Every single non trivial line of code must be enclosed into an autorelease pool. Create an autorelease pool here to wrap synchronize and the NSDebugLog. */ IF_NO_GC(_runLoopPool = [arpClass new]); [[NSUserDefaults standardUserDefaults] synchronize]; DESTROY (_runLoopPool); } /** * Returns whether the event loop managed by -run is currently active. */ - (BOOL) isRunning { return _app_is_running; } /* * Running modal event loops */ /** * Halts a currently running modal event loop started by -runModalForWindow: * or -runModalSession: . If you wish to halt the session in response to * user interaction with the modal window, use -stopModalWithCode: or * -stopModal instead; only use this to halt the loop from elsewhere, such as * another thread. */ - (void) abortModal { if (_session == 0) { [NSException raise: NSAbortModalException format: @"abortModal called while not in a modal session"]; } [NSException raise: NSAbortModalException format: @"abortModal"]; } /** * Set up modal session for theWindow, and, if it is not visible already, * puts it up on screen, centering it if it is an NSPanel. It is then * ordered front and made key or main window. */ - (NSModalSession) beginModalSessionForWindow: (NSWindow*)theWindow { NSModalSession theSession; theSession = (NSModalSession)NSZoneMalloc(NSDefaultMallocZone(), sizeof(struct _NSModalSession)); theSession->runState = NSRunContinuesResponse; theSession->entryLevel = [theWindow level]; theSession->window = theWindow; theSession->previous = _session; _session = theSession; /* * Displaying / raising window but centering panel only if not up * seems to match the behavior on OS X (Panther). */ if ([theWindow isKindOfClass: [NSPanel class]]) { if ([theWindow isVisible] == NO) [theWindow center]; [theWindow setLevel: NSModalPanelWindowLevel]; } [theWindow orderFrontRegardless]; if ([self isActive] == YES) { if ([theWindow canBecomeKeyWindow] == YES) { [theWindow makeKeyWindow]; } else if ([theWindow canBecomeMainWindow] == YES) { [theWindow makeMainWindow]; } } return theSession; } /** * Clean up after a modal session has been run. Called with theSession * returned from a previous call to beginModalSessionForWindow: . */ - (void) endModalSession: (NSModalSession)theSession { NSModalSession tmp = _session; NSArray *windows = [self windows]; if (theSession == 0) { [NSException raise: NSInvalidArgumentException format: @"null pointer passed to endModalSession:"]; } /* Remove this session from linked list of sessions. */ while (tmp != 0 && tmp != theSession) { tmp = tmp->previous; } if (tmp == 0) { [NSException raise: NSInvalidArgumentException format: @"unknown session passed to endModalSession:"]; } while (_session != theSession) { tmp = _session; _session = tmp->previous; if ([windows indexOfObjectIdenticalTo: tmp->window] != NSNotFound) { [tmp->window setLevel: tmp->entryLevel]; } NSZoneFree(NSDefaultMallocZone(), tmp); } _session = _session->previous; if ([windows indexOfObjectIdenticalTo: theSession->window] != NSNotFound) { [theSession->window setLevel: theSession->entryLevel]; } NSZoneFree(NSDefaultMallocZone(), theSession); } /** * Starts modal event loop for given window, after calling * -beginModalSessionForWindow:. Loop is broken only by -stopModal , * -stopModalWithCode: , or -abortModal , at which time -endModalSession: * is called automatically. */ - (int) runModalForWindow: (NSWindow*)theWindow { NSModalSession theSession = 0; int code = NSRunContinuesResponse; NS_DURING { NSDate *limit; GSDisplayServer *srv; theSession = [self beginModalSessionForWindow: theWindow]; limit = [NSDate distantFuture]; srv = GSCurrentServer(); while (code == NSRunContinuesResponse) { /* * Try to handle events for this session, discarding others. */ code = [self runModalSession: theSession]; if (code == NSRunContinuesResponse) { /* * Wait until there are more events to handle. */ DPSPeekEvent(srv, NSAnyEventMask, limit, NSDefaultRunLoopMode); } } [self endModalSession: theSession]; } NS_HANDLER { if (theSession != 0) { NSWindow *win_to_close = theSession->window; [self endModalSession: theSession]; [win_to_close close]; } if ([[localException name] isEqual: NSAbortModalException] == NO) { [localException raise]; } code = NSRunAbortedResponse; } NS_ENDHANDLER return code; } /**Processes any events for a modal session described by the theSession variable. When finished, it returns the state of the session (i.e. whether it is still running or has been stopped, etc)
If there are no pending events for the session, this method returns immediately.
Although Apple's docs state that, before processing the events, it makes the session window key and orders the window front, this method does not attempt to do this, because: 1) we don't want to interfere with use of other apps during modal session for this app; 2) occasionally other windows are active and should be usable during modal sessions (e.g., a popup dialog from a modal window); 3) most of the time -beginModalSessionForWindow: will have been called in advance. If the latter is not the case, you may need to order the window front yourself in advance.
See Also: -runModalForWindow:
*/ - (int) runModalSession: (NSModalSession)theSession { NSAutoreleasePool *pool; GSDisplayServer *srv; BOOL done = NO; NSEvent *event; NSDate *limit; if (theSession != _session) { [NSException raise: NSInvalidArgumentException format: @"runModalSession: with wrong session"]; } // Use the default context for all events. srv = GSCurrentServer(); // Only handle input which is already available. limit = [NSDate distantPast]; /* * Deal with the events in the queue. */ while (done == NO && theSession->runState == NSRunContinuesResponse) { IF_NO_GC(pool = [arpClass new]); event = DPSGetEvent(srv, NSAnyEventMask, limit, NSDefaultRunLoopMode); if (event != nil) { NSWindow *eventWindow = [event window]; /* * We handle events for the session window, events for any * window which works when modal, and any window management * events. All others are ignored/discarded. */ if (eventWindow == theSession->window || [eventWindow worksWhenModal] == YES || [event type] == NSAppKitDefined) { ASSIGN(_current_event, event); } else { event = nil; // Ignore/discard this event. } } else { done = YES; // No more events pending. } if (event != nil) { NSEventType type = [_current_event type]; [self sendEvent: _current_event]; // update (en/disable) the services menu's items if (type != NSPeriodic && type != NSMouseMoved) { [_listener updateServicesMenu]; [_main_menu update]; } /* * Check to see if the window has gone away - if so, end session. */ if ([[self windows] indexOfObjectIdenticalTo: _session->window] == NSNotFound) { [self stopModal]; } if (_windows_need_update) { [self updateWindows]; } } RELEASE (pool); } NSAssert(_session == theSession, @"Session was changed while running"); return theSession->runState; } /**Returns the window that is part of the current modal session, if any.
See -runModalForWindow:
*/ - (NSWindow *) modalWindow { if (_session != 0) return (_session->window); else return nil; } /** * Stops the main run loop, as well as a modal session if it is running. */ - (void) stop: (id)sender { if (_session != 0) [self stopModal]; else { _app_is_running = NO; /* * add dummy event to queue to assure loop cycles * at least one more time */ DPSPostEvent(GSCurrentServer(), null_event, NO); } } /** Stops a running modal session causing -runModalForWindow: or
* -runModalSession: to return NSRunStoppedResponse. Use this
* or -stopModalWithCode: to end a modal session in response to user input.
See Also: -stopModalWithCode:
*/ - (void) stopModal { [self stopModalWithCode: NSRunStoppedResponse]; } /** * Stops a running modal session causing -runModalForWindow: or * -runModalSession: to return the specified integer code. Use this * or -stopModal to end a modal session in response to user input. */ - (void) stopModalWithCode: (int)returnCode { if (_session == 0) { [NSException raise: NSInvalidArgumentException format: @"stopModalWithCode: when not in a modal session"]; } else if (returnCode == NSRunContinuesResponse) { [NSException raise: NSInvalidArgumentException format: @"stopModalWithCode: with NSRunContinuesResponse"]; } _session->runState = returnCode; } /** * Put up a modal window centered relative to docWindow. On OS X this is * deprecated in favor of * -beginSheet:modalForWindow:modalDelegate:didEndSelector:contextInfo: . * Not implemented under GNUstep. Currently just centers window on the * screen. */ - (int) runModalForWindow: (NSWindow *)theWindow relativeToWindow: (NSWindow *)docWindow { // FIXME return [self runModalForWindow: theWindow]; } /** * Put up a modal sheet sliding down from top of docWindow. If modalDelegate * is non-nil and responds to didEndSelector (this is optional), it is invoked * after the session ends. The selector should take three arguments: * NSWindow *, int, void *. It is passed the sheet window, the return code, * and the contextInfo passed in here. * Under GNUstep, the sheet aspect is not implemented (just centers * window on the screen), but modalDelegate didEndSelector is called if * both non-nil. */ - (void) beginSheet: (NSWindow *)sheet modalForWindow: (NSWindow *)docWindow modalDelegate: (id)modalDelegate didEndSelector: (SEL)didEndSelector contextInfo: (void *)contextInfo { // FIXME int ret; ret = [self runModalForWindow: sheet relativeToWindow: docWindow]; if ([modalDelegate respondsToSelector: didEndSelector]) { void (*didEnd)(id, SEL, id, int, void*); didEnd = (void (*)(id, SEL, id, int, void*))[modalDelegate methodForSelector: didEndSelector]; didEnd(modalDelegate, didEndSelector, sheet, ret, contextInfo); } } /** * Analogous to -stopModal for sheets. */ - (void) endSheet: (NSWindow *)sheet { // FIXME [self stopModal]; } /** * Analogous to -stopModalWithCode: for sheets. */ - (void) endSheet: (NSWindow *)sheet returnCode: (int)returnCode { // FIXME [self stopModalWithCode: returnCode]; } /* * Getting, removing, and posting events */ /** * Called by -run to dispatch events that are received according to AppKit's * forwarding conventions. You rarely need to invoke this directly. If you * want to synthesize an event for processing, call -postEvent:atStart: . */ - (void) sendEvent: (NSEvent *)theEvent { NSEventType type; type = [theEvent type]; switch (type) { case NSPeriodic: /* NSApplication traps the periodic events */ break; case NSKeyDown: { NSDebugLLog(@"NSEvent", @"send key down event\n"); if ([theEvent modifierFlags] & NSCommandKeyMask) { NSArray *window_list = [self windows]; unsigned i; unsigned count = [window_list count]; for (i = 0; i < count; i++) { NSWindow *window = [window_list objectAtIndex: i]; if ([window performKeyEquivalent: theEvent] == YES) break; } } else [[theEvent window] sendEvent: theEvent]; break; } case NSKeyUp: { NSDebugLLog(@"NSEvent", @"send key up event\n"); [[theEvent window] sendEvent: theEvent]; break; } default: /* pass all other events to the event's window */ { NSWindow *window = [theEvent window]; if (!theEvent) NSDebugLLog(@"NSEvent", @"NSEvent is nil!\n"); if (type == NSMouseMoved) NSDebugLLog(@"NSMotionEvent", @"Send move (%d) to window %d", type, [window windowNumber]); else NSDebugLLog(@"NSEvent", @"Send NSEvent type: %d to window %d", type, [window windowNumber]); if (window) [window sendEvent: theEvent]; else if (type == NSRightMouseDown) [self rightMouseDown: theEvent]; } } } /** * Returns the most recent event -run pulled off the event queue. */ - (NSEvent*) currentEvent { return _current_event; } /* Utility for pen-device input. See NSResponder. */ - (BOOL) shouldBeTreatedAsInkEvent: (NSEvent *)theEvent { return [[theEvent window] shouldBeTreatedAsInkEvent: theEvent]; } /** * Drop events matching mask from the queue, before but not including * lastEvent. The mask is a bitwise AND of event mask constants. * See (EventType) . UseNSAnyEventMask to discard everything
* up to lastEvent.
*/
- (void) discardEventsMatchingMask: (unsigned int)mask
beforeEvent: (NSEvent *)lastEvent
{
DPSDiscardEvents(GSCurrentServer(), mask, lastEvent);
}
/**
* Return the next event matching mask from the queue, dequeuing if flag is
* YES. Intervening events are NOT dequeued. If no matching event is on the
* queue, will wait for one until expiration, returning nil if none found.
* See (EventType) for the list of masks.
*/
- (NSEvent*) nextEventMatchingMask: (unsigned int)mask
untilDate: (NSDate*)expiration
inMode: (NSString*)mode
dequeue: (BOOL)flag
{
NSEvent *event;
if (!expiration)
expiration = [NSDate distantFuture];
if (flag)
event = DPSGetEvent(GSCurrentServer(), mask, expiration, mode);
else
event = DPSPeekEvent(GSCurrentServer(), mask, expiration, mode);
if (event)
{
IF_NO_GC(NSAssert([event retainCount] > 0, NSInternalInconsistencyException));
/*
* If we are not in a tracking loop, we may want to unhide a hidden
* because the mouse has been moved.
*/
if (mode != NSEventTrackingRunLoopMode && event != null_event)
{
if ([NSCursor isHiddenUntilMouseMoves])
{
NSEventType type = [event type];
if ((type == NSLeftMouseDown) || (type == NSLeftMouseUp)
|| (type == NSOtherMouseDown) || (type == NSOtherMouseUp)
|| (type == NSRightMouseDown) || (type == NSRightMouseUp)
|| (type == NSMouseMoved))
{
[NSCursor setHiddenUntilMouseMoves: NO];
}
}
}
ASSIGN(_current_event, event);
}
return event;
}
/**
* Add an event to be processed by the app, either at end or at beginning
* (next up) if flag is YES. This provides a way to provide synthetic input
* to an application, or, for whatever reason, to allow a real event to be
* re-dispatched.
*/
- (void) postEvent: (NSEvent *)event atStart: (BOOL)flag
{
DPSPostEvent(GSCurrentServer(), event, flag);
}
/**
* Sends the aSelector message to the receiver returned by the
* -targetForAction:to:from: method (to which the aTarget and sender
* arguments are passed).* Returns the target object that will respond to aSelector, if any. The * method first checks if any of the key window's first responders, the * key window or its delegate responds. Next it checks the main window in * the same way. Finally it checks the receiver (NSApplication) and its * delegate. *
*/ - (id) targetForAction: (SEL)aSelector { NSWindow *keyWindow; NSWindow *mainWindow; id resp; keyWindow = [self keyWindow]; if (keyWindow != nil) { resp = [keyWindow firstResponder]; while (resp != nil && resp != keyWindow) { if ([resp respondsToSelector: aSelector]) { return resp; } resp = [resp nextResponder]; } if ([keyWindow respondsToSelector: aSelector]) { return keyWindow; } resp = [keyWindow delegate]; if (resp != nil && [resp respondsToSelector: aSelector]) { return resp; } if ([NSDocumentController isDocumentBasedApplication]) { resp = [[NSDocumentController sharedDocumentController] documentForWindow: keyWindow]; if (resp != nil && [resp respondsToSelector: aSelector]) { return resp; } } } if (_session != 0) return nil; mainWindow = [self mainWindow]; if (keyWindow != mainWindow && mainWindow != nil) { resp = [mainWindow firstResponder]; while (resp != nil && resp != mainWindow) { if ([resp respondsToSelector: aSelector]) { return resp; } resp = [resp nextResponder]; } if ([mainWindow respondsToSelector: aSelector]) { return mainWindow; } resp = [mainWindow delegate]; if (resp != nil && [resp respondsToSelector: aSelector]) { return resp; } if ([NSDocumentController isDocumentBasedApplication]) { resp = [[NSDocumentController sharedDocumentController] documentForWindow: mainWindow]; if (resp != nil && [resp respondsToSelector: aSelector]) { return resp; } } } if ([self respondsToSelector: aSelector]) { return self; } if (_delegate != nil && [_delegate respondsToSelector: aSelector]) { return _delegate; } if ([NSDocumentController isDocumentBasedApplication] && [[NSDocumentController sharedDocumentController] respondsToSelector: aSelector]) { return [NSDocumentController sharedDocumentController]; } return nil; } /** * Attempts to perform aSelector using [NSResponder-tryToPerform:with:] * and if that is not possible, attempts to get the application * delegate to perform the aSelector.Sets the application's icon. Any windows that use the old application icon image as their mini window image will be updated to use the new image.
See Also: -applicationIconImage
*/ - (void) setApplicationIconImage: (NSImage*)anImage { NSEnumerator *iterator = [[self windows] objectEnumerator]; NSWindow *current; NSImage *old_app_icon = _app_icon; RETAIN(old_app_icon); [_app_icon setName: nil]; [anImage setName: @"NSApplicationIcon"]; ASSIGN(_app_icon, anImage); [_main_menu _organizeMenu]; // Let horizontal menu change icon if (_app_icon_window != nil) { [(NSAppIconView *)[_app_icon_window contentView] setImage: anImage]; } // Swap the old image for the new one wherever it's used while ((current = [iterator nextObject]) != nil) { if ([current miniwindowImage] == old_app_icon) [current setMiniwindowImage: anImage]; } DESTROY(old_app_icon); } /**Returns the current icon be used for the application.
See Also: -setApplicationIconImage:
*/ - (NSImage*) applicationIconImage { return _app_icon; } /** * Returns the actual window object being used to display the application * icon (usually in the dock). */ - (NSWindow*) iconWindow { return _app_icon_window; } /* * Hiding and arranging windows */ /** Request this application to "hide" (unmap all windows from the screen
* except the icon window). Posts
* NSApplicationWillHideNotification and
* NSApplicationDidHideNotification. On OS X this activates
* the next app that is running, however on GNUstep this is up to the window
* manager.
See Also: -unhide: -isHidden
*/ - (void) hide: (id)sender { if (_app_is_hidden == NO) { NSArray *windows_list = [self windows]; unsigned count = [windows_list count]; NSDictionary *info; unsigned i; [nc postNotificationName: NSApplicationWillHideNotification object: self]; if ([self keyWindow] != nil) { _hidden_key = [self keyWindow]; [_hidden_key resignKeyWindow]; } for (i = 0; i < count; i++) { NSWindow *win = [windows_list objectAtIndex: i]; if ([win isVisible] == NO) { continue; /* Already invisible */ } if ([win canHide] == NO) { continue; /* Not hideable */ } if (win == _app_icon_window) { continue; /* can't hide the app icon. */ } if (_app_is_active == YES && [win hidesOnDeactivate] == YES) { continue; /* Will be hidden by deactivation */ } [_hidden addObject: win]; [win orderOut: self]; } _app_is_hidden = YES; [[_app_icon_window contentView] setNeedsDisplay: YES]; /* * On hiding we also deactivate the application which will make the menus * go away too. */ [self deactivate]; _unhide_on_activation = YES; info = [self _notificationUserInfo]; [nc postNotificationName: NSApplicationDidHideNotification object: self userInfo: info]; [[[NSWorkspace sharedWorkspace] notificationCenter] postNotificationName: NSApplicationDidHideNotification object: [NSWorkspace sharedWorkspace] userInfo: info]; } } /**Returns whether app is currently in hidden state.
See Also: -hide: -unhide:
*/ - (BOOL) isHidden { return _app_is_hidden; } /**Unhides and activates this application.
See Also: -unhideWithoutActivation -hide: -isHidden
*/ - (void) unhide: (id)sender { if (_app_is_hidden) { [self unhideWithoutActivation]; _unhide_on_activation = NO; } if (_app_is_active == NO) { /* * Activation should make the applications menus visible. */ [self activateIgnoringOtherApps: YES]; } } /** * Unhides this app (displays its windows) but does not activate it. */ - (void) unhideWithoutActivation { if (_app_is_hidden == YES) { NSDictionary *info; unsigned count; unsigned i; [nc postNotificationName: NSApplicationWillUnhideNotification object: self]; /* Make sure we set this before ordering windows to avoid possible recursive loops (some methods window/backend methods check if the app is hidden before ordering a window). */ _app_is_hidden = NO; count = [_hidden count]; for (i = 0; i < count; i++) { [[_hidden objectAtIndex: i] orderFrontRegardless]; } [_hidden removeAllObjects]; if (_hidden_key != nil && [[self windows] indexOfObjectIdenticalTo: _hidden_key] != NSNotFound) { [_hidden_key makeKeyAndOrderFront: self]; _hidden_key = nil; } [[_app_icon_window contentView] setNeedsDisplay: YES]; info = [self _notificationUserInfo]; [nc postNotificationName: NSApplicationDidUnhideNotification object: self userInfo: info]; [[[NSWorkspace sharedWorkspace] notificationCenter] postNotificationName: NSApplicationDidUnhideNotification object: [NSWorkspace sharedWorkspace] userInfo: info]; } } /** * Arranges all app's windows in front by successively calling * [NSWindow-orderFront:] on each window in the app's Windows menu. */ - (void) arrangeInFront: (id)sender { NSMenu *menu; menu = [self windowsMenu]; if (menu) { NSArray *itemArray; unsigned count; unsigned i; itemArray = [menu itemArray]; count = [itemArray count]; for (i = 0; i < count; i++) { id win = [(NSMenuItem*)[itemArray objectAtIndex: i] target]; if ([win isKindOfClass: [NSWindow class]]) { [win orderFront: sender]; } } } } /* * Managing windows */ /** * Returns current key window. If this app is active, one window should be * key. If this app is not active, nil should be returned. The key window * is the one that will receive keyboard input. */ - (NSWindow*) keyWindow { return _key_window; } /** * Returns current main window of this application. There need not necessarily * be a main window, even if app is active, and this should return nil if the * app is inactive. */ - (NSWindow*) mainWindow { return _main_window; } /** * Sends aSelector to each window, either in the app's internal window list * (flag = NO) or their stacking order from front to back on the screen * (flag = YES, currently not implemented under GNUstep). */ - (NSWindow*) makeWindowsPerform: (SEL)aSelector inOrder: (BOOL)flag { NSArray *window_list = [self windows]; unsigned i; // FIXME flag ignored i = [window_list count]; while (i-- > 0) { NSWindow *window = [window_list objectAtIndex: i]; if ([window performSelector: aSelector] != nil) { return window; } } return nil; } /** * Iconify all windows in the app. */ - (void) miniaturizeAll: sender { NSArray *window_list = [self windows]; unsigned i, count; for (i = 0, count = [window_list count]; i < count; i++) [[window_list objectAtIndex: i] miniaturize: sender]; } /** * Prevent window reordering in response to most recent mouse down (useful to * prevent raise-on-mouse-click). Not implemented under GNUstep. */ - (void) preventWindowOrdering { //TODO } /** * Set whether the main run loop will request all visible windows update * themselves after the current or next event is processed. (Update occurs * after event dispatch in the loop.) */ - (void) setWindowsNeedUpdate: (BOOL)flag { _windows_need_update = flag; } /** * Sends each of the app's visible windows an [NSWindow-update] message. * This method is called once per iteration of the main run loop managed * by -run . */ - (void) updateWindows { NSArray *window_list = [self windows]; unsigned count = [window_list count]; unsigned i; _windows_need_update = NO; [nc postNotificationName: NSApplicationWillUpdateNotification object: self]; for (i = 0; i < count; i++) { NSWindow *win = [window_list objectAtIndex: i]; if ([win isVisible]) [win update]; } [nc postNotificationName: NSApplicationDidUpdateNotification object: self]; } /** * Returns array of app's visible and invisible windows. */ - (NSArray*) windows { return GSAllWindows(); } /** * Returns window for windowNum. Note the window number can be obtained for * a window from [NSWindow-windowNumber]. */ - (NSWindow *) windowWithWindowNumber: (int)windowNum { return GSWindowWithNumber(windowNum); } /* * Showing Standard Panels */ /** Calls -orderFrontStandardAboutPanelWithOptions: with nil passed as the options dictionary. */ - (void) orderFrontStandardAboutPanel: sender { [self orderFrontStandardAboutPanelWithOptions: nil]; } /** OS X compatibility: Calls -orderFrontStandardInfoPanelWithOptions: . */ - (void) orderFrontStandardAboutPanelWithOptions: (NSDictionary *)dictionary { [self orderFrontStandardInfoPanelWithOptions: dictionary]; } /* infoPanel, GNUstep API */ /** Calls -orderFrontStandardInfoPanelWithOptions: with nil passed as the options dictionary. */ - (void) orderFrontStandardInfoPanel: sender { [self orderFrontStandardInfoPanelWithOptions: nil]; } /**
Orders front the standard info panel for the application,
taking the needed information from the dictionary
argument. There is a single standard info panel per application;
it is created the first time that this method is invoked, and then
reused in all subsequent calls. The application standard info
panel is immutable and can not be changed after creation. Useful
keys for the dictionary are:
Returns the services menu of the receiver.
See Also: -setServicesMenu:
*/ - (NSMenu *) servicesMenu { return [_listener servicesMenu]; } /**Returns the services provided previously registered using the * -setServicesProvider: method.
See Also: -setServicesProvider:
*/ - (id) servicesProvider { return [_listener servicesProvider]; } /**ets the services menu for the receiver. This should be called, otherwise * warnings will be generated by the main event loop, which is in charge of * updating all menus, including the Services menu.
*See Also: -servicesMenu
*/ - (void) setServicesMenu: (NSMenu *)aMenu { [_listener setServicesMenu: aMenu]; } /** * Sets the object which provides services to other applications.NSTerminateNow) will termination be
* carried out.
*/
- (void) terminate: (id)sender
{
int shouldTerminate = YES;
if ([_delegate respondsToSelector: @selector(applicationShouldTerminate:)])
{
shouldTerminate = [_delegate applicationShouldTerminate: self];
}
else
{
if ([NSDocumentController isDocumentBasedApplication])
{
shouldTerminate = [[NSDocumentController sharedDocumentController]
reviewUnsavedDocumentsWithAlertTitle: _(@"Quit")
cancellable:YES];
}
}
if (shouldTerminate == NSTerminateNow)
{
[self replyToApplicationShouldTerminate: YES];
}
/*
Don't need to do anything on NSTerminateLater, as long as user code
follows the contract (to call replyTo... later).
*/
}
/**
* Terminates the app if shouldTerminate is YES, otherwise does nothing.
* This should be called by user code if a delegate has returned
* NSTerminateLater to an -applicationShouldTerminate: message.
*/
- (void) replyToApplicationShouldTerminate: (BOOL)shouldTerminate
{
if (shouldTerminate)
{
[nc postNotificationName: NSApplicationWillTerminateNotification
object: self];
_app_is_running = NO;
[[self windows] makeObjectsPerformSelector: @selector(close)];
[NSCursor setHiddenUntilMouseMoves: NO];
/* Store our user information. */
[[NSUserDefaults standardUserDefaults] synchronize];
/* Tell the Workspace that we really did terminate. */
[[[NSWorkspace sharedWorkspace] notificationCenter]
postNotificationName: NSWorkspaceDidTerminateApplicationNotification
object: [NSWorkspace sharedWorkspace]
userInfo: [self _notificationUserInfo]];
/* Destroy the main run loop pool (this also destroys any nested
pools which might have been created inside this one). */
DESTROY (_runLoopPool);
/* Now free the NSApplication object. Enclose the operation
into an autorelease pool, in case some -dealloc method needs
to use any temporary object. */
{
NSAutoreleasePool *pool;
IF_NO_GC(pool = [arpClass new]);
DESTROY(NSApp);
DESTROY(pool);
}
/* And finally, stop the program. */
exit(0);
}
}
/**
* Returns the application's delegate, as set by the -setDelegate: method.The application delegate will automatically be sent various
* notifications (as long as it implements the appropriate methods)
* when application events occur. The method to handle each of these
* notifications has name mirroring the notification name, so for instance
* an NSApplicationDidBecomeActiveNotification is handled by an
* applicationDidBecomeActive: method.
*
The delegate is also sent various messages to ask for authorisation * to perform actions, or to ask it to perform actions (again, as long * as it implements the appropriate methods). *
*The delegate is also called upon to respond to any actions which * are not handled by a window, a window delgate, or by the application * object itself. This is controlled by the -targetForAction: method. *
*Finally, the application delegate is responsible for handling * messages sent to the application from remote processes (see the * section documenting distributed objects for [NSPasteboard]). *
*See -setDelegate: and [(GSAppDelegateProtocol)] for more information.
*/ - (id) delegate { return _delegate; } /** * Sets the delegate of the application to anObject.Beware, this does not retain anObject, so you must be sure * that, in the event of anObject being deallocated, you * stop it being the application delagate by calling this * method again with another object (or nil) as the argument. *
*See -delegate and [(GSAppDelegateProtocol)] for more information.
*/ - (void) setDelegate: (id)anObject { if (_delegate) [nc removeObserver: _delegate name: nil object: self]; _delegate = anObject; #define SET_DELEGATE_NOTIFICATION(notif_name) \ if ([_delegate respondsToSelector: @selector(application##notif_name:)]) \ [nc addObserver: _delegate \ selector: @selector(application##notif_name:) \ name: NSApplication##notif_name##Notification object: self] SET_DELEGATE_NOTIFICATION(DidBecomeActive); SET_DELEGATE_NOTIFICATION(DidFinishLaunching); SET_DELEGATE_NOTIFICATION(DidHide); SET_DELEGATE_NOTIFICATION(DidResignActive); SET_DELEGATE_NOTIFICATION(DidUnhide); SET_DELEGATE_NOTIFICATION(DidUpdate); SET_DELEGATE_NOTIFICATION(WillBecomeActive); SET_DELEGATE_NOTIFICATION(WillFinishLaunching); SET_DELEGATE_NOTIFICATION(WillHide); SET_DELEGATE_NOTIFICATION(WillResignActive); SET_DELEGATE_NOTIFICATION(WillTerminate); SET_DELEGATE_NOTIFICATION(WillUnhide); SET_DELEGATE_NOTIFICATION(WillUpdate); } /* * Methods for scripting */ /** * OS X scripting method to return document objects being handled by * application. Not implemented yet under GNUstep. */ - (NSArray *) orderedDocuments { // FIXME return nil; } /** * OS X scripting method to return windows in front-to-back on-screen order. * The GNUstep implementation returns all the windows in an arbitrary * order. */ - (NSArray *) orderedWindows { // FIXME return [self windows]; } /* * Methods for user attention requests */ /** * Cancels a request previously made through calling -requestUserAttention: . * Note that request is cancelled automatically if user activates the app. */ - (void) cancelUserAttentionRequest: (int)request { // FIXME } /** * Method that on OS X makes the icon jump in the doc. Mercifully, this is * unimplemented under GNUstep. If it were implemented, requestType * could be eitherNSCriticalRequest (bounce endlessly) or
* NSInformationalRequest (bounce for one second).
*/
- (int) requestUserAttention: (NSRequestUserAttentionType)requestType
{
// FIXME
return 0;
}
/*
* NSCoding protocol
*/
- (void) encodeWithCoder: (NSCoder*)aCoder
{
[super encodeWithCoder: aCoder];
[aCoder encodeConditionalObject: _delegate];
[aCoder encodeObject: _main_menu];
[aCoder encodeConditionalObject: _windows_menu];
}
- (id) initWithCoder: (NSCoder*)aDecoder
{
id obj;
[super initWithCoder: aDecoder];
obj = [aDecoder decodeObject];
[self setDelegate: obj];
obj = [aDecoder decodeObject];
[self setMainMenu: obj];
obj = [aDecoder decodeObject];
[self setWindowsMenu: obj];
return self;
}
@end /* NSApplication */
@implementation NSApplication (Private)
- _appIconInit
{
NSAppIconView *iv;
NSSize iconSize = [GSCurrentServer() iconSize];
NSRect iconRect = NSMakeRect(0, 0, iconSize.width, iconSize.height);
if (_app_icon == nil)
{
[self setApplicationIconImage: [NSImage imageNamed: @"GNUstep"]];
}
_app_icon_window = [[NSIconWindow alloc] initWithContentRect: iconRect
styleMask: NSIconWindowMask
backing: NSBackingStoreRetained
defer: NO
screen: nil];
iv = [[NSAppIconView alloc] initWithFrame: iconRect];
[iv setImage: _app_icon];
[_app_icon_window setContentView: iv];
RELEASE(iv);
[_app_icon_window orderFrontRegardless];
return self;
}
- (NSDictionary*) _notificationUserInfo
{
NSString *path;
NSString *port;
NSNumber *processIdentifier;
NSDictionary *userInfo;
processIdentifier = [NSNumber numberWithInt:
[[NSProcessInfo processInfo] processIdentifier]];
port = [(GSServicesManager*)_listener port];
path = [[NSBundle mainBundle] bundlePath];
if (port == nil)
{
if (path == nil)
{
userInfo = [NSDictionary dictionaryWithObjectsAndKeys:
processIdentifier, @"NSApplicationProcessIdentifier",
nil];
}
else
{
userInfo = [NSDictionary dictionaryWithObjectsAndKeys:
path, @"NSApplicationPath",
processIdentifier, @"NSApplicationProcessIdentifier",
nil];
}
}
else if (path == nil)
{
userInfo = [NSDictionary dictionaryWithObjectsAndKeys:
port, @"NSApplicationName",
processIdentifier, @"NSApplicationProcessIdentifier",
nil];
}
else
{
userInfo = [NSDictionary dictionaryWithObjectsAndKeys:
port, @"NSApplicationName",
path, @"NSApplicationPath",
processIdentifier, @"NSApplicationProcessIdentifier",
nil];
}
return userInfo;
}
- (void) _openDocument: (NSString*)filePath
{
[_listener application: self openFile: filePath];
}
- (void) _windowDidBecomeKey: (NSNotification*) notification
{
id obj = [notification object];
if (_key_window == nil && [obj isKindOfClass: [NSWindow class]])
{
_key_window = obj;
}
else
{
NSLog(@"Bogus attempt to set key window");
}
}
- (void) _windowDidBecomeMain: (NSNotification*) notification
{
id obj = [notification object];
if (_main_window == nil && [obj isKindOfClass: [NSWindow class]])
{
_main_window = obj;
}
else
{
NSLog(@"Bogus attempt to set main window");
}
}
- (void) _windowDidResignKey: (NSNotification*) notification
{
id obj = [notification object];
if (_key_window == obj)
{
_key_window = nil;
[NSCursor setHiddenUntilMouseMoves: NO];
}
else
{
NSLog(@"Bogus attempt to resign key window");
}
}
- (void) _windowDidResignMain: (NSNotification*) notification
{
id obj = [notification object];
if (_main_window == obj)
{
_main_window = nil;
}
else
{
NSLog(@"Bogus attempt to resign key window");
}
}
- (void) _windowWillClose: (NSNotification*) notification
{
NSWindow *win = [notification object];
NSArray *windows_list = [self windows];
unsigned count = [windows_list count];
unsigned i;
NSMutableArray *list = [NSMutableArray arrayWithCapacity: count];
BOOL wasKey = [win isKeyWindow];
BOOL wasMain = [win isMainWindow];
for (i = 0; i < count; i++)
{
NSWindow *tmp = [windows_list objectAtIndex: i];
if ([tmp canBecomeMainWindow] == YES && [tmp isVisible] == YES)
{
[list addObject: tmp];
}
}
[list removeObjectIdenticalTo: win];
count = [list count];
/* If there's only one window left, and that's the one being closed,
then we ask the delegate if the app is to be terminated. */
if (wasMain && count == 0 && _app_is_running)
{
if ([_delegate respondsToSelector:
@selector(applicationShouldTerminateAfterLastWindowClosed:)])
{
if ([_delegate applicationShouldTerminateAfterLastWindowClosed: self])
{
[self terminate: self];
}
}
}
if (wasMain == YES)
{
[win resignMainWindow];
}
if (wasKey == YES)
{
[win resignKeyWindow];
}
if (_app_is_running)
{
/*
* If we are not quitting, we may need to find a new key/main window.
*/
if (wasKey == YES && [self keyWindow] == nil)
{
win = [self mainWindow];
if (win != nil && [win canBecomeKeyWindow] == YES)
{
/*
* We have a main window that can become key, so do it.
*/
[win makeKeyAndOrderFront: self];
}
else if (win != nil)
{
/*
* We have a main window that can't become key, so we just
* find a new window to make into our key window.
*/
for (i = 0; i < count; i++)
{
win = [list objectAtIndex: i];
if ([win canBecomeKeyWindow] == YES)
{
[win makeKeyAndOrderFront: self];
}
}
}
else
{
/*
* Find a window that can be made key and main - and do it.
*/
for (i = 0; i < count; i++)
{
win = [list objectAtIndex: i];
if ([win canBecomeKeyWindow] && [win canBecomeMainWindow])
{
break;
}
}
if (i < count)
{
[win makeMainWindow];
[win makeKeyAndOrderFront: self];
}
else
{
/*
* No window we can use, so just find any candidate to
* be main window and another to be key window.
*/
for (i = 0; i < count; i++)
{
win = [list objectAtIndex: i];
if ([win canBecomeMainWindow] == YES)
{
[win makeMainWindow];
break;
}
}
for (i = 0; i < count; i++)
{
win = [list objectAtIndex: i];
if ([win canBecomeKeyWindow] == YES)
{
[win makeKeyAndOrderFront: self];
break;
}
}
}
}
}
else if ([self mainWindow] == nil)
{
win = [self keyWindow];
if ([win canBecomeMainWindow] == YES)
{
[win makeMainWindow];
}
else
{
for (i = 0; i < count; i++)
{
win = [list objectAtIndex: i];
if ([win canBecomeMainWindow] == YES)
{
[win makeMainWindow];
break;
}
}
}
}
}
}
- (void) _workspaceNotification: (NSNotification*) notification
{
NSString *name = [notification name];
NSDictionary *info = [notification userInfo];
/*
* Handle hiding and unhiding of this app if necessary.
*/
if ([name isEqualToString: GSUnhideAllApplicationsNotification] == YES)
{
[self unhideWithoutActivation];
}
else if ([name isEqualToString: GSHideOtherApplicationsNotification] == YES)
{
NSString *port = [info objectForKey: @"NSApplicationName"];
if ([port isEqual: [[GSServicesManager manager] port]] == NO)
{
[self hide: self];
}
}
}
@end // NSApplication (Private)
@implementation NSApplication (GSGUIInternal)
- (void) _windowWillDealloc: (NSWindow *)window
{
if (window == _key_window)
_key_window = nil;
if (window == _main_window)
_main_window = nil;
}
@end