diff --git a/gfxconf.example.h b/gfxconf.example.h index 7ac48591..0ff436ca 100644 --- a/gfxconf.example.h +++ b/gfxconf.example.h @@ -210,6 +210,16 @@ //#define GFX_USE_GINPUT FALSE //#define GINPUT_NEED_MOUSE FALSE +// #define GINPUT_TOUCH_STARTRAW FALSE +// #define GINPUT_TOUCH_NOTOUCH FALSE +// #define GINPUT_TOUCH_NOCALIBRATE FALSE +// #define GINPUT_TOUCH_NOCALIBRATE_GUI FALSE +// #define GINPUT_MOUSE_POLL_PERIOD 25 +// #define GINPUT_MOUSE_CLICK_TIME 300 +// #define GINPUT_TOUCH_CXTCLICK_TIME 700 +// #define GINPUT_TOUCH_USER_CALIBRATION_LOAD FALSE +// #define GINPUT_TOUCH_USER_CALIBRATION_FREE FALSE +// #define GINPUT_TOUCH_USER_CALIBRATION_SAVE FALSE //#define GINPUT_NEED_KEYBOARD FALSE //#define GINPUT_NEED_TOGGLE FALSE //#define GINPUT_NEED_DIAL FALSE diff --git a/src/ginput/driver_mouse.h b/src/ginput/driver_mouse.h index a0f0f807..ababfef8 100644 --- a/src/ginput/driver_mouse.h +++ b/src/ginput/driver_mouse.h @@ -42,21 +42,17 @@ typedef struct GMouse { GDriver d; // The driver overheads and vmt GMouseReading r; // The current position and state uint16_t flags; // Flags - #define GMOUSE_FLG_ACTIVE 0x0001 // Mouse is currently active - #define GMOUSE_FLG_CLICK_TIMER 0x0002 // Currently timing a click event - #define GMOUSE_FLG_INDELTA 0x0004 // Currently in a up/down transition test - #define GMOUSE_FLG_CLIP 0x0008 // Clip reading to the display - #define GMOUSE_FLG_CALIBRATE 0x0010 // Calibrate readings - #define GMOUSE_FLG_CAL_INPROGRESS 0x0020 // Calibrate is currently in progress - #define GMOUSE_FLG_CAL_SAVED 0x0040 // Calibration has been saved - #define GMOUSE_FLG_FINGERMODE 0x0080 // Mouse is currently in finger mode - #define GMOUSE_FLG_NEEDREAD 0x0100 // The mouse needs reading + #define GMOUSE_FLG_CLICK_TIMER 0x0001 // Currently timing a click + #define GMOUSE_FLG_INDELTA 0x0002 // Currently in a up/down transition test + #define GMOUSE_FLG_CLIP 0x0004 // Clip reading to the display + #define GMOUSE_FLG_CALIBRATE 0x0008 // Calibrate readings + #define GMOUSE_FLG_IN_CAL 0x0010 // Currently in calibration routine + #define GMOUSE_FLG_FINGERMODE 0x0020 // Mouse is currently in finger mode + #define GMOUSE_FLG_NEEDREAD 0x0040 // The mouse needs reading point clickpos; // The position of the last click event systemticks_t clicktime; // The time of the last click event GDisplay * display; // The display the mouse is associated with #if !GINPUT_TOUCH_NOCALIBRATE - GMouseCalibrationSaveRoutine fnsavecal; // The calibration load routine - GMouseCalibrationLoadRoutine fnloadcal; // The calibration save routine GMouseCalibration caldata; // The calibration data #endif // Other driver specific fields may follow. @@ -77,8 +73,10 @@ typedef struct GMouseVMT { #define GMOUSE_VFLG_CALIBRATE 0x0010 // This device requires calibration #define GMOUSE_VFLG_CAL_EXTREMES 0x0020 // Use edge to edge calibration #define GMOUSE_VFLG_CAL_TEST 0x0040 // Test the results of the calibration + #define GMOUSE_VFLG_CAL_LOADFREE 0x0080 // Call gfxFree on the buffer returned by the VMT calload() routine. #define GMOUSE_VFLG_ONLY_DOWN 0x0100 // This device returns a valid position only when the mouse is down #define GMOUSE_VFLG_POORUPDOWN 0x0200 // Position readings during up/down are unreliable + #define GMOUSE_VFLG_DYNAMICONLY 0x8000 // This mouse driver should not be statically initialized eg Win32 coord_t z_max; // TOUCH: Maximum possible z value (fully touched) coord_t z_min; // TOUCH: Minimum possible z value (touch off screen). Note may also be > z_max coord_t z_touchon; // TOUCH: z values between z_max and this are a solid touch on @@ -87,10 +85,11 @@ typedef struct GMouseVMT { GMouseJitter pen_jitter; // PEN MODE: Jitter settings GMouseJitter finger_jitter; // FINGER MODE: Jitter settings - bool_t (*init)(GMouse *m); // Required + bool_t (*init)(GMouse *m, unsigned driverinstance); // Required + void (*deinit)(GMouse *m); // Optional void (*get)(GMouse *m, GMouseReading *prd); // Required void (*calsave)(GMouse *m, void *buf, size_t sz); // Optional - const char *(*calload)(GMouse *m); // Optional: Can return NULL if no data is saved. Buffer is automatically gfxFree()'d afterwards. + const char *(*calload)(GMouse *m, size_t sz); // Optional: Can return NULL if no data is saved. } GMouseVMT; #define gmvmt(m) ((const GMouseVMT const *)((m)->d.vmt)) @@ -99,9 +98,28 @@ typedef struct GMouseVMT { /* External declarations. */ /*===========================================================================*/ +// If we are not using multiple mice then hard-code the VMT name +#if !defined(GINPUT_MOUSE_DRIVER_LIST) + #undef GMOUSE_DRIVER_VMT + #define GMOUSE_DRIVER_VMT GMOUSEVMT_OnlyOne +#endif + #ifdef __cplusplus extern "C" { #endif + /** + * @brief Routines needed by the general driver VMT + * @note These routines are provided by the high level code for + * use in the GMouseVMT.d structure. + * + * @notapi + * @{ + */ + bool_t _gmouseInitDriver(GDriver *g, unsigned driverinstance, unsigned systeminstance); + void _gmousePostInitDriver(GDriver *g); + void _gmouseDeInitDriver(GDriver *g); + /** @} */ + /** * @brief Wakeup the high level code so that it attempts another read * @@ -109,7 +127,7 @@ extern "C" { * * @notapi */ - void ginputMouseWakeup(GMouse *m); + void _gmouseWakeup(GMouse *m); /** * @brief Wakeup the high level code so that it attempts another read @@ -119,7 +137,7 @@ extern "C" { * @iclass * @notapi */ - void ginputMouseWakeupI(GMouse *m); + void _gmouseWakeupI(GMouse *m); #ifdef __cplusplus } 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,72 +8,341 @@ /** * @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" -#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" - #endif - - #include // Required for memcpy - - #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) - -#endif - +// The mouse poll timer static GTIMER_DECL(MouseTimer); +// Calibration application #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; - } - */ - - 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); - } - - static inline void CalibrationCrossClear(GMouse *m, const point *pp) { - gdispGFillArea(m->display, pp->x - 15, pp->y - 15, 32, 32, CALIBRATION_BACKGROUND); - } + #if GINPUT_TOUCH_USER_CALIBRATION_LOAD + #include // Required for memcpy + #endif 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 + +static void SendMouseEvent(GSourceListener *psl, GMouse *m, GMouseReading *r) { + GEventMouse *pe; + + // 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; + } + + // 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; + + // 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); + } + + // 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 + } + + // 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; + } + } + } + } + + // 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) { float dx; @@ -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; + 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; - // Get the raw reading. - gmvmt(m)->get(m, &r); - m->flags &= ~GMOUSE_FLG_NEEDREAD; - - // 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; - // We now need display information - w = gdispGGetWidth(m->display); - h = gdispGGetHeight(m->display); + // 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); + } + + // 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; + + // Clear the current calibration point + CalibrationCrossClear(m, &cross[i]); + } + + // Apply 3 point calibration algorithm + CalibrationCalculate(m, cross, points); + + // Skip the 4th point tests if we don't want them + if (maxpoints < 4) + break; + } + + /* 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; + + // Are we in pen or finger mode + pj = (m->flags & GMOUSE_FLG_FINGERMODE) ? &gmvmt(m)->finger_jitter : &gmvmt(m)->pen_jitter; + + // Transform the co-ordinates + CalibrationTransform((GMouseReading *)&points[3], &m->caldata); - #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; + #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 = 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; + 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 + #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; + // 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; + + // 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); } } + + // We are done calibrating + gdispCloseFont(font1); + gdispCloseFont(font2); + m->flags |= GMOUSE_FLG_CALIBRATE|GMOUSE_FLG_CLIP; + m->flags &= ~GMOUSE_FLG_IN_CAL; + + // Force an initial reading + m->r.buttons = 0; + 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 } - - { - 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; - } - } - - { - 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; - - // 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; - } - - // 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; - } - } - - // 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; - } - - // 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); - } - } - } - - // 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); - } -} +#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_TOUCH_NOCALIBRATE && !GINPUT_TOUCH_STARTRAW + if ((gmvmt(m)->d.flags & GMOUSE_VFLG_CALIBRATE)) { + GMouseCalibration *pc; - #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_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); - } - - // Return our structure as the handle - return (GSourceHandle)m; + #undef m } -void ginputSetMouseDisplay(uint16_t instance, GDisplay *g) { - if (instance) +void _gmouseDeInitDriver(GDriver *g) { + (void) g; +} + +GSourceHandle ginputGetMouse(unsigned instance) { + if (instance == GMOUSE_ALL_INSTANCES) + return (GSourceHandle)&MouseTimer; + return (GSourceHandle)gdriverGetInstance(GDRIVER_TYPE_MOUSE, 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; + #if !GINPUT_TOUCH_NOCALIBRATE_GUI + if ((m->flags & GMOUSE_FLG_IN_CAL)) + return FALSE; + #endif + + #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; } -bool_t ginputCalibrateMouse(uint16_t instance) { - #if GINPUT_TOUCH_NOCALIBRATE +#if !GINPUT_TOUCH_NOTOUCH + void ginputSetFingerMode(unsigned instance, bool_t on) { + GMouse *m; - (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)) - return FALSE; - - 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; - #endif -} - -/* 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 (!(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_MOUSE_NEED_CALIBRATION && !GINPUT_MOUSE_LLD_CALIBRATION_LOADSAVE +#if !GINPUT_TOUCH_NOCALIBRATE_GUI + bool_t ginputCalibrateMouse(unsigned instance) { + GMouse *m; + + 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) { diff --git a/src/ginput/ginput_mouse.h b/src/ginput/ginput_mouse.h index 6cae66d1..1eff64f4 100644 --- a/src/ginput/ginput_mouse.h +++ b/src/ginput/ginput_mouse.h @@ -17,7 +17,7 @@ * * @pre GFX_USE_GINPUT must be set to TRUE in your gfxconf.h * @pre GINPUT_NEED_MOUSE must be set to TRUE in your gfxconf.h - * + * * @{ */ @@ -32,31 +32,29 @@ /* This type definition is also used by touch */ typedef struct GEventMouse_t { - GEventType type; // The type of this event (GEVENT_MOUSE or GEVENT_TOUCH) - coord_t x, y, z; // The position of the mouse. - // - For touch devices, Z is the current pressure if supported (otherwise 0) - // - For mice, Z is the 3rd dimension if supported (otherwise 0) - uint16_t current_buttons; // A bit is set if the button is down. - // - For touch only bit 0 is relevant - // - For mice the order of the buttons is (from 0 to n) left, right, middle, any other buttons - // - Bit 15 being set indicates that an important mouse event has been missed. - #define GINPUT_MOUSE_BTN_LEFT 0x0001 - #define GINPUT_MOUSE_BTN_RIGHT 0x0002 - #define GINPUT_MOUSE_BTN_MIDDLE 0x0004 - #define GINPUT_MOUSE_BTN_4 0x0008 - #define GINPUT_MISSED_MOUSE_EVENT 0x8000 - #define GINPUT_TOUCH_PRESSED GINPUT_MOUSE_BTN_LEFT - uint16_t last_buttons; // The value of current_buttons on the last event - enum GMouseMeta_e { - GMETA_NONE = 0, // There is no meta event currently happening - GMETA_MOUSE_DOWN = 1, // Button 0 has just gone down - GMETA_MOUSE_UP = 2, // Button 0 has just gone up - GMETA_MOUSE_CLICK = 4, // Button 0 has just gone through a short down - up cycle - GMETA_MOUSE_CXTCLICK = 8 // For mice - The right button has just been depressed - // For touch - a long press has just occurred - } meta; + GEventType type; // The type of this event (GEVENT_MOUSE or GEVENT_TOUCH) + coord_t x, y, z; // The position of the mouse. + // - For touch devices, Z is the current pressure if supported (values are device specific) + // - For mice, Z is the 3rd dimension if supported (values are device specific) + uint16_t buttons; // A bit is set if the button is down or a meta event has occurred. + #define GINPUT_MOUSE_BTN_MASK 0x000F // The "button is down" mask + #define GINPUT_MOUSE_BTN_LEFT 0x0001 // The left mouse button is currently down + #define GINPUT_MOUSE_BTN_RIGHT 0x0002 // The right mouse button is currently down + #define GINPUT_MOUSE_BTN_MIDDLE 0x0004 // The middle mouse button is currently down + #define GINPUT_MOUSE_BTN_4 0x0008 // The 4th mouse button is currently down + #define GINPUT_TOUCH_PRESSED 0x0001 // The touch surface is currently touched + + #define GMETA_MASK 0x00F0 // The "button transition" mask + #define GMETA_NONE 0x0000 // No "button transition" events + #define GMETA_MOUSE_DOWN 0x0001 // Left mouse/touch has just gone down + #define GMETA_MOUSE_UP 0x0002 // Left mouse/touch has just gone up + #define GMETA_MOUSE_CLICK 0x0004 // Left mouse/touch has just gone through a click (short down - up cycle) + #define GMETA_MOUSE_CXTCLICK 0x0008 // Right mouse has just been depressed or touch has gone through a long click + + #define GINPUT_MISSED_MOUSE_EVENT 0x8000 // Oops - a mouse event has previously been missed + GDisplay * display; // The display this mouse is currently associated with. - } GEventMouse; +} GEventMouse; // Mouse/Touch Listen Flags - passed to geventAddSourceToListener() #define GLISTEN_MOUSEMETA 0x0001 // Create events for meta events such as CLICK and CXTCLICK @@ -68,12 +66,13 @@ typedef struct GEventMouse_t { #define GLISTEN_TOUCHUPMOVES GLISTEN_MOUSEUPMOVES #define GLISTEN_TOUCHNOFILTER GLISTEN_MOUSENOFILTER -#define GINPUT_MOUSE_NUM_PORTS 1 // The total number of mouse/touch inputs supported - // Event types for the mouse ginput source #define GEVENT_MOUSE (GEVENT_GINPUT_FIRST+0) #define GEVENT_TOUCH (GEVENT_GINPUT_FIRST+1) +// All mice +#define GMOUSE_ALL_INSTANCES ((unsigned)-1) + /*===========================================================================*/ /* External declarations. */ /*===========================================================================*/ @@ -83,16 +82,32 @@ extern "C" { #endif /** - * @brief Creates an instance of a mouse and returns the Source handler - * @note HACK: if the instance is 9999, it is treated as instance 0 except - * that no calibration will be performed! + * @brief Get the Source handler for a mouse using the instance number * - * @param[in] instance The ID of the mouse input instance (from 0 to 9999) + * @param[in] instance The mouse instance number * - * @return The source handle of the created instance + * @return The source handle of the mouse or NULL + * @note You can use the special value of GMOUSE_ALL_INSTANCES to + * get a source handle that returns events for all mice rather + * than a specific mouse. Using GMOUSE_ALL_INSTANCES will always + * return a valid spurce handle even if there are currently no mice + * in the system. */ - GSourceHandle ginputGetMouse(uint16_t instance); - + GSourceHandle ginputGetMouse(unsigned instance); + + /** + * @brief Should this device be in Pen mode or Finger mode + * @note A touch device (and even theoritically a mouse) can operate + * in either pen or finger mode. In finger mode typically a + * touch device will be far more tolerant of movement and other + * inaccuracies. Each driver specifies its own tolerances for + * pen versus finger mode. + * + * @param[in] instance The ID of the mouse input instance + * @param[in] on If true then finger mode is turned on. + */ + void ginputSetFingerMode(unsigned instance, bool_t on); + /** * @brief Assign the display associated with the mouse * @note This only needs to be called if the mouse is associated with a display @@ -104,7 +119,7 @@ extern "C" { * @param[in] instance The ID of the mouse input instance * @param[in] g The GDisplay to which this mouse belongs */ - void ginputSetMouseDisplay(uint16_t instance, GDisplay *g); + void ginputSetMouseDisplay(unsigned instance, GDisplay *g); /** * @brief Get the display currently associated with the mouse @@ -112,7 +127,7 @@ extern "C" { * * @param[in] instance The ID of the mouse input instance */ - GDisplay *ginputGetMouseDisplay(uint16_t instance); + GDisplay *ginputGetMouseDisplay(unsigned instance); /** * @brief Get the current mouse position and button status @@ -124,7 +139,7 @@ extern "C" { * * @return FALSE on an error (eg. invalid instance) */ - bool_t ginputGetMouseStatus(uint16_t instance, GEventMouse *pmouse); + bool_t ginputGetMouseStatus(unsigned instance, GEventMouse *pmouse); /** * @brief Performs a calibration @@ -133,42 +148,37 @@ extern "C" { * * @return FALSE if the driver dosen't support a calibration of if the handle is invalid */ - bool_t ginputCalibrateMouse(uint16_t instance); + bool_t ginputCalibrateMouse(unsigned instance); - /* Set the routines to save and fetch calibration data. - * This function should be called before first calling ginputGetMouse() for a particular instance - * as the gdispGetMouse() 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 gdispGetMouse() 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. - */ - typedef void (*GMouseCalibrationSaveRoutine)(uint16_t instance, const uint8_t *calbuf, size_t sz); // Save calibration data - typedef const char * (*GMouseCalibrationLoadRoutine)(uint16_t instance); // Load calibration data (returns NULL if not data saved) + /** + * @brief Load a set of mouse calibration data + * @return A pointer to the data or NULL on failure + * + * @param[in] instance The mouse input instance number + * @param[in] sz The size in bytes of the data to retrieve. + * + * @note This routine is provided by the user application. It is only + * called if GINPUT_TOUCH_USER_CALIBRATION_LOAD has been set to TRUE in the + * users gfxconf.h file. + * @note If GINPUT_TOUCH_USER_CALIBRATION_FREE has been set to TRUE in the users + * gfxconf.h file then the buffer returned will be free'd using gfxFree(). + */ + void *LoadMouseCalibration(unsigned instance, size_t sz); - /** - * @brief Set the routines to store and restore calibration data + /** + * @brief Save a set of mouse calibration data + * @return TRUE if the save operation was successful. + * + * @param[in] instance The mouse input instance number + * @param[in] data The data to save + * @param[in] sz The size in bytes of the data to retrieve. * - * @details This function should be called before first calling ginputGetMouse() for a particular instance - * as the gdispGetMouse() 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 gdispGetMouse() has been called and the driver requires calibration storage, it will immediately save the - * data is has already obtained. - * - * @param[in] instance The ID of the mouse input instance - * @param[in] fnsave The routine to save the data - * @param[in] fnload The routine to restore the data - * @param[in] requireFree TRUE if the buffer returned by the load function must be freed by the mouse code. - */ - void ginputSetMouseCalibrationRoutines(uint16_t instance, GMouseCalibrationSaveRoutine fnsave, GMouseCalibrationLoadRoutine fnload, bool_t requireFree); + * @note This routine is provided by the user application. It is only + * called if GINPUT_TOUCH_USER_CALIBRATION_SAVE has been set to TRUE in the + * users gfxconf.h file. + */ + bool_t SaveMouseCalibration(unsigned instance, const void *data, size_t sz); - /** - * @brief Test if a particular mouse/touch instance requires routines to save it's alibration data - * @note Not implemented yet - * - * @param[in] instance The ID of the mouse input instance - * - * @return TRUE if needed - */ - bool_t ginputRequireMouseCalibrationStorage(uint16_t instance); - #ifdef __cplusplus } #endif diff --git a/src/ginput/sys_options.h b/src/ginput/sys_options.h index 7ccc7b78..e67a03ce 100644 --- a/src/ginput/sys_options.h +++ b/src/ginput/sys_options.h @@ -73,41 +73,97 @@ * @{ */ /** - * @brief Turn off touch mouse support. + * @brief Start touch devices without loading or running calibration. * @details Defaults to FALSE - * @note Touch device handling requires a lot of code. If your mouse doesn't require it - * this can be turned off to save a lot of space. + * @note This is used if you want to manually control the initial calibration + * process. In practice this is only useful for a touch driver test program. */ - #ifndef GINPUT_TOUCH_NOTOUCH - #define GINPUT_TOUCH_NOTOUCH FALSE + #ifndef GINPUT_TOUCH_STARTRAW + #define GINPUT_TOUCH_STARTRAW FALSE + #endif + /** + * @brief Turn off the touch calibration GUI. + * @details Defaults to FALSE + * @note Turning off the calibration GUI just turns off the manual calibration + * process. Readings may still be calibrated if calibration data + * can be loaded. + * @note Calibration requires a lot of code. If your device doesn't require it + * using this option can save a lot of space. + */ + #ifndef GINPUT_TOUCH_NOCALIBRATE_GUI + #define GINPUT_TOUCH_NOCALIBRATE_GUI FALSE #endif /** - * @brief Turn off calibration support. + * @brief Turn off all touch calibration support. * @details Defaults to FALSE - * @note Calibration requires a lot of code. If your mouse doesn't require it - * this can be turned off to save a lot of space. + * @note With this set to TRUE touch readings will not be calibrated. + * @note This automatically turns off the calibration GUI too! + * @note Calibration requires a lot of code. If your device doesn't require it + * using this option can save a lot of space. */ #ifndef GINPUT_TOUCH_NOCALIBRATE #define GINPUT_TOUCH_NOCALIBRATE FALSE #endif + /** + * @brief Turn off all touch support. + * @details Defaults to FALSE + * @note This automatically turns off all calibration and the calibration GUI too! + * @note Touch device handling requires a lot of code. If your device doesn't require it + * using this option can save a lot of space. + */ + #ifndef GINPUT_TOUCH_NOTOUCH + #define GINPUT_TOUCH_NOTOUCH FALSE + #endif /** * @brief Milliseconds between mouse polls. * @details Defaults to 25 millseconds * @note How often mice should be polled. More often leads to smoother mouse movement - * but increases CPU usage. If no mouse drivers need polling the poll is not - * started. + * but increases CPU usage. */ #ifndef GINPUT_MOUSE_POLL_PERIOD #define GINPUT_MOUSE_POLL_PERIOD 25 #endif /** - * @brief Milliseconds separating a CLICK from a CXTCLICK. - * @details Defaults to 700 millseconds - * @note How long it takes for a click to turn into a CXTCLICK on a touch device. + * @brief Maximum length of CLICK in milliseconds + * @details Defaults to 300 millseconds + * @note Mouse down to Mouse up times greater than this are not clicks. */ - #ifndef GINPUT_TOUCH_CLICK_TIME - #define GINPUT_TOUCH_CLICK_TIME 700 + #ifndef GINPUT_MOUSE_CLICK_TIME + #define GINPUT_MOUSE_CLICK_TIME 300 + #endif + /** + * @brief Milliseconds to generate a CXTCLICK on a touch device. + * @details Defaults to 700 millseconds + * @note If you hold the touch down for longer than this a CXTCLICK is generated + * but only on a touch device. + */ + #ifndef GINPUT_TOUCH_CXTCLICK_TIME + #define GINPUT_TOUCH_CXTCLICK_TIME 700 + #endif + /** + * @brief There is a user supplied routine to load mouse calibration data + * @details Defaults to FALSE + * @note If TRUE the user must supply the @p LoadMouseCalibration() routine. + */ + #ifndef GINPUT_TOUCH_USER_CALIBRATION_LOAD + #define GINPUT_TOUCH_USER_CALIBRATION_LOAD FALSE + #endif + /** + * @brief The buffer returned by the users @p LoadMouseCalibration() routine must be gfxFree()'d + * by the mouse code. + * @details Defaults to FALSE + */ + #ifndef GINPUT_TOUCH_USER_CALIBRATION_FREE + #define GINPUT_TOUCH_USER_CALIBRATION_FREE FALSE + #endif + /** + * @brief There is a user supplied routine to save mouse calibration data + * @details Defaults to FALSE + * @note If TRUE the user must supply the @p SaveMouseCalibration() routine. + */ + #ifndef GINPUT_TOUCH_USER_CALIBRATION_SAVE + #define GINPUT_TOUCH_USER_CALIBRATION_SAVE FALSE #endif /** @} */ diff --git a/src/ginput/sys_rules.h b/src/ginput/sys_rules.h index f98cc469..d9a367ce 100644 --- a/src/ginput/sys_rules.h +++ b/src/ginput/sys_rules.h @@ -31,6 +31,21 @@ #undef GFX_USE_GTIMER #define GFX_USE_GTIMER TRUE #endif + #if GINPUT_NEED_MOUSE + #if GINPUT_TOUCH_NOTOUCH + // No warning needed for this + #undef GINPUT_TOUCH_NOCALIBRATE + #define GINPUT_TOUCH_NOCALIBRATE TRUE + #endif + #if GINPUT_TOUCH_NOCALIBRATE + // No warning needed for this + #undef GINPUT_TOUCH_NOCALIBRATE_GUI + #define GINPUT_TOUCH_NOCALIBRATE_GUI TRUE + #endif + #if !GINPUT_TOUCH_NOTOUCH && GINPUT_MOUSE_CLICK_TIME > GINPUT_TOUCH_CXTCLICK_TIME + #error "GINPUT MOUSE: The GINPUT_MOUSE_CLICK_TIME must be <= GINPUT_TOUCH_CXTCLICK_TIME" + #endif + #endif #endif #endif /* _GINPUT_RULES_H */ diff --git a/src/gwin/gwin_widget.c b/src/gwin/gwin_widget.c index f85e6f20..cf1f59c7 100644 --- a/src/gwin/gwin_widget.c +++ b/src/gwin/gwin_widget.c @@ -114,7 +114,7 @@ static void gwidgetEvent(void *param, GEvent *pe) { // Is the mouse currently captured by this widget? if ((h->flags & (GWIN_FLG_WIDGET|GWIN_FLG_MOUSECAPTURE)) == (GWIN_FLG_WIDGET|GWIN_FLG_MOUSECAPTURE)) { gh = h; - if ((pme->last_buttons & ~pme->current_buttons & GINPUT_MOUSE_BTN_LEFT)) { + if ((pme->buttons & GMETA_MOUSE_UP)) { gh->flags &= ~GWIN_FLG_MOUSECAPTURE; if (wvmt->MouseUp) wvmt->MouseUp(gw, pme->x - gh->x, pme->y - gh->y); @@ -133,7 +133,7 @@ static void gwidgetEvent(void *param, GEvent *pe) { // Process any mouse down over the highest order window if it is an enabled widget if (gh && (gh->flags & (GWIN_FLG_WIDGET|GWIN_FLG_SYSENABLED)) == (GWIN_FLG_WIDGET|GWIN_FLG_SYSENABLED)) { - if ((~pme->last_buttons & pme->current_buttons & GINPUT_MOUSE_BTN_LEFT)) { + if ((pme->buttons & GMETA_MOUSE_DOWN)) { gh->flags |= GWIN_FLG_MOUSECAPTURE; if (wvmt->MouseDown) wvmt->MouseDown(gw, pme->x - gh->x, pme->y - gh->y); @@ -234,6 +234,7 @@ void _gwidgetInit(void) { geventListenerInit(&gl); geventRegisterCallback(&gl, gwidgetEvent, 0); + geventAttachSource(&gl, ginputGetMouse(GMOUSE_ALL_INSTANCES), GLISTEN_MOUSEMETA|GLISTEN_MOUSEDOWNMOVES); } void _gwidgetDeinit(void) @@ -427,13 +428,10 @@ bool_t gwinAttachListener(GListener *pl) { } #if GFX_USE_GINPUT && GINPUT_NEED_MOUSE - bool_t gwinAttachMouse(uint16_t instance) { - GSourceHandle gsh; - - if (!(gsh = ginputGetMouse(instance))) - return FALSE; - - return geventAttachSource(&gl, gsh, GLISTEN_MOUSEMETA|GLISTEN_MOUSEDOWNMOVES); + bool_t DEPRECATED("This call can now be removed. Attaching the mouse to GWIN is now automatic.") gwinAttachMouse(uint16_t instance) { + // This is now a NULL event because we automatically attach to all mice in the system. + (void) instance; + return TRUE; } #endif diff --git a/src/gwin/gwin_widget.h b/src/gwin/gwin_widget.h index 81c76263..2c503116 100644 --- a/src/gwin/gwin_widget.h +++ b/src/gwin/gwin_widget.h @@ -199,7 +199,7 @@ void gwinSetDefaultStyle(const GWidgetStyle *pstyle, bool_t updateAll); * @brief Get the current default style. * * @return The current default style. - * + * * @api */ const GWidgetStyle *gwinGetDefaultStyle(void); @@ -315,7 +315,7 @@ bool_t gwinAttachListener(GListener *pl); * * @api */ - bool_t gwinAttachMouse(uint16_t instance); + bool_t DEPRECATED("This call can now be removed. Attaching the mouse to GWIN is now automatic.") gwinAttachMouse(uint16_t instance); #endif #if (GFX_USE_GINPUT && GINPUT_NEED_TOGGLE) || defined(__DOXYGEN__)