Home | History | Annotate | Download | only in display 
      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 #ifndef ASH_DISPLAY_DISPLAY_CONTROLLER_H_
      6 #define ASH_DISPLAY_DISPLAY_CONTROLLER_H_
      7 
      8 #include <map>
      9 #include <vector>
     10 
     11 #include "ash/ash_export.h"
     12 #include "ash/display/display_manager.h"
     13 #include "base/basictypes.h"
     14 #include "base/compiler_specific.h"
     15 #include "base/gtest_prod_util.h"
     16 #include "base/memory/scoped_ptr.h"
     17 #include "base/memory/weak_ptr.h"
     18 #include "base/observer_list.h"
     19 #include "base/time/time.h"
     20 #include "ui/aura/window.h"
     21 #include "ui/aura/window_tree_host_observer.h"
     22 #include "ui/gfx/display_observer.h"
     23 #include "ui/gfx/point.h"
     24 
     25 namespace aura {
     26 class Display;
     27 class WindowTreeHost;
     28 }
     29 
     30 namespace base {
     31 class Value;
     32 template <typename T> class JSONValueConverter;
     33 }
     34 
     35 namespace gfx {
     36 class Display;
     37 class Insets;
     38 }
     39 
     40 namespace ash {
     41 class AshWindowTreeHost;
     42 struct AshWindowTreeHostInitParams;
     43 class CursorWindowController;
     44 class DisplayInfo;
     45 class DisplayManager;
     46 class FocusActivationStore;
     47 class MirrorWindowController;
     48 class RootWindowController;
     49 class VirtualKeyboardWindowController;
     50 
     51 // DisplayController owns and maintains RootWindows for each attached
     52 // display, keeping them in sync with display configuration changes.
     53 class ASH_EXPORT DisplayController : public gfx::DisplayObserver,
     54                                      public aura::WindowTreeHostObserver,
     55                                      public DisplayManager::Delegate {
     56  public:
     57   class ASH_EXPORT Observer {
     58    public:
     59     // Invoked only once after all displays are initialized
     60     // after startup.
     61     virtual void OnDisplaysInitialized() {}
     62 
     63     // Invoked when the display configuration change is requested,
     64     // but before the change is applied to aura/ash.
     65     virtual void OnDisplayConfigurationChanging() {}
     66 
     67     // Invoked when the all display configuration changes
     68     // have been applied.
     69     virtual void OnDisplayConfigurationChanged() {};
     70 
     71    protected:
     72     virtual ~Observer() {}
     73   };
     74 
     75   DisplayController();
     76   virtual ~DisplayController();
     77 
     78   void Start();
     79   void Shutdown();
     80 
     81   // Returns primary display's ID.
     82   // TODO(oshima): Move this out from DisplayController;
     83   static int64 GetPrimaryDisplayId();
     84 
     85   CursorWindowController* cursor_window_controller() {
     86     return cursor_window_controller_.get();
     87   }
     88 
     89   MirrorWindowController* mirror_window_controller() {
     90     return mirror_window_controller_.get();
     91   }
     92 
     93   VirtualKeyboardWindowController* virtual_keyboard_window_controller() {
     94     return virtual_keyboard_window_controller_.get();
     95   }
     96 
     97   // Create a WindowTreeHost for the primary display. This replaces
     98   // |initial_bounds| in |init_params|.
     99   void CreatePrimaryHost(const AshWindowTreeHostInitParams& init_params);
    100 
    101   // Initializes all displays.
    102   void InitDisplays();
    103 
    104   // Add/Remove observers.
    105   void AddObserver(Observer* observer);
    106   void RemoveObserver(Observer* observer);
    107 
    108   // Returns the root window for primary display.
    109   aura::Window* GetPrimaryRootWindow();
    110 
    111   // Returns the root window for |display_id|.
    112   aura::Window* GetRootWindowForDisplayId(int64 id);
    113 
    114   // Toggle mirror mode.
    115   void ToggleMirrorMode();
    116 
    117   // Swap primary and secondary display.
    118   void SwapPrimaryDisplay();
    119 
    120   // Sets the ID of the primary display.  If the display is not connected, it
    121   // will switch the primary display when connected.
    122   void SetPrimaryDisplayId(int64 id);
    123 
    124   // Sets primary display. This re-assigns the current root
    125   // window to given |display|.
    126   void SetPrimaryDisplay(const gfx::Display& display);
    127 
    128   // Closes all child windows in the all root windows.
    129   void CloseChildWindows();
    130 
    131   // Returns all root windows. In non extended desktop mode, this
    132   // returns the primary root window only.
    133   aura::Window::Windows GetAllRootWindows();
    134 
    135   // Returns all oot window controllers. In non extended desktop
    136   // mode, this return a RootWindowController for the primary root window only.
    137   std::vector<RootWindowController*> GetAllRootWindowControllers();
    138 
    139   // Gets/Sets/Clears the overscan insets for the specified |display_id|. See
    140   // display_manager.h for the details.
    141   gfx::Insets GetOverscanInsets(int64 display_id) const;
    142   void SetOverscanInsets(int64 display_id, const gfx::Insets& insets_in_dip);
    143 
    144   // Checks if the mouse pointer is on one of displays, and moves to
    145   // the center of the nearest display if it's outside of all displays.
    146   void EnsurePointerInDisplays();
    147 
    148   // Sets the work area's |insets| to the display assigned to |window|.
    149   bool UpdateWorkAreaOfDisplayNearestWindow(const aura::Window* window,
    150                                             const gfx::Insets& insets);
    151   // gfx::DisplayObserver overrides:
    152   virtual void OnDisplayAdded(const gfx::Display& display) OVERRIDE;
    153   virtual void OnDisplayRemoved(const gfx::Display& display) OVERRIDE;
    154   virtual void OnDisplayMetricsChanged(const gfx::Display& display,
    155                                        uint32_t metrics) OVERRIDE;
    156 
    157   // aura::WindowTreeHostObserver overrides:
    158   virtual void OnHostResized(const aura::WindowTreeHost* host) OVERRIDE;
    159 
    160   // aura::DisplayManager::Delegate overrides:
    161   virtual void CreateOrUpdateNonDesktopDisplay(const DisplayInfo& info)
    162       OVERRIDE;
    163   virtual void CloseNonDesktopDisplay() OVERRIDE;
    164   virtual void PreDisplayConfigurationChange(bool clear_focus) OVERRIDE;
    165   virtual void PostDisplayConfigurationChange() OVERRIDE;
    166 
    167  private:
    168   FRIEND_TEST_ALL_PREFIXES(DisplayControllerTest, BoundsUpdated);
    169   FRIEND_TEST_ALL_PREFIXES(DisplayControllerTest, SecondaryDisplayLayout);
    170   friend class DisplayManager;
    171   friend class MirrorWindowController;
    172 
    173   // Creates a WindowTreeHost for |display| and stores it in the
    174   // |window_tree_hosts_| map.
    175   AshWindowTreeHost* AddWindowTreeHostForDisplay(
    176       const gfx::Display& display,
    177       const AshWindowTreeHostInitParams& params);
    178 
    179   void OnFadeOutForSwapDisplayFinished();
    180 
    181   void SetMirrorModeAfterAnimation(bool mirror);
    182 
    183   void UpdateHostWindowNames();
    184 
    185   class DisplayChangeLimiter {
    186    public:
    187     DisplayChangeLimiter();
    188 
    189     // Sets how long the throttling should last.
    190     void SetThrottleTimeout(int64 throttle_ms);
    191 
    192     bool IsThrottled() const;
    193 
    194    private:
    195     // The time when the throttling ends.
    196     base::Time throttle_timeout_;
    197 
    198     DISALLOW_COPY_AND_ASSIGN(DisplayChangeLimiter);
    199   };
    200 
    201   // The limiter to throttle how fast a user can
    202   // change the display configuration.
    203   scoped_ptr<DisplayChangeLimiter> limiter_;
    204 
    205   typedef std::map<int64, AshWindowTreeHost*> WindowTreeHostMap;
    206   // The mapping from display ID to its window tree host.
    207   WindowTreeHostMap window_tree_hosts_;
    208 
    209   ObserverList<Observer> observers_;
    210 
    211   // Store the primary window tree host temporarily while replacing
    212   // display.
    213   AshWindowTreeHost* primary_tree_host_for_replace_;
    214 
    215   scoped_ptr<FocusActivationStore> focus_activation_store_;
    216 
    217   scoped_ptr<CursorWindowController> cursor_window_controller_;
    218   scoped_ptr<MirrorWindowController> mirror_window_controller_;
    219   scoped_ptr<VirtualKeyboardWindowController>
    220       virtual_keyboard_window_controller_;
    221 
    222   // Stores the curent cursor location (in native coordinates) used to
    223   // restore the cursor location when display configuration
    224   // changed.
    225   gfx::Point cursor_location_in_native_coords_for_restore_;
    226 
    227   base::WeakPtrFactory<DisplayController> weak_ptr_factory_;
    228 
    229   DISALLOW_COPY_AND_ASSIGN(DisplayController);
    230 };
    231 
    232 }  // namespace ash
    233 
    234 #endif  // ASH_DISPLAY_DISPLAY_CONTROLLER_H_
    235