display_change_observer_chromeos.cc revision 1320f92c476a1ad9d19dba2a48c72b75566198e9 
1// Copyright 2013 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/display_change_observer_chromeos.h"
6
7#include <algorithm>
8#include <map>
9#include <set>
10#include <vector>
11
12#include "ash/ash_switches.h"
13#include "ash/display/display_info.h"
14#include "ash/display/display_layout_store.h"
15#include "ash/display/display_manager.h"
16#include "ash/shell.h"
17#include "ash/touch/touchscreen_util.h"
18#include "base/command_line.h"
19#include "base/logging.h"
20#include "grit/ash_strings.h"
21#include "ui/base/l10n/l10n_util.h"
22#include "ui/compositor/dip_util.h"
23#include "ui/display/types/display_mode.h"
24#include "ui/display/types/display_snapshot.h"
25#include "ui/display/util/display_util.h"
26#include "ui/events/device_data_manager.h"
27#include "ui/events/touchscreen_device.h"
28#include "ui/gfx/display.h"
29#include "ui/wm/core/user_activity_detector.h"
30
31namespace ash {
32
33using ui::DisplayConfigurator;
34
35namespace {
36
37// The DPI threshold to determine the device scale factor.
38// DPI higher than |dpi| will use |device_scale_factor|.
39struct DeviceScaleFactorDPIThreshold {
40  float dpi;
41  float device_scale_factor;
42};
43
44const DeviceScaleFactorDPIThreshold kThresholdTable[] = {
45  {180.0f, 2.0f},
46  {150.0f, 1.25f},
47  {0.0f, 1.0f},
48};
49
50// 1 inch in mm.
51const float kInchInMm = 25.4f;
52
53// The minimum pixel width whose monitor can be called as '4K'.
54const int kMinimumWidthFor4K = 3840;
55
56// The list of device scale factors (in addition to 1.0f) which is
57// available in extrenal large monitors.
58const float kAdditionalDeviceScaleFactorsFor4k[] = {1.25f, 2.0f};
59
60// Display mode list is sorted by:
61//  * the area in pixels in ascending order
62//  * refresh rate in descending order
63struct DisplayModeSorter {
64  bool operator()(const DisplayMode& a, const DisplayMode& b) {
65    gfx::Size size_a_dip = a.GetSizeInDIP();
66    gfx::Size size_b_dip = b.GetSizeInDIP();
67    if (size_a_dip.GetArea() == size_b_dip.GetArea())
68      return (a.refresh_rate > b.refresh_rate);
69    return (size_a_dip.GetArea() < size_b_dip.GetArea());
70  }
71};
72
73}  // namespace
74
75// static
76std::vector<DisplayMode> DisplayChangeObserver::GetInternalDisplayModeList(
77    const DisplayInfo& display_info,
78    const DisplayConfigurator::DisplayState& output) {
79  std::vector<DisplayMode> display_mode_list;
80  const ui::DisplayMode* ui_native_mode = output.display->native_mode();
81  DisplayMode native_mode(ui_native_mode->size(),
82                          ui_native_mode->refresh_rate(),
83                          ui_native_mode->is_interlaced(),
84                          true);
85  native_mode.device_scale_factor = display_info.device_scale_factor();
86  std::vector<float> ui_scales =
87      DisplayManager::GetScalesForDisplay(display_info);
88  for (size_t i = 0; i < ui_scales.size(); ++i) {
89    DisplayMode mode = native_mode;
90    mode.ui_scale = ui_scales[i];
91    mode.native = (ui_scales[i] == display_info.device_scale_factor());
92    display_mode_list.push_back(mode);
93  }
94
95  std::sort(
96      display_mode_list.begin(), display_mode_list.end(), DisplayModeSorter());
97  return display_mode_list;
98}
99
100// static
101std::vector<DisplayMode> DisplayChangeObserver::GetExternalDisplayModeList(
102    const DisplayConfigurator::DisplayState& output) {
103  typedef std::map<std::pair<int, int>, DisplayMode> DisplayModeMap;
104  DisplayModeMap display_mode_map;
105
106  DisplayMode native_mode;
107  for (std::vector<const ui::DisplayMode*>::const_iterator it =
108           output.display->modes().begin();
109       it != output.display->modes().end();
110       ++it) {
111    const ui::DisplayMode& mode_info = **it;
112    const std::pair<int, int> size(mode_info.size().width(),
113                                   mode_info.size().height());
114    const DisplayMode display_mode(mode_info.size(),
115                                   mode_info.refresh_rate(),
116                                   mode_info.is_interlaced(),
117                                   output.display->native_mode() == *it);
118    if (display_mode.native)
119      native_mode = display_mode;
120
121    // Add the display mode if it isn't already present and override interlaced
122    // display modes with non-interlaced ones.
123    DisplayModeMap::iterator display_mode_it = display_mode_map.find(size);
124    if (display_mode_it == display_mode_map.end())
125      display_mode_map.insert(std::make_pair(size, display_mode));
126    else if (display_mode_it->second.interlaced && !display_mode.interlaced)
127      display_mode_it->second = display_mode;
128  }
129
130  std::vector<DisplayMode> display_mode_list;
131  for (DisplayModeMap::const_iterator iter = display_mode_map.begin();
132       iter != display_mode_map.end();
133       ++iter) {
134    display_mode_list.push_back(iter->second);
135  }
136
137  if (native_mode.size.width() >= kMinimumWidthFor4K) {
138    for (size_t i = 0; i < arraysize(kAdditionalDeviceScaleFactorsFor4k);
139         ++i) {
140      DisplayMode mode = native_mode;
141      mode.device_scale_factor = kAdditionalDeviceScaleFactorsFor4k[i];
142      mode.native = false;
143      display_mode_list.push_back(mode);
144    }
145  }
146
147  std::sort(
148      display_mode_list.begin(), display_mode_list.end(), DisplayModeSorter());
149  return display_mode_list;
150}
151
152DisplayChangeObserver::DisplayChangeObserver() {
153  Shell::GetInstance()->AddShellObserver(this);
154  ui::DeviceDataManager::GetInstance()->AddObserver(this);
155}
156
157DisplayChangeObserver::~DisplayChangeObserver() {
158  ui::DeviceDataManager::GetInstance()->RemoveObserver(this);
159  Shell::GetInstance()->RemoveShellObserver(this);
160}
161
162ui::MultipleDisplayState DisplayChangeObserver::GetStateForDisplayIds(
163    const std::vector<int64>& display_ids) const {
164  CHECK_EQ(2U, display_ids.size());
165  DisplayIdPair pair = std::make_pair(display_ids[0], display_ids[1]);
166  DisplayLayout layout = Shell::GetInstance()->display_manager()->
167      layout_store()->GetRegisteredDisplayLayout(pair);
168  return layout.mirrored ? ui::MULTIPLE_DISPLAY_STATE_DUAL_MIRROR :
169                           ui::MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED;
170}
171
172bool DisplayChangeObserver::GetResolutionForDisplayId(int64 display_id,
173                                                      gfx::Size* size) const {
174  DisplayMode mode;
175  if (!Shell::GetInstance()->display_manager()->GetSelectedModeForDisplayId(
176           display_id, &mode))
177    return false;
178
179  *size = mode.size;
180  return true;
181}
182
183void DisplayChangeObserver::OnDisplayModeChanged(
184    const std::vector<DisplayConfigurator::DisplayState>& display_states) {
185  std::vector<DisplayInfo> displays;
186  std::set<int64> ids;
187  for (size_t i = 0; i < display_states.size(); ++i) {
188    const DisplayConfigurator::DisplayState& state = display_states[i];
189
190    if (state.display->type() == ui::DISPLAY_CONNECTION_TYPE_INTERNAL &&
191        gfx::Display::InternalDisplayId() == gfx::Display::kInvalidDisplayID) {
192      gfx::Display::SetInternalDisplayId(state.display->display_id());
193    }
194
195    const ui::DisplayMode* mode_info = state.display->current_mode();
196    if (!mode_info)
197      continue;
198
199    float device_scale_factor = 1.0f;
200    if (state.display->type() == ui::DISPLAY_CONNECTION_TYPE_INTERNAL) {
201      if (!ui::IsDisplaySizeBlackListed(state.display->physical_size())) {
202        device_scale_factor =
203            FindDeviceScaleFactor((kInchInMm * mode_info->size().width() /
204                                   state.display->physical_size().width()));
205      }
206    } else {
207      DisplayMode mode;
208      if (Shell::GetInstance()->display_manager()->GetSelectedModeForDisplayId(
209              state.display->display_id(), &mode)) {
210        device_scale_factor = mode.device_scale_factor;
211      }
212    }
213    gfx::Rect display_bounds(state.display->origin(), mode_info->size());
214
215    std::string name =
216        state.display->type() == ui::DISPLAY_CONNECTION_TYPE_INTERNAL ?
217            l10n_util::GetStringUTF8(IDS_ASH_INTERNAL_DISPLAY_NAME) :
218            state.display->display_name();
219    if (name.empty())
220      name = l10n_util::GetStringUTF8(IDS_ASH_STATUS_TRAY_UNKNOWN_DISPLAY_NAME);
221
222    bool has_overscan = state.display->has_overscan();
223    int64 id = state.display->display_id();
224    ids.insert(id);
225
226    displays.push_back(DisplayInfo(id, name, has_overscan));
227    DisplayInfo& new_info = displays.back();
228    new_info.set_device_scale_factor(device_scale_factor);
229    new_info.SetBounds(display_bounds);
230    new_info.set_native(true);
231    new_info.set_is_aspect_preserving_scaling(
232        state.display->is_aspect_preserving_scaling());
233
234    std::vector<DisplayMode> display_modes =
235        (state.display->type() == ui::DISPLAY_CONNECTION_TYPE_INTERNAL) ?
236        GetInternalDisplayModeList(new_info, state) :
237        GetExternalDisplayModeList(state);
238    new_info.set_display_modes(display_modes);
239
240    new_info.set_available_color_profiles(
241        Shell::GetInstance()
242            ->display_configurator()
243            ->GetAvailableColorCalibrationProfiles(id));
244  }
245
246  AssociateTouchscreens(
247      &displays, ui::DeviceDataManager::GetInstance()->touchscreen_devices());
248  // DisplayManager can be null during the boot.
249  Shell::GetInstance()->display_manager()->OnNativeDisplaysChanged(displays);
250
251  // For the purposes of user activity detection, ignore synthetic mouse events
252  // that are triggered by screen resizes: http://crbug.com/360634
253  ::wm::UserActivityDetector* user_activity_detector =
254      Shell::GetInstance()->user_activity_detector();
255  if (user_activity_detector)
256    user_activity_detector->OnDisplayPowerChanging();
257}
258
259void DisplayChangeObserver::OnAppTerminating() {
260#if defined(USE_ASH)
261  // Stop handling display configuration events once the shutdown
262  // process starts. crbug.com/177014.
263  Shell::GetInstance()->display_configurator()->PrepareForExit();
264#endif
265}
266
267// static
268float DisplayChangeObserver::FindDeviceScaleFactor(float dpi) {
269  for (size_t i = 0; i < arraysize(kThresholdTable); ++i) {
270    if (dpi > kThresholdTable[i].dpi)
271      return kThresholdTable[i].device_scale_factor;
272  }
273  return 1.0f;
274}
275
276void DisplayChangeObserver::OnInputDeviceConfigurationChanged() {
277  std::vector<DisplayInfo> display_infos;
278  DisplayManager* display_manager =
279      ash::Shell::GetInstance()->display_manager();
280  const std::vector<gfx::Display>& displays = display_manager->displays();
281  // Reuse the current state in DisplayManager and re-associate the displays
282  // with the touchscreens.
283  for (size_t i = 0; i < displays.size(); ++i) {
284    DisplayInfo display = display_manager->GetDisplayInfo(displays[i].id());
285    // Unset the touchscreen configuration since we'll be rematching them from
286    // scratch.
287    display.set_touch_device_id(ui::TouchscreenDevice::kInvalidId);
288    display.set_touch_support(gfx::Display::TOUCH_SUPPORT_UNKNOWN);
289
290    display_infos.push_back(display);
291  }
292
293  AssociateTouchscreens(
294      &display_infos,
295      ui::DeviceDataManager::GetInstance()->touchscreen_devices());
296  display_manager->OnNativeDisplaysChanged(display_infos);
297}
298
299}  // namespace ash
300