ui/base/layout.cc

   1 // Copyright (c) 2012 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 "ui/base/layout.h"
   6
   7 #include <algorithm>
   8 #include <cmath>
   9 #include <limits>
  10
  11 #include "base/basictypes.h"
  12 #include "base/command_line.h"
  13 #include "base/logging.h"
  14 #include "build/build_config.h"
  15 #include "ui/base/touch/touch_device.h"
  16 #include "ui/base/ui_base_switches.h"
  17 #include "ui/gfx/display.h"
  18 #include "ui/gfx/image/image_skia.h"
  19 #include "ui/gfx/screen.h"
  20
  21 #if defined(OS_WIN)
  22 #include "base/win/metro.h"
  23 #include <Windows.h>
  24 #endif  // defined(OS_WIN)
  25
  26 namespace ui {
  27
  28 namespace {
  29
  30 bool ScaleFactorComparator(const ScaleFactor& lhs, const ScaleFactor& rhs){
  31   return GetImageScale(lhs) < GetImageScale(rhs);
  32 }
  33
  34 std::vector<ScaleFactor>* g_supported_scale_factors = NULL;
  35
  36 #if defined(OS_WIN)
  37 // Helper function that determines whether we want to optimize the UI for touch.
  38 bool UseTouchOptimizedUI() {
  39   // If --touch-optimized-ui is specified and not set to "auto", then override
  40   // the hardware-determined setting (eg. for testing purposes).
  41   static bool has_touch_optimized_ui = CommandLine::ForCurrentProcess()->
  42       HasSwitch(switches::kTouchOptimizedUI);
  43   if (has_touch_optimized_ui) {
  44     const std::string switch_value = CommandLine::ForCurrentProcess()->
  45         GetSwitchValueASCII(switches::kTouchOptimizedUI);
  46
  47     // Note that simply specifying the switch is the same as enabled.
  48     if (switch_value.empty() ||
  49         switch_value == switches::kTouchOptimizedUIEnabled) {
  50       return true;
  51     } else if (switch_value == switches::kTouchOptimizedUIDisabled) {
  52       return false;
  53     } else if (switch_value != switches::kTouchOptimizedUIAuto) {
  54       LOG(ERROR) << "Invalid --touch-optimized-ui option: " << switch_value;
  55     }
  56   }
  57
  58   // We use the touch layout only when we are running in Metro mode.
  59   return base::win::IsMetroProcess() && ui::IsTouchDevicePresent();
  60 }
  61 #endif  // defined(OS_WIN)
  62
  63 const float kScaleFactorScales[] = {1.0f, 1.0f, 1.25f, 1.33f, 1.4f, 1.5f, 1.8f,
  64                                     2.0f, 3.0f};
  65 COMPILE_ASSERT(NUM_SCALE_FACTORS == arraysize(kScaleFactorScales),
  66                kScaleFactorScales_incorrect_size);
  67
  68 }  // namespace
  69
  70 DisplayLayout GetDisplayLayout() {
  71 #if defined(OS_WIN)
  72   if (UseTouchOptimizedUI())
  73     return LAYOUT_TOUCH;
  74 #endif
  75   return LAYOUT_DESKTOP;
  76 }
  77
  78 void SetSupportedScaleFactors(
  79     const std::vector<ui::ScaleFactor>& scale_factors) {
  80   if (g_supported_scale_factors != NULL)
  81     delete g_supported_scale_factors;
  82
  83   g_supported_scale_factors = new std::vector<ScaleFactor>(scale_factors);
  84   std::sort(g_supported_scale_factors->begin(),
  85             g_supported_scale_factors->end(),
  86             ScaleFactorComparator);
  87
  88   // Set ImageSkia's supported scales.
  89   std::vector<float> scales;
  90   for (std::vector<ScaleFactor>::const_iterator it =
  91           g_supported_scale_factors->begin();
  92        it != g_supported_scale_factors->end(); ++it) {
  93     scales.push_back(GetImageScale(*it));
  94   }
  95   gfx::ImageSkia::SetSupportedScales(scales);
  96 }
  97
  98 const std::vector<ScaleFactor>& GetSupportedScaleFactors() {
  99   DCHECK(g_supported_scale_factors != NULL);
 100   return *g_supported_scale_factors;
 101 }
 102
 103 ScaleFactor GetSupportedScaleFactor(float scale) {
 104   DCHECK(g_supported_scale_factors != NULL);
 105   ScaleFactor closest_match = SCALE_FACTOR_100P;
 106   float smallest_diff =  std::numeric_limits<float>::max();
 107   for (size_t i = 0; i < g_supported_scale_factors->size(); ++i) {
 108     ScaleFactor scale_factor = (*g_supported_scale_factors)[i];
 109     float diff = std::abs(kScaleFactorScales[scale_factor] - scale);
 110     if (diff < smallest_diff) {
 111       closest_match = scale_factor;
 112       smallest_diff = diff;
 113     }
 114   }
 115   DCHECK_NE(closest_match, SCALE_FACTOR_NONE);
 116   return closest_match;
 117 }
 118
 119 float GetImageScale(ScaleFactor scale_factor) {
 120   return kScaleFactorScales[scale_factor];
 121 }
 122
 123 bool IsScaleFactorSupported(ScaleFactor scale_factor) {
 124   DCHECK(g_supported_scale_factors != NULL);
 125   return std::find(g_supported_scale_factors->begin(),
 126                    g_supported_scale_factors->end(),
 127                    scale_factor) != g_supported_scale_factors->end();
 128 }
 129
 130 // Returns the scale factor closest to |scale| from the full list of factors.
 131 // Note that it does NOT rely on the list of supported scale factors.
 132 // Finding the closest match is inefficient and shouldn't be done frequently.
 133 ScaleFactor FindClosestScaleFactorUnsafe(float scale) {
 134   float smallest_diff =  std::numeric_limits<float>::max();
 135   ScaleFactor closest_match = SCALE_FACTOR_100P;
 136   for (int i = SCALE_FACTOR_100P; i < NUM_SCALE_FACTORS; ++i) {
 137     const ScaleFactor scale_factor = static_cast<ScaleFactor>(i);
 138     float diff = std::abs(kScaleFactorScales[scale_factor] - scale);
 139     if (diff < smallest_diff) {
 140       closest_match = scale_factor;
 141       smallest_diff = diff;
 142     }
 143   }
 144   return closest_match;
 145 }
 146
 147 namespace test {
 148
 149 ScopedSetSupportedScaleFactors::ScopedSetSupportedScaleFactors(
 150     const std::vector<ui::ScaleFactor>& new_scale_factors) {
 151   if (g_supported_scale_factors) {
 152     original_scale_factors_ =
 153         new std::vector<ScaleFactor>(*g_supported_scale_factors);
 154   } else {
 155     original_scale_factors_ = NULL;
 156   }
 157   SetSupportedScaleFactors(new_scale_factors);
 158 }
 159
 160 ScopedSetSupportedScaleFactors::~ScopedSetSupportedScaleFactors() {
 161   if (original_scale_factors_) {
 162     SetSupportedScaleFactors(*original_scale_factors_);
 163     delete original_scale_factors_;
 164   } else {
 165     delete g_supported_scale_factors;
 166     g_supported_scale_factors = NULL;
 167   }
 168 }
 169
 170 }  // namespace test
 171
 172 #if !defined(OS_MACOSX)
 173 ScaleFactor GetScaleFactorForNativeView(gfx::NativeView view) {
 174   gfx::Screen* screen = gfx::Screen::GetScreenFor(view);
 175   if (screen->IsDIPEnabled()) {
 176     gfx::Display display = screen->GetDisplayNearestWindow(view);
 177     return GetSupportedScaleFactor(display.device_scale_factor());
 178   }
 179   return ui::SCALE_FACTOR_100P;
 180 }
 181 #endif  // !defined(OS_MACOSX)
 182
 183 }  // namespace ui