#include <string>
+#include "ash/display/display_configurator_animation.h"
#include "ash/display/display_controller.h"
#include "ash/display/display_manager.h"
-#include "ash/display/output_configurator_animation.h"
#include "ash/display/resolution_notification_controller.h"
#include "ash/shell.h"
#include "base/bind.h"
#include "base/strings/stringprintf.h"
#include "base/values.h"
#include "chrome/browser/chromeos/display/display_preferences.h"
-#include "chromeos/display/output_configurator.h"
+#include "chrome/grit/generated_resources.h"
+#include "content/public/browser/user_metrics.h"
#include "content/public/browser/web_ui.h"
#include "grit/ash_strings.h"
-#include "grit/generated_resources.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/gfx/display.h"
#include "ui/gfx/rect.h"
#include "ui/gfx/screen.h"
#include "ui/gfx/size_conversions.h"
-using ash::internal::DisplayManager;
+using ash::DisplayManager;
namespace chromeos {
namespace options {
return display_id;
}
-bool CompareDisplayMode(ash::internal::DisplayMode d1,
- ash::internal::DisplayMode d2) {
- if (d1.size.GetArea() == d2.size.GetArea())
- return d1.refresh_rate < d2.refresh_rate;
- return d1.size.GetArea() < d2.size.GetArea();
+base::string16 GetColorProfileName(ui::ColorCalibrationProfile profile) {
+ switch (profile) {
+ case ui::COLOR_PROFILE_STANDARD:
+ return l10n_util::GetStringUTF16(
+ IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_COLOR_PROFILE_STANDARD);
+ case ui::COLOR_PROFILE_DYNAMIC:
+ return l10n_util::GetStringUTF16(
+ IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_COLOR_PROFILE_DYNAMIC);
+ case ui::COLOR_PROFILE_MOVIE:
+ return l10n_util::GetStringUTF16(
+ IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_COLOR_PROFILE_MOVIE);
+ case ui::COLOR_PROFILE_READING:
+ return l10n_util::GetStringUTF16(
+ IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_COLOR_PROFILE_READING);
+ case ui::NUM_COLOR_PROFILES:
+ break;
+ }
+
+ NOTREACHED();
+ return base::string16();
+}
+
+int GetIntOrDouble(const base::DictionaryValue* dict,
+ const std::string& field) {
+ double double_result = 0;
+ if (dict->GetDouble(field, &double_result))
+ return static_cast<int>(double_result);
+
+ int result = 0;
+ dict->GetInteger(field, &result);
+ return result;
+}
+
+bool GetFloat(const base::DictionaryValue* dict,
+ const std::string& field,
+ float* result) {
+ double double_result = 0;
+ if (dict->GetDouble(field, &double_result)) {
+ *result = static_cast<float>(double_result);
+ return true;
+ }
+ return false;
+}
+
+bool ConvertValueToDisplayMode(const base::DictionaryValue* dict,
+ ash::DisplayMode* mode) {
+ mode->size.set_width(GetIntOrDouble(dict, "originalWidth"));
+ mode->size.set_height(GetIntOrDouble(dict, "originalHeight"));
+ if (mode->size.IsEmpty()) {
+ LOG(ERROR) << "missing width or height.";
+ return false;
+ }
+ if (!GetFloat(dict, "refreshRate", &mode->refresh_rate)) {
+ LOG(ERROR) << "missing refreshRate.";
+ return false;
+ }
+ if (!GetFloat(dict, "scale", &mode->ui_scale)) {
+ LOG(ERROR) << "missing ui-scale.";
+ return false;
+ }
+ if (!GetFloat(dict, "deviceScaleFactor", &mode->device_scale_factor)) {
+ LOG(ERROR) << "missing deviceScaleFactor.";
+ return false;
+ }
+ return true;
+}
+
+base::DictionaryValue* ConvertDisplayModeToValue(int64 display_id,
+ const ash::DisplayMode& mode) {
+ bool is_internal = GetDisplayManager()->IsInternalDisplayId(display_id);
+ base::DictionaryValue* result = new base::DictionaryValue();
+ gfx::Size size_dip = mode.GetSizeInDIP();
+ result->SetInteger("width", size_dip.width());
+ result->SetInteger("height", size_dip.height());
+ result->SetInteger("originalWidth", mode.size.width());
+ result->SetInteger("originalHeight", mode.size.height());
+ result->SetDouble("deviceScaleFactor", mode.device_scale_factor);
+ result->SetDouble("scale", mode.ui_scale);
+ result->SetDouble("refreshRate", mode.refresh_rate);
+ result->SetBoolean(
+ "isBest", is_internal ? (mode.ui_scale == 1.0f) : mode.native);
+ result->SetBoolean("isNative", mode.native);
+ result->SetBoolean(
+ "selected", mode.IsEquivalent(
+ GetDisplayManager()->GetActiveModeForDisplayId(display_id)));
+ return result;
}
} // namespace
DisplayOptionsHandler::DisplayOptionsHandler() {
+ // ash::Shell doesn't exist in Athena.
+ // See: http://crbug.com/416961
ash::Shell::GetInstance()->display_controller()->AddObserver(this);
}
DisplayOptionsHandler::~DisplayOptionsHandler() {
+ // ash::Shell doesn't exist in Athena.
ash::Shell::GetInstance()->display_controller()->RemoveObserver(this);
}
IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_SET_PRIMARY));
localized_strings->SetString("annotateBest", l10n_util::GetStringUTF16(
IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_RESOLUTION_ANNOTATION_BEST));
+ localized_strings->SetString("annotateNative", l10n_util::GetStringUTF16(
+ IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_RESOLUTION_ANNOTATION_NATIVE));
localized_strings->SetString("orientation0", l10n_util::GetStringUTF16(
IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_STANDARD_ORIENTATION));
localized_strings->SetString("orientation90", l10n_util::GetStringUTF16(
localized_strings->SetString(
"startCalibratingOverscan", l10n_util::GetStringUTF16(
IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_START_CALIBRATING_OVERSCAN));
+ localized_strings->SetString(
+ "selectedDisplayColorProfile", l10n_util::GetStringUTF16(
+ IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_COLOR_PROFILE));
}
void DisplayOptionsHandler::InitializePage() {
DCHECK(web_ui());
+ web_ui()->CallJavascriptFunction(
+ "options.BrowserOptions.enableDisplayButton",
+ base::FundamentalValue(true));
}
void DisplayOptionsHandler::RegisterMessages() {
base::Bind(&DisplayOptionsHandler::HandleDisplayLayout,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
- "setUIScale",
- base::Bind(&DisplayOptionsHandler::HandleSetUIScale,
- base::Unretained(this)));
- web_ui()->RegisterMessageCallback(
- "setResolution",
- base::Bind(&DisplayOptionsHandler::HandleSetResolution,
+ "setDisplayMode",
+ base::Bind(&DisplayOptionsHandler::HandleSetDisplayMode,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"setOrientation",
base::Bind(&DisplayOptionsHandler::HandleSetOrientation,
base::Unretained(this)));
+ web_ui()->RegisterMessageCallback(
+ "setColorProfile",
+ base::Bind(&DisplayOptionsHandler::HandleSetColorProfile,
+ base::Unretained(this)));
}
void DisplayOptionsHandler::OnDisplayConfigurationChanging() {
base::ListValue js_displays;
for (size_t i = 0; i < displays.size(); ++i) {
const gfx::Display& display = displays[i];
- const ash::internal::DisplayInfo& display_info =
+ const ash::DisplayInfo& display_info =
display_manager->GetDisplayInfo(display.id());
const gfx::Rect& bounds = display.bounds();
base::DictionaryValue* js_display = new base::DictionaryValue();
js_display->SetBoolean("isInternal", display.IsInternal());
js_display->SetInteger("orientation",
static_cast<int>(display_info.rotation()));
- std::vector<ash::internal::DisplayMode> display_modes;
- std::vector<float> ui_scales;
- if (display.IsInternal()) {
- ui_scales = DisplayManager::GetScalesForDisplay(display_info);
- gfx::SizeF base_size = display_info.bounds_in_native().size();
- base_size.Scale(1.0f / display_info.device_scale_factor());
- if (display_info.rotation() == gfx::Display::ROTATE_90 ||
- display_info.rotation() == gfx::Display::ROTATE_270) {
- float tmp = base_size.width();
- base_size.set_width(base_size.height());
- base_size.set_height(tmp);
- }
- for (size_t i = 0; i < ui_scales.size(); ++i) {
- gfx::SizeF new_size = base_size;
- new_size.Scale(ui_scales[i]);
- display_modes.push_back(ash::internal::DisplayMode(
- gfx::ToFlooredSize(new_size), -1.0f, false, false));
- }
- } else {
- for (size_t i = 0; i < display_info.display_modes().size(); ++i)
- display_modes.push_back(display_info.display_modes()[i]);
- }
- std::sort(display_modes.begin(), display_modes.end(), CompareDisplayMode);
base::ListValue* js_resolutions = new base::ListValue();
- gfx::Size current_size = display_info.bounds_in_native().size();
- gfx::Insets current_overscan = display_info.GetOverscanInsetsInPixel();
+ const std::vector<ash::DisplayMode>& display_modes =
+ display_info.display_modes();
for (size_t i = 0; i < display_modes.size(); ++i) {
- base::DictionaryValue* resolution_info = new base::DictionaryValue();
- gfx::Size resolution = display_modes[i].size;
- if (!ui_scales.empty()) {
- resolution_info->SetDouble("scale", ui_scales[i]);
- if (ui_scales[i] == 1.0f)
- resolution_info->SetBoolean("isBest", true);
- resolution_info->SetBoolean(
- "selected", display_info.configured_ui_scale() == ui_scales[i]);
- } else {
- // Picks the largest one as the "best", which is the last element
- // because |display_modes| is sorted by its area.
- if (i == display_modes.size() - 1)
- resolution_info->SetBoolean("isBest", true);
- resolution_info->SetBoolean("selected", (resolution == current_size));
- resolution.Enlarge(
- -current_overscan.width(), -current_overscan.height());
- }
- resolution_info->SetInteger("width", resolution.width());
- resolution_info->SetInteger("height", resolution.height());
- if (display_modes[i].refresh_rate > 0.0f) {
- resolution_info->SetDouble("refreshRate",
- display_modes[i].refresh_rate);
- }
- js_resolutions->Append(resolution_info);
+ js_resolutions->Append(
+ ConvertDisplayModeToValue(display.id(), display_modes[i]));
}
js_display->Set("resolutions", js_resolutions);
+
+ js_display->SetInteger("colorProfile", display_info.color_profile());
+ base::ListValue* available_color_profiles = new base::ListValue();
+ for (size_t i = 0;
+ i < display_info.available_color_profiles().size(); ++i) {
+ base::DictionaryValue* color_profile_dict = new base::DictionaryValue();
+ ui::ColorCalibrationProfile color_profile =
+ display_info.available_color_profiles()[i];
+ color_profile_dict->SetInteger("profileId", color_profile);
+ color_profile_dict->SetString("name", GetColorProfileName(color_profile));
+ available_color_profiles->Append(color_profile_dict);
+ }
+ js_display->Set("availableColorProfiles", available_color_profiles);
js_displays.Append(js_display);
}
void DisplayOptionsHandler::OnFadeOutForMirroringFinished(bool is_mirroring) {
ash::Shell::GetInstance()->display_manager()->SetMirrorMode(is_mirroring);
- // Not necessary to start fade-in animation. OutputConfigurator will do that.
+ // Not necessary to start fade-in animation. DisplayConfigurator will do that.
}
void DisplayOptionsHandler::OnFadeOutForDisplayLayoutFinished(
int position, int offset) {
SetCurrentDisplayLayout(
ash::DisplayLayout::FromInts(position, offset));
- ash::Shell::GetInstance()->output_configurator_animation()->
+ ash::Shell::GetInstance()->display_configurator_animation()->
StartFadeInAnimation();
}
void DisplayOptionsHandler::HandleMirroring(const base::ListValue* args) {
DCHECK(!args->empty());
+ content::RecordAction(
+ base::UserMetricsAction("Options_DisplayToggleMirroring"));
bool is_mirroring = false;
args->GetBoolean(0, &is_mirroring);
- ash::Shell::GetInstance()->output_configurator_animation()->
+ ash::Shell::GetInstance()->display_configurator_animation()->
StartFadeOutAnimation(base::Bind(
&DisplayOptionsHandler::OnFadeOutForMirroringFinished,
base::Unretained(this),
if (display_id == gfx::Display::kInvalidDisplayID)
return;
+ content::RecordAction(base::UserMetricsAction("Options_DisplaySetPrimary"));
ash::Shell::GetInstance()->display_controller()->
SetPrimaryDisplayId(display_id);
}
}
DCHECK_LE(ash::DisplayLayout::TOP, layout);
DCHECK_GE(ash::DisplayLayout::LEFT, layout);
- ash::Shell::GetInstance()->output_configurator_animation()->
+ content::RecordAction(base::UserMetricsAction("Options_DisplayRearrange"));
+ ash::Shell::GetInstance()->display_configurator_animation()->
StartFadeOutAnimation(base::Bind(
&DisplayOptionsHandler::OnFadeOutForDisplayLayoutFinished,
base::Unretained(this),
static_cast<int>(offset)));
}
-void DisplayOptionsHandler::HandleSetUIScale(const base::ListValue* args) {
+void DisplayOptionsHandler::HandleSetDisplayMode(const base::ListValue* args) {
DCHECK(!args->empty());
int64 display_id = GetDisplayId(args);
if (display_id == gfx::Display::kInvalidDisplayID)
return;
- double ui_scale = 0.0f;
- if (!args->GetDouble(1, &ui_scale) || ui_scale == 0.0f) {
- LOG(ERROR) << "Can't find new ui_scale";
+ const base::DictionaryValue* mode_data = NULL;
+ if (!args->GetDictionary(1, &mode_data)) {
+ LOG(ERROR) << "Failed to get mode data";
return;
}
- GetDisplayManager()->SetDisplayUIScale(display_id, ui_scale);
-}
-
-void DisplayOptionsHandler::HandleSetResolution(const base::ListValue* args) {
- DCHECK(!args->empty());
- int64 display_id = GetDisplayId(args);
- if (display_id == gfx::Display::kInvalidDisplayID)
+ ash::DisplayMode mode;
+ if (!ConvertValueToDisplayMode(mode_data, &mode))
return;
- double width = 0.0f;
- double height = 0.0f;
- if (!args->GetDouble(1, &width) || width == 0.0f) {
- LOG(ERROR) << "Can't find new width";
- return;
- }
- if (!args->GetDouble(2, &height) || height == 0.0f) {
- LOG(ERROR) << "Can't find new height";
- return;
- }
-
- const ash::internal::DisplayInfo& display_info =
- GetDisplayManager()->GetDisplayInfo(display_id);
- gfx::Insets current_overscan = display_info.GetOverscanInsetsInPixel();
- gfx::Size new_resolution = gfx::ToFlooredSize(gfx::SizeF(width, height));
- new_resolution.Enlarge(current_overscan.width(), current_overscan.height());
- gfx::Size old_resolution = display_info.bounds_in_native().size();
- bool has_new_resolution = false;
- bool has_old_resolution = false;
- for (size_t i = 0; i < display_info.display_modes().size(); ++i) {
- ash::internal::DisplayMode display_mode = display_info.display_modes()[i];
- if (display_mode.size == new_resolution)
- has_new_resolution = true;
- if (display_mode.size == old_resolution)
- has_old_resolution = true;
- }
- if (!has_new_resolution) {
- LOG(ERROR) << "No new resolution " << new_resolution.ToString()
- << " is found in the display info " << display_info.ToString();
- return;
- }
- if (!has_old_resolution) {
- LOG(ERROR) << "No old resolution " << old_resolution.ToString()
- << " is found in the display info " << display_info.ToString();
- return;
+ content::RecordAction(
+ base::UserMetricsAction("Options_DisplaySetResolution"));
+ ash::DisplayManager* display_manager = GetDisplayManager();
+ ash::DisplayMode current_mode =
+ display_manager->GetActiveModeForDisplayId(display_id);
+ if (display_manager->SetDisplayMode(display_id, mode)) {
+ ash::Shell::GetInstance()->resolution_notification_controller()->
+ PrepareNotification(
+ display_id, current_mode, mode, base::Bind(&StoreDisplayPrefs));
}
-
- ash::Shell::GetInstance()->resolution_notification_controller()->
- SetDisplayResolutionAndNotify(
- display_id, old_resolution, new_resolution,
- base::Bind(&StoreDisplayPrefs));
}
void DisplayOptionsHandler::HandleSetOrientation(const base::ListValue* args) {
else if (rotation_value != "0")
LOG(ERROR) << "Invalid rotation: " << rotation_value << " Falls back to 0";
+ content::RecordAction(
+ base::UserMetricsAction("Options_DisplaySetOrientation"));
GetDisplayManager()->SetDisplayRotation(display_id, new_rotation);
}
+void DisplayOptionsHandler::HandleSetColorProfile(const base::ListValue* args) {
+ DCHECK(!args->empty());
+ int64 display_id = GetDisplayId(args);
+ if (display_id == gfx::Display::kInvalidDisplayID)
+ return;
+
+ std::string profile_value;
+ if (!args->GetString(1, &profile_value)) {
+ LOG(ERROR) << "Invalid profile_value";
+ return;
+ }
+
+ int profile_id;
+ if (!base::StringToInt(profile_value, &profile_id)) {
+ LOG(ERROR) << "Invalid profile: " << profile_value;
+ return;
+ }
+
+ if (profile_id < ui::COLOR_PROFILE_STANDARD ||
+ profile_id > ui::COLOR_PROFILE_READING) {
+ LOG(ERROR) << "Invalid profile_id: " << profile_id;
+ return;
+ }
+
+ GetDisplayManager()->SetColorCalibrationProfile(
+ display_id, static_cast<ui::ColorCalibrationProfile>(profile_id));
+ SendAllDisplayInfo();
+}
+
} // namespace options
} // namespace chromeos
projects / platform / framework / web / crosswalk.git / blobdiff