Home | History | Annotate | Download | only in test 
      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/aura/test/test_screen.h"
      6 
      7 #include "base/logging.h"
      8 #include "ui/aura/env.h"
      9 #include "ui/aura/window.h"
     10 #include "ui/aura/window_event_dispatcher.h"
     11 #include "ui/aura/window_tree_host.h"
     12 #include "ui/gfx/geometry/size_conversions.h"
     13 #include "ui/gfx/native_widget_types.h"
     14 #include "ui/gfx/rect_conversions.h"
     15 #include "ui/gfx/screen.h"
     16 
     17 namespace aura {
     18 
     19 // static
     20 TestScreen* TestScreen::Create(const gfx::Size& size) {
     21   const gfx::Size kDefaultSize(800, 600);
     22   // Use (0,0) because the desktop aura tests are executed in
     23   // native environment where the display's origin is (0,0).
     24   return new TestScreen(gfx::Rect(size.IsEmpty() ? kDefaultSize : size));
     25 }
     26 
     27 // static
     28 TestScreen* TestScreen::CreateFullscreen() {
     29   return new TestScreen(gfx::Rect(WindowTreeHost::GetNativeScreenSize()));
     30 }
     31 
     32 TestScreen::~TestScreen() {
     33 }
     34 
     35 WindowTreeHost* TestScreen::CreateHostForPrimaryDisplay() {
     36   DCHECK(!host_);
     37   host_ = WindowTreeHost::Create(gfx::Rect(display_.GetSizeInPixel()));
     38   host_->window()->AddObserver(this);
     39   host_->InitHost();
     40   return host_;
     41 }
     42 
     43 void TestScreen::SetDeviceScaleFactor(float device_scale_factor) {
     44   gfx::Rect bounds_in_pixel(display_.GetSizeInPixel());
     45   display_.SetScaleAndBounds(device_scale_factor, bounds_in_pixel);
     46   host_->OnHostResized(bounds_in_pixel.size());
     47 }
     48 
     49 void TestScreen::SetDisplayRotation(gfx::Display::Rotation rotation) {
     50   display_.set_rotation(rotation);
     51   // TODO(oshima|mukai): Update the display_ as well.
     52   host_->SetRootTransform(GetRotationTransform() * GetUIScaleTransform());
     53 }
     54 
     55 void TestScreen::SetUIScale(float ui_scale) {
     56   ui_scale_ = ui_scale;
     57   gfx::Rect bounds_in_pixel(display_.GetSizeInPixel());
     58   gfx::Rect new_bounds = gfx::ToNearestRect(
     59       gfx::ScaleRect(bounds_in_pixel, 1.0f / ui_scale));
     60   display_.SetScaleAndBounds(display_.device_scale_factor(), new_bounds);
     61   host_->SetRootTransform(GetRotationTransform() * GetUIScaleTransform());
     62 }
     63 
     64 gfx::Transform TestScreen::GetRotationTransform() const {
     65   gfx::Transform rotate;
     66   float one_pixel = 1.0f / display_.device_scale_factor();
     67   switch (display_.rotation()) {
     68     case gfx::Display::ROTATE_0:
     69       break;
     70     case gfx::Display::ROTATE_90:
     71       rotate.Translate(display_.bounds().height() - one_pixel, 0);
     72       rotate.Rotate(90);
     73       break;
     74     case gfx::Display::ROTATE_270:
     75       rotate.Translate(0, display_.bounds().width() - one_pixel);
     76       rotate.Rotate(270);
     77       break;
     78     case gfx::Display::ROTATE_180:
     79       rotate.Translate(display_.bounds().width() - one_pixel,
     80                        display_.bounds().height() - one_pixel);
     81       rotate.Rotate(180);
     82       break;
     83   }
     84 
     85   return rotate;
     86 }
     87 
     88 gfx::Transform TestScreen::GetUIScaleTransform() const {
     89   gfx::Transform ui_scale;
     90   ui_scale.Scale(1.0f / ui_scale_, 1.0f / ui_scale_);
     91   return ui_scale;
     92 }
     93 
     94 bool TestScreen::IsDIPEnabled() {
     95   return true;
     96 }
     97 
     98 void TestScreen::OnWindowBoundsChanged(
     99     Window* window, const gfx::Rect& old_bounds, const gfx::Rect& new_bounds) {
    100   DCHECK_EQ(host_->window(), window);
    101   display_.SetSize(gfx::ToFlooredSize(
    102       gfx::ScaleSize(new_bounds.size(), display_.device_scale_factor())));
    103 }
    104 
    105 void TestScreen::OnWindowDestroying(Window* window) {
    106   if (host_->window() == window)
    107     host_ = NULL;
    108 }
    109 
    110 gfx::Point TestScreen::GetCursorScreenPoint() {
    111   return Env::GetInstance()->last_mouse_location();
    112 }
    113 
    114 gfx::NativeWindow TestScreen::GetWindowUnderCursor() {
    115   return GetWindowAtScreenPoint(GetCursorScreenPoint());
    116 }
    117 
    118 gfx::NativeWindow TestScreen::GetWindowAtScreenPoint(const gfx::Point& point) {
    119   return host_->window()->GetTopWindowContainingPoint(point);
    120 }
    121 
    122 int TestScreen::GetNumDisplays() const {
    123   return 1;
    124 }
    125 
    126 std::vector<gfx::Display> TestScreen::GetAllDisplays() const {
    127   return std::vector<gfx::Display>(1, display_);
    128 }
    129 
    130 gfx::Display TestScreen::GetDisplayNearestWindow(
    131     gfx::NativeWindow window) const {
    132   return display_;
    133 }
    134 
    135 gfx::Display TestScreen::GetDisplayNearestPoint(const gfx::Point& point) const {
    136   return display_;
    137 }
    138 
    139 gfx::Display TestScreen::GetDisplayMatching(const gfx::Rect& match_rect) const {
    140   return display_;
    141 }
    142 
    143 gfx::Display TestScreen::GetPrimaryDisplay() const {
    144   return display_;
    145 }
    146 
    147 void TestScreen::AddObserver(gfx::DisplayObserver* observer) {
    148 }
    149 
    150 void TestScreen::RemoveObserver(gfx::DisplayObserver* observer) {
    151 }
    152 
    153 TestScreen::TestScreen(const gfx::Rect& screen_bounds)
    154     : host_(NULL),
    155       ui_scale_(1.0f) {
    156   static int64 synthesized_display_id = 2000;
    157   display_.set_id(synthesized_display_id++);
    158   display_.SetScaleAndBounds(1.0f, screen_bounds);
    159 }
    160 
    161 }  // namespace aura
    162