ash/display/screen_ash.cc

   1 // Copyright 2014 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 #include "ash/display/screen_ash.h"
   6
   7 #include "ash/display/display_controller.h"
   8 #include "ash/display/display_manager.h"
   9 #include "ash/root_window_controller.h"
  10 #include "ash/root_window_settings.h"
  11 #include "ash/shelf/shelf_layout_manager.h"
  12 #include "ash/shelf/shelf_widget.h"
  13 #include "ash/shell.h"
  14 #include "ash/wm/coordinate_conversion.h"
  15 #include "base/logging.h"
  16 #include "ui/aura/client/screen_position_client.h"
  17 #include "ui/aura/env.h"
  18 #include "ui/aura/window_event_dispatcher.h"
  19 #include "ui/gfx/display.h"
  20 #include "ui/gfx/screen.h"
  21
  22 namespace ash {
  23
  24 namespace {
  25
  26 DisplayManager* GetDisplayManager() {
  27   return Shell::GetInstance()->display_manager();
  28 }
  29
  30 gfx::Display FindDisplayNearestPoint(const std::vector<gfx::Display>& displays,
  31                                      const gfx::Point& point) {
  32   int min_distance = INT_MAX;
  33   const gfx::Display* nearest_display = NULL;
  34   for (std::vector<gfx::Display>::const_iterator iter = displays.begin();
  35        iter != displays.end(); ++iter) {
  36     const gfx::Display& display = *iter;
  37     int distance = display.bounds().ManhattanDistanceToPoint(point);
  38     if (distance < min_distance) {
  39       min_distance = distance;
  40       nearest_display = &display;
  41     }
  42   }
  43   // There should always be at least one display that is less than INT_MAX away.
  44   DCHECK(nearest_display);
  45   return *nearest_display;
  46 }
  47
  48 const gfx::Display* FindDisplayMatching(
  49     const std::vector<gfx::Display>& displays,
  50     const gfx::Rect& match_rect) {
  51   int max_area = 0;
  52   const gfx::Display* matching = NULL;
  53   for (std::vector<gfx::Display>::const_iterator iter = displays.begin();
  54        iter != displays.end(); ++iter) {
  55     const gfx::Display& display = *iter;
  56     gfx::Rect intersect = gfx::IntersectRects(display.bounds(), match_rect);
  57     int area = intersect.width() * intersect.height();
  58     if (area > max_area) {
  59       max_area = area;
  60       matching = &display;
  61     }
  62   }
  63   return matching;
  64 }
  65
  66 class ScreenForShutdown : public gfx::Screen {
  67  public:
  68   explicit ScreenForShutdown(ScreenAsh* screen_ash)
  69       : display_list_(screen_ash->GetAllDisplays()),
  70         primary_display_(screen_ash->GetPrimaryDisplay()) {
  71   }
  72
  73   // gfx::Screen overrides:
  74   gfx::Point GetCursorScreenPoint() override { return gfx::Point(); }
  75   gfx::NativeWindow GetWindowUnderCursor() override { return NULL; }
  76   gfx::NativeWindow GetWindowAtScreenPoint(const gfx::Point& point) override {
  77     return NULL;
  78   }
  79   int GetNumDisplays() const override { return display_list_.size(); }
  80   std::vector<gfx::Display> GetAllDisplays() const override {
  81     return display_list_;
  82   }
  83   gfx::Display GetDisplayNearestWindow(gfx::NativeView view) const override {
  84     return primary_display_;
  85   }
  86   gfx::Display GetDisplayNearestPoint(const gfx::Point& point) const override {
  87     return FindDisplayNearestPoint(display_list_, point);
  88   }
  89   gfx::Display GetDisplayMatching(const gfx::Rect& match_rect) const override {
  90     const gfx::Display* matching =
  91         FindDisplayMatching(display_list_, match_rect);
  92     // Fallback to the primary display if there is no matching display.
  93     return matching ? *matching : GetPrimaryDisplay();
  94   }
  95   gfx::Display GetPrimaryDisplay() const override { return primary_display_; }
  96   void AddObserver(gfx::DisplayObserver* observer) override {
  97     NOTREACHED() << "Observer should not be added during shutdown";
  98   }
  99   void RemoveObserver(gfx::DisplayObserver* observer) override {}
 100
 101  private:
 102   const std::vector<gfx::Display> display_list_;
 103   const gfx::Display primary_display_;
 104
 105   DISALLOW_COPY_AND_ASSIGN(ScreenForShutdown);
 106 };
 107
 108 }  // namespace
 109
 110 ScreenAsh::ScreenAsh() {
 111 }
 112
 113 ScreenAsh::~ScreenAsh() {
 114 }
 115
 116 void ScreenAsh::NotifyMetricsChanged(const gfx::Display& display,
 117                                      uint32_t metrics) {
 118   FOR_EACH_OBSERVER(gfx::DisplayObserver,
 119                     observers_,
 120                     OnDisplayMetricsChanged(display, metrics));
 121 }
 122
 123 void ScreenAsh::NotifyDisplayAdded(const gfx::Display& display) {
 124   FOR_EACH_OBSERVER(gfx::DisplayObserver, observers_, OnDisplayAdded(display));
 125 }
 126
 127 void ScreenAsh::NotifyDisplayRemoved(const gfx::Display& display) {
 128   FOR_EACH_OBSERVER(
 129       gfx::DisplayObserver, observers_, OnDisplayRemoved(display));
 130 }
 131
 132 gfx::Point ScreenAsh::GetCursorScreenPoint() {
 133   return aura::Env::GetInstance()->last_mouse_location();
 134 }
 135
 136 gfx::NativeWindow ScreenAsh::GetWindowUnderCursor() {
 137   return GetWindowAtScreenPoint(Shell::GetScreen()->GetCursorScreenPoint());
 138 }
 139
 140 gfx::NativeWindow ScreenAsh::GetWindowAtScreenPoint(const gfx::Point& point) {
 141   return wm::GetRootWindowAt(point)->GetTopWindowContainingPoint(point);
 142 }
 143
 144 int ScreenAsh::GetNumDisplays() const {
 145   return GetDisplayManager()->GetNumDisplays();
 146 }
 147
 148 std::vector<gfx::Display> ScreenAsh::GetAllDisplays() const {
 149   return GetDisplayManager()->active_display_list();
 150 }
 151
 152 gfx::Display ScreenAsh::GetDisplayNearestWindow(gfx::NativeView window) const {
 153   if (!window)
 154     return GetPrimaryDisplay();
 155   const aura::Window* root_window = window->GetRootWindow();
 156   if (!root_window)
 157     return GetPrimaryDisplay();
 158   const RootWindowSettings* rws = GetRootWindowSettings(root_window);
 159   int64 id = rws->display_id;
 160   // if id is |kInvaildDisplayID|, it's being deleted.
 161   DCHECK(id != gfx::Display::kInvalidDisplayID);
 162   if (id == gfx::Display::kInvalidDisplayID)
 163     return GetPrimaryDisplay();
 164
 165   DisplayManager* display_manager = GetDisplayManager();
 166   // RootWindow needs Display to determine its device scale factor
 167   // for non desktop display.
 168   gfx::Display mirroring_display = display_manager->GetMirroringDisplayById(id);
 169   if (mirroring_display.is_valid())
 170     return mirroring_display;
 171   return display_manager->GetDisplayForId(id);
 172 }
 173
 174 gfx::Display ScreenAsh::GetDisplayNearestPoint(const gfx::Point& point) const {
 175   const gfx::Display& display =
 176       GetDisplayManager()->FindDisplayContainingPoint(point);
 177   if (display.is_valid())
 178     return display;
 179   // Fallback to the display that has the shortest Manhattan distance from
 180   // the |point|. This is correct in the only areas that matter, namely in the
 181   // corners between the physical screens.
 182   return FindDisplayNearestPoint(GetDisplayManager()->active_display_list(),
 183                                  point);
 184 }
 185
 186 gfx::Display ScreenAsh::GetDisplayMatching(const gfx::Rect& match_rect) const {
 187   if (match_rect.IsEmpty())
 188     return GetDisplayNearestPoint(match_rect.origin());
 189   const gfx::Display* matching = FindDisplayMatching(
 190       GetDisplayManager()->active_display_list(), match_rect);
 191   // Fallback to the primary display if there is no matching display.
 192   return matching ? *matching : GetPrimaryDisplay();
 193 }
 194
 195 gfx::Display ScreenAsh::GetPrimaryDisplay() const {
 196   return GetDisplayManager()->GetDisplayForId(
 197       DisplayController::GetPrimaryDisplayId());
 198 }
 199
 200 void ScreenAsh::AddObserver(gfx::DisplayObserver* observer) {
 201   observers_.AddObserver(observer);
 202 }
 203
 204 void ScreenAsh::RemoveObserver(gfx::DisplayObserver* observer) {
 205   observers_.RemoveObserver(observer);
 206 }
 207
 208 gfx::Screen* ScreenAsh::CloneForShutdown() {
 209   return new ScreenForShutdown(this);
 210 }
 211
 212 }  // namespace ash