diff options
Diffstat (limited to 'chromium/ui/gfx/display.cc')
-rw-r--r-- | chromium/ui/gfx/display.cc | 150 |
1 files changed, 150 insertions, 0 deletions
diff --git a/chromium/ui/gfx/display.cc b/chromium/ui/gfx/display.cc new file mode 100644 index 00000000000..02d97a903fc --- /dev/null +++ b/chromium/ui/gfx/display.cc @@ -0,0 +1,150 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "ui/gfx/display.h" + +#include "base/command_line.h" +#include "base/logging.h" +#include "base/strings/string_number_conversions.h" +#include "base/strings/stringprintf.h" +#include "ui/base/ui_base_switches.h" +#include "ui/gfx/insets.h" +#include "ui/gfx/point_conversions.h" +#include "ui/gfx/point_f.h" +#include "ui/gfx/size_conversions.h" + +namespace gfx { +namespace { + +bool HasForceDeviceScaleFactorImpl() { + return CommandLine::ForCurrentProcess()->HasSwitch( + switches::kForceDeviceScaleFactor); +} + +float GetForcedDeviceScaleFactorImpl() { + double scale_in_double = 1.0; + if (HasForceDeviceScaleFactorImpl()) { + std::string value = CommandLine::ForCurrentProcess()-> + GetSwitchValueASCII(switches::kForceDeviceScaleFactor); + if (!base::StringToDouble(value, &scale_in_double)) + LOG(ERROR) << "Failed to parse the default device scale factor:" << value; + } + return static_cast<float>(scale_in_double); +} + +const int64 kInvalidDisplayIDForCompileTimeInit = -1; +int64 internal_display_id_ = kInvalidDisplayIDForCompileTimeInit; + +} // namespace + +const int64 Display::kInvalidDisplayID = kInvalidDisplayIDForCompileTimeInit; + +// static +float Display::GetForcedDeviceScaleFactor() { + static const float kForcedDeviceScaleFactor = + GetForcedDeviceScaleFactorImpl(); + return kForcedDeviceScaleFactor; +} + +//static +bool Display::HasForceDeviceScaleFactor() { + return HasForceDeviceScaleFactorImpl(); +} + +Display::Display() + : id_(kInvalidDisplayID), + device_scale_factor_(GetForcedDeviceScaleFactor()), + rotation_(ROTATE_0) { +} + +Display::Display(int64 id) + : id_(id), + device_scale_factor_(GetForcedDeviceScaleFactor()), + rotation_(ROTATE_0) { +} + +Display::Display(int64 id, const gfx::Rect& bounds) + : id_(id), + bounds_(bounds), + work_area_(bounds), + device_scale_factor_(GetForcedDeviceScaleFactor()), + rotation_(ROTATE_0) { +#if defined(USE_AURA) + SetScaleAndBounds(device_scale_factor_, bounds); +#endif +} + +Display::~Display() { +} + +Insets Display::GetWorkAreaInsets() const { + return gfx::Insets(work_area_.y() - bounds_.y(), + work_area_.x() - bounds_.x(), + bounds_.bottom() - work_area_.bottom(), + bounds_.right() - work_area_.right()); +} + +void Display::SetScaleAndBounds( + float device_scale_factor, + const gfx::Rect& bounds_in_pixel) { + Insets insets = bounds_.InsetsFrom(work_area_); + if (!HasForceDeviceScaleFactor()) { +#if defined(OS_MACOSX) + // Unless an explicit scale factor was provided for testing, ensure the + // scale is integral. + device_scale_factor = static_cast<int>(device_scale_factor); +#endif + device_scale_factor_ = device_scale_factor; + } + device_scale_factor_ = std::max(1.0f, device_scale_factor_); + bounds_ = gfx::Rect( + gfx::ToFlooredPoint(gfx::ScalePoint(bounds_in_pixel.origin(), + 1.0f / device_scale_factor_)), + gfx::ToFlooredSize(gfx::ScaleSize(bounds_in_pixel.size(), + 1.0f / device_scale_factor_))); + UpdateWorkAreaFromInsets(insets); +} + +void Display::SetSize(const gfx::Size& size_in_pixel) { + gfx::Point origin = bounds_.origin(); +#if defined(USE_AURA) + gfx::PointF origin_f = origin; + origin_f.Scale(device_scale_factor_); + origin.SetPoint(origin_f.x(), origin_f.y()); +#endif + SetScaleAndBounds(device_scale_factor_, gfx::Rect(origin, size_in_pixel)); +} + +void Display::UpdateWorkAreaFromInsets(const gfx::Insets& insets) { + work_area_ = bounds_; + work_area_.Inset(insets); +} + +gfx::Size Display::GetSizeInPixel() const { + return gfx::ToFlooredSize(gfx::ScaleSize(size(), device_scale_factor_)); +} + +std::string Display::ToString() const { + return base::StringPrintf( + "Display[%lld] bounds=%s, workarea=%s, scale=%f, %s", + static_cast<long long int>(id_), + bounds_.ToString().c_str(), + work_area_.ToString().c_str(), + device_scale_factor_, + IsInternal() ? "internal" : "external"); +} + +bool Display::IsInternal() const { + return is_valid() && (id_ == internal_display_id_); +} + +int64 Display::InternalDisplayId() { + return internal_display_id_; +} + +void Display::SetInternalDisplayId(int64 internal_display_id) { + internal_display_id_ = internal_display_id; +} + +} // namespace gfx |