| OLD | NEW |
|---|
| (Empty) |
| 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 <string> | |
| 11 #include <utility> | |
| 12 #include <vector> | |
| 13 | |
| 14 #include "base/logging.h" | |
| 15 #include "ui/base/user_activity/user_activity_detector.h" | |
| 16 #include "ui/display/chromeos/touchscreen_util.h" | |
| 17 #include "ui/display/display.h" | |
| 18 #include "ui/display/manager/display_layout.h" | |
| 19 #include "ui/display/manager/display_layout_store.h" | |
| 20 #include "ui/display/manager/display_manager.h" | |
| 21 #include "ui/display/manager/display_manager_utilities.h" | |
| 22 #include "ui/display/types/display_mode.h" | |
| 23 #include "ui/display/types/display_snapshot.h" | |
| 24 #include "ui/display/util/display_util.h" | |
| 25 #include "ui/events/devices/input_device_manager.h" | |
| 26 #include "ui/events/devices/touchscreen_device.h" | |
| 27 | |
| 28 namespace ash { | |
| 29 | |
| 30 using ui::DisplayConfigurator; | |
| 31 | |
| 32 namespace { | |
| 33 | |
| 34 // 1 inch in mm. | |
| 35 const float kInchInMm = 25.4f; | |
| 36 | |
| 37 // The minimum pixel width whose monitor can be called as '4K'. | |
| 38 const int kMinimumWidthFor4K = 3840; | |
| 39 | |
| 40 // The list of device scale factors (in addition to 1.0f) which is | |
| 41 // available in external large monitors. | |
| 42 const float kAdditionalDeviceScaleFactorsFor4k[] = {1.25f, 2.0f}; | |
| 43 | |
| 44 void UpdateInternalDisplayId( | |
| 45 const ui::DisplayConfigurator::DisplayStateList& display_states) { | |
| 46 for (auto* state : display_states) { | |
| 47 if (state->type() == ui::DISPLAY_CONNECTION_TYPE_INTERNAL) { | |
| 48 if (display::Display::HasInternalDisplay()) | |
| 49 DCHECK_EQ(display::Display::InternalDisplayId(), state->display_id()); | |
| 50 display::Display::SetInternalDisplayId(state->display_id()); | |
| 51 } | |
| 52 } | |
| 53 } | |
| 54 | |
| 55 } // namespace | |
| 56 | |
| 57 // static | |
| 58 display::ManagedDisplayInfo::ManagedDisplayModeList | |
| 59 DisplayChangeObserver::GetInternalManagedDisplayModeList( | |
| 60 const display::ManagedDisplayInfo& display_info, | |
| 61 const ui::DisplaySnapshot& output) { | |
| 62 const ui::DisplayMode* ui_native_mode = output.native_mode(); | |
| 63 scoped_refptr<display::ManagedDisplayMode> native_mode = | |
| 64 new display::ManagedDisplayMode(ui_native_mode->size(), | |
| 65 ui_native_mode->refresh_rate(), | |
| 66 ui_native_mode->is_interlaced(), true, | |
| 67 1.0, display_info.device_scale_factor()); | |
| 68 | |
| 69 return display::CreateInternalManagedDisplayModeList(native_mode); | |
| 70 } | |
| 71 | |
| 72 // static | |
| 73 display::ManagedDisplayInfo::ManagedDisplayModeList | |
| 74 DisplayChangeObserver::GetExternalManagedDisplayModeList( | |
| 75 const ui::DisplaySnapshot& output) { | |
| 76 using DisplayModeMap = | |
| 77 std::map<std::pair<int, int>, scoped_refptr<display::ManagedDisplayMode>>; | |
| 78 DisplayModeMap display_mode_map; | |
| 79 | |
| 80 scoped_refptr<display::ManagedDisplayMode> native_mode = | |
| 81 new display::ManagedDisplayMode(); | |
| 82 for (const auto& mode_info : output.modes()) { | |
| 83 const std::pair<int, int> size(mode_info->size().width(), | |
| 84 mode_info->size().height()); | |
| 85 scoped_refptr<display::ManagedDisplayMode> display_mode = | |
| 86 new display::ManagedDisplayMode( | |
| 87 mode_info->size(), mode_info->refresh_rate(), | |
| 88 mode_info->is_interlaced(), output.native_mode() == mode_info.get(), | |
| 89 1.0, 1.0); | |
| 90 if (display_mode->native()) | |
| 91 native_mode = display_mode; | |
| 92 | |
| 93 // Add the display mode if it isn't already present and override interlaced | |
| 94 // display modes with non-interlaced ones. | |
| 95 auto display_mode_it = display_mode_map.find(size); | |
| 96 if (display_mode_it == display_mode_map.end()) | |
| 97 display_mode_map.insert(std::make_pair(size, display_mode)); | |
| 98 else if (display_mode_it->second->is_interlaced() && | |
| 99 !display_mode->is_interlaced()) | |
| 100 display_mode_it->second = std::move(display_mode); | |
| 101 } | |
| 102 | |
| 103 display::ManagedDisplayInfo::ManagedDisplayModeList display_mode_list; | |
| 104 for (const auto& display_mode_pair : display_mode_map) | |
| 105 display_mode_list.push_back(std::move(display_mode_pair.second)); | |
| 106 | |
| 107 if (output.native_mode()) { | |
| 108 const std::pair<int, int> size(native_mode->size().width(), | |
| 109 native_mode->size().height()); | |
| 110 auto it = display_mode_map.find(size); | |
| 111 DCHECK(it != display_mode_map.end()) | |
| 112 << "Native mode must be part of the mode list."; | |
| 113 | |
| 114 // If the native mode was replaced re-add it. | |
| 115 if (!it->second->native()) | |
| 116 display_mode_list.push_back(native_mode); | |
| 117 } | |
| 118 | |
| 119 if (native_mode->size().width() >= kMinimumWidthFor4K) { | |
| 120 for (size_t i = 0; i < arraysize(kAdditionalDeviceScaleFactorsFor4k); ++i) { | |
| 121 scoped_refptr<display::ManagedDisplayMode> mode = | |
| 122 new display::ManagedDisplayMode( | |
| 123 native_mode->size(), native_mode->refresh_rate(), | |
| 124 native_mode->is_interlaced(), false /* native */, | |
| 125 native_mode->ui_scale(), kAdditionalDeviceScaleFactorsFor4k[i]); | |
| 126 display_mode_list.push_back(mode); | |
| 127 } | |
| 128 } | |
| 129 | |
| 130 return display_mode_list; | |
| 131 } | |
| 132 | |
| 133 DisplayChangeObserver::DisplayChangeObserver( | |
| 134 std::unique_ptr<display::DisplayStringProvider> string_provider) | |
| 135 : string_provider_(std::move(string_provider)) { | |
| 136 ui::InputDeviceManager::GetInstance()->AddObserver(this); | |
| 137 } | |
| 138 | |
| 139 DisplayChangeObserver::~DisplayChangeObserver() { | |
| 140 ui::InputDeviceManager::GetInstance()->RemoveObserver(this); | |
| 141 } | |
| 142 | |
| 143 ui::MultipleDisplayState DisplayChangeObserver::GetStateForDisplayIds( | |
| 144 const ui::DisplayConfigurator::DisplayStateList& display_states) const { | |
| 145 UpdateInternalDisplayId(display_states); | |
| 146 if (display_states.size() == 1) | |
| 147 return ui::MULTIPLE_DISPLAY_STATE_SINGLE; | |
| 148 display::DisplayIdList list = display::GenerateDisplayIdList( | |
| 149 display_states.begin(), display_states.end(), | |
| 150 [](const ui::DisplaySnapshot* display_state) { | |
| 151 return display_state->display_id(); | |
| 152 }); | |
| 153 | |
| 154 const display::DisplayLayout& layout = | |
| 155 display_manager_->layout_store()->GetRegisteredDisplayLayout(list); | |
| 156 return layout.mirrored ? ui::MULTIPLE_DISPLAY_STATE_DUAL_MIRROR | |
| 157 : ui::MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED; | |
| 158 } | |
| 159 | |
| 160 bool DisplayChangeObserver::GetResolutionForDisplayId(int64_t display_id, | |
| 161 gfx::Size* size) const { | |
| 162 scoped_refptr<display::ManagedDisplayMode> mode = | |
| 163 display_manager_->GetSelectedModeForDisplayId(display_id); | |
| 164 if (!mode) | |
| 165 return false; | |
| 166 *size = mode->size(); | |
| 167 return true; | |
| 168 } | |
| 169 | |
| 170 void DisplayChangeObserver::OnDisplayModeChanged( | |
| 171 const ui::DisplayConfigurator::DisplayStateList& display_states) { | |
| 172 UpdateInternalDisplayId(display_states); | |
| 173 | |
| 174 std::vector<display::ManagedDisplayInfo> displays; | |
| 175 std::set<int64_t> ids; | |
| 176 for (const ui::DisplaySnapshot* state : display_states) { | |
| 177 const ui::DisplayMode* mode_info = state->current_mode(); | |
| 178 if (!mode_info) | |
| 179 continue; | |
| 180 | |
| 181 float device_scale_factor = 1.0f; | |
| 182 // Sets dpi only if the screen size is not blacklisted. | |
| 183 float dpi = display::IsDisplaySizeBlackListed(state->physical_size()) | |
| 184 ? 0 | |
| 185 : kInchInMm * mode_info->size().width() / | |
| 186 state->physical_size().width(); | |
| 187 if (state->type() == ui::DISPLAY_CONNECTION_TYPE_INTERNAL) { | |
| 188 if (dpi) | |
| 189 device_scale_factor = FindDeviceScaleFactor(dpi); | |
| 190 } else { | |
| 191 scoped_refptr<display::ManagedDisplayMode> mode = | |
| 192 display_manager_->GetSelectedModeForDisplayId(state->display_id()); | |
| 193 if (mode) { | |
| 194 device_scale_factor = mode->device_scale_factor(); | |
| 195 } else { | |
| 196 // For monitors that are 40 inches and 4K or above, set | |
| 197 // |device_scale_factor| to 2x. For margin purposes, 100 is subtracted | |
| 198 // from the value of |k2xThreshouldSizeSquaredFor4KInMm| | |
| 199 const int k2xThreshouldSizeSquaredFor4KInMm = | |
| 200 (40 * 40 * kInchInMm * kInchInMm) - 100; | |
| 201 gfx::Vector2d size_in_vec(state->physical_size().width(), | |
| 202 state->physical_size().height()); | |
| 203 if (size_in_vec.LengthSquared() > k2xThreshouldSizeSquaredFor4KInMm && | |
| 204 mode_info->size().width() >= kMinimumWidthFor4K) { | |
| 205 // Make sure that additional device scale factors table has 2x. | |
| 206 DCHECK_EQ(2.0f, kAdditionalDeviceScaleFactorsFor4k[1]); | |
| 207 device_scale_factor = 2.0f; | |
| 208 } | |
| 209 } | |
| 210 } | |
| 211 gfx::Rect display_bounds(state->origin(), mode_info->size()); | |
| 212 | |
| 213 std::string name; | |
| 214 switch (state->type()) { | |
| 215 case ui::DISPLAY_CONNECTION_TYPE_INTERNAL: | |
| 216 name = string_provider_->GetInternalDisplayNameString(); | |
| 217 break; | |
| 218 case ui::DISPLAY_CONNECTION_TYPE_VIRTUAL: | |
| 219 name = string_provider_->GetVirtualDisplayNameString(); | |
| 220 break; | |
| 221 default: | |
| 222 name = state->display_name(); | |
| 223 } | |
| 224 | |
| 225 if (name.empty()) | |
| 226 name = string_provider_->GetUnknownDisplayNameString(); | |
| 227 | |
| 228 bool has_overscan = state->has_overscan(); | |
| 229 int64_t id = state->display_id(); | |
| 230 ids.insert(id); | |
| 231 | |
| 232 displays.push_back(display::ManagedDisplayInfo(id, name, has_overscan)); | |
| 233 display::ManagedDisplayInfo& new_info = displays.back(); | |
| 234 new_info.set_sys_path(state->sys_path()); | |
| 235 new_info.set_device_scale_factor(device_scale_factor); | |
| 236 new_info.SetBounds(display_bounds); | |
| 237 new_info.set_native(true); | |
| 238 new_info.set_is_aspect_preserving_scaling( | |
| 239 state->is_aspect_preserving_scaling()); | |
| 240 if (dpi) | |
| 241 new_info.set_device_dpi(dpi); | |
| 242 | |
| 243 display::ManagedDisplayInfo::ManagedDisplayModeList display_modes = | |
| 244 (state->type() == ui::DISPLAY_CONNECTION_TYPE_INTERNAL) | |
| 245 ? GetInternalManagedDisplayModeList(new_info, *state) | |
| 246 : GetExternalManagedDisplayModeList(*state); | |
| 247 new_info.SetManagedDisplayModes(display_modes); | |
| 248 | |
| 249 new_info.set_available_color_profiles( | |
| 250 display_configurator_->GetAvailableColorCalibrationProfiles(id)); | |
| 251 new_info.set_maximum_cursor_size(state->maximum_cursor_size()); | |
| 252 } | |
| 253 | |
| 254 display::AssociateTouchscreens( | |
| 255 &displays, | |
| 256 ui::InputDeviceManager::GetInstance()->GetTouchscreenDevices()); | |
| 257 display_manager_->OnNativeDisplaysChanged(displays); | |
| 258 | |
| 259 // For the purposes of user activity detection, ignore synthetic mouse events | |
| 260 // that are triggered by screen resizes: http://crbug.com/360634 | |
| 261 ui::UserActivityDetector* user_activity_detector = | |
| 262 ui::UserActivityDetector::Get(); | |
| 263 if (user_activity_detector) | |
| 264 user_activity_detector->OnDisplayPowerChanging(); | |
| 265 } | |
| 266 | |
| 267 void DisplayChangeObserver::OnDisplayModeChangeFailed( | |
| 268 const ui::DisplayConfigurator::DisplayStateList& displays, | |
| 269 ui::MultipleDisplayState failed_new_state) { | |
| 270 // If display configuration failed during startup, simply update the display | |
| 271 // manager with detected displays. If no display is detected, it will | |
| 272 // create a pseudo display. | |
| 273 if (display_manager_->GetNumDisplays() == 0) | |
| 274 OnDisplayModeChanged(displays); | |
| 275 } | |
| 276 | |
| 277 void DisplayChangeObserver::OnTouchscreenDeviceConfigurationChanged() { | |
| 278 OnDisplayModeChanged(display_configurator_->cached_displays()); | |
| 279 } | |
| 280 | |
| 281 // static | |
| 282 float DisplayChangeObserver::FindDeviceScaleFactor(float dpi) { | |
| 283 if (dpi > 200.0f) | |
| 284 return 2.0f; | |
| 285 else if (dpi > 150.0f) | |
| 286 return 1.25f; | |
| 287 else | |
| 288 return 1.0f; | |
| 289 } | |
| 290 | |
| 291 } // namespace ash | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2524863003:
Move DisplayChangeObserver + tests from ash to ui. (Closed)
