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_util.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 379 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_(0),
+      right_(0),
+      top_(0),
+      bottom_(0) {
+  std::vector<std::string> parts;
+  if (Tokenize(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+      switches::kTouchCalibration), ",", &parts) >= 4) {
+    if (!base::StringToInt(parts[0], &left_))
+      DLOG(ERROR) << "Incorrect left border calibration value passed.";
+    if (!base::StringToInt(parts[1], &right_))
+      DLOG(ERROR) << "Incorrect right border calibration value passed.";
+    if (!base::StringToInt(parts[2], &top_))
+      DLOG(ERROR) << "Incorrect top border calibration value passed.";
+    if (!base::StringToInt(parts[3], &bottom_))
+      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_ && !right_ && !top_ && !bottom_)
+    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_ || right_) {
+    // Offset the x position to the real
+    x -= left_;
+    // 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_ * 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_ &&
+        x < resolution_x - left_ + right_ * kGraceAreaFraction)
+      x = resolution_x - left_;
+    // Scale the screen area back to the full resolution of the screen.
+    x = (x * resolution_x) / (resolution_x - (right_ + left_));
+  }
+  if (top_ || bottom_) {
+    // When there is a top bezel we add our border,
+    y -= top_;
+
+    // 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_ * 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_ &&
+        y < resolution_y - top_ + bottom_ * kGraceAreaFraction)
+      y = resolution_y - top_;
+    // Scale the screen area back to the full resolution of the screen.
+    y = (y * resolution_y) / (resolution_y - (bottom_ + top_));
+  }
+
+  // Set the modified coordinate back to the event.
+  if (event->root_location() == event->location()) {
+    // Usually those will be equal,
+    // if not, I am not sure what the correct value should be.
+    event->set_root_location(gfx::Point(x, y));
+  }
+  event->set_location(gfx::Point(x, y));
+}
+#endif  // defined(USE_XI2_MT)
+
 ////////////////////////////////////////////////////////////////////////////////
 // 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  // defined(USE_XI2_MT)
+
 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 251 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