Mac: make save/open dialogs operate as tab-modal sheets....

chrome/browser/cocoa/browser_window_controller.mm

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <Carbon/Carbon.h>
 
 #include "base/mac_util.h"
 #include "base/scoped_nsdisable_screen_updates.h"
 #import "base/scoped_nsobject.h"
 #include "base/sys_string_conversions.h"
@@ skipping 179 matching lines @@
     }
     [[[self window] contentView] addSubview:[toolbarController_ view]];
 
     // Create a sub-controller for the bookmark bar.
     bookmarkBarController_.reset(
         [[BookmarkBarController alloc]
             initWithBrowser:browser_.get()
                initialWidth:NSWidth([[[self window] contentView] frame])
            compressDelegate:toolbarController_.get()
              resizeDelegate:self
-                urlDelegate:self]);
+                urlDelegate:self
+                   commands:browser->command_updater()]);
 
     // Add bookmark bar to the view hierarchy.  This also triggers the
     // nib load.  The bookmark bar is defined (in the nib) to be
     // bottom-aligned to it's parent view (among other things), so
     // position and resize properties don't need to be set.
     [[[self window] contentView] addSubview:[bookmarkBarController_ view]
                                  positioned:NSWindowBelow
                                  relativeTo:[toolbarController_ view]];
 
     // Disable the bookmark bar if this window doesn't support them.
@@ skipping 291 matching lines @@
   if (frame.size.height == height)
     return;
 
   frame.size.height = height;
   // TODO(rohitrao): Determine if calling setFrame: twice is bad.
   [view setFrame:frame];
   [self layoutSubviews];
 }
 
 // Update a toggle state for an NSMenuItem if modified.
-// Take care to insure |item| looks like a NSMenuItem.
+// Take care to ensure |item| looks like a NSMenuItem.
 // Called by validateUserInterfaceItem:.
 - (void)updateToggleStateWithTag:(NSInteger)tag forItem:(id)item {
   if (![item respondsToSelector:@selector(state)] ||
       ![item respondsToSelector:@selector(setState:)])
     return;
 
   // On Windows this logic happens in bookmark_bar_view.cc.  On the
   // Mac we're a lot more MVC happy so we've moved it into a
   // controller.  To be clear, this simply updates the menu item; it
   // does not display the bookmark bar itself.
   if (tag == IDC_SHOW_BOOKMARK_BAR) {
     bool toggled = windowShim_->IsBookmarkBarVisible();
     NSInteger oldState = [item state];
     NSInteger newState = toggled ? NSOnState : NSOffState;
     if (oldState != newState)
       [item setState:newState];
+    return;
   }
 
   // Update the checked/Unchecked state of items in the encoding menu.
   // On Windows, this logic is part of |EncodingMenuModel| in
   // browser/views/toolbar_view.h.
   EncodingMenuController encoding_controller;
   if (encoding_controller.DoesCommandBelongToEncodingMenu(tag)) {
     DCHECK(browser_.get());
     Profile *profile = browser_->profile();
     DCHECK(profile);
     TabContents* current_tab = browser_->GetSelectedTabContents();
-    if (!current_tab) {
+    if (!current_tab)
       return;
-    }
+
     const std::string encoding = current_tab->encoding();
-
     bool toggled = encoding_controller.IsItemChecked(profile, encoding, tag);
     NSInteger oldState = [item state];
     NSInteger newState = toggled ? NSOnState : NSOffState;
     if (oldState != newState)
       [item setState:newState];
   }
 }
 
 - (BOOL)supportsFullscreen {
   // TODO(avi, thakis): GTMWindowSheetController has no api to move
   // tabsheets between windows. Until then, we have to prevent having to
   // move a tabsheet between windows, e.g. no fullscreen toggling
   NSArray* a = [[tabStripController_ sheetController] viewsWithAttachedSheets];
   return [a count] == 0;
 }
 
 // Called to validate menu and toolbar items when this window is key. All the
 // items we care about have been set with the |commandDispatch:| action and
 // a target of FirstResponder in IB. If it's not one of those, let it
 // continue up the responder chain to be handled elsewhere. We pull out the
 // tag as the cross-platform constant to differentiate and dispatch the
 // various commands.
 // NOTE: we might have to handle state for app-wide menu items,
 // although we could cheat and directly ask the app controller if our
 // command_updater doesn't support the command. This may or may not be an issue,
 // too early to tell.
 - (BOOL)validateUserInterfaceItem:(id<NSValidatedUserInterfaceItem>)item {
   SEL action = [item action];
   BOOL enable = NO;
+  NSInteger tag = [item tag];
   if (action == @selector(commandDispatch:)) {
-    NSInteger tag = [item tag];
     if (browser_->command_updater()->SupportsCommand(tag)) {
       // Generate return value (enabled state)
       enable = browser_->command_updater()->IsCommandEnabled(tag) ? YES : NO;
       switch (tag) {
         case IDC_CLOSE_TAB:
           // Disable "close tab" if we're not the key window or if there's only
           // one tab.
           enable &= [self numberOfTabs] > 1 && [[self window] isKeyWindow];
           break;
         case IDC_RESTORE_TAB:
           // We have to ask the Browser manually if we can restore. The
           // command updater doesn't know.
-          enable &= browser_->CanRestoreTab();
+          enable &= browser_->CanRestoreTab() ? YES : NO;
           break;
         case IDC_FULLSCREEN:
           enable &= [self supportsFullscreen];
           break;
+        default:
+          // Special handling for the contents of the encoding menu; we
+          // enable/disable them en masse.
+          EncodingMenuController encoding_controller;
+          if (encoding_controller.DoesCommandBelongToEncodingMenu(tag)) {
+            enable &= browser_->command_updater()->IsCommandEnabled(
+                                         IDC_ENCODING_MENU_CONTENTS) ? YES : NO;
+          }
       }
 
       // If the item is toggleable, find its toggle state and
       // try to update it.  This is a little awkward, but the alternative is
       // to check after a commandDispatch, which seems worse.
       [self updateToggleStateWithTag:tag forItem:item];
     }
+  } else {
+    // Use the command updater for enabled state anyway.
+    switch (tag) {
+      case IDC_EMAIL_PAGE_LOCATION:
+      case IDC_PRINT_PAGE_SETUP:
+      case IDC_PRINT:
+        enable = browser_->command_updater()->IsCommandEnabled(tag) ? YES : NO;
+        break;
+      default:
+        // This line intentionally left blank.
+        break;
+    }
   }
   return enable;
 }
 
 // Called when the user picks a menu or toolbar item when this window is key.
 // Calls through to the browser object to execute the command. This assumes that
 // the command is supported and doesn't check, otherwise it would have been
 // disabled in the UI in validateUserInterfaceItem:.
 - (void)commandDispatch:(id)sender {
   NSInteger tag = [sender tag];
@@ skipping 22 matching lines @@
   if (browser_->command_updater()->IsCommandEnabled(command))
     browser_->ExecuteCommand(command);
 }
 
 // StatusBubble delegate method: tell the status bubble how far above the bottom
 // of the window it should position itself.
 - (float)verticalOffsetForStatusBubble {
   return verticalOffsetForStatusBubble_;
 }
 
+- (ToolbarController*)toolbarController {
+  return toolbarController_.get();
+}
+
+- (InfoBarContainerController*)infoBarContainerController {
+  return infoBarContainerController_.get();
+}
+
 - (GTMWindowSheetController*)sheetController {
   return [tabStripController_ sheetController];
 }
 
 - (LocationBar*)locationBar {
   return [toolbarController_ locationBar];
 }
 
 - (StatusBubble*)statusBubble {
   return statusBubble_.get();
@@ skipping 511 matching lines @@
   windowPreferences->SetInteger(L"top", bounds.y());
   windowPreferences->SetInteger(L"right", bounds.right());
   windowPreferences->SetInteger(L"bottom", bounds.bottom());
   windowPreferences->SetBoolean(L"maximized", false);
   windowPreferences->SetBoolean(L"always_on_top", false);
 }
 
 - (NSRect)window:(NSWindow*)window
 willPositionSheet:(NSWindow*)sheet
        usingRect:(NSRect)defaultSheetRect {
+#if 1
   // Any sheet should come from right above the visible content area.
   NSRect toolbarFrame = [[toolbarController_ view] frame];
   NSRect infobarFrame = [[infoBarContainerController_ view] frame];
   defaultSheetRect.origin.y = toolbarFrame.origin.y - infobarFrame.size.height;
-
+#elif 0
+  // FIXME(viettrungluu): I had this, which I think is better than the above.
+  // This hangs them below the toolbar (incl. bookmark bar), which is illogical
+  // but a bit more normal-looking (not quite, since the shading doesn't match).
+  NSView* tabContentView = [self tabContentArea];
+  NSRect tabContentFrame = [tabContentView frame];
+  defaultSheetRect.origin.y = tabContentFrame.origin.y +
+                                tabContentFrame.size.height;
+#else
+  // This was the original, hanging window-modal sheets off the title bar, which
+  // was logical but weird-looking.
+  NSRect windowFrame = [window frame];
+  defaultSheetRect.origin.y = windowFrame.size.height - 10;
+#endif
   return defaultSheetRect;
 }
 
 // Undocumented method for multi-touch gestures in 10.5. Future OS's will
 // likely add a public API, but the worst that will happen is that this will
 // turn into dead code and just won't get called.
 - (void)swipeWithEvent:(NSEvent*)event {
   // Map forwards and backwards to history; left is positive, right is negative.
   unsigned int command = 0;
   if ([event deltaX] > 0.5)
@@ skipping 281 matching lines @@
       provider->GetNSColor(BrowserThemeProvider::COLOR_TOOLBAR);
   [theme setValue:toolbarBackgroundColor
      forAttribute:@"backgroundColor"
             style:GTMThemeStyleToolBar
             state:GTMThemeStateActiveWindow];
 
   return theme;
 }
 @end