// 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_WINDOW_SIZER_WINDOW_SIZER_H_
#define CHROME_BROWSER_UI_WINDOW_SIZER_WINDOW_SIZER_H_
#include "base/basictypes.h"
#include "base/memory/scoped_ptr.h"
#include "chrome/browser/ui/host_desktop.h"
#include "ui/base/ui_base_types.h"
#include "ui/gfx/rect.h"
class Browser;
namespace gfx {
class Display;
class Screen;
}
///////////////////////////////////////////////////////////////////////////////
// WindowSizer
//
// A class that determines the best new size and position for a window to be
// shown at based several factors, including the position and size of the last
// window of the same type, the last saved bounds of the window from the
// previous session, and default system metrics if neither of the above two
// conditions exist. The system has built-in providers for monitor metrics
// and persistent storage (using preferences) but can be overrided with mocks
// for testing.
//
class WindowSizer {
public:
class StateProvider;
class TargetDisplayProvider;
// WindowSizer owns |state_provider| and |target_display_provider|,
// and will use the platforms's gfx::Screen.
WindowSizer(scoped_ptr<StateProvider> state_provider,
scoped_ptr<TargetDisplayProvider> target_display_provider,
const Browser* browser);
// WindowSizer owns |state_provider| and |target_display_provider|,
// and will use the supplied |screen|. Used only for testing.
WindowSizer(scoped_ptr<StateProvider> state_provider,
scoped_ptr<TargetDisplayProvider> target_display_provider,
gfx::Screen* screen,
const Browser* browser);
virtual ~WindowSizer();
// An interface implemented by an object that can retrieve state from either a
// persistent store or an existing window.
class StateProvider {
public:
virtual ~StateProvider() {}
// Retrieve the persisted bounds of the window. Returns true if there was
// persisted data to retrieve state information, false otherwise.
// The |show_state| variable will only be touched if there was persisted
// data and the |show_state| variable is SHOW_STATE_DEFAULT.
virtual bool GetPersistentState(gfx::Rect* bounds,
gfx::Rect* work_area,
ui::WindowShowState* show_state) const = 0;
// Retrieve the bounds of the most recent window of the matching type.
// Returns true if there was a last active window to retrieve state
// information from, false otherwise.
// The |show_state| variable will only be touched if we have found a
// suitable window and the |show_state| variable is SHOW_STATE_DEFAULT.
virtual bool GetLastActiveWindowState(
gfx::Rect* bounds,
ui::WindowShowState* show_state) const = 0;
};
// An interface implemented by an object to identify on which
// display a new window should be located.
class TargetDisplayProvider {
public:
virtual ~TargetDisplayProvider() {}
virtual gfx::Display GetTargetDisplay(const gfx::Screen* screen,
const gfx::Rect& bounds) const = 0;
};
// Determines the position and size for a window as it is created as well
// as the initial state. This function uses several strategies to figure out
// optimal size and placement, first looking for an existing active window,
// then falling back to persisted data from a previous session, finally
// utilizing a default algorithm. If |specified_bounds| are non-empty, this
// value is returned instead. For use only in testing.
// |show_state| will be overwritten and return the initial visual state of
// the window to use.
void DetermineWindowBoundsAndShowState(
const gfx::Rect& specified_bounds,
gfx::Rect* bounds,
ui::WindowShowState* show_state) const;
// Determines the size, position and maximized state for the browser window.
// See documentation for DetermineWindowBounds above. Normally,
// |window_bounds| is calculated by calling GetLastActiveWindowState(). To
// explicitly specify a particular window to base the bounds on, pass in a
// non-NULL value for |browser|.
static void GetBrowserWindowBoundsAndShowState(
const std::string& app_name,
const gfx::Rect& specified_bounds,
const Browser* browser,
gfx::Rect* window_bounds,
ui::WindowShowState* show_state);
// Returns the default origin for popups of the given size.
static gfx::Point GetDefaultPopupOrigin(const gfx::Size& size,
chrome::HostDesktopType type);
// How much horizontal and vertical offset there is between newly
// opened windows. This value may be different on each platform.
static const int kWindowTilePixels;
private:
// The edge of the screen to check for out-of-bounds.
enum Edge { TOP, LEFT, BOTTOM, RIGHT };
// Gets the size and placement of the last active window. Returns true if this
// data is valid, false if there is no last window and the application should
// restore saved state from preferences using RestoreWindowPosition.
// |show_state| will only be changed if it was set to SHOW_STATE_DEFAULT.
bool GetLastActiveWindowBounds(gfx::Rect* bounds,
ui::WindowShowState* show_state) const;
// Gets the size and placement of the last window in the last session, saved
// in local state preferences. Returns true if local state exists containing
// this information, false if this information does not exist and a default
// size should be used.
// |show_state| will only be changed if it was set to SHOW_STATE_DEFAULT.
bool GetSavedWindowBounds(gfx::Rect* bounds,
ui::WindowShowState* show_state) const;
// Gets the default window position and size to be shown on
// |display| if there is no last window and no saved window
// placement in prefs. This function determines the default size
// based on monitor size, etc.
void GetDefaultWindowBounds(const gfx::Display& display,
gfx::Rect* default_bounds) const;
// Adjusts |bounds| to be visible on-screen, biased toward the work area of
// the |display|. Despite the name, this doesn't
// guarantee the bounds are fully contained within this display's work rect;
// it just tried to ensure the edges are visible on _some_ work rect.
// If |saved_work_area| is non-empty, it is used to determine whether the
// monitor configuration has changed. If it has, bounds are repositioned and
// resized if necessary to make them completely contained in the current work
// area.
void AdjustBoundsToBeVisibleOnDisplay(
const gfx::Display& display,
const gfx::Rect& saved_work_area,
gfx::Rect* bounds) const;
// Determine the target display for a new window based on
// |bounds|. On ash environment, this returns the display containing
// ash's the target root window.
gfx::Display GetTargetDisplay(const gfx::Rect& bounds) const;
#if defined(USE_ASH)
// Determines the position and size for a tabbed browser window in
// ash as it gets created. This will be called before other standard
// placement logic. |show_state| will only be changed
// if it was set to SHOW_STATE_DEFAULT.
void GetTabbedBrowserBoundsAsh(gfx::Rect* bounds_in_screen,
ui::WindowShowState* show_state) const;
#endif
// Determine the default show state for the window - not looking at other
// windows or at persistent information.
ui::WindowShowState GetWindowDefaultShowState() const;
#if defined(USE_ASH)
bool IsTabbedBrowserInAsh() const;
bool IsPopupBrowserInAsh() const;
#endif
// Providers for persistent storage and monitor metrics.
scoped_ptr<StateProvider> state_provider_;
scoped_ptr<TargetDisplayProvider> target_display_provider_;
gfx::Screen* screen_; // not owned.
// Note that this browser handle might be NULL.
const Browser* browser_;
DISALLOW_COPY_AND_ASSIGN(WindowSizer);
};
#endif // CHROME_BROWSER_UI_WINDOW_SIZER_WINDOW_SIZER_H_