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