aboutsummaryrefslogtreecommitdiffstats
path: root/src/ginput/ginput_mouse.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/ginput/ginput_mouse.c')
-rw-r--r--src/ginput/ginput_mouse.c1056
1 files changed, 579 insertions, 477 deletions
diff --git a/src/ginput/ginput_mouse.c b/src/ginput/ginput_mouse.c
index ee6f51b6..f33a74e0 100644
--- a/src/ginput/ginput_mouse.c
+++ b/src/ginput/ginput_mouse.c
@@ -8,71 +8,340 @@
/**
* @file src/ginput/ginput_mouse.c
* @brief GINPUT mouse/touch code.
- *
- * @defgroup Mouse Mouse
- * @ingroup GINPUT
- * @{
*/
#include "gfx.h"
-#if (GFX_USE_GINPUT && GINPUT_NEED_MOUSE) || defined(__DOXYGEN__)
+#if GFX_USE_GINPUT && GINPUT_NEED_MOUSE
+
+// Local Settings
+#define CALIBRATION_POLL_PERIOD 20 // milliseconds
+#define CALIBRATION_MINPRESS_PERIOD 300 // milliseconds
+#define CALIBRATION_MAXPRESS_PERIOD 5000 // milliseconds
+
+#define CALIBRATION_FONT "* Double"
+#define CALIBRATION_FONT2 "* Narrow"
+#define CALIBRATION_BACKGROUND Blue
+
+#define CALIBRATION_CROSS_COLOR1 White
+#define CALIBRATION_CROSS_COLOR2 RGB2COLOR(184,158,131)
+#define CALIBRATION_CROSS_INNERGAP 2
+#define CALIBRATION_CROSS_RADIUS 15
+
+#define CALIBRATION_TITLE "Calibration"
+#define CALIBRATION_TITLE_Y 5
+#define CALIBRATION_TITLE_HEIGHT 30
+#define CALIBRATION_TITLE_COLOR White
+#define CALIBRATION_TITLE_BACKGROUND Blue
+
+#define CALIBRATION_ERROR_TEXT "Failed - Please try again!"
+#define CALIBRATION_ERROR_COLOR Red
+#define CALIBRATION_ERROR_BACKGROUND Yellow
+#define CALIBRATION_ERROR_Y 35
+#define CALIBRATION_ERROR_HEIGHT 40
+// Get the mouse driver interface
#include "driver_mouse.h"
+// The mouse poll timer
+static GTIMER_DECL(MouseTimer);
+
+// Calibration application
#if !GINPUT_TOUCH_NOCALIBRATE
- #if !defined(GFX_USE_GDISP) || !GFX_USE_GDISP
- #error "GINPUT: GFX_USE_GDISP must be defined when mouse or touch calibration is required"
+ #if GINPUT_TOUCH_USER_CALIBRATION_LOAD
+ #include <string.h> // Required for memcpy
#endif
- #include <string.h> // Required for memcpy
+ static inline void CalibrationTransform(GMouseReading *pt, const GMouseCalibration *c) {
+ pt->x = (coord_t) (c->ax * pt->x + c->bx * pt->y + c->cx);
+ pt->y = (coord_t) (c->ay * pt->x + c->by * pt->y + c->cy);
+ }
+#endif
- #define CALIBRATION_FONT "* Double"
- #define CALIBRATION_FONT2 "* Narrow"
- #define CALIBRATION_TEXT "Calibration"
- #define CALIBRATION_ERROR_TEXT "Failed - Please try again!"
- #define CALIBRATION_SAME_TEXT "Error: Same Reading - Check Driver!"
- #define CALIBRATION_BACKGROUND Blue
- #define CALIBRATION_COLOR1 White
- #define CALIBRATION_COLOR2 RGB2COLOR(184,158,131)
+static void SendMouseEvent(GSourceListener *psl, GMouse *m, GMouseReading *r) {
+ GEventMouse *pe;
-#endif
+ // If there is no event buffer just mark a missed event
+ if (!(pe = (GEventMouse *)geventGetEventBuffer(psl))) {
+ // This listener is missing - save the meta events that have happened
+ psl->srcflags |= ((r->buttons & GMETA_MASK)|GINPUT_MISSED_MOUSE_EVENT);
+ return;
+ }
-static GTIMER_DECL(MouseTimer);
+ // If we haven't really moved (and there are no meta events) don't bother sending the event
+ if (!(r->buttons & GMETA_MASK) && !psl->srcflags && !(psl->listenflags & GLISTEN_MOUSENOFILTER)
+ && r->x == m->r.x && r->y == m->r.y && (r->buttons & GINPUT_MOUSE_BTN_MASK) == (m->r.buttons & GINPUT_MOUSE_BTN_MASK))
+ return;
-#if !GINPUT_TOUCH_NOCALIBRATE
- /*
- static inline void CalibrationSetIdentity(MouseCalibration *c) {
- c->ax = 1;
- c->bx = 0;
- c->cx = 0;
- c->ay = 0;
- c->by = 1;
- c->cy = 0;
+ // Send the event only if we are listening for it
+ if (!((r->buttons & GINPUT_MOUSE_BTN_LEFT) && (psl->listenflags & GLISTEN_MOUSEDOWNMOVES))
+ && !((r->buttons & GINPUT_MOUSE_BTN_LEFT) && (psl->listenflags & GLISTEN_MOUSEUPMOVES))
+ && !((r->buttons & GMETA_MASK) && (psl->listenflags & GLISTEN_MOUSEMETA)))
+ return;
+
+ #if !GINPUT_TOUCH_NOTOUCH
+ pe->type = (gmvmt(m)->d.flags & GMOUSE_VFLG_TOUCH) ? GEVENT_TOUCH : GEVENT_MOUSE;
+ #else
+ pe->type = GEVENT_MOUSE;
+ #endif
+ pe->x = r->x;
+ pe->y = r->y;
+ pe->z = r->z;
+ pe->buttons = r->buttons | psl->srcflags;
+ psl->srcflags = 0;
+ pe->display = m->display;
+ geventSendEvent(psl);
+}
+
+static void GetMouseReading(GMouse *m) {
+ GMouseReading r;
+
+ // Step 1 - Get the Raw Reading
+ {
+ m->flags &= ~GMOUSE_FLG_NEEDREAD;
+ gmvmt(m)->get(m, &r);
}
- */
- static inline void CalibrationCrossDraw(GMouse *m, const point *pp) {
- gdispGDrawLine(m->display, pp->x-15, pp->y, pp->x-2, pp->y, CALIBRATION_COLOR1);
- gdispGDrawLine(m->display, pp->x+2, pp->y, pp->x+15, pp->y, CALIBRATION_COLOR1);
- gdispGDrawLine(m->display, pp->x, pp->y-15, pp->x, pp->y-2, CALIBRATION_COLOR1);
- gdispGDrawLine(m->display, pp->x, pp->y+2, pp->x, pp->y+15, CALIBRATION_COLOR1);
- gdispGDrawLine(m->display, pp->x-15, pp->y+15, pp->x-7, pp->y+15, CALIBRATION_COLOR2);
- gdispGDrawLine(m->display, pp->x-15, pp->y+7, pp->x-15, pp->y+15, CALIBRATION_COLOR2);
- gdispGDrawLine(m->display, pp->x-15, pp->y-15, pp->x-7, pp->y-15, CALIBRATION_COLOR2);
- gdispGDrawLine(m->display, pp->x-15, pp->y-7, pp->x-15, pp->y-15, CALIBRATION_COLOR2);
- gdispGDrawLine(m->display, pp->x+7, pp->y+15, pp->x+15, pp->y+15, CALIBRATION_COLOR2);
- gdispGDrawLine(m->display, pp->x+15, pp->y+7, pp->x+15, pp->y+15, CALIBRATION_COLOR2);
- gdispGDrawLine(m->display, pp->x+7, pp->y-15, pp->x+15, pp->y-15, CALIBRATION_COLOR2);
- gdispGDrawLine(m->display, pp->x+15, pp->y-15, pp->x+15, pp->y-7, CALIBRATION_COLOR2);
+ // Step 2 - Handle touch and button 0 debouncing
+ {
+ // Clean off button garbage
+ r.buttons &= GINPUT_MOUSE_BTN_MASK;
+
+ #if !GINPUT_TOUCH_NOTOUCH
+ // If touch then calculate button 0 from z
+ if ((gmvmt(m)->d.flags & GMOUSE_VFLG_TOUCH)) {
+ if (gmvmt(m)->z_min <= gmvmt(m)->z_max) {
+ if (r.z >= gmvmt(m)->z_touchon) r.buttons |= GINPUT_MOUSE_BTN_LEFT;
+ else if (r.z <= gmvmt(m)->z_touchoff) r.buttons &= ~GINPUT_MOUSE_BTN_LEFT;
+ else return; // bad transitional reading
+ } else {
+ if (r.z <= gmvmt(m)->z_touchon) r.buttons |= GINPUT_MOUSE_BTN_LEFT;
+ else if (r.z >= gmvmt(m)->z_touchoff) r.buttons &= ~GINPUT_MOUSE_BTN_LEFT;
+ else return; // bad transitional reading
+ }
+ }
+
+ // Devices with poor button 0 transitioning need debouncing
+ if ((gmvmt(m)->d.flags & GMOUSE_VFLG_POORUPDOWN)) {
+ // Are we in a transition test
+ if ((m->flags & GMOUSE_FLG_INDELTA)) {
+ if (!((r.buttons ^ m->r.buttons) & GINPUT_MOUSE_BTN_LEFT)) {
+ // Transition failed
+ m->flags &= ~GMOUSE_FLG_INDELTA;
+ return;
+ }
+ // Transition succeeded
+ m->flags &= ~GMOUSE_FLG_INDELTA;
+
+ // Should we start a transition test
+ } else if (((r.buttons ^ m->r.buttons) & GINPUT_MOUSE_BTN_LEFT)) {
+ m->flags |= GMOUSE_FLG_INDELTA;
+ return;
+ }
+ }
+ #endif
+
+ #if !GINPUT_TOUCH_NOCALIBRATE_GUI
+ // Stop here with just the raw x,y reading during calibration
+ if ((m->flags & GMOUSE_FLG_IN_CAL)) {
+ if ((r.buttons & GINPUT_MOUSE_BTN_LEFT)) {
+ m->r.x = r.x;
+ m->r.y = r.y;
+ }
+ m->r.buttons = r.buttons;
+ return;
+ }
+ #endif
}
- static inline void CalibrationCrossClear(GMouse *m, const point *pp) {
- gdispGFillArea(m->display, pp->x - 15, pp->y - 15, 32, 32, CALIBRATION_BACKGROUND);
+ // Step 3 - Apply calibration, rotation and display clipping
+ {
+ // If the mouse is up we may need to keep our previous position
+ if ((gmvmt(m)->d.flags & GMOUSE_VFLG_ONLY_DOWN) && !(r.buttons & GINPUT_MOUSE_BTN_LEFT)) {
+ r.x = m->r.x;
+ r.y = m->r.y;
+
+ } else {
+
+ #if !GINPUT_TOUCH_NOCALIBRATE
+ // Do we need to calibrate the reading?
+ if ((m->flags & GMOUSE_FLG_CALIBRATE))
+ CalibrationTransform(&r, &m->caldata);
+ #endif
+
+ // We can't clip or rotate if we don't have a display
+ if (m->display) {
+ coord_t w, h;
+
+ // We now need display information
+ w = gdispGGetWidth(m->display);
+ h = gdispGGetHeight(m->display);
+
+ #if GDISP_NEED_CONTROL
+ // Do we need to rotate the reading to match the display
+ if (!(gmvmt(m)->d.flags & GMOUSE_VFLG_SELFROTATION)) {
+ coord_t t;
+
+ switch(gdispGGetOrientation(m->display)) {
+ case GDISP_ROTATE_0:
+ break;
+ case GDISP_ROTATE_90:
+ t = r.x;
+ r.x = w - 1 - r.y;
+ r.y = t;
+ break;
+ case GDISP_ROTATE_180:
+ r.x = w - 1 - r.x;
+ r.y = h - 1 - r.y;
+ break;
+ case GDISP_ROTATE_270:
+ t = r.y;
+ r.y = h - 1 - r.x;
+ r.x = t;
+ break;
+ default:
+ break;
+ }
+ }
+ #endif
+
+ // Do we need to clip the reading to the display
+ if ((m->flags & GMOUSE_FLG_CLIP)) {
+ if (r.x < 0) r.x = 0;
+ else if (r.x >= w) r.x = w-1;
+ if (r.y < 0) r.y = 0;
+ else if (r.y >= h) r.y = h-1;
+ }
+ }
+ }
}
- static inline void CalibrationTransform(GMouseReading *pt, const GMouseCalibration *c) {
- pt->x = (coord_t) (c->ax * pt->x + c->bx * pt->y + c->cx);
- pt->y = (coord_t) (c->ay * pt->x + c->by * pt->y + c->cy);
+ // Step 4 - Apply jitter detection
+ #if !GINPUT_TOUCH_NOTOUCH
+ {
+ const GMouseJitter *pj;
+ uint32_t diff;
+
+ // Are we in pen or finger mode
+ pj = (m->flags & GMOUSE_FLG_FINGERMODE) ? &gmvmt(m)->finger_jitter : &gmvmt(m)->pen_jitter;
+
+ // Is this just movement jitter
+ if (pj->move > 0) {
+ diff = (uint32_t)(r.x - m->r.x) * (uint32_t)(r.x - m->r.x) + (uint32_t)(r.y - m->r.y) * (uint32_t)(r.y - m->r.y);
+ if (diff > (uint32_t)pj->move * (uint32_t)pj->move) {
+ r.x = m->r.x;
+ r.y = m->r.y;
+ }
+ }
+
+ // Check if the click has moved outside the click area and if so cancel the click
+ if (pj->click > 0 && (m->flags & GMOUSE_FLG_CLICK_TIMER)) {
+ diff = (uint32_t)(r.x - m->clickpos.x) * (uint32_t)(r.x - m->clickpos.x) + (uint32_t)(r.y - m->clickpos.y) * (uint32_t)(r.y - m->clickpos.y);
+ if (diff > (uint32_t)pj->click * (uint32_t)pj->click)
+ m->flags &= ~GMOUSE_FLG_CLICK_TIMER;
+ }
+ }
+ #endif
+
+ // Step 5 - Click, context-click and other meta event detection
+ {
+ uint16_t upbtns, dnbtns;
+
+ // Calculate button transitions
+ dnbtns = r.buttons & ~m->r.buttons;
+ upbtns = ~r.buttons & m->r.buttons;
+
+ // Left mouse down generates the Mouse-down meta event
+ if ((dnbtns & GINPUT_MOUSE_BTN_LEFT))
+ r.buttons |= GMETA_MOUSE_DOWN;
+
+ // Left mouse up generates the Mouse-up meta event
+ if ((upbtns & GINPUT_MOUSE_BTN_LEFT))
+ r.buttons |= GMETA_MOUSE_UP;
+
+ // Left/Right mouse down starts the click timer
+ if ((dnbtns & (GINPUT_MOUSE_BTN_LEFT|GINPUT_MOUSE_BTN_RIGHT))) {
+ m->clickpos.x = r.x;
+ m->clickpos.y = r.y;
+ m->clicktime = gfxSystemTicks();
+ m->flags |= GMOUSE_FLG_CLICK_TIMER;
+ }
+
+ // Left/Right mouse up with the click timer still running may generate a click or context click
+ if ((upbtns & (GINPUT_MOUSE_BTN_LEFT|GINPUT_MOUSE_BTN_RIGHT)) && (m->flags & GMOUSE_FLG_CLICK_TIMER)) {
+ m->flags &= ~GMOUSE_FLG_CLICK_TIMER;
+ m->clicktime = gfxSystemTicks() - m->clicktime;
+
+ // Was this a short click?
+ if (m->clicktime <= gfxMillisecondsToTicks(GINPUT_MOUSE_CLICK_TIME)) {
+ if ((upbtns & GINPUT_MOUSE_BTN_RIGHT))
+ r.buttons |= GMETA_MOUSE_CXTCLICK;
+ if ((upbtns & GINPUT_MOUSE_BTN_LEFT))
+ r.buttons |= GMETA_MOUSE_CLICK;
+ }
+
+ #if !GINPUT_TOUCH_NOTOUCH
+ // Was this a long click on a touch device?
+ if ((gmvmt(m)->d.flags & GMOUSE_VFLG_TOUCH) && m->clicktime >= gfxMillisecondsToTicks(GINPUT_TOUCH_CXTCLICK_TIME))
+ r.buttons |= GMETA_MOUSE_CXTCLICK;
+ #endif
+ }
+ }
+
+ // Step 6 - Send the event to the listeners that are interested.
+ {
+ GSourceListener *psl;
+
+ // Send to the "All Mice" source listeners
+ psl = 0;
+ while ((psl = geventGetSourceListener((GSourceHandle)&MouseTimer, psl)))
+ SendMouseEvent(psl, m, &r);
+
+ // Send to the mouse specific source listeners
+ psl = 0;
+ while ((psl = geventGetSourceListener((GSourceHandle)m, psl)))
+ SendMouseEvent(psl, m, &r);
+ }
+
+ // Step 7 - Finally save the results
+ m->r.x = r.x;
+ m->r.y = r.y;
+ m->r.z = r.z;
+ m->r.buttons = r.buttons;
+}
+
+static void MousePoll(void *param) {
+ GMouse * m;
+ (void) param;
+
+ for(m = (GMouse *)gdriverGetNext(GDRIVER_TYPE_MOUSE, 0); m; m = (GMouse *)gdriverGetNext(GDRIVER_TYPE_MOUSE, (GDriver *)m)) {
+ if (!(gmvmt(m)->d.flags & GMOUSE_VFLG_NOPOLL) || (m->flags & GMOUSE_FLG_NEEDREAD))
+ GetMouseReading(m);
+ }
+}
+
+// Calibration user interface
+#if !GINPUT_TOUCH_NOCALIBRATE_GUI
+ #if !defined(GFX_USE_GDISP) || !GFX_USE_GDISP
+ #error "GINPUT: GFX_USE_GDISP must be defined when calibration is required"
+ #endif
+
+ static inline void CalibrationCrossDraw(GMouse *m, const point *pp) {
+ gdispGDrawLine(m->display, pp->x-CALIBRATION_CROSS_RADIUS, pp->y, pp->x-CALIBRATION_CROSS_INNERGAP, pp->y, CALIBRATION_CROSS_COLOR1);
+ gdispGDrawLine(m->display, pp->x+CALIBRATION_CROSS_INNERGAP, pp->y, pp->x+CALIBRATION_CROSS_RADIUS, pp->y, CALIBRATION_CROSS_COLOR1);
+ gdispGDrawLine(m->display, pp->x, pp->y-CALIBRATION_CROSS_RADIUS, pp->x, pp->y-CALIBRATION_CROSS_INNERGAP, CALIBRATION_CROSS_COLOR1);
+ gdispGDrawLine(m->display, pp->x, pp->y+CALIBRATION_CROSS_INNERGAP, pp->x, pp->y+CALIBRATION_CROSS_RADIUS, CALIBRATION_CROSS_COLOR1);
+ gdispGDrawLine(m->display, pp->x-CALIBRATION_CROSS_RADIUS, pp->y+CALIBRATION_CROSS_RADIUS, pp->x-CALIBRATION_CROSS_RADIUS/2, pp->y+CALIBRATION_CROSS_RADIUS, CALIBRATION_CROSS_COLOR2);
+ gdispGDrawLine(m->display, pp->x-CALIBRATION_CROSS_RADIUS, pp->y+CALIBRATION_CROSS_RADIUS/2, pp->x-CALIBRATION_CROSS_RADIUS, pp->y+CALIBRATION_CROSS_RADIUS, CALIBRATION_CROSS_COLOR2);
+ gdispGDrawLine(m->display, pp->x-CALIBRATION_CROSS_RADIUS, pp->y-CALIBRATION_CROSS_RADIUS, pp->x-CALIBRATION_CROSS_RADIUS/2, pp->y-CALIBRATION_CROSS_RADIUS, CALIBRATION_CROSS_COLOR2);
+ gdispGDrawLine(m->display, pp->x-CALIBRATION_CROSS_RADIUS, pp->y-CALIBRATION_CROSS_RADIUS/2, pp->x-CALIBRATION_CROSS_RADIUS, pp->y-CALIBRATION_CROSS_RADIUS, CALIBRATION_CROSS_COLOR2);
+ gdispGDrawLine(m->display, pp->x+CALIBRATION_CROSS_RADIUS/2, pp->y+CALIBRATION_CROSS_RADIUS, pp->x+CALIBRATION_CROSS_RADIUS, pp->y+CALIBRATION_CROSS_RADIUS, CALIBRATION_CROSS_COLOR2);
+ gdispGDrawLine(m->display, pp->x+CALIBRATION_CROSS_RADIUS, pp->y+CALIBRATION_CROSS_RADIUS/2, pp->x+CALIBRATION_CROSS_RADIUS, pp->y+CALIBRATION_CROSS_RADIUS, CALIBRATION_CROSS_COLOR2);
+ gdispGDrawLine(m->display, pp->x+CALIBRATION_CROSS_RADIUS/2, pp->y-CALIBRATION_CROSS_RADIUS, pp->x+CALIBRATION_CROSS_RADIUS, pp->y-CALIBRATION_CROSS_RADIUS, CALIBRATION_CROSS_COLOR2);
+ gdispGDrawLine(m->display, pp->x+CALIBRATION_CROSS_RADIUS, pp->y-CALIBRATION_CROSS_RADIUS, pp->x+CALIBRATION_CROSS_RADIUS, pp->y-CALIBRATION_CROSS_RADIUS/2, CALIBRATION_CROSS_COLOR2);
+ }
+
+ static inline void CalibrationCrossClear(GMouse *m, const point *pp) {
+ gdispGFillArea(m->display, pp->x - CALIBRATION_CROSS_RADIUS, pp->y - CALIBRATION_CROSS_RADIUS, CALIBRATION_CROSS_RADIUS*2, CALIBRATION_CROSS_RADIUS*2, CALIBRATION_BACKGROUND);
}
static inline void CalibrationCalculate(GMouse *m, const point *cross, const point *points) {
@@ -165,220 +434,178 @@ static GTIMER_DECL(MouseTimer);
- c1 * ((float)points[0].x * (float)points[2].y - (float)points[2].x * (float)points[0].y)
+ c2 * ((float)points[0].x * (float)points[1].y - (float)points[1].x * (float)points[0].y)) / dx;
}
-#endif
-
-static void GetMouseReading(GMouse *m) {
- GMouseReading r;
- // Get the raw reading.
- gmvmt(m)->get(m, &r);
- m->flags &= ~GMOUSE_FLG_NEEDREAD;
+ static void CalibrateMouse(GMouse *m) {
+ coord_t w, h;
+ point cross[4]; // The locations of the test points on the display
+ point points[4]; // The x, y readings obtained from the mouse for each test point
+ font_t font1, font2;
- // If touch then calculate button 0 from z
- if ((gmvmt(m)->d.flags & GMOUSE_VFLG_TOUCH)) {
- if (gmvmt(m)->z_min <= gmvmt(m)->z_max) {
- if (r.z >= gmvmt(m)->z_touchon) r.buttons |= GINPUT_MOUSE_BTN_LEFT;
- else if (r.z <= gmvmt(m)->z_touchoff) r.buttons &= ~GINPUT_MOUSE_BTN_LEFT;
- else return; // bad transitional reading
- } else {
- if (r.z <= gmvmt(m)->z_touchon) r.buttons |= GINPUT_MOUSE_BTN_LEFT;
- else if (r.z >= gmvmt(m)->z_touchoff) r.buttons &= ~GINPUT_MOUSE_BTN_LEFT;
- else return; // bad transitional reading
- }
- }
-
- // Double check up & down events if needed
- if ((gmvmt(m)->d.flags & GMOUSE_VFLG_POORUPDOWN)) {
- // Are we in a transition test
- if ((m->flags & GMOUSE_FLG_INDELTA)) {
- if (!((r.buttons ^ m->r.buttons) & GINPUT_MOUSE_BTN_LEFT)) {
- // Transition failed
- m->flags &= ~GMOUSE_FLG_INDELTA;
- return;
- }
- // Transition succeeded
- m->flags &= ~GMOUSE_FLG_INDELTA;
-
- // Should we start a transition test
- } else if (((r.buttons ^ m->r.buttons) & GINPUT_MOUSE_BTN_LEFT)) {
- m->flags |= GMOUSE_FLG_INDELTA;
- return;
- }
- }
-
- // If the mouse is up we may need to keep our previous position
- if ((gmvmt(m)->d.flags & GMOUSE_VFLG_ONLY_DOWN) && !(r.buttons & GINPUT_MOUSE_BTN_LEFT)) {
- r.x = m->r.x;
- r.y = m->r.y;
-
- } else {
- coord_t w, h;
-
- #if !GINPUT_TOUCH_NOCALIBRATE
- // Do we need to calibrate the reading?
- if ((m->flags & GMOUSE_FLG_CALIBRATE))
- CalibrationTransform(&r, &m->caldata);
+ font1 = gdispOpenFont(CALIBRATION_FONT);
+ font2 = gdispOpenFont(CALIBRATION_FONT2);
+ w = gdispGGetWidth(m->display);
+ h = gdispGGetHeight(m->display);
+ #if GDISP_NEED_CLIP
+ gdispGSetClip(m->display, 0, 0, w, h);
#endif
- // We can't clip or rotate if we don't have a display
- if (m->display) {
+ // Ensure we get minimaly processed readings for the calibration
+ m->flags |= GMOUSE_FLG_IN_CAL;
+
+ // Set up our calibration locations
+ if ((gmvmt(m)->d.flags & GMOUSE_VFLG_CAL_EXTREMES)) {
+ cross[0].x = 0; cross[0].y = 0;
+ cross[1].x = w-1; cross[1].y = 0;
+ cross[2].x = w-1; cross[2].y = h-1;
+ cross[3].x = w/2; cross[3].y = h/2;
+ } else {
+ cross[0].x = w/4; cross[0].y = h/4;
+ cross[1].x = w-w/4; cross[1].y = h/4;
+ cross[2].x = w-w/4; cross[2].y = h-h/4;
+ cross[3].x = w/2; cross[3].y = h/2;
+ }
+
+ // Perform calibration until we get a valid result
+ while(1) {
+
+ // Set up the calibration display
+ gdispGClear(m->display, Blue);
+ gdispGFillStringBox(m->display,
+ 0, CALIBRATION_TITLE_Y, w, CALIBRATION_TITLE_HEIGHT,
+ CALIBRATION_TITLE, font1, CALIBRATION_TITLE_COLOR, CALIBRATION_TITLE_BACKGROUND,
+ justifyCenter);
+
+ // Calculate the calibration
+ {
+ unsigned i, maxpoints;
+
+ maxpoints = (gmvmt(m)->d.flags & GMOUSE_VFLG_CAL_TEST) ? 4 : 3;
+
+ // Loop through the calibration points
+ for(i = 0; i < maxpoints; i++) {
+ int32_t px, py;
+ unsigned j;
+
+ // Draw the current calibration point
+ CalibrationCrossDraw(m, &cross[i]);
+
+ // Get a valid "point pressed" average reading
+ do {
+ // Wait for the mouse to be pressed
+ while(!(m->r.buttons & GINPUT_MOUSE_BTN_LEFT))
+ gfxSleepMilliseconds(CALIBRATION_POLL_PERIOD);
+
+ // Sum samples taken every CALIBRATION_POLL_PERIOD milliseconds while the mouse is down
+ px = py = j = 0;
+ while((m->r.buttons & GINPUT_MOUSE_BTN_LEFT)) {
+ // Limit sampling period to prevent overflow
+ if (j < CALIBRATION_MAXPRESS_PERIOD/CALIBRATION_POLL_PERIOD) {
+ px += m->r.x;
+ py += m->r.y;
+ j++;
+ }
+ gfxSleepMilliseconds(CALIBRATION_POLL_PERIOD);
+ }
- // We now need display information
- w = gdispGGetWidth(m->display);
- h = gdispGGetHeight(m->display);
+ // Ignore presses less than CALIBRATION_MAXPRESS_PERIOD milliseconds
+ } while(j < CALIBRATION_MINPRESS_PERIOD/CALIBRATION_POLL_PERIOD);
+ points[i].x = px / j;
+ points[i].y = py / j;
- #if GDISP_NEED_CONTROL
- // Do we need to rotate the reading to match the display
- if (!(gmvmt(m)->d.flags & GMOUSE_VFLG_SELFROTATION)) {
- coord_t t;
-
- switch(gdispGGetOrientation(m->display)) {
- case GDISP_ROTATE_0:
- break;
- case GDISP_ROTATE_90:
- t = r.x;
- r.x = w - 1 - r.y;
- r.y = t;
- break;
- case GDISP_ROTATE_180:
- r.x = w - 1 - r.x;
- r.y = h - 1 - r.y;
- break;
- case GDISP_ROTATE_270:
- t = r.y;
- r.y = h - 1 - r.x;
- r.x = t;
- break;
- default:
- break;
- }
+ // Clear the current calibration point
+ CalibrationCrossClear(m, &cross[i]);
}
- #endif
-
- // Do we need to clip the reading to the display
- if ((m->flags & GMOUSE_FLG_CLIP)) {
- if (r.x < 0) r.x = 0;
- else if (r.x >= w) r.x = w-1;
- if (r.y < 0) r.y = 0;
- else if (r.y >= h) r.y = h-1;
- }
- }
- }
- {
- const GMouseJitter *pj;
- uint32_t diff;
-
- // Are we in pen or finger mode
- pj = (m->flags & GMOUSE_FLG_FINGERMODE) ? &gmvmt(m)->finger_jitter : &gmvmt(m)->pen_jitter;
+ // Apply 3 point calibration algorithm
+ CalibrationCalculate(m, cross, points);
- // Is this just movement jitter
- if (pj->move > 0) {
- diff = (uint32_t)(r.x - m->r.x) * (uint32_t)(r.x - m->r.x) + (uint32_t)(r.y - m->r.y) * (uint32_t)(r.y - m->r.y);
- if (diff > (uint32_t)pj->move * (uint32_t)pj->move) {
- r.x = m->r.x;
- r.y = m->r.y;
+ // Skip the 4th point tests if we don't want them
+ if (maxpoints < 4)
+ break;
}
- }
- // Check if the click has moved outside the click area and if so cancel the click
- if (pj->click > 0 && (m->flags & GMOUSE_FLG_CLICK_TIMER)) {
- diff = (uint32_t)(r.x - m->clickpos.x) * (uint32_t)(r.x - m->clickpos.x) + (uint32_t)(r.y - m->clickpos.y) * (uint32_t)(r.y - m->clickpos.y);
- if (diff > (uint32_t)pj->click * (uint32_t)pj->click)
- m->flags &= ~GMOUSE_FLG_CLICK_TIMER;
- }
- }
+ /* Verification of correctness of calibration (optional) :
+ * See if the 4th point (Middle of the screen) coincides with the calibrated
+ * result. If point is within +/- Squareroot(ERROR) pixel margin, then successful calibration
+ * Else, start from the beginning.
+ */
+ {
+ const GMouseJitter *pj;
+ uint32_t err;
- {
- GSourceListener *psl;
- GEventMouse *pe;
- unsigned meta;
- uint16_t upbtns, dnbtns;
-
- // Calculate out new event meta value and handle CLICK and CXTCLICK
- dnbtns = r.buttons & ~m->r.buttons;
- upbtns = ~r.buttons & m->r.buttons;
- meta = GMETA_NONE;
+ // Are we in pen or finger mode
+ pj = (m->flags & GMOUSE_FLG_FINGERMODE) ? &gmvmt(m)->finger_jitter : &gmvmt(m)->pen_jitter;
- // Mouse down
- if ((dnbtns & (GINPUT_MOUSE_BTN_LEFT|GINPUT_MOUSE_BTN_RIGHT))) {
- m->clickpos.x = r.x;
- m->clickpos.y = r.y;
- m->clicktime = gfxSystemTicks();
- m->flags |= GMOUSE_FLG_CLICK_TIMER;
- if ((dnbtns & GINPUT_MOUSE_BTN_LEFT))
- meta |= GMETA_MOUSE_DOWN;
- }
+ // Transform the co-ordinates
+ CalibrationTransform((GMouseReading *)&points[3], &m->caldata);
- // Mouse up
- if ((upbtns & (GINPUT_MOUSE_BTN_LEFT|GINPUT_MOUSE_BTN_RIGHT))) {
- if ((upbtns & GINPUT_MOUSE_BTN_LEFT))
- meta |= GMETA_MOUSE_UP;
- if ((m->flags & GMOUSE_FLG_CLICK_TIMER)) {
- if ((upbtns & GINPUT_MOUSE_BTN_LEFT)
- #if GINPUT_TOUCH_CLICK_TIME != TIME_INFINITE
- && gfxSystemTicks() - m->clicktime < gfxMillisecondsToTicks(GINPUT_TOUCH_CLICK_TIME)
- #endif
- )
- meta |= GMETA_MOUSE_CLICK;
- else
- meta |= GMETA_MOUSE_CXTCLICK;
- m->flags &= ~GMOUSE_FLG_CLICK_TIMER;
- }
- }
+ // Do we need to rotate the reading to match the display
+ #if GDISP_NEED_CONTROL
+ if (!(gmvmt(m)->d.flags & GMOUSE_VFLG_SELFROTATION)) {
+ coord_t t;
+
+ switch(gdispGGetOrientation(m->display)) {
+ case GDISP_ROTATE_0:
+ break;
+ case GDISP_ROTATE_90:
+ t = points[3].x;
+ points[3].x = w - 1 - points[3].y;
+ points[3].y = t;
+ break;
+ case GDISP_ROTATE_180:
+ points[3].x = w - 1 - points[3].x;
+ points[3].y = h - 1 - points[3].y;
+ break;
+ case GDISP_ROTATE_270:
+ t = points[3].y;
+ points[3].y = h - 1 - points[3].x;
+ points[3].x = t;
+ break;
+ default:
+ break;
+ }
+ }
+ #endif
- // Send the event to the listeners that are interested.
- psl = 0;
- while ((psl = geventGetSourceListener((GSourceHandle)m, psl))) {
- if (!(pe = (GEventMouse *)geventGetEventBuffer(psl))) {
- // This listener is missing - save the meta events that have happened
- psl->srcflags |= meta;
- continue;
- }
+ // Is this accurate enough?
+ err = (points[3].x - cross[3].x) * (points[3].x - cross[3].x) + (points[3].y - cross[3].y) * (points[3].y - cross[3].y);
+ if (err <= (uint32_t)pj->calibrate * (uint32_t)pj->calibrate)
+ break;
- // If we haven't really moved (and there are no meta events) don't bother sending the event
- if (!meta && !psl->srcflags && !(psl->listenflags & GLISTEN_MOUSENOFILTER)
- && r.x == m->r.x && r.y == m->r.y && r.buttons == m->r.buttons)
- continue;
-
- // Send the event if we are listening for it
- if (((r.buttons & GINPUT_MOUSE_BTN_LEFT) && (psl->listenflags & GLISTEN_MOUSEDOWNMOVES))
- || (!(r.buttons & GINPUT_MOUSE_BTN_LEFT) && (psl->listenflags & GLISTEN_MOUSEUPMOVES))
- || (meta && (psl->listenflags & GLISTEN_MOUSEMETA))) {
- pe->type = (gmvmt(m)->d.flags & GMOUSE_VFLG_TOUCH) ? GEVENT_TOUCH : GEVENT_MOUSE;
- pe->x = r.x;
- pe->y = r.y;
- pe->z = r.z;
- pe->current_buttons = r.buttons;
- pe->last_buttons = m->r.buttons;
- pe->meta = meta;
- if (psl->srcflags) {
- pe->current_buttons |= GINPUT_MISSED_MOUSE_EVENT;
- pe->meta |= psl->srcflags;
- psl->srcflags = 0;
- }
- pe->display = m->display;
- geventSendEvent(psl);
+ // No - Display error and try again
+ gdispGFillStringBox(m->display,
+ 0, CALIBRATION_ERROR_Y, w, CALIBRATION_ERROR_HEIGHT,
+ CALIBRATION_ERROR_TEXT, font2, CALIBRATION_ERROR_COLOR, CALIBRATION_ERROR_BACKGROUND,
+ justifyCenter);
+ gfxSleepMilliseconds(5000);
}
}
- }
- // Finally save the results
- m->r.x = r.x;
- m->r.y = r.y;
- m->r.z = r.z;
- m->r.buttons = r.buttons;
-}
+ // We are done calibrating
+ gdispCloseFont(font1);
+ gdispCloseFont(font2);
+ m->flags |= GMOUSE_FLG_CALIBRATE|GMOUSE_FLG_CLIP;
+ m->flags &= ~GMOUSE_FLG_IN_CAL;
-static void MousePoll(void *param) {
- GMouse * m;
- (void) param;
+ // Force an initial reading
+ m->r.buttons = 0;
+ GetMouseReading(m);
- for(m = (GMouse *)gdriverGetNext(GDRIVER_TYPE_MOUSE, 0); m; m = (GMouse *)gdriverGetNext(GDRIVER_TYPE_MOUSE, (GDriver *)m)) {
- if (!(gmvmt(m)->d.flags & GMOUSE_VFLG_NOPOLL) || (m->flags & GMOUSE_FLG_NEEDREAD))
- GetMouseReading(m);
+ // Save the calibration data (if possible)
+ #if GINPUT_TOUCH_USER_CALIBRATION_SAVE
+ SaveMouseCalibration(gdriverGetDriverInstanceNumber((GDriver *)m), &m->caldata, sizeof(GMouseCalibration));
+ #endif
+ if (gmvmt(m)->calsave)
+ gmvmt(m)->calsave(m, &m->caldata, sizeof(GMouseCalibration));
+
+ // Clear the screen using the GWIN default background color
+ #if GFX_USE_GWIN
+ gdispGClear(m->display, gwinGetDefaultBgColor());
+ #else
+ gdispGClear(m->display, GDISP_STARTUP_COLOR);
+ #endif
}
-}
+#endif
void _gmouseInit(void) {
// GINPUT_MOUSE_DRIVER_LIST is defined - create each driver instance
@@ -388,298 +615,173 @@ void _gmouseInit(void) {
extern GDriverVMTList GINPUT_MOUSE_DRIVER_LIST;
static const struct GDriverVMT const * dclist[] = {GINPUT_MOUSE_DRIVER_LIST};
- static const unsigned dnlist[] = {GDISP_CONTROLLER_DISPLAYS};
- for(i = 0; i < sizeof(dclist)/sizeof(dclist[0]); i++)
- gdriverRegister(dclist[i]);
+ for(i = 0; i < sizeof(dclist)/sizeof(dclist[0]); i++) {
+ if (!(dclist[i]->flags & GMOUSE_VFLG_DYNAMICONLY))
+ gdriverRegister(dclist[i]);
+ }
}
- // One and only one display
+ // One and only one mouse
#else
{
- extern GDriverVMTList GINPUTMOUSEVMT_OnlyOne;
+ extern GDriverVMTList GMOUSEVMT_OnlyOne;
- gdriverRegister(GINPUTMOUSEVMT_OnlyOne);
+ if (!(GMOUSEVMT_OnlyOne->flags & GMOUSE_VFLG_DYNAMICONLY))
+ gdriverRegister(GMOUSEVMT_OnlyOne);
}
#endif
+
}
void _gmouseDeinit(void) {
+ gtimerDeinit(&MouseTimer);
}
-GSourceHandle ginputGetMouse(uint16_t instance) {
- GMouse *m;
- #if GINPUT_MOUSE_NEED_CALIBRATION
- GCalibration *pc;
+bool_t _gmouseInitDriver(GDriver *g, unsigned driverinstance, unsigned systeminstance) {
+ #define m ((GMouse *)g)
+ (void) systeminstance;
+
+ // Init the mouse
+ if (!gmvmt(m)->init((GMouse *)g, driverinstance))
+ return FALSE;
+
+ #if !GINPUT_TOUCH_NOTOUCH
+ // Should this mouse start in finger mode?
+ if ((gmvmt(m)->d.flags & GMOUSE_VFLG_DEFAULTFINGER))
+ m->flags |= GMOUSE_FLG_FINGERMODE;
#endif
- if (!(m = (GMouse *)gdriverGetInstance(GDRIVER_TYPE_MOUSE, instance)))
- return 0;
+ // Ensure the Poll timer is started
+ if (!gtimerIsActive(&MouseTimer))
+ gtimerStart(&MouseTimer, MousePoll, 0, TRUE, GINPUT_MOUSE_POLL_PERIOD);
+
+ return TRUE;
+
+ #undef m
+}
+
+void _gmousePostInitDriver(GDriver *g) {
+ #define m ((GMouse *)g)
// Make sure we have a valid mouse display
if (!m->display)
m->display = GDISP;
- // Do we need to initialise the mouse subsystem?
- if (!(m->flags & FLG_INIT_DONE)) {
- ginput_lld_mouse_init();
-
- #if GINPUT_MOUSE_NEED_CALIBRATION
- #if GINPUT_MOUSE_LLD_CALIBRATION_LOADSAVE
- if (!m->fnloadcal) {
- m->fnloadcal = ginput_lld_mouse_calibration_load;
- m->flags &= ~FLG_CAL_FREE;
- }
- if (!m->fnsavecal)
- m->fnsavecal = ginput_lld_mouse_calibration_save;
+ #if !GINPUT_TOUCH_NOCALIBRATE && !GINPUT_TOUCH_STARTRAW
+ if ((gmvmt(m)->d.flags & GMOUSE_VFLG_CALIBRATE)) {
+ GMouseCalibration *pc;
+
+ #if GINPUT_TOUCH_USER_CALIBRATION_LOAD
+ if ((pc = (GMouseCalibration *)LoadMouseCalibration(gdriverGetDriverInstanceNumber((GDriver *)m), sizeof(GMouseCalibration)))) {
+ memcpy(&m->caldata, pc, sizeof(GMouseCalibration));
+ #if GINPUT_TOUCH_USER_CALIBRATION_FREE
+ gfxFree(pc);
+ #endif
+ m->flags |= GMOUSE_FLG_CALIBRATE|GMOUSE_FLG_CLIP;
+ } else
+ #endif
+ if (gmvmt(m)->calload && (pc = (GMouseCalibration *)gmvmt(m)->calload(m, sizeof(GMouseCalibration)))) {
+ memcpy(&m->caldata, pc, sizeof(GMouseCalibration));
+ if ((gmvmt(m)->d.flags & GMOUSE_VFLG_CAL_LOADFREE))
+ gfxFree(pc);
+ m->flags |= GMOUSE_FLG_CALIBRATE|GMOUSE_FLG_CLIP;
+ }
+ #if !GINPUT_TOUCH_NOCALIBRATE_GUI
+ else
+ CalibrateMouse(m);
#endif
- if (m->fnloadcal && (pc = (Calibration *)m->fnloadcal(instance))) {
- memcpy(&m->caldata, pc, sizeof(m->caldata));
- m->flags |= (FLG_CAL_OK|FLG_CAL_SAVED);
- if ((m->flags & FLG_CAL_FREE))
- gfxFree((void *)pc);
- } else if (instance == 9999) {
- CalibrationSetIdentity(&m->caldata);
- m->flags |= (FLG_CAL_OK|FLG_CAL_SAVED|FLG_CAL_RAW);
- } else
- ginputCalibrateMouse(instance);
- #endif
+ }
+ #endif
- // Get the first reading
- m->last_buttons = 0;
- get_calibrated_reading(&m->t);
+ // Get the first reading
+ GetMouseReading(m);
- // Mark init as done and start the Poll timer
- m->flags |= FLG_INIT_DONE;
- gtimerStart(&MouseTimer, MousePoll, 0, TRUE, GINPUT_MOUSE_POLL_PERIOD);
- }
+ #undef m
+}
+
+void _gmouseDeInitDriver(GDriver *g) {
+ (void) g;
+}
- // Return our structure as the handle
- return (GSourceHandle)m;
+GSourceHandle ginputGetMouse(unsigned instance) {
+ if (instance == GMOUSE_ALL_INSTANCES)
+ return (GSourceHandle)&MouseTimer;
+ return (GSourceHandle)gdriverGetInstance(GDRIVER_TYPE_MOUSE, instance);
}
-void ginputSetMouseDisplay(uint16_t instance, GDisplay *g) {
- if (instance)
+void ginputSetMouseDisplay(unsigned instance, GDisplay *g) {
+ GMouse *m;
+
+ if (!(m = (GMouse *)gdriverGetInstance(GDRIVER_TYPE_MOUSE, instance)))
return;
m->display = g ? g : GDISP;
}
-GDisplay *ginputGetMouseDisplay(uint16_t instance) {
- if (instance)
+GDisplay *ginputGetMouseDisplay(unsigned instance) {
+ GMouse *m;
+
+ if (!(m = (GMouse *)gdriverGetInstance(GDRIVER_TYPE_MOUSE, instance)))
return 0;
return m->display;
}
-bool_t ginputGetMouseStatus(uint16_t instance, GEventMouse *pe) {
+bool_t ginputGetMouseStatus(unsigned instance, GEventMouse *pe) {
+ GMouse *m;
+
// Win32 threads don't seem to recognise priority and/or pre-emption
// so we add a sleep here to prevent 100% polled applications from locking up.
gfxSleepMilliseconds(1);
- if (instance || (m->flags & (FLG_INIT_DONE|FLG_IN_CAL)) != FLG_INIT_DONE)
+ if (!(m = (GMouse *)gdriverGetInstance(GDRIVER_TYPE_MOUSE, instance)))
return FALSE;
- pe->type = GINPUT_MOUSE_EVENT_TYPE;
- pe->x = m->t.x;
- pe->y = m->t.y;
- pe->z = m->t.z;
- pe->current_buttons = m->t.buttons;
- pe->last_buttons = m->last_buttons;
- if (pe->current_buttons & ~pe->last_buttons & GINPUT_MOUSE_BTN_LEFT)
- pe->meta = GMETA_MOUSE_DOWN;
- else if (~pe->current_buttons & pe->last_buttons & GINPUT_MOUSE_BTN_LEFT)
- pe->meta = GMETA_MOUSE_UP;
- else
- pe->meta = GMETA_NONE;
- return TRUE;
-}
-
-bool_t ginputCalibrateMouse(uint16_t instance) {
- #if GINPUT_TOUCH_NOCALIBRATE
-
- (void) instance;
-
- return FALSE;
- #else
-
- const coord_t height = gdispGGetHeight(MouseConfig.display);
- const coord_t width = gdispGGetWidth(MouseConfig.display);
- #if GINPUT_MOUSE_CALIBRATE_EXTREMES
- const MousePoint cross[] = {{0, 0},
- {(width - 1) , 0},
- {(width - 1) , (height - 1)},
- {(width / 2), (height / 2)}}; /* Check point */
- #else
- const MousePoint cross[] = {{(width / 4), (height / 4)},
- {(width - (width / 4)) , (height / 4)},
- {(width - (width / 4)) , (height - (height / 4))},
- {(width / 2), (height / 2)}}; /* Check point */
- #endif
- MousePoint points[4];
- const MousePoint *pc;
- MousePoint *pt;
- int32_t px, py;
- unsigned i, j;
- font_t font1, font2;
- #if GINPUT_MOUSE_MAX_CALIBRATION_ERROR >= 0
- unsigned err;
- #endif
-
- if (instance || (MouseConfig.flags & FLG_IN_CAL))
+ #if !GINPUT_TOUCH_NOCALIBRATE_GUI
+ if ((m->flags & GMOUSE_FLG_IN_CAL))
return FALSE;
+ #endif
- font1 = gdispOpenFont(GINPUT_MOUSE_CALIBRATION_FONT);
- font2 = gdispOpenFont(GINPUT_MOUSE_CALIBRATION_FONT2);
-
- MouseConfig.flags |= FLG_IN_CAL;
- gtimerStop(&MouseTimer);
- MouseConfig.flags &= ~(FLG_CAL_OK|FLG_CAL_SAVED|FLG_CAL_RAW);
-
- #if GDISP_NEED_CLIP
- gdispGSetClip(MouseConfig.display, 0, 0, width, height);
- #endif
-
- #if GINPUT_MOUSE_MAX_CALIBRATION_ERROR >= 0
- while(1) {
- #endif
- gdispGClear(MouseConfig.display, Blue);
-
- gdispGFillStringBox(MouseConfig.display, 0, 5, width, 30, GINPUT_MOUSE_CALIBRATION_TEXT, font1, White, Blue, justifyCenter);
-
- for(i = 0, pt = points, pc = cross; i < GINPUT_MOUSE_CALIBRATION_POINTS; i++, pt++, pc++) {
- CalibrationCrossDraw(pc);
-
- do {
-
- /* Wait for the mouse to be pressed */
- while(get_raw_reading(&MouseConfig.t), !(MouseConfig.t.buttons & GINPUT_MOUSE_BTN_LEFT))
- gfxSleepMilliseconds(20);
-
- /* Average all the samples while the mouse is down */
- for(px = py = 0, j = 0;
- gfxSleepMilliseconds(20), /* Settling time between readings */
- get_raw_reading(&MouseConfig.t),
- (MouseConfig.t.buttons & GINPUT_MOUSE_BTN_LEFT);
- j++) {
- px += MouseConfig.t.x;
- py += MouseConfig.t.y;
- }
-
- } while(!j);
-
- pt->x = px / j;
- pt->y = py / j;
-
- CalibrationCrossClear(pc);
-
- if (i >= 1 && pt->x == (pt-1)->x && pt->y == (pt-1)->y) {
- gdispGFillStringBox(MouseConfig.display, 0, 35, width, 40, GINPUT_MOUSE_CALIBRATION_SAME_TEXT, font2, Red, Yellow, justifyCenter);
- gfxSleepMilliseconds(5000);
- gdispGFillArea(MouseConfig.display, 0, 35, width, 40, Blue);
- }
-
- }
-
- /* Apply 3 point calibration algorithm */
- CalibrationCalculate(&MouseConfig, cross, points);
-
- /* Verification of correctness of calibration (optional) :
- * See if the 4th point (Middle of the screen) coincides with the calibrated
- * result. If point is within +/- Squareroot(ERROR) pixel margin, then successful calibration
- * Else, start from the beginning.
- */
- #if GINPUT_MOUSE_MAX_CALIBRATION_ERROR >= 0
- /* Transform the co-ordinates */
- MouseConfig.t.x = points[3].x;
- MouseConfig.t.y = points[3].y;
- CalibrationTransform(&MouseConfig.t, &MouseConfig.caldata);
- _tsOrientClip(&MouseConfig.t, MouseConfig.display, FALSE);
-
- /* Calculate the delta */
- err = (MouseConfig.t.x - cross[3].x) * (MouseConfig.t.x - cross[3].x) +
- (MouseConfig.t.y - cross[3].y) * (MouseConfig.t.y - cross[3].y);
-
- if (err <= GINPUT_MOUSE_MAX_CALIBRATION_ERROR * GINPUT_MOUSE_MAX_CALIBRATION_ERROR)
- break;
-
- gdispGFillStringBox(MouseConfig.display, 0, 35, width, 40, GINPUT_MOUSE_CALIBRATION_ERROR_TEXT, font2, Red, Yellow, justifyCenter);
- gfxSleepMilliseconds(5000);
- }
- #endif
-
- // Restart everything
- gdispCloseFont(font1);
- gdispCloseFont(font2);
- MouseConfig.flags |= FLG_CAL_OK;
- MouseConfig.last_buttons = 0;
- get_calibrated_reading(&MouseConfig.t);
- MouseConfig.flags &= ~FLG_IN_CAL;
- if ((MouseConfig.flags & FLG_INIT_DONE))
- gtimerStart(&MouseTimer, MousePoll, 0, TRUE, GINPUT_MOUSE_POLL_PERIOD);
-
- // Save the calibration data (if possible)
- if (MouseConfig.fnsavecal) {
- MouseConfig.fnsavecal(instance, (const uint8_t *)&MouseConfig.caldata, sizeof(MouseConfig.caldata));
- MouseConfig.flags |= FLG_CAL_SAVED;
- }
-
- // Clear the screen using the GWIN default background color
- #if GFX_USE_GWIN
- gdispGClear(MouseConfig.display, gwinGetDefaultBgColor());
- #else
- gdispGClear(MouseConfig.display, Black);
- #endif
-
- return TRUE;
+ #if !GINPUT_TOUCH_NOTOUCH
+ pe->type = (gmvmt(m)->d.flags & GMOUSE_VFLG_TOUCH) ? GEVENT_TOUCH : GEVENT_MOUSE;
+ #else
+ pe->type = GEVENT_MOUSE;
#endif
+ pe->x = m->r.x;
+ pe->y = m->r.y;
+ pe->z = m->r.z;
+ pe->buttons = m->r.buttons;
+ pe->display = m->display;
+ return TRUE;
}
-/* Set the routines to save and fetch calibration data.
- * This function should be called before first calling ginputGetMouse() for a particular instance
- * as the ginputGetMouse() routine may attempt to fetch calibration data and perform a startup calibration if there is no way to get it.
- * If this is called after ginputGetMouse() has been called and the driver requires calibration storage, it will immediately save the data is has already obtained.
- * The 'requireFree' parameter indicates if the fetch buffer must be free()'d to deallocate the buffer provided by the Fetch routine.
- */
-void ginputSetMouseCalibrationRoutines(uint16_t instance, GMouseCalibrationSaveRoutine fnsave, GMouseCalibrationLoadRoutine fnload, bool_t requireFree) {
- #if GINPUT_MOUSE_NEED_CALIBRATION
- if (instance)
+#if !GINPUT_TOUCH_NOTOUCH
+ void ginputSetFingerMode(unsigned instance, bool_t on) {
+ GMouse *m;
+
+ if (!(m = (GMouse *)gdriverGetInstance(GDRIVER_TYPE_MOUSE, instance)))
return;
- MouseConfig.fnloadcal = fnload;
- MouseConfig.fnsavecal = fnsave;
- if (requireFree)
- MouseConfig.flags |= FLG_CAL_FREE;
+ if (on)
+ m->flags |= GMOUSE_FLG_FINGERMODE;
else
- MouseConfig.flags &= ~FLG_CAL_FREE;
- #if GINPUT_MOUSE_LLD_CALIBRATION_LOADSAVE
- if (!MouseConfig.fnloadcal) {
- MouseConfig.fnloadcal = ginput_lld_mouse_calibration_load;
- MouseConfig.flags &= ~FLG_CAL_FREE;
- }
- if (!MouseConfig.fnsavecal)
- MouseConfig.fnsavecal = ginput_lld_mouse_calibration_save;
- #endif
- if (MouseConfig.fnsavecal && (MouseConfig.flags & (FLG_CAL_OK|FLG_CAL_SAVED)) == FLG_CAL_OK) {
- MouseConfig.fnsavecal(instance, (const uint8_t *)&MouseConfig.caldata, sizeof(MouseConfig.caldata));
- MouseConfig.flags |= FLG_CAL_SAVED;
- }
- #else
- (void)instance, (void)fnsave, (void)fnload, (void)requireFree;
- #endif
-}
+ m->flags &= ~GMOUSE_FLG_FINGERMODE;
-/* Test if a particular mouse instance requires routines to save its calibration data. */
-bool_t ginputRequireMouseCalibrationStorage(uint16_t instance) {
- if (instance)
- return FALSE;
+ }
+#endif
+
+#if !GINPUT_TOUCH_NOCALIBRATE_GUI
+ bool_t ginputCalibrateMouse(unsigned instance) {
+ GMouse *m;
- #if GINPUT_MOUSE_NEED_CALIBRATION && !GINPUT_MOUSE_LLD_CALIBRATION_LOADSAVE
+ if (!(m = (GMouse *)gdriverGetInstance(GDRIVER_TYPE_MOUSE, instance)))
+ return FALSE;
+
+ CalibrateMouse(m);
return TRUE;
- #else
- return FALSE;
- #endif
-}
+ }
+#endif
/* Wake up the mouse driver from an interrupt service routine (there may be new readings available) */
void ginputMouseWakeup(GMouse *m) {