NxWM: Finishes touchscreen implementation; NuttX: Standardize touchscreen initialization interfaces for all boards

git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@4721 42af7a65-404d-4744-a932-0658087f49c3

1 files changed, 110 insertions, 9 deletions

diff --git a/NxWidgets/nxwm/include/ctouchscreen.hxx b/NxWidgets/nxwm/include/ctouchscreen.hxx
index f8eaeaee8..c3aa198cb 100644
--- a/NxWidgets/nxwm/include/ctouchscreen.hxx
+++ b/NxWidgets/nxwm/include/ctouchscreen.hxx
@@ -43,8 +43,13 @@
 #include <nuttx/nx/nxglib.h>
 
 #include <semaphore.h>
+#include <pthread.h>
+
 #include <nuttx/input/touchscreen.h>
 
+#include "cnxserver.hxx"
+#include "ccalibration.hxx"
+
 /****************************************************************************
  * Pre-processor Definitions
  ****************************************************************************/
@@ -63,16 +68,68 @@ namespace NxWM
   class CTouchscreen
   {
   private:
-    int   m_touchFd; /**< File descriptor of the opened touchscreen device */
-    sem_t m_waitSem; /**< Semaphore the supports waits for touchscreen data */
+    /**
+     * The state of the listener thread.
+     */
+
+    enum EListenerState
+    {
+      LISTENER_NOTRUNNING = 0,  /**< The listener thread has not yet been started */
+      LISTENER_STARTED,         /**< The listener thread has been started, but is not yet running */
+      LISTENER_RUNNING,         /**< The listener thread is running normally */
+      LISTENER_STOPREQUESTED,   /**< The listener thread has been requested to stop */
+      LISTENER_TERMINATED,      /**< The listener thread terminated normally */
+      LISTENER_FAILED           /**< The listener thread terminated abnormally */
+    };
+
+    /**
+     * CTouchscreen state data
+     */
+
+    NXWidgets::CNxServer        *m_server;     /**< The current NX server */
+    int                          m_touchFd;    /**< File descriptor of the opened touchscreen device */
+    sem_t                        m_waitSem;    /**< Semaphore the supports waits for touchscreen data */
+    pthread_t                    m_thread;     /**< The listener thread ID */
+    volatile enum EListenerState m_state;      /**< The state of the listener thread */
+    volatile bool                m_enabled;    /**< True: Normal touchscreen processing */
+    volatile bool                m_capture;    /**< True: There is a thread waiting for raw touch data */
+    volatile bool                m_calibrated; /**< True: If have calibration data */
+    struct nxgl_size_s           m_windowSize; /**< The size of the physical display */
+    struct SCalibrationData      m_calibData;  /**< Calibration data */
+    struct touch_sample_s        m_sample;     /**< In normal mode, touch data is collected here */
+    struct touch_sample_s       *m_touch;      /**< Points to the current touch data buffer */
+
+    /**
+     * The touchscreen listener thread.  This is the entry point of a thread that
+     * listeners for and dispatches touchscreens events to the NX server.
+     *
+     * @param arg.  The CTouchscreen 'this' pointer cast to a void*.
+     * @return This function normally does not return but may return NULL on
+     *   error conditions.
+     */
+
+    static FAR void *listener(FAR void *arg);
+
+    /**
+     *  Inject touchscreen data into NX as mouse intput
+     *
+     * @param sample.  The buffer where data was collected.
+     */
+
+    void handleMouseInput(struct touch_sample_s *sample);
 
   public:
 
     /**
      * CTouchscreen Constructor
+     *
+     * @param server. An instance of the NX server.  This will be needed for
+     *   injecting mouse data.
+     * @param windowSize.  The size of the physical window in pixels.  This
+     *   is needed for touchscreen scaling.
      */
 
-    CTouchscreen(void);
+    CTouchscreen(NXWidgets::CNxServer *server, struct nxgl_size_s *windowSize);
 
     /**
      * CTouchscreen Destructor
@@ -81,22 +138,66 @@ namespace NxWM
     ~CTouchscreen(void);
 
     /**
-     * Initialize the touchscreen device.  Initialization is separate from
-     * object instantiation so that failures can be reported.
+     * Start the touchscreen listener thread.
      *
-     * @return True if the touchscreen device was correctly initialized
+     * @return True if the touchscreen listener thread was correctly started.
      */
 
-    bool open(void);
+    bool start(void);
+
+    /**
+     * Enable/disable touchscreen data processing.  When enabled, touchscreen events
+     * are calibrated and forwarded to the NX layer which dispatches the touchscreen
+     * events in window-relative positions to the correct NX window.
+     *
+     * When disabled, touchscreen data is not forwarded to NX, but is instead captured
+     * and made available for touchscreen calibration.  The touchscreen driver is
+     * initially disabled and must be specifically enabled be begin normal processing.
+     * Normal processing also requires calibration data (see method setCalibrationData)
+     *
+     * @param capture.  True enables capture mode; false disables.
+     */
+
+    inline void setEnabled(bool enable)
+    {
+      // Set the capture flag.  m_calibrated must also be set to get to normal
+      // mode where touchscreen data is forwarded to NX.
+ 
+      m_enabled = enable;
+    }
+
+    /**
+     * Provide touchscreen calibration data.  If calibration data is received (and
+     * the touchscreen is enabled), then received touchscreen data will be scaled
+     * using the calibration data and forward to the NX layer which dispatches the
+     * touchscreen events in window-relative positions to the correct NX window.
+     *
+     * @param data.  A reference to the touchscreen data.
+     */
+
+    inline void setCalibrationData(struct SCalibrationData &caldata)
+    {
+      // Save a copy of the calibration data
+
+      m_calibData = caldata;
+ 
+      // Note that we have calibration data.  Data will now be scaled and forwarded
+      // to NX (unless we are still in cpature mode)
+ 
+      m_calibrated = true;
+    }
 
     /**
-     * Capture raw driver data.
+     * Capture raw driver data.  This method will capture mode one raw touchscreen
+     * input.  The normal use of this method is for touchscreen calibration.
      *
+     * This function is not re-entrant:  There may be only one thread waiting for
+     * raw touchscreen data.
      *
      * @return True if the raw touchscreen data was sucessfully obtained
      */
 
-    bool waitRawTouchData(struct touch_sample_s &touch);
+    bool waitRawTouchData(struct touch_sample_s *touch);
   };
 }