Home | History | Annotate | Download | only in touch 
      1 // Copyright 2014 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/touch/touch_transformer_controller.h"
      6 
      7 #include "ash/display/display_controller.h"
      8 #include "ash/display/display_manager.h"
      9 #include "ash/host/ash_window_tree_host.h"
     10 #include "ash/root_window_controller.h"
     11 #include "ash/shell.h"
     12 #include "ui/aura/window_tree_host.h"
     13 #include "ui/display/chromeos/display_configurator.h"
     14 #include "ui/display/types/display_snapshot.h"
     15 #include "ui/events/device_data_manager.h"
     16 #include "ui/events/x/device_data_manager_x11.h"
     17 
     18 namespace ash {
     19 
     20 namespace {
     21 
     22 DisplayManager* GetDisplayManager() {
     23   return Shell::GetInstance()->display_manager();
     24 }
     25 
     26 }  // namespace
     27 
     28 // This is to compute the scale ratio for the TouchEvent's radius. The
     29 // configured resolution of the display is not always the same as the touch
     30 // screen's reporting resolution, e.g. the display could be set as
     31 // 1920x1080 while the touchscreen is reporting touch position range at
     32 // 32767x32767. Touch radius is reported in the units the same as touch position
     33 // so we need to scale the touch radius to be compatible with the display's
     34 // resolution. We compute the scale as
     35 // sqrt of (display_area / touchscreen_area)
     36 double TouchTransformerController::GetTouchResolutionScale(
     37     const DisplayInfo& touch_display) const {
     38   if (touch_display.touch_device_id() == 0)
     39     return 1.0;
     40 
     41   double min_x, max_x;
     42   double min_y, max_y;
     43   if (!ui::DeviceDataManagerX11::GetInstance()->GetDataRange(
     44           touch_display.touch_device_id(),
     45           ui::DeviceDataManagerX11::DT_TOUCH_POSITION_X,
     46           &min_x, &max_x) ||
     47       !ui::DeviceDataManagerX11::GetInstance()->GetDataRange(
     48           touch_display.touch_device_id(),
     49           ui::DeviceDataManagerX11::DT_TOUCH_POSITION_Y,
     50           &min_y, &max_y)) {
     51     return 1.0;
     52   }
     53 
     54   double width = touch_display.bounds_in_native().width();
     55   double height = touch_display.bounds_in_native().height();
     56 
     57   if (max_x == 0.0 || max_y == 0.0 || width == 0.0 || height == 0.0)
     58     return 1.0;
     59 
     60   // [0, max_x] -> touchscreen width = max_x + 1
     61   // [0, max_y] -> touchscreen height = max_y + 1
     62   max_x += 1.0;
     63   max_y += 1.0;
     64 
     65   double ratio = std::sqrt((width * height) / (max_x * max_y));
     66 
     67   VLOG(2) << "Screen width/height: " << width << "/" << height
     68           << ", Touchscreen width/height: " << max_x << "/" << max_y
     69           << ", Touch radius scale ratio: " << ratio;
     70   return ratio;
     71 }
     72 
     73 // This function computes the extended mode TouchTransformer for
     74 // |touch_display|. The TouchTransformer maps the touch event position
     75 // from framebuffer size to the display size.
     76 gfx::Transform
     77 TouchTransformerController::GetExtendedModeTouchTransformer(
     78     const DisplayInfo& touch_display, const gfx::Size& fb_size) const {
     79   gfx::Transform ctm;
     80   if (touch_display.touch_device_id() == 0 ||
     81       fb_size.width() == 0.0 ||
     82       fb_size.height() == 0.0)
     83     return ctm;
     84   float width = touch_display.bounds_in_native().width();
     85   float height = touch_display.bounds_in_native().height();
     86   ctm.Scale(width / fb_size.width(), height / fb_size.height());
     87   return ctm;
     88 }
     89 
     90 bool TouchTransformerController::ShouldComputeMirrorModeTouchTransformer(
     91     const DisplayInfo& touch_display) const {
     92   if (force_compute_mirror_mode_touch_transformer_)
     93     return true;
     94 
     95   if (touch_display.touch_device_id() == 0)
     96     return false;
     97 
     98   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
     99   const std::vector<gfx::Display>& displays = display_manager->displays();
    100   const DisplayInfo* info = NULL;
    101   for (size_t i = 0; i < displays.size(); i++) {
    102     const DisplayInfo& current_info =
    103         display_manager->GetDisplayInfo(displays[i].id());
    104     if (current_info.touch_device_id() == touch_display.touch_device_id()) {
    105       info = &current_info;
    106       break;
    107     }
    108   }
    109 
    110   if (!info || info->size_in_pixel() == info->GetNativeModeSize() ||
    111       !info->is_aspect_preserving_scaling()) {
    112     return false;
    113   }
    114   return true;
    115 }
    116 
    117 // This function computes the mirror mode TouchTransformer for |touch_display|.
    118 // When internal monitor is applied a resolution that does not have
    119 // the same aspect ratio as its native resolution, there would be
    120 // blank regions in the letterboxing/pillarboxing mode.
    121 // The TouchTransformer will make sure the touch events on the blank region
    122 // have negative coordinates and touch events within the chrome region
    123 // have the correct positive coordinates.
    124 gfx::Transform TouchTransformerController::GetMirrorModeTouchTransformer(
    125     const DisplayInfo& touch_display) const {
    126   gfx::Transform ctm;
    127   if (!ShouldComputeMirrorModeTouchTransformer(touch_display))
    128     return ctm;
    129 
    130   float mirror_width = touch_display.bounds_in_native().width();
    131   float mirror_height = touch_display.bounds_in_native().height();
    132   float native_width = 0;
    133   float native_height = 0;
    134 
    135   std::vector<DisplayMode> modes = touch_display.display_modes();
    136   for (size_t i = 0; i < modes.size(); i++) {
    137        if (modes[i].native) {
    138          native_width = modes[i].size.width();
    139          native_height = modes[i].size.height();
    140          break;
    141        }
    142   }
    143 
    144   if (native_height == 0.0 || mirror_height == 0.0 ||
    145       native_width == 0.0 || mirror_width == 0.0)
    146     return ctm;
    147 
    148   float native_ar = static_cast<float>(native_width) /
    149       static_cast<float>(native_height);
    150   float mirror_ar = static_cast<float>(mirror_width) /
    151       static_cast<float>(mirror_height);
    152 
    153   if (mirror_ar > native_ar) {  // Letterboxing
    154     // Translate before scale.
    155     ctm.Translate(0.0, (1.0 - mirror_ar / native_ar) * 0.5 * mirror_height);
    156     ctm.Scale(1.0, mirror_ar / native_ar);
    157     return ctm;
    158   }
    159 
    160   if (native_ar > mirror_ar) {  // Pillarboxing
    161     // Translate before scale.
    162     ctm.Translate((1.0 - native_ar / mirror_ar) * 0.5 * mirror_width, 0.0);
    163     ctm.Scale(native_ar / mirror_ar, 1.0);
    164     return ctm;
    165   }
    166 
    167   return ctm;  // Same aspect ratio - return identity
    168 }
    169 
    170 TouchTransformerController::TouchTransformerController() :
    171     force_compute_mirror_mode_touch_transformer_ (false) {
    172   Shell::GetInstance()->display_controller()->AddObserver(this);
    173 }
    174 
    175 TouchTransformerController::~TouchTransformerController() {
    176   Shell::GetInstance()->display_controller()->RemoveObserver(this);
    177 }
    178 
    179 void TouchTransformerController::UpdateTouchTransformer() const {
    180   ui::DeviceDataManager* device_manager = ui::DeviceDataManager::GetInstance();
    181   device_manager->ClearTouchTransformerRecord();
    182 
    183   // Display IDs and DisplayInfo for mirror or extended mode.
    184   int64 display1_id = gfx::Display::kInvalidDisplayID;
    185   int64 display2_id = gfx::Display::kInvalidDisplayID;
    186   DisplayInfo display1;
    187   DisplayInfo display2;
    188   // Display ID and DisplayInfo for single display mode.
    189   int64 single_display_id = gfx::Display::kInvalidDisplayID;
    190   DisplayInfo single_display;
    191 
    192   DisplayController* display_controller =
    193       Shell::GetInstance()->display_controller();
    194   ui::MultipleDisplayState display_state =
    195       Shell::GetInstance()->display_configurator()->display_state();
    196   if (display_state == ui::MULTIPLE_DISPLAY_STATE_INVALID ||
    197       display_state == ui::MULTIPLE_DISPLAY_STATE_HEADLESS) {
    198     return;
    199   } else if (display_state == ui::MULTIPLE_DISPLAY_STATE_DUAL_MIRROR ||
    200              display_state == ui::MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED) {
    201     DisplayIdPair id_pair = GetDisplayManager()->GetCurrentDisplayIdPair();
    202     display1_id = id_pair.first;
    203     display2_id = id_pair.second;
    204     DCHECK(display1_id != gfx::Display::kInvalidDisplayID &&
    205            display2_id != gfx::Display::kInvalidDisplayID);
    206     display1 = GetDisplayManager()->GetDisplayInfo(display1_id);
    207     display2 = GetDisplayManager()->GetDisplayInfo(display2_id);
    208     device_manager->UpdateTouchRadiusScale(display1.touch_device_id(),
    209                                            GetTouchResolutionScale(display1));
    210     device_manager->UpdateTouchRadiusScale(display2.touch_device_id(),
    211                                            GetTouchResolutionScale(display2));
    212   } else {
    213     single_display_id = GetDisplayManager()->first_display_id();
    214     DCHECK(single_display_id != gfx::Display::kInvalidDisplayID);
    215     single_display = GetDisplayManager()->GetDisplayInfo(single_display_id);
    216     device_manager->UpdateTouchRadiusScale(
    217         single_display.touch_device_id(),
    218         GetTouchResolutionScale(single_display));
    219   }
    220 
    221   if (display_state == ui::MULTIPLE_DISPLAY_STATE_DUAL_MIRROR) {
    222     // In mirror mode, both displays share the same root window so
    223     // both display ids are associated with the root window.
    224     aura::Window* root = display_controller->GetPrimaryRootWindow();
    225     RootWindowController::ForWindow(root)->ash_host()->UpdateDisplayID(
    226         display1_id, display2_id);
    227     device_manager->UpdateTouchInfoForDisplay(
    228         display1_id,
    229         display1.touch_device_id(),
    230         GetMirrorModeTouchTransformer(display1));
    231     device_manager->UpdateTouchInfoForDisplay(
    232         display2_id,
    233         display2.touch_device_id(),
    234         GetMirrorModeTouchTransformer(display2));
    235     return;
    236   }
    237 
    238   if (display_state == ui::MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED) {
    239     gfx::Size fb_size =
    240         Shell::GetInstance()->display_configurator()->framebuffer_size();
    241     // In extended but software mirroring mode, ther is only one X root window
    242     // that associates with both displays.
    243     if (GetDisplayManager()->software_mirroring_enabled())  {
    244       aura::Window* root = display_controller->GetPrimaryRootWindow();
    245       RootWindowController::ForWindow(root)->ash_host()->UpdateDisplayID(
    246           display1_id, display2_id);
    247       DisplayInfo source_display =
    248           gfx::Display::InternalDisplayId() == display1_id ?
    249           display1 : display2;
    250       // Mapping from framebuffer size to the source display's native
    251       // resolution.
    252       device_manager->UpdateTouchInfoForDisplay(
    253           display1_id,
    254           display1.touch_device_id(),
    255           GetExtendedModeTouchTransformer(source_display, fb_size));
    256       device_manager->UpdateTouchInfoForDisplay(
    257           display2_id,
    258           display2.touch_device_id(),
    259           GetExtendedModeTouchTransformer(source_display, fb_size));
    260     } else {
    261       // In actual extended mode, each display is associated with one root
    262       // window.
    263       aura::Window* root1 =
    264           display_controller->GetRootWindowForDisplayId(display1_id);
    265       aura::Window* root2 =
    266           display_controller->GetRootWindowForDisplayId(display2_id);
    267       RootWindowController::ForWindow(root1)->ash_host()->UpdateDisplayID(
    268           display1_id, gfx::Display::kInvalidDisplayID);
    269       RootWindowController::ForWindow(root2)->ash_host()->UpdateDisplayID(
    270           display2_id, gfx::Display::kInvalidDisplayID);
    271       // Mapping from framebuffer size to each display's native resolution.
    272       device_manager->UpdateTouchInfoForDisplay(
    273           display1_id,
    274           display1.touch_device_id(),
    275           GetExtendedModeTouchTransformer(display1, fb_size));
    276       device_manager->UpdateTouchInfoForDisplay(
    277           display2_id,
    278           display2.touch_device_id(),
    279           GetExtendedModeTouchTransformer(display2, fb_size));
    280     }
    281     return;
    282   }
    283 
    284   // Single display mode. The root window has one associated display id.
    285   aura::Window* root =
    286       display_controller->GetRootWindowForDisplayId(single_display.id());
    287   RootWindowController::ForWindow(root)->ash_host()->UpdateDisplayID(
    288       single_display.id(), gfx::Display::kInvalidDisplayID);
    289   device_manager->UpdateTouchInfoForDisplay(single_display_id,
    290                                             single_display.touch_device_id(),
    291                                             gfx::Transform());
    292 }
    293 
    294 void TouchTransformerController::OnDisplaysInitialized() {
    295   UpdateTouchTransformer();
    296 }
    297 
    298 void TouchTransformerController::OnDisplayConfigurationChanged() {
    299   UpdateTouchTransformer();
    300 }
    301 
    302 }  // namespace ash
    303