src/chrome/browser/window_sizer.h

// Copyright (c) 2006-2008 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_WINDOW_SIZER_H__
#define CHROME_BROWSER_WINDOW_SIZER_H__

#include "base/gfx/rect.h"
#include "base/logging.h"
#include "testing/gtest/include/gtest/gtest_prod.h"

///////////////////////////////////////////////////////////////////////////////
// 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 MonitorInfoProvider;
  class StateProvider;

  // The WindowSizer assumes ownership of these objects.
  WindowSizer(StateProvider* state_provider,
              MonitorInfoProvider* monitor_info_provider);
  virtual ~WindowSizer();

  // An interface implemented by an object that can retrieve information about
  // the monitors on the system.
  class MonitorInfoProvider {
   public:
    virtual ~MonitorInfoProvider() { }

    // Returns the bounds of the working rect of the primary monitor.
    virtual gfx::Rect GetPrimaryMonitorWorkingRect() const = 0;

    // Returns the bounds of the entire primary screen.
    virtual gfx::Rect GetPrimaryMonitorBounds() const = 0;

    // Returns the bounds of the working rect of the monitor that most closely
    // intersects the provided bounds.
    virtual gfx::Rect GetMonitorBoundsMatching(
        const gfx::Rect& match_rect) const = 0;

    // Returns the delta between the working rect and the monitor size of the
    // monitor that most closely intersects the provided bounds.
    virtual gfx::Point GetBoundsOffsetMatching(
        const gfx::Rect& match_rect) const = 0;

    // Returns the number of monitors on the system.
    virtual int GetMonitorCount() const = 0;

    // Returns the bounds of the working rect of the monitor at the specified
    // index.
    virtual gfx::Rect GetWorkingRectAt(int index) const = 0;
  };

  // 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.
    virtual bool GetPersistentState(gfx::Rect* bounds,
                                    bool* maximized) 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.
    virtual bool GetLastActiveWindowState(gfx::Rect* bounds) const = 0;
  };

  // Determines the size, position and maximized state for the browser window.
  // See documentation for DetermineWindowBounds below.
  static void GetBrowserWindowBounds(const std::wstring& app_name,
                                     const gfx::Rect& specified_bounds,
                                     gfx::Rect* window_bounds,
                                     bool* maximized);

  // Determines the position, size and maximized state for a window as it is
  // created. 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.
  //
  // NOTE: |maximized| is only set if we're restoring a saved maximized window.
  // When creating a new window based on an existing active window, standard
  // Windows behavior is to have it always be nonmaximized, even if the existing
  // window is maximized.
  void DetermineWindowBounds(const gfx::Rect& specified_bounds,
                             gfx::Rect* bounds,
                             bool* maximized) const;
 private:
  explicit WindowSizer(const std::wstring& app_name);

  void Init(StateProvider* state_provider,
            MonitorInfoProvider* monitor_info_provider);

  // Gets the size and placement of the last 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.
  bool GetLastWindowBounds(gfx::Rect* bounds) 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.
  bool GetSavedWindowBounds(gfx::Rect* bounds, bool* maximized) const;

  // Gets the default window position and size 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(gfx::Rect* default_bounds) const;

  // The edge of the work area to check for out-of-bounds.
  enum Edge { TOP, LEFT, BOTTOM, RIGHT };

  // Return true if the position is over the specified edge on the valid
  // monitor work are rects.
  bool PositionIsOffscreen(int position, Edge edge) const;

  // Adjust the bounds specified in |bounds| so that they fit completely within
  // the work area of the monitor that contains |other_bounds|.
  void AdjustBoundsToBeVisibleOnMonitorContaining(
      const gfx::Rect& other_bounds,
      gfx::Rect* bounds /* inout */) const;

  // Providers for persistent storage and monitor metrics.
  StateProvider* state_provider_;
  MonitorInfoProvider* monitor_info_provider_;

  DISALLOW_EVIL_CONSTRUCTORS(WindowSizer);
};


#endif  // #ifndef CHROME_BROWSER_WINDOW_SIZER_H__