widget/cocoa/nsWindowMap.mm

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "nsWindowMap.h"
   7 #include "nsObjCExceptions.h"
   8 #include "nsChildView.h"
   9 #include "nsCocoaWindow.h"
  10
  11 @interface WindowDataMap (Private)
  12
  13 - (NSString*)keyForWindow:(NSWindow*)inWindow;
  14
  15 @end
  16
  17 @interface TopLevelWindowData (Private)
  18
  19 - (void)windowResignedKey:(NSNotification*)inNotification;
  20 - (void)windowBecameKey:(NSNotification*)inNotification;
  21 - (void)windowWillClose:(NSNotification*)inNotification;
  22
  23 @end
  24
  25 #pragma mark -
  26
  27 @implementation WindowDataMap
  28
  29 + (WindowDataMap*)sharedWindowDataMap {
  30   NS_OBJC_BEGIN_TRY_BLOCK_RETURN;
  31
  32   static WindowDataMap* sWindowMap = nil;
  33   if (!sWindowMap) sWindowMap = [[WindowDataMap alloc] init];
  34
  35   return sWindowMap;
  36
  37   NS_OBJC_END_TRY_BLOCK_RETURN(nil);
  38 }
  39
  40 - (id)init {
  41   NS_OBJC_BEGIN_TRY_BLOCK_RETURN;
  42
  43   if ((self = [super init])) {
  44     mWindowMap = [[NSMutableDictionary alloc] initWithCapacity:10];
  45   }
  46   return self;
  47
  48   NS_OBJC_END_TRY_BLOCK_RETURN(nil);
  49 }
  50
  51 - (void)dealloc {
  52   NS_OBJC_BEGIN_TRY_IGNORE_BLOCK;
  53
  54   [mWindowMap release];
  55   [super dealloc];
  56
  57   NS_OBJC_END_TRY_IGNORE_BLOCK;
  58 }
  59
  60 - (void)ensureDataForWindow:(NSWindow*)inWindow {
  61   NS_OBJC_BEGIN_TRY_IGNORE_BLOCK;
  62
  63   if (!inWindow || [self dataForWindow:inWindow]) return;
  64
  65   TopLevelWindowData* windowData =
  66       [[TopLevelWindowData alloc] initWithWindow:inWindow];
  67   [self setData:windowData forWindow:inWindow];  // takes ownership
  68   [windowData release];
  69
  70   NS_OBJC_END_TRY_IGNORE_BLOCK;
  71 }
  72
  73 - (id)dataForWindow:(NSWindow*)inWindow {
  74   NS_OBJC_BEGIN_TRY_BLOCK_RETURN;
  75
  76   return [mWindowMap objectForKey:[self keyForWindow:inWindow]];
  77
  78   NS_OBJC_END_TRY_BLOCK_RETURN(nil);
  79 }
  80
  81 - (void)setData:(id)inData forWindow:(NSWindow*)inWindow {
  82   NS_OBJC_BEGIN_TRY_IGNORE_BLOCK;
  83
  84   [mWindowMap setObject:inData forKey:[self keyForWindow:inWindow]];
  85
  86   NS_OBJC_END_TRY_IGNORE_BLOCK;
  87 }
  88
  89 - (void)removeDataForWindow:(NSWindow*)inWindow {
  90   NS_OBJC_BEGIN_TRY_IGNORE_BLOCK;
  91
  92   [mWindowMap removeObjectForKey:[self keyForWindow:inWindow]];
  93
  94   NS_OBJC_END_TRY_IGNORE_BLOCK;
  95 }
  96
  97 - (NSString*)keyForWindow:(NSWindow*)inWindow {
  98   NS_OBJC_BEGIN_TRY_BLOCK_RETURN;
  99
 100   return [NSString stringWithFormat:@"%p", inWindow];
 101
 102   NS_OBJC_END_TRY_BLOCK_RETURN(nil);
 103 }
 104
 105 @end
 106
 107 //  TopLevelWindowData
 108 //
 109 //  This class holds data about top-level windows. We can't use a window
 110 //  delegate, because an embedder may already have one.
 111
 112 @implementation TopLevelWindowData
 113
 114 - (id)initWithWindow:(NSWindow*)inWindow {
 115   NS_OBJC_BEGIN_TRY_BLOCK_RETURN;
 116
 117   if ((self = [super init])) {
 118     [NSNotificationCenter.defaultCenter
 119         addObserver:self
 120            selector:@selector(windowBecameKey:)
 121                name:NSWindowDidBecomeKeyNotification
 122              object:inWindow];
 123
 124     [NSNotificationCenter.defaultCenter
 125         addObserver:self
 126            selector:@selector(windowResignedKey:)
 127                name:NSWindowDidResignKeyNotification
 128              object:inWindow];
 129
 130     [NSNotificationCenter.defaultCenter
 131         addObserver:self
 132            selector:@selector(windowBecameMain:)
 133                name:NSWindowDidBecomeMainNotification
 134              object:inWindow];
 135
 136     [NSNotificationCenter.defaultCenter
 137         addObserver:self
 138            selector:@selector(windowResignedMain:)
 139                name:NSWindowDidResignMainNotification
 140              object:inWindow];
 141
 142     [NSNotificationCenter.defaultCenter
 143         addObserver:self
 144            selector:@selector(windowWillClose:)
 145                name:NSWindowWillCloseNotification
 146              object:inWindow];
 147   }
 148   return self;
 149
 150   NS_OBJC_END_TRY_BLOCK_RETURN(nil);
 151 }
 152
 153 - (void)dealloc {
 154   NS_OBJC_BEGIN_TRY_IGNORE_BLOCK;
 155
 156   [NSNotificationCenter.defaultCenter removeObserver:self];
 157   [super dealloc];
 158
 159   NS_OBJC_END_TRY_IGNORE_BLOCK;
 160 }
 161
 162 // As best I can tell, if the notification's object has a corresponding
 163 // top-level widget (an nsCocoaWindow object), it has a delegate (set in
 164 // nsCocoaWindow::StandardCreate()) of class WindowDelegate, and otherwise
 165 // not (Camino didn't use top-level widgets (nsCocoaWindow objects) --
 166 // only child widgets (nsChildView objects)).  (The notification is sent
 167 // to windowBecameKey: or windowBecameMain: below.)
 168 //
 169 // For use with clients that (like Firefox) do use top-level widgets (and
 170 // have NSWindow delegates of class WindowDelegate).
 171 + (void)activateInWindow:(NSWindow*)aWindow {
 172   NS_OBJC_BEGIN_TRY_IGNORE_BLOCK;
 173
 174   WindowDelegate* delegate = (WindowDelegate*)aWindow.delegate;
 175   if (!delegate || ![delegate isKindOfClass:[WindowDelegate class]]) return;
 176
 177   if ([delegate toplevelActiveState]) return;
 178   [delegate sendToplevelActivateEvents];
 179
 180   NS_OBJC_END_TRY_IGNORE_BLOCK;
 181 }
 182
 183 // See comments above activateInWindow:
 184 //
 185 // If we're using top-level widgets (nsCocoaWindow objects), we send them
 186 // NS_DEACTIVATE events (which propagate to child widgets (nsChildView
 187 // objects) via nsWebShellWindow::HandleEvent()).
 188 //
 189 // For use with clients that (like Firefox) do use top-level widgets (and
 190 // have NSWindow delegates of class WindowDelegate).
 191 + (void)deactivateInWindow:(NSWindow*)aWindow {
 192   NS_OBJC_BEGIN_TRY_IGNORE_BLOCK;
 193
 194   WindowDelegate* delegate = (WindowDelegate*)aWindow.delegate;
 195   if (!delegate || ![delegate isKindOfClass:[WindowDelegate class]]) return;
 196
 197   if (![delegate toplevelActiveState]) return;
 198   [delegate sendToplevelDeactivateEvents];
 199
 200   NS_OBJC_END_TRY_IGNORE_BLOCK;
 201 }
 202
 203 // For use with clients that (like Camino) don't use top-level widgets (and
 204 // don't have NSWindow delegates of class WindowDelegate).
 205 + (void)activateInWindowViews:(NSWindow*)aWindow {
 206   NS_OBJC_BEGIN_TRY_IGNORE_BLOCK;
 207
 208   id firstResponder = aWindow.firstResponder;
 209   if ([firstResponder isKindOfClass:[ChildView class]]) {
 210     [firstResponder viewsWindowDidBecomeKey];
 211   }
 212
 213   NS_OBJC_END_TRY_IGNORE_BLOCK;
 214 }
 215
 216 // For use with clients that (like Camino) don't use top-level widgets (and
 217 // don't have NSWindow delegates of class WindowDelegate).
 218 + (void)deactivateInWindowViews:(NSWindow*)aWindow {
 219   NS_OBJC_BEGIN_TRY_IGNORE_BLOCK;
 220
 221   id firstResponder = aWindow.firstResponder;
 222   if ([firstResponder isKindOfClass:[ChildView class]]) {
 223     [firstResponder viewsWindowDidResignKey];
 224   }
 225
 226   NS_OBJC_END_TRY_IGNORE_BLOCK;
 227 }
 228
 229 // We make certain exceptions for top-level windows in non-embedders (see
 230 // comment above windowBecameMain below).  And we need (elsewhere) to guard
 231 // against sending duplicate events.  But in general the NS_ACTIVATE event
 232 // should be sent when a native window becomes key, and the NS_DEACTIVATE
 233 // event should be sent when it resignes key.
 234 - (void)windowBecameKey:(NSNotification*)inNotification {
 235   NSWindow* window = inNotification.object;
 236
 237   id delegate = window.delegate;
 238   if (!delegate || ![delegate isKindOfClass:[WindowDelegate class]]) {
 239     [TopLevelWindowData activateInWindowViews:window];
 240   } else if (window.isSheet || window.isMainWindow) {
 241     [TopLevelWindowData activateInWindow:window];
 242   }
 243 }
 244
 245 - (void)windowResignedKey:(NSNotification*)inNotification {
 246   NSWindow* window = inNotification.object;
 247
 248   id delegate = window.delegate;
 249   if (!delegate || ![delegate isKindOfClass:[WindowDelegate class]]) {
 250     [TopLevelWindowData deactivateInWindowViews:window];
 251   } else if (window.isSheet || window.isMainWindow) {
 252     [TopLevelWindowData deactivateInWindow:window];
 253   }
 254 }
 255
 256 // The appearance of a top-level window depends on its main state (not its key
 257 // state).  So (for non-embedders) we need to ensure that a top-level window
 258 // is main when an NS_ACTIVATE event is sent to Gecko for it.
 259 - (void)windowBecameMain:(NSNotification*)inNotification {
 260   NSWindow* window = inNotification.object;
 261   id delegate = window.delegate;
 262   // Don't send events to a top-level window that has a sheet/modal-window open
 263   // above it -- as far as Gecko is concerned, it's inactive, and stays so until
 264   // the sheet/modal-window closes.
 265   if (delegate && [delegate isKindOfClass:[WindowDelegate class]] &&
 266       !window.attachedSheet && window.isKeyWindow) {
 267     [TopLevelWindowData activateInWindow:window];
 268   }
 269 }
 270
 271 - (void)windowResignedMain:(NSNotification*)inNotification {
 272   NSWindow* window = inNotification.object;
 273   id delegate = window.delegate;
 274   if (delegate && [delegate isKindOfClass:[WindowDelegate class]] &&
 275       ![window attachedSheet] && ![NSApp modalWindow]) {
 276     [TopLevelWindowData deactivateInWindow:window];
 277   }
 278 }
 279
 280 - (void)windowWillClose:(NSNotification*)inNotification {
 281   NS_OBJC_BEGIN_TRY_IGNORE_BLOCK;
 282
 283   // postpone our destruction
 284   [[self retain] autorelease];
 285
 286   // remove ourselves from the window map (which owns us)
 287   [[WindowDataMap sharedWindowDataMap]
 288       removeDataForWindow:[inNotification object]];
 289
 290   NS_OBJC_END_TRY_IGNORE_BLOCK;
 291 }
 292
 293 @end