Home | History | Annotate | Download | only in cocoa 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #import "chrome/browser/ui/cocoa/base_bubble_controller.h"
      6 
      7 #include "base/logging.h"
      8 #include "base/mac/bundle_locations.h"
      9 #include "base/mac/mac_util.h"
     10 #include "base/mac/scoped_nsobject.h"
     11 #include "base/mac/sdk_forward_declarations.h"
     12 #include "base/strings/string_util.h"
     13 #import "chrome/browser/ui/cocoa/browser_window_controller.h"
     14 #import "chrome/browser/ui/cocoa/info_bubble_view.h"
     15 #import "chrome/browser/ui/cocoa/info_bubble_window.h"
     16 #import "chrome/browser/ui/cocoa/tabs/tab_strip_model_observer_bridge.h"
     17 
     18 @interface BaseBubbleController (Private)
     19 - (void)registerForNotifications;
     20 - (void)updateOriginFromAnchor;
     21 - (void)activateTabWithContents:(content::WebContents*)newContents
     22                previousContents:(content::WebContents*)oldContents
     23                         atIndex:(NSInteger)index
     24                          reason:(int)reason;
     25 - (void)recordAnchorOffset;
     26 - (void)parentWindowDidResize:(NSNotification*)notification;
     27 - (void)parentWindowWillClose:(NSNotification*)notification;
     28 - (void)parentWindowWillBecomeFullScreen:(NSNotification*)notification;
     29 - (void)closeCleanup;
     30 @end
     31 
     32 @implementation BaseBubbleController
     33 
     34 @synthesize parentWindow = parentWindow_;
     35 @synthesize anchorPoint = anchor_;
     36 @synthesize bubble = bubble_;
     37 @synthesize shouldOpenAsKeyWindow = shouldOpenAsKeyWindow_;
     38 @synthesize shouldCloseOnResignKey = shouldCloseOnResignKey_;
     39 
     40 - (id)initWithWindowNibPath:(NSString*)nibPath
     41                parentWindow:(NSWindow*)parentWindow
     42                  anchoredAt:(NSPoint)anchoredAt {
     43   nibPath = [base::mac::FrameworkBundle() pathForResource:nibPath
     44                                                    ofType:@"nib"];
     45   if ((self = [super initWithWindowNibPath:nibPath owner:self])) {
     46     parentWindow_ = parentWindow;
     47     anchor_ = anchoredAt;
     48     shouldOpenAsKeyWindow_ = YES;
     49     shouldCloseOnResignKey_ = YES;
     50     [self registerForNotifications];
     51   }
     52   return self;
     53 }
     54 
     55 - (id)initWithWindowNibPath:(NSString*)nibPath
     56              relativeToView:(NSView*)view
     57                      offset:(NSPoint)offset {
     58   DCHECK([view window]);
     59   NSWindow* window = [view window];
     60   NSRect bounds = [view convertRect:[view bounds] toView:nil];
     61   NSPoint anchor = NSMakePoint(NSMinX(bounds) + offset.x,
     62                                NSMinY(bounds) + offset.y);
     63   anchor = [window convertBaseToScreen:anchor];
     64   return [self initWithWindowNibPath:nibPath
     65                         parentWindow:window
     66                           anchoredAt:anchor];
     67 }
     68 
     69 - (id)initWithWindow:(NSWindow*)theWindow
     70         parentWindow:(NSWindow*)parentWindow
     71           anchoredAt:(NSPoint)anchoredAt {
     72   DCHECK(theWindow);
     73   if ((self = [super initWithWindow:theWindow])) {
     74     parentWindow_ = parentWindow;
     75     shouldOpenAsKeyWindow_ = YES;
     76     shouldCloseOnResignKey_ = YES;
     77 
     78     DCHECK(![[self window] delegate]);
     79     [theWindow setDelegate:self];
     80 
     81     base::scoped_nsobject<InfoBubbleView> contentView(
     82         [[InfoBubbleView alloc] initWithFrame:NSZeroRect]);
     83     [theWindow setContentView:contentView.get()];
     84     bubble_ = contentView.get();
     85 
     86     [self registerForNotifications];
     87     [self awakeFromNib];
     88     [self setAnchorPoint:anchoredAt];
     89   }
     90   return self;
     91 }
     92 
     93 - (void)awakeFromNib {
     94   // Check all connections have been made in Interface Builder.
     95   DCHECK([self window]);
     96   DCHECK(bubble_);
     97   DCHECK_EQ(self, [[self window] delegate]);
     98 
     99   BrowserWindowController* bwc =
    100       [BrowserWindowController browserWindowControllerForWindow:parentWindow_];
    101   if (bwc) {
    102     TabStripController* tabStripController = [bwc tabStripController];
    103     TabStripModel* tabStripModel = [tabStripController tabStripModel];
    104     tabStripObserverBridge_.reset(new TabStripModelObserverBridge(tabStripModel,
    105                                                                   self));
    106   }
    107 
    108   [bubble_ setArrowLocation:info_bubble::kTopRight];
    109 }
    110 
    111 - (void)dealloc {
    112   [[NSNotificationCenter defaultCenter] removeObserver:self];
    113   [super dealloc];
    114 }
    115 
    116 - (void)registerForNotifications {
    117   NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
    118   // Watch to see if the parent window closes, and if so, close this one.
    119   [center addObserver:self
    120              selector:@selector(parentWindowWillClose:)
    121                  name:NSWindowWillCloseNotification
    122                object:parentWindow_];
    123   // Watch for the full screen event, if so, close the bubble
    124   [center addObserver:self
    125              selector:@selector(parentWindowWillBecomeFullScreen:)
    126                  name:NSWindowWillEnterFullScreenNotification
    127                object:parentWindow_];
    128   // Watch for parent window's resizing, to ensure this one is always
    129   // anchored correctly.
    130   [center addObserver:self
    131              selector:@selector(parentWindowDidResize:)
    132                  name:NSWindowDidResizeNotification
    133                object:parentWindow_];
    134 }
    135 
    136 - (void)setAnchorPoint:(NSPoint)anchor {
    137   anchor_ = anchor;
    138   [self updateOriginFromAnchor];
    139 }
    140 
    141 - (void)recordAnchorOffset {
    142   // The offset of the anchor from the parent's upper-left-hand corner is kept
    143   // to ensure the bubble stays anchored correctly if the parent is resized.
    144   anchorOffset_ = NSMakePoint(NSMinX([parentWindow_ frame]),
    145                               NSMaxY([parentWindow_ frame]));
    146   anchorOffset_.x -= anchor_.x;
    147   anchorOffset_.y -= anchor_.y;
    148 }
    149 
    150 - (NSBox*)horizontalSeparatorWithFrame:(NSRect)frame {
    151   frame.size.height = 1.0;
    152   base::scoped_nsobject<NSBox> spacer([[NSBox alloc] initWithFrame:frame]);
    153   [spacer setBoxType:NSBoxSeparator];
    154   [spacer setBorderType:NSLineBorder];
    155   [spacer setAlphaValue:0.2];
    156   return [spacer.release() autorelease];
    157 }
    158 
    159 - (NSBox*)verticalSeparatorWithFrame:(NSRect)frame {
    160   frame.size.width = 1.0;
    161   base::scoped_nsobject<NSBox> spacer([[NSBox alloc] initWithFrame:frame]);
    162   [spacer setBoxType:NSBoxSeparator];
    163   [spacer setBorderType:NSLineBorder];
    164   [spacer setAlphaValue:0.2];
    165   return [spacer.release() autorelease];
    166 }
    167 
    168 - (void)parentWindowDidResize:(NSNotification*)notification {
    169   if (!parentWindow_)
    170     return;
    171 
    172   DCHECK_EQ(parentWindow_, [notification object]);
    173   NSPoint newOrigin = NSMakePoint(NSMinX([parentWindow_ frame]),
    174                                   NSMaxY([parentWindow_ frame]));
    175   newOrigin.x -= anchorOffset_.x;
    176   newOrigin.y -= anchorOffset_.y;
    177   [self setAnchorPoint:newOrigin];
    178 }
    179 
    180 - (void)parentWindowWillClose:(NSNotification*)notification {
    181   parentWindow_ = nil;
    182   [self close];
    183 }
    184 
    185 - (void)parentWindowWillBecomeFullScreen:(NSNotification*)notification {
    186   parentWindow_ = nil;
    187   [self close];
    188 }
    189 
    190 - (void)closeCleanup {
    191   if (eventTap_) {
    192     [NSEvent removeMonitor:eventTap_];
    193     eventTap_ = nil;
    194   }
    195   if (resignationObserver_) {
    196     [[NSNotificationCenter defaultCenter]
    197         removeObserver:resignationObserver_
    198                   name:NSWindowDidResignKeyNotification
    199                 object:nil];
    200     resignationObserver_ = nil;
    201   }
    202 
    203   tabStripObserverBridge_.reset();
    204 
    205   NSWindow* window = [self window];
    206   [[window parentWindow] removeChildWindow:window];
    207 }
    208 
    209 - (void)windowWillClose:(NSNotification*)notification {
    210   [self closeCleanup];
    211   [[NSNotificationCenter defaultCenter] removeObserver:self];
    212   [self autorelease];
    213 }
    214 
    215 // We want this to be a child of a browser window.  addChildWindow:
    216 // (called from this function) will bring the window on-screen;
    217 // unfortunately, [NSWindowController showWindow:] will also bring it
    218 // on-screen (but will cause unexpected changes to the window's
    219 // position).  We cannot have an addChildWindow: and a subsequent
    220 // showWindow:. Thus, we have our own version.
    221 - (void)showWindow:(id)sender {
    222   NSWindow* window = [self window];  // Completes nib load.
    223   [self updateOriginFromAnchor];
    224   [parentWindow_ addChildWindow:window ordered:NSWindowAbove];
    225   if (shouldOpenAsKeyWindow_)
    226     [window makeKeyAndOrderFront:self];
    227   else
    228     [window orderFront:nil];
    229   [self registerKeyStateEventTap];
    230   [self recordAnchorOffset];
    231 }
    232 
    233 - (void)close {
    234   [self closeCleanup];
    235   [super close];
    236 }
    237 
    238 // The controller is the delegate of the window so it receives did resign key
    239 // notifications. When key is resigned mirror Windows behavior and close the
    240 // window.
    241 - (void)windowDidResignKey:(NSNotification*)notification {
    242   NSWindow* window = [self window];
    243   DCHECK_EQ([notification object], window);
    244 
    245   // If the window isn't visible, it is already closed, and this notification
    246   // has been sent as part of the closing operation, so no need to close.
    247   if (![window isVisible])
    248     return;
    249 
    250   // Don't close when explicily disabled, or if there's an attached sheet (e.g.
    251   // Open File dialog).
    252   if ([self shouldCloseOnResignKey] && ![window attachedSheet]) {
    253     [self close];
    254     return;
    255   }
    256 
    257   // The bubble should not receive key events when it is no longer key window,
    258   // so disable sharing parent key state. Share parent key state is only used
    259   // to enable the close/minimize/maximize buttons of the parent window when
    260   // the bubble has key state, so disabling it here is safe.
    261   InfoBubbleWindow* bubbleWindow =
    262       base::mac::ObjCCastStrict<InfoBubbleWindow>([self window]);
    263   [bubbleWindow setAllowShareParentKeyState:NO];
    264 }
    265 
    266 - (void)windowDidBecomeKey:(NSNotification*)notification {
    267   // Re-enable share parent key state to make sure the close/minimize/maximize
    268   // buttons of the parent window are active.
    269   InfoBubbleWindow* bubbleWindow =
    270       base::mac::ObjCCastStrict<InfoBubbleWindow>([self window]);
    271   [bubbleWindow setAllowShareParentKeyState:YES];
    272 }
    273 
    274 // Since the bubble shares first responder with its parent window, set event
    275 // handlers to dismiss the bubble when it would normally lose key state.
    276 // Events on sheets are ignored: this assumes the sheet belongs to the bubble
    277 // since, to affect a sheet on a different window, the bubble would also lose
    278 // key status in -[NSWindowDelegate windowDidResignKey:]. This keeps the logic
    279 // simple, since -[NSWindow attachedSheet] returns nil while the sheet is still
    280 // closing.
    281 - (void)registerKeyStateEventTap {
    282   // Parent key state sharing is only avaiable on 10.7+.
    283   if (!base::mac::IsOSLionOrLater())
    284     return;
    285 
    286   NSWindow* window = self.window;
    287   NSNotification* note =
    288       [NSNotification notificationWithName:NSWindowDidResignKeyNotification
    289                                     object:window];
    290 
    291   // The eventTap_ catches clicks within the application that are outside the
    292   // window.
    293   eventTap_ = [NSEvent
    294       addLocalMonitorForEventsMatchingMask:NSLeftMouseDownMask |
    295                                            NSRightMouseDownMask
    296       handler:^NSEvent* (NSEvent* event) {
    297           if ([event window] != window && ![[event window] isSheet]) {
    298             // Do it right now, because if this event is right mouse event,
    299             // it may pop up a menu. windowDidResignKey: will not run until
    300             // the menu is closed.
    301             if ([self respondsToSelector:@selector(windowDidResignKey:)]) {
    302               [self windowDidResignKey:note];
    303             }
    304           }
    305           return event;
    306       }];
    307 
    308   // The resignationObserver_ watches for when a window resigns key state,
    309   // meaning the key window has changed and the bubble should be dismissed.
    310   NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
    311   resignationObserver_ =
    312       [center addObserverForName:NSWindowDidResignKeyNotification
    313                           object:nil
    314                            queue:[NSOperationQueue mainQueue]
    315                       usingBlock:^(NSNotification* notif) {
    316                           if (![[notif object] isSheet])
    317                             [self windowDidResignKey:note];
    318                       }];
    319 }
    320 
    321 // By implementing this, ESC causes the window to go away.
    322 - (IBAction)cancel:(id)sender {
    323   // This is not a "real" cancel as potential changes to the radio group are not
    324   // undone. That's ok.
    325   [self close];
    326 }
    327 
    328 // Takes the |anchor_| point and adjusts the window's origin accordingly.
    329 - (void)updateOriginFromAnchor {
    330   NSWindow* window = [self window];
    331   NSPoint origin = anchor_;
    332 
    333   switch ([bubble_ alignment]) {
    334     case info_bubble::kAlignArrowToAnchor: {
    335       NSSize offsets = NSMakeSize(info_bubble::kBubbleArrowXOffset +
    336                                   info_bubble::kBubbleArrowWidth / 2.0, 0);
    337       offsets = [[parentWindow_ contentView] convertSize:offsets toView:nil];
    338       switch ([bubble_ arrowLocation]) {
    339         case info_bubble::kTopRight:
    340           origin.x -= NSWidth([window frame]) - offsets.width;
    341           break;
    342         case info_bubble::kTopLeft:
    343           origin.x -= offsets.width;
    344           break;
    345         case info_bubble::kTopCenter:
    346           origin.x -= NSWidth([window frame]) / 2.0;
    347           break;
    348         case info_bubble::kNoArrow:
    349           NOTREACHED();
    350           break;
    351       }
    352       break;
    353     }
    354 
    355     case info_bubble::kAlignEdgeToAnchorEdge:
    356       // If the arrow is to the right then move the origin so that the right
    357       // edge aligns with the anchor. If the arrow is to the left then there's
    358       // nothing to do because the left edge is already aligned with the left
    359       // edge of the anchor.
    360       if ([bubble_ arrowLocation] == info_bubble::kTopRight) {
    361         origin.x -= NSWidth([window frame]);
    362       }
    363       break;
    364 
    365     case info_bubble::kAlignRightEdgeToAnchorEdge:
    366       origin.x -= NSWidth([window frame]);
    367       break;
    368 
    369     case info_bubble::kAlignLeftEdgeToAnchorEdge:
    370       // Nothing to do.
    371       break;
    372 
    373     default:
    374       NOTREACHED();
    375   }
    376 
    377   origin.y -= NSHeight([window frame]);
    378   [window setFrameOrigin:origin];
    379 }
    380 
    381 - (void)activateTabWithContents:(content::WebContents*)newContents
    382                previousContents:(content::WebContents*)oldContents
    383                         atIndex:(NSInteger)index
    384                          reason:(int)reason {
    385   // The user switched tabs; close.
    386   [self close];
    387 }
    388 
    389 @end  // BaseBubbleController
    390