Disable touch calibration on external touchscreen.

ui/base/events/event.cc

 // 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/base/events/event.h"
 
 #if defined(USE_X11)
 #include <X11/Xlib.h>
 #endif
 
 #include <cmath>
 #include <cstring>
 
+#include "base/command_line.h"
 #include "base/metrics/histogram.h"
+#include "base/string_number_conversions.h"
+#include "base/string_split.h"
 #include "base/stringprintf.h"
 #include "ui/base/events/event_utils.h"
 #include "ui/base/keycodes/keyboard_code_conversion.h"
+#include "ui/base/ui_base_switches.h"
 #include "ui/gfx/point3_f.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/transform_util.h"
 
 #if defined(USE_X11)
 #include "ui/base/keycodes/keyboard_code_conversion_x.h"
 #endif
 
 namespace {
@@ skipping 371 matching lines @@
 
 #if defined(OS_WIN)
 // This value matches windows WHEEL_DELTA.
 // static
 const int MouseWheelEvent::kWheelDelta = 120;
 #else
 // This value matches GTK+ wheel scroll amount.
 const int MouseWheelEvent::kWheelDelta = 53;
 #endif
 
+#if defined(USE_XI2_MT)
+////////////////////////////////////////////////////////////////////////////////
+// TouchCoordinatesCalibrator
+
+TouchCoordinatesCalibrator::TouchCoordinatesCalibrator()
+    : left_border_touch_calibration(0),
+      right_border_touch_calibration(0),
+      top_border_touch_calibration(0),
+      bottom_border_touch_calibration(0) {
+  std::vector<std::string> parts;
+  base::SplitString(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+      switches::kTouchCalibration), ',', &parts);
+  if (parts.size() >= 4) {
+    if (!base::StringToInt(parts[0], &left_border_touch_calibration))
+      DLOG(ERROR) << "Incorrect left border calibration value passed.";
+    if (!base::StringToInt(parts[1], &right_border_touch_calibration))
+      DLOG(ERROR) << "Incorrect right border calibration value passed.";
+    if (!base::StringToInt(parts[2], &top_border_touch_calibration))
+      DLOG(ERROR) << "Incorrect top border calibration value passed.";
+    if (!base::StringToInt(parts[3], &bottom_border_touch_calibration))
+      DLOG(ERROR) << "Incorrect bottom border calibration value passed.";
+  }
+}
+
+TouchCoordinatesCalibrator* TouchCoordinatesCalibrator::GetInstance() {
+  return Singleton<TouchCoordinatesCalibrator>::get();
+}
+
+void TouchCoordinatesCalibrator::Calibrate(TouchEvent& event,
+                                           const gfx::Rect& bounds) {
+  int x = event.x();
+  int y = event.y();
+
+  if (!left_border_touch_calibration && !right_border_touch_calibration &&
+      !top_border_touch_calibration && !bottom_border_touch_calibration)
+    return;
+
+  const int resolution_x = bounds.width();
+  const int resolution_y = bounds.height();
+  // The "grace area" (10% in this case) is to make it easier for the user to
+  // navigate to the corner.
+  const double kGraceAreaFraction = 0.1;
+  if (left_border_touch_calibration || right_border_touch_calibration) {
+    // Offset the x position to the real
+    x -= left_border_touch_calibration;
+    // Check if we are in the grace area of the left side.
+    // Note: We might not want to do this when the gesture is locked?
+    if (x < 0 && x > -left_border_touch_calibration * kGraceAreaFraction)
+      x = 0;
+    // Check if we are in the grace area of the right side.
+    // Note: We might not want to do this when the gesture is locked?
+    if (x > resolution_x - left_border_touch_calibration &&
+        x < resolution_x - left_border_touch_calibration +
+            right_border_touch_calibration * kGraceAreaFraction)
+      x = resolution_x - left_border_touch_calibration;
+    // Scale the screen area back to the full resolution of the screen.
+    x = (x * resolution_x) / (resolution_x - (right_border_touch_calibration +
+                                              left_border_touch_calibration));
+  }
+  if (top_border_touch_calibration || bottom_border_touch_calibration) {
+    // When there is a top bezel we add our border,
+    y -= top_border_touch_calibration;
+
+    // Check if we are in the grace area of the top side.
+    // Note: We might not want to do this when the gesture is locked?
+    if (y < 0 && y > -top_border_touch_calibration * kGraceAreaFraction)
+      y = 0;
+
+    // Check if we are in the grace area of the bottom side.
+    // Note: We might not want to do this when the gesture is locked?
+    if (y > resolution_y - top_border_touch_calibration &&
+        y < resolution_y - top_border_touch_calibration +
+        bottom_border_touch_calibration * kGraceAreaFraction)
+      y = resolution_y - top_border_touch_calibration;
+    // Scale the screen area back to the full resolution of the screen.
+    y = (y * resolution_y) / (resolution_y - (bottom_border_touch_calibration +
+                                              top_border_touch_calibration));
+  }
+  // Set the modified coordinate back to the event.
+  if (event.root_location() == event.location())
+    event.set_root_location(gfx::Point(x, y));
+  event.set_location(gfx::Point(x, y));
+}
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////
 // TouchEvent
 
 TouchEvent::TouchEvent(const base::NativeEvent& native_event)
     : LocatedEvent(native_event),
       touch_id_(GetTouchId(native_event)),
       radius_x_(GetTouchRadiusX(native_event)),
       radius_y_(GetTouchRadiusY(native_event)),
       rotation_angle_(GetTouchAngle(native_event)),
       force_(GetTouchForce(native_event)) {
@@ skipping 29 matching lines @@
 }
 
 TouchEvent::~TouchEvent() {
 }
 
 void TouchEvent::Relocate(const gfx::Point& origin) {
   location_ -= origin.OffsetFromOrigin();
   root_location_ -= origin.OffsetFromOrigin();
 }
 
+#if defined(USE_XI2_MT)
+void TouchEvent::Calibrate(const gfx::Rect& bounds) {
+  TouchCoordinatesCalibrator::GetInstance()->Calibrate(*this, bounds);
+}
+#endif
+
 void TouchEvent::UpdateForRootTransform(const gfx::Transform& root_transform) {
   LocatedEvent::UpdateForRootTransform(root_transform);
   gfx::DecomposedTransform decomp;
   bool success = gfx::DecomposeTransform(&decomp, root_transform);
   DCHECK(success);
   if (decomp.scale[0])
     radius_x_ /= decomp.scale[0];
   if (decomp.scale[1])
     radius_y_ /= decomp.scale[1];
 }
@@ skipping 215 matching lines @@
 int GestureEvent::GetLowestTouchId() const {
   if (touch_ids_bitfield_ == 0)
     return -1;
   int i = -1;
   // Find the index of the least significant 1 bit
   while (!(1 << ++i & touch_ids_bitfield_));
   return i;
 }
 
 }  // namespace ui