Calibrating touch input

ui/base/x/events_x.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.h"
 
 #include <X11/Xlib.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 #include <string.h>
 
+#include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_pump_x.h"
 #include "ui/base/keycodes/keyboard_code_conversion_x.h"
+#include "ui/base/ui_base_switches.h"
 #include "ui/base/touch/touch_factory.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/point.h"
+#include "ui/gfx/monitor.h"
+#include "ui/gfx/rect.h"
+#include "ui/gfx/screen.h"
 
 // Copied from xserver-properties.h
 #define AXIS_LABEL_PROP_REL_HWHEEL "Rel Horiz Wheel"
 #define AXIS_LABEL_PROP_REL_WHEEL "Rel Vert Wheel"
 
 // CMT specific timings
 #define AXIS_LABEL_PROP_ABS_START_TIME "Abs Start Timestamp"
 #define AXIS_LABEL_PROP_ABS_END_TIME "Abs End Timestamp"
 
 // Fling properties
@@ skipping 476 matching lines @@
   ui::TouchFactory::GetInstance()->ExtractTouchParam(*xev, tp, &default_value);
   return default_value;
 }
 
 Atom GetNoopEventAtom() {
   return XInternAtom(
       base::MessagePumpX::GetDefaultXDisplay(),
       "noop", False);
 }
 
+#if defined(USE_XI2_MT)
+gfx::Point CalibrateTouchCoordinates(
+    const XIDeviceEvent* xievent) {
+  int x = static_cast<int>(xievent->event_x);
+  int y = static_cast<int>(xievent->event_y);
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kDisableTouchCalibration))
+    return gfx::Point(x, y);
+  // TODO(skuhne): Find a new home for these hardware dependent touch
+  // constants.
+  // Note: These values have been found to be correct for the device I was
+  // testing with. I have the feeling that the DPI resolution of the bezel is
+  // less then the dpi resolution over the visible part - which would explain
+  // why the small value (50) is so wide compared to the entire area.
+  gfx::Rect bounds = gfx::Screen::GetPrimaryMonitor().bounds_in_pixel();
+  const int kLeftBorder = 50;
+  const int kRightBorder = 50;
+  const int kBottomBorder = 50;
+  const int kTopBorder = 0;
+  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;
+  // Offset the x position to the real
+  x -= kLeftBorder;
+  // 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 > -kLeftBorder * 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 - kLeftBorder &&
+      x < resolution_x - kLeftBorder + kRightBorder * kGraceAreaFraction)
+    x = resolution_x - kLeftBorder;
+  // Scale the screen area back to the full resolution of the screen.
+  x = (x * resolution_x) / (resolution_x - (kRightBorder + kLeftBorder));
+  // Offset the y position to the real
+  y -= kTopBorder;
+  // 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 (y < 0 && y > -kTopBorder * kGraceAreaFraction)
+    y = 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 (y > resolution_y - kTopBorder &&
+      y < resolution_y - kTopBorder + kBottomBorder * kGraceAreaFraction)
+    y = resolution_y - kTopBorder;
+  // Scale the screen area back to the full resolution of the screen.
+  y = (y * resolution_y) / (resolution_y - (kBottomBorder + kTopBorder));
+  // Set the modified coordinate back to the event.
+  return gfx::Point(x, y);
+}
+#endif

[sadrul, 2012/05/07 17:40:47]

#endif  // defined(USE_XI2_MT)

[Mr4D (OOO till 08-26), 2012/05/07 18:30:40]

Done.

+
 }  // namespace
 
 namespace ui {
 
 void UpdateDeviceList() {
   Display* display = GetXDisplay();
   CMTEventData::GetInstance()->UpdateDeviceList(display);
   TouchFactory::GetInstance()->UpdateDeviceList(display);
 }
 
@@ skipping 161 matching lines @@
     case GenericEvent: {
       XIDeviceEvent* xievent =
           static_cast<XIDeviceEvent*>(native_event->xcookie.data);
 
 #if defined(USE_XI2_MT)
       // Touch event valuators aren't coordinates.
       // Return the |event_x|/|event_y| directly as event's position.
       if (xievent->evtype == XI_TouchBegin ||
           xievent->evtype == XI_TouchUpdate ||
           xievent->evtype == XI_TouchEnd)
-        return gfx::Point(static_cast<int>(xievent->event_x),
-                          static_cast<int>(xievent->event_y));
+        // Note: Touch events are always touch screen events.
+        return CalibrateTouchCoordinates(xievent);
 #endif
       // Read the position from the valuators, because the location reported in
       // event_x/event_y seems to be different (and doesn't match for events
       // coming from slave device and master device) from the values in the
       // valuators. See more on crbug.com/103981. The position in the valuators
       // is in the global screen coordinates. But it is necessary to convert it
       // into the window's coordinates. If the valuator is not set, that means
       // the value hasn't changed, and so we can use the value from
       // event_x/event_y (which are in the window's coordinates).
       double* valuators = xievent->valuators.values;
@@ skipping 164 matching lines @@
     noop->xclient.format = 8;
     DCHECK(!noop->xclient.display);
   }
   // Make sure we use atom from current xdisplay, which may
   // change during the test.
   noop->xclient.message_type = GetNoopEventAtom();
   return noop;
 }
 
 }  // namespace ui