// Copyright (c) 2012 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.
#ifndef CHROME_BROWSER_UI_COCOA_BROWSER_WINDOW_CONTROLLER_H_
#define CHROME_BROWSER_UI_COCOA_BROWSER_WINDOW_CONTROLLER_H_
// A class acting as the Objective-C controller for the Browser
// object. Handles interactions between Cocoa and the cross-platform
// code. Each window has a single toolbar and, by virtue of being a
// TabWindowController, a tab strip along the top.
#import <Cocoa/Cocoa.h>
#include "base/mac/scoped_nsobject.h"
#include "base/memory/scoped_ptr.h"
#include "chrome/browser/translate/translate_tab_helper.h"
#import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_controller.h"
#import "chrome/browser/ui/cocoa/bookmarks/bookmark_bubble_controller.h"
#import "chrome/browser/ui/cocoa/browser_command_executor.h"
#import "chrome/browser/ui/cocoa/fullscreen_exit_bubble_controller.h"
#import "chrome/browser/ui/cocoa/tabs/tab_strip_controller.h"
#import "chrome/browser/ui/cocoa/tabs/tab_window_controller.h"
#import "chrome/browser/ui/cocoa/themed_window.h"
#import "chrome/browser/ui/cocoa/url_drop_target.h"
#import "chrome/browser/ui/cocoa/view_resizer.h"
#include "components/translate/core/common/translate_errors.h"
#include "ui/gfx/rect.h"
@class AvatarBaseController;
class Browser;
class BrowserWindow;
class BrowserWindowCocoa;
@class DevToolsController;
@class DownloadShelfController;
class ExtensionKeybindingRegistryCocoa;
@class FindBarCocoaController;
@class FullscreenModeController;
@class FullscreenWindow;
@class InfoBarContainerController;
class LocationBarViewMac;
@class OverlayableContentsController;
class PermissionBubbleCocoa;
@class PresentationModeController;
class StatusBubbleMac;
@class TabStripController;
@class TabStripView;
@class ToolbarController;
@class TranslateBubbleController;
namespace content {
class WebContents;
}
namespace extensions {
class Command;
}
@interface BrowserWindowController :
TabWindowController<NSUserInterfaceValidations,
BookmarkBarControllerDelegate,
BrowserCommandExecutor,
ViewResizer,
TabStripControllerDelegate> {
@private
// The ordering of these members is important as it determines the order in
// which they are destroyed. |browser_| needs to be destroyed last as most of
// the other objects hold weak references to it or things it owns
// (tab/toolbar/bookmark models, profiles, etc).
scoped_ptr<Browser> browser_;
NSWindow* savedRegularWindow_;
scoped_ptr<BrowserWindowCocoa> windowShim_;
base::scoped_nsobject<ToolbarController> toolbarController_;
base::scoped_nsobject<TabStripController> tabStripController_;
base::scoped_nsobject<FindBarCocoaController> findBarCocoaController_;
base::scoped_nsobject<InfoBarContainerController> infoBarContainerController_;
base::scoped_nsobject<DownloadShelfController> downloadShelfController_;
base::scoped_nsobject<BookmarkBarController> bookmarkBarController_;
base::scoped_nsobject<DevToolsController> devToolsController_;
base::scoped_nsobject<OverlayableContentsController>
overlayableContentsController_;
base::scoped_nsobject<PresentationModeController> presentationModeController_;
base::scoped_nsobject<FullscreenModeController> fullscreenModeController_;
base::scoped_nsobject<FullscreenExitBubbleController>
fullscreenExitBubbleController_;
// Strong. StatusBubble is a special case of a strong reference that
// we don't wrap in a scoped_ptr because it is acting the same
// as an NSWindowController in that it wraps a window that must
// be shut down before our destructors are called.
StatusBubbleMac* statusBubble_;
BookmarkBubbleController* bookmarkBubbleController_; // Weak.
BOOL initializing_; // YES while we are currently in initWithBrowser:
BOOL ownsBrowser_; // Only ever NO when testing
TranslateBubbleController* translateBubbleController_; // Weak.
// The total amount by which we've grown the window up or down (to display a
// bookmark bar and/or download shelf), respectively; reset to 0 when moved
// away from the bottom/top or resized (or zoomed).
CGFloat windowTopGrowth_;
CGFloat windowBottomGrowth_;
// YES only if we're shrinking the window from an apparent zoomed state (which
// we'll only do if we grew it to the zoomed state); needed since we'll then
// restrict the amount of shrinking by the amounts specified above. Reset to
// NO on growth.
BOOL isShrinkingFromZoomed_;
// The view controller that manages the incognito badge or the multi-profile
// avatar button. Depending on whether the --new-profile-management flag is
// used, the multi-profile button can either be the avatar's icon badge or a
// button with the profile's name. If the flag is used, the button is always
// shown, otherwise the view will always be in the view hierarchy but will
// be hidden unless it's appropriate to show it (i.e. if there's more than
// one profile).
base::scoped_nsobject<AvatarBaseController> avatarButtonController_;
// Lazily created view which draws the background for the floating set of bars
// in presentation mode (for window types having a floating bar; it remains
// nil for those which don't).
base::scoped_nsobject<NSView> floatingBarBackingView_;
// The borderless window used in fullscreen mode when Cocoa's System
// Fullscreen API is not being used (or not available, before OS 10.7).
base::scoped_nsobject<NSWindow> fullscreenWindow_;
// The Cocoa implementation of the PermissionBubbleView.
scoped_ptr<PermissionBubbleCocoa> permissionBubbleCocoa_;
// True between |-windowWillEnterFullScreen:| and |-windowDidEnterFullScreen:|
// to indicate that the window is in the process of transitioning into
// fullscreen mode.
BOOL enteringFullscreen_;
// True between |-setPresentationMode:url:bubbleType:| and
// |-windowDidEnterFullScreen:| to indicate that the window is in the process
// of transitioning into fullscreen presentation mode.
BOOL enteringPresentationMode_;
// The size of the original (non-fullscreen) window. This is saved just
// before entering fullscreen mode and is only valid when |-isFullscreen|
// returns YES.
NSRect savedRegularWindowFrame_;
// The proportion of the floating bar which is shown (in presentation mode).
CGFloat floatingBarShownFraction_;
// Various UI elements/events may want to ensure that the floating bar is
// visible (in presentation mode), e.g., because of where the mouse is or
// where keyboard focus is. Whenever an object requires bar visibility, it has
// itself added to |barVisibilityLocks_|. When it no longer requires bar
// visibility, it has itself removed.
base::scoped_nsobject<NSMutableSet> barVisibilityLocks_;
// Bar visibility locks and releases only result (when appropriate) in changes
// in visible state when the following is |YES|.
BOOL barVisibilityUpdatesEnabled_;
// When going fullscreen for a tab, we need to store the URL and the
// fullscreen type, since we can't show the bubble until
// -windowDidEnterFullScreen: gets called.
GURL fullscreenUrl_;
FullscreenExitBubbleType fullscreenBubbleType_;
// The Extension Command Registry used to determine which keyboard events to
// handle.
scoped_ptr<ExtensionKeybindingRegistryCocoa> extension_keybinding_registry_;
// The number of overlapped views being shown.
NSUInteger overlappedViewCount_;
}
// A convenience class method which gets the |BrowserWindowController| for a
// given window. This method returns nil if no window in the chain has a BWC.
+ (BrowserWindowController*)browserWindowControllerForWindow:(NSWindow*)window;
// A convenience class method which gets the |BrowserWindowController| for a
// given view. This is the controller for the window containing |view|, if it
// is a BWC, or the first controller in the parent-window chain that is a
// BWC. This method returns nil if no window in the chain has a BWC.
+ (BrowserWindowController*)browserWindowControllerForView:(NSView*)view;
// Helper method used to update the "Signin" menu item to reflect the current
// signed in state. Class-level function as it's still required even when there
// are no open browser windows.
+ (void)updateSigninItem:(id)signinItem
shouldShow:(BOOL)showSigninMenuItem
currentProfile:(Profile*)profile;
// Load the browser window nib and do any Cocoa-specific initialization.
// Takes ownership of |browser|.
- (id)initWithBrowser:(Browser*)browser;
// Call to make the browser go away from other places in the cross-platform
// code.
- (void)destroyBrowser;
// Ensure bounds for the window abide by the minimum window size.
- (gfx::Rect)enforceMinWindowSize:(gfx::Rect)bounds;
// Access the C++ bridge between the NSWindow and the rest of Chromium.
- (BrowserWindow*)browserWindow;
// Return a weak pointer to the toolbar controller.
- (ToolbarController*)toolbarController;
// Return a weak pointer to the tab strip controller.
- (TabStripController*)tabStripController;
// Return a weak pointer to the find bar controller.
- (FindBarCocoaController*)findBarCocoaController;
// Access the ObjC controller that contains the infobars.
- (InfoBarContainerController*)infoBarContainerController;
// Access the C++ bridge object representing the status bubble for the window.
- (StatusBubbleMac*)statusBubble;
// Access the C++ bridge object representing the location bar.
- (LocationBarViewMac*)locationBarBridge;
// Returns a weak pointer to the floating bar backing view;
- (NSView*)floatingBarBackingView;
// Returns a weak pointer to the overlayable contents controller.
- (OverlayableContentsController*)overlayableContentsController;
// Access the Profile object that backs this Browser.
- (Profile*)profile;
// Access the avatar button controller.
- (AvatarBaseController*)avatarButtonController;
// Forces the toolbar (and transitively the location bar) to update its current
// state. If |tab| is non-NULL, we're switching (back?) to this tab and should
// restore any previous location bar state (such as user editing) as well.
- (void)updateToolbarWithContents:(content::WebContents*)tab;
// Sets whether or not the current page in the frontmost tab is bookmarked.
- (void)setStarredState:(BOOL)isStarred;
// Sets whether or not the current page is translated.
- (void)setCurrentPageIsTranslated:(BOOL)on;
// Happens when the zoom level is changed in the active tab, the active tab is
// changed, or a new browser window or tab is created. |canShowBubble| denotes
// whether it would be appropriate to show a zoom bubble or not.
- (void)zoomChangedForActiveTab:(BOOL)canShowBubble;
// Return the rect, in WebKit coordinates (flipped), of the window's grow box
// in the coordinate system of the content area of the currently selected tab.
- (NSRect)selectedTabGrowBoxRect;
// Called to tell the selected tab to update its loading state.
// |force| is set if the update is due to changing tabs, as opposed to
// the page-load finishing. See comment in reload_button.h.
- (void)setIsLoading:(BOOL)isLoading force:(BOOL)force;
// Brings this controller's window to the front.
- (void)activate;
// Make the location bar the first responder, if possible.
- (void)focusLocationBar:(BOOL)selectAll;
// Make the (currently-selected) tab contents the first responder, if possible.
- (void)focusTabContents;
// Returns the frame of the regular (non-fullscreened) window (even if the
// window is currently in fullscreen mode). The frame is returned in Cocoa
// coordinates (origin in bottom-left).
- (NSRect)regularWindowFrame;
// Whether or not to show the avatar, which is either the incognito guy or the
// user's profile avatar.
- (BOOL)shouldShowAvatar;
// Whether or not to show the new avatar button used by --new-profile-maagement.
- (BOOL)shouldUseNewAvatarButton;
- (BOOL)isBookmarkBarVisible;
// Returns YES if the bookmark bar is currently animating.
- (BOOL)isBookmarkBarAnimating;
- (BookmarkBarController*)bookmarkBarController;
- (DevToolsController*)devToolsController;
- (BOOL)isDownloadShelfVisible;
// Lazily creates the download shelf in visible state if it doesn't exist yet.
- (DownloadShelfController*)downloadShelf;
// Retains the given FindBarCocoaController and adds its view to this
// browser window. Must only be called once per
// BrowserWindowController.
- (void)addFindBar:(FindBarCocoaController*)findBarCocoaController;
// The user changed the theme.
- (void)userChangedTheme;
// Executes the command in the context of the current browser.
// |command| is an integer value containing one of the constants defined in the
// "chrome/app/chrome_command_ids.h" file.
- (void)executeCommand:(int)command;
// Consults the Command Registry to see if this |event| needs to be handled as
// an extension command and returns YES if so (NO otherwise).
- (BOOL)handledByExtensionCommand:(NSEvent*)event;
// Delegate method for the status bubble to query its base frame.
- (NSRect)statusBubbleBaseFrame;
// Show the bookmark bubble (e.g. user just clicked on the STAR)
- (void)showBookmarkBubbleForURL:(const GURL&)url
alreadyBookmarked:(BOOL)alreadyBookmarked;
// Show the translate bubble.
- (void)showTranslateBubbleForWebContents:(content::WebContents*)contents
step:
(TranslateTabHelper::TranslateStep)step
errorType:(TranslateErrors::Type)errorType;
// Shows or hides the docked web inspector depending on |contents|'s state.
- (void)updateDevToolsForContents:(content::WebContents*)contents;
// Gets the current theme provider.
- (ui::ThemeProvider*)themeProvider;
// Gets the window style.
- (ThemedWindowStyle)themedWindowStyle;
// Returns the position in the coordinates of the root view
// ([[self contentView] superview]) that the top left of a theme image with
// |alignment| should be painted at. If the window does not have a tab strip,
// the offset for THEME_IMAGE_ALIGN_WITH_FRAME is always returned. The result of
// this method can be used in conjunction with
// [NSGraphicsContext cr_setPatternPhase:] to set the offset of pattern colors.
- (NSPoint)themeImagePositionForAlignment:(ThemeImageAlignment)alignment;
// Return the point to which a bubble window's arrow should point, in window
// coordinates.
- (NSPoint)bookmarkBubblePoint;
// Called when the Add Search Engine dialog is closed.
- (void)sheetDidEnd:(NSWindow*)sheet
returnCode:(NSInteger)code
context:(void*)context;
// Called when the find bar visibility changes. This is used to update the
// allowOverlappingViews state.
- (void)onFindBarVisibilityChanged;
// Called when an overlapped view is shown. This is used to update the
// allowOverlappingViews state. Currently used for history overlay and
// confirm bubble.
- (void)onOverlappedViewShown;
// Called when a history overlay is hidden. This is used to update the
// allowOverlappingViews state. Currently used for history overlay and
// confirm bubble.
- (void)onOverlappedViewHidden;
// Executes the command registered by the extension that has the given id.
- (void)executeExtensionCommand:(const std::string&)extension_id
command:(const extensions::Command&)command;
// Activates the page action for the extension that has the given id.
- (void)activatePageAction:(const std::string&)extension_id;
// Activates the browser action for the extension that has the given id.
- (void)activateBrowserAction:(const std::string&)extension_id;
@end // @interface BrowserWindowController
// Methods having to do with the window type (normal/popup/app, and whether the
// window has various features; fullscreen and presentation mode methods are
// separate).
@interface BrowserWindowController(WindowType)
// Determines whether this controller's window supports a given feature (i.e.,
// whether a given feature is or can be shown in the window).
// TODO(viettrungluu): |feature| is really should be |Browser::Feature|, but I
// don't want to include browser.h (and you can't forward declare enums).
- (BOOL)supportsWindowFeature:(int)feature;
// Called to check whether or not this window has a normal title bar (YES if it
// does, NO otherwise). (E.g., normal browser windows do not, pop-ups do.)
- (BOOL)hasTitleBar;
// Called to check whether or not this window has a toolbar (YES if it does, NO
// otherwise). (E.g., normal browser windows do, pop-ups do not.)
- (BOOL)hasToolbar;
// Called to check whether or not this window has a location bar (YES if it
// does, NO otherwise). (E.g., normal browser windows do, pop-ups may or may
// not.)
- (BOOL)hasLocationBar;
// Called to check whether or not this window can have bookmark bar (YES if it
// does, NO otherwise). (E.g., normal browser windows may, pop-ups may not.)
- (BOOL)supportsBookmarkBar;
// Called to check if this controller's window is a tabbed window (e.g., not a
// pop-up window). Returns YES if it is, NO otherwise.
// Note: The |-has...| methods are usually preferred, so this method is largely
// deprecated.
- (BOOL)isTabbedWindow;
@end // @interface BrowserWindowController(WindowType)
// Methods having to do with fullscreen and presentation mode.
@interface BrowserWindowController(Fullscreen)
// Toggles fullscreen mode. Meant to be called by Lion windows when they enter
// or exit Lion fullscreen mode. Must not be called on Snow Leopard or earlier.
- (void)handleLionToggleFullscreen;
// Enters (or exits) fullscreen mode. This method is safe to call on all OS
// versions.
- (void)enterFullscreen;
- (void)exitFullscreen;
// Updates the contents of the fullscreen exit bubble with |url| and
// |bubbleType|.
- (void)updateFullscreenExitBubbleURL:(const GURL&)url
bubbleType:(FullscreenExitBubbleType)bubbleType;
// Returns fullscreen state: YES when the window is in fullscreen or is
// animating into fullscreen.
- (BOOL)isFullscreen;
// Returns YES if the browser window is currently in fullscreen via the built-in
// immersive mechanism.
- (BOOL)isInImmersiveFullscreen;
// Returns YES if the browser window is currently in fullscreen via the Cocoa
// System Fullscreen API.
- (BOOL)isInSystemFullscreen;
// Enters (or exits) presentation mode. Also enters fullscreen mode if this
// window is not already fullscreen. This method is safe to call on all OS
// versions.
- (void)enterPresentationModeForURL:(const GURL&)url
bubbleType:(FullscreenExitBubbleType)bubbleType;
- (void)exitPresentationMode;
// For simplified fullscreen: Enters fullscreen for a tab at a URL. The |url|
// is guaranteed to be non-empty; see -enterFullscreen for the user-initiated
// fullscreen mode. Called on Snow Leopard and Lion+.
- (void)enterFullscreenForURL:(const GURL&)url
bubbleType:(FullscreenExitBubbleType)bubbleType;
// Returns presentation mode state. This method is safe to call on all OS
// versions.
- (BOOL)inPresentationMode;
// Resizes the fullscreen window to fit the screen it's currently on. Called by
// the PresentationModeController when there is a change in monitor placement or
// resolution.
- (void)resizeFullscreenWindow;
// Gets or sets the fraction of the floating bar (presentation mode overlay)
// that is shown. 0 is completely hidden, 1 is fully shown.
- (CGFloat)floatingBarShownFraction;
- (void)setFloatingBarShownFraction:(CGFloat)fraction;
// Query/lock/release the requirement that the tab strip/toolbar/attached
// bookmark bar bar cluster is visible (e.g., when one of its elements has
// focus). This is required for the floating bar in presentation mode, but
// should also be called when not in presentation mode; see the comments for
// |barVisibilityLocks_| for more details. Double locks/releases by the same
// owner are ignored. If |animate:| is YES, then an animation may be performed,
// possibly after a small delay if |delay:| is YES. If |animate:| is NO,
// |delay:| will be ignored. In the case of multiple calls, later calls have
// precedence with the rule that |animate:NO| has precedence over |animate:YES|,
// and |delay:NO| has precedence over |delay:YES|.
- (BOOL)isBarVisibilityLockedForOwner:(id)owner;
- (void)lockBarVisibilityForOwner:(id)owner
withAnimation:(BOOL)animate
delay:(BOOL)delay;
- (void)releaseBarVisibilityForOwner:(id)owner
withAnimation:(BOOL)animate
delay:(BOOL)delay;
// Returns YES if any of the views in the floating bar currently has focus.
- (BOOL)floatingBarHasFocus;
@end // @interface BrowserWindowController(Fullscreen)
// Methods which are either only for testing, or only public for testing.
@interface BrowserWindowController (TestingAPI)
// Put the incognito badge or multi-profile avatar on the browser and adjust the
// tab strip accordingly.
- (void)installAvatar;
// Allows us to initWithBrowser withOUT taking ownership of the browser.
- (id)initWithBrowser:(Browser*)browser takeOwnership:(BOOL)ownIt;
// Adjusts the window height by the given amount. If the window spans from the
// top of the current workspace to the bottom of the current workspace, the
// height is not adjusted. If growing the window by the requested amount would
// size the window to be taller than the current workspace, the window height is
// capped to be equal to the height of the current workspace. If the window is
// partially offscreen, its height is not adjusted at all. This function
// prefers to grow the window down, but will grow up if needed. Calls to this
// function should be followed by a call to |layoutSubviews|.
// Returns if the window height was changed.
- (BOOL)adjustWindowHeightBy:(CGFloat)deltaH;
// Return an autoreleased NSWindow suitable for fullscreen use.
- (NSWindow*)createFullscreenWindow;
// Resets any saved state about window growth (due to showing the bookmark bar
// or the download shelf), so that future shrinking will occur from the bottom.
- (void)resetWindowGrowthState;
// Computes by how far in each direction, horizontal and vertical, the
// |source| rect doesn't fit into |target|.
- (NSSize)overflowFrom:(NSRect)source
to:(NSRect)target;
// The fullscreen exit bubble controller, or nil if the bubble isn't showing.
- (FullscreenExitBubbleController*)fullscreenExitBubbleController;
// Gets the rect, in window base coordinates, that the omnibox popup should be
// positioned relative to.
- (NSRect)omniboxPopupAnchorRect;
// Force a layout of info bars.
- (void)layoutInfoBars;
@end // @interface BrowserWindowController (TestingAPI)
#endif // CHROME_BROWSER_UI_COCOA_BROWSER_WINDOW_CONTROLLER_H_