576 lines
17 KiB
C
576 lines
17 KiB
C
/****************************************************************************
|
|
* apps/graphics/pdcurses/pdc_mouse.c
|
|
* Public Domain Curses
|
|
* RCSID("$Id: mouse.c,v 1.45 2008/07/13 16:08:18 wmcbrine Exp $")
|
|
*
|
|
* Copyright (C) 2017 Gregory Nutt. All rights reserved.
|
|
* Adapted by: Gregory Nutt <gnutt@nuttx.org>
|
|
*
|
|
* Adapted from the original public domain pdcurses by Gregory Nutt and
|
|
* released as part of NuttX under the 3-clause BSD license:
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
* 3. Neither the name NuttX nor the names of its contributors may be
|
|
* used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
|
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
|
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
****************************************************************************/
|
|
|
|
/* Name: mouse
|
|
*
|
|
* Synopsis:
|
|
* int mouse_set(unsigned long mbe);
|
|
* int mouse_on(unsigned long mbe);
|
|
* int mouse_off(unsigned long mbe);
|
|
* int request_mouse_pos(void);
|
|
* int map_button(unsigned long button);
|
|
* void wmouse_position(WINDOW *win, int *y, int *x);
|
|
* unsigned long getmouse(void);
|
|
* unsigned long getbmap(void);
|
|
*
|
|
* int mouseinterval(int wait);
|
|
* bool wenclose(const WINDOW *win, int y, int x);
|
|
* bool wmouse_trafo(const WINDOW *win, int *y, int *x, bool to_screen);
|
|
* bool mouse_trafo(int *y, int *x, bool to_screen);
|
|
* mmask_t mousemask(mmask_t mask, mmask_t *oldmask);
|
|
* int nc_getmouse(MEVENT *event);
|
|
* int ungetmouse(MEVENT *event);
|
|
*
|
|
* Description:
|
|
* As of PDCurses 3.0, there are two separate mouse interfaces: the
|
|
* classic interface, which is based on the undocumented Sys V
|
|
* mouse functions; and an ncurses-compatible interface. Both are
|
|
* active at all times, and you can mix and match functions from
|
|
* each, though it's not recommended. The ncurses interface is
|
|
* essentially an emulation layer built on top of the classic
|
|
* interface; it's here to allow easier porting of ncurses apps.
|
|
*
|
|
* The classic interface: mouse_set(), mouse_on(), mouse_off(),
|
|
* request_mouse_pos(), map_button(), wmouse_position(),
|
|
* getmouse(), and getbmap(). An application using this interface
|
|
* would start by calling mouse_set() or mouse_on() with a non-zero
|
|
* value, often ALL_MOUSE_EVENTS. Then it would check for a
|
|
* KEY_MOUSE return from getch(). If found, it would call
|
|
* request_mouse_pos() to get the current mouse status.
|
|
*
|
|
* mouse_set(), mouse_on() and mouse_off() are analogous to
|
|
* attrset(), attron() and attroff(). These functions set the
|
|
* mouse button events to trap. The button masks used in these
|
|
* functions are defined in curses.h and can be or'ed together.
|
|
* They are the group of masks starting with BUTTON1_RELEASED.
|
|
*
|
|
* request_mouse_pos() requests curses to fill in the Mouse_status
|
|
* structure with the current state of the mouse.
|
|
*
|
|
* map_button() enables the specified mouse action to activate the
|
|
* Soft Label Keys if the action occurs over the area of the screen
|
|
* where the Soft Label Keys are displayed. The mouse actions are
|
|
* defined in curses.h in the group that starts with BUTTON_RELEASED.
|
|
*
|
|
* wmouse_position() determines if the current mouse position is
|
|
* within the window passed as an argument. If the mouse is
|
|
* outside the current window, -1 is returned in the y and x
|
|
* arguments; otherwise the y and x coordinates of the mouse
|
|
* (relative to the top left corner of the window) are returned in
|
|
* y and x.
|
|
*
|
|
* getmouse() returns the current status of the trapped mouse
|
|
* buttons as set by mouse_set() or mouse_on().
|
|
*
|
|
* getbmap() returns the current status of the button action used
|
|
* to map a mouse action to the Soft Label Keys as set by the
|
|
* map_button() function.
|
|
*
|
|
* The ncurses interface: mouseinterval(), wenclose(),
|
|
* wmouse_trafo(), mouse_trafo(), mousemask(), nc_getmouse(), and
|
|
* ungetmouse(). A typical application using this interface would
|
|
* start by calling mousemask() with a non-zero value, often
|
|
* ALL_MOUSE_EVENTS. Then it would check for a KEY_MOUSE return
|
|
* from getch(). If found, it would call nc_getmouse() to get the
|
|
* current mouse status.
|
|
*
|
|
* mouseinterval() sets the timeout for a mouse click. On all
|
|
* current platforms, PDCurses receives mouse button press and
|
|
* release events, but must synthesize click events. It does this
|
|
* by checking whether a release event is queued up after a press
|
|
* event. If it gets a press event, and there are no more events
|
|
* waiting, it will wait for the timeout interval, then check again
|
|
* for a release. A press followed by a release is reported as
|
|
* BUTTON_CLICKED; otherwise it's passed through as BUTTON_PRESSED.
|
|
* The default timeout is 150ms; valid values are 0 (no clicks
|
|
* reported) through 1000ms. In x11, the timeout can also be set
|
|
* via the clickPeriod resource. The return value from
|
|
* mouseinterval() is the old timeout. To check the old value
|
|
* without setting a new one, call it with a parameter of -1. Note
|
|
* that although there's no classic equivalent for this function
|
|
* (apart from the clickPeriod resource), the value set applies in
|
|
* both interfaces.
|
|
*
|
|
* wenclose() reports whether the given screen-relative y, x
|
|
* coordinates fall within the given window.
|
|
*
|
|
* wmouse_trafo() converts between screen-relative and window-
|
|
* relative coordinates. A to_screen parameter of true means to
|
|
* convert from window to screen; otherwise the reverse. The
|
|
* function returns false if the coordinates aren't within the
|
|
* window, or if any of the parameters are NULL. The coordinates
|
|
* have been converted when the function returns true.
|
|
*
|
|
* mouse_trafo() is the stdscr version of wmouse_trafo().
|
|
*
|
|
* mousemask() is nearly equivalent to mouse_set(), but instead of
|
|
* OK/ERR, it returns the value of the mask after setting it. (This
|
|
* isn't necessarily the same value passed in, since the mask could
|
|
* be altered on some platforms.) And if the second parameter is a
|
|
* non-null pointer, mousemask() stores the previous mask value
|
|
* there. Also, since the ncurses interface doesn't work with
|
|
* PDCurses' BUTTON_MOVED events, mousemask() filters them out.
|
|
*
|
|
* nc_getmouse() returns the current mouse status in an MEVENT
|
|
* struct. This is equivalent to ncurses' getmouse(), renamed to
|
|
* avoid conflict with PDCurses' getmouse(). But if you define
|
|
* NCURSES_MOUSE_VERSION (preferably as 2) before including
|
|
* curses.h, it defines getmouse() to nc_getmouse(), along with a
|
|
* few other redefinitions needed for compatibility with ncurses
|
|
* code. nc_getmouse() calls request_mouse_pos(), which (not
|
|
* getmouse()) is the classic equivalent.
|
|
*
|
|
* ungetmouse() is the mouse equivalent of ungetch(). However,
|
|
* PDCurses doesn't maintain a queue of mouse events; only one can
|
|
* be pushed back, and it can overwrite or be overwritten by real
|
|
* mouse events.
|
|
*
|
|
* Portability X/Open BSD SYS V
|
|
* mouse_set - - 4.0
|
|
* mouse_on - - 4.0
|
|
* mouse_off - - 4.0
|
|
* request_mouse_pos - - 4.0
|
|
* map_button - - 4.0
|
|
* wmouse_position - - 4.0
|
|
* getmouse - - 4.0
|
|
* getbmap - - 4.0
|
|
* mouseinterval - - -
|
|
* wenclose - - -
|
|
* wmouse_trafo - - -
|
|
* mouse_trafo - - -
|
|
* mousemask - - -
|
|
* nc_getmouse - - -
|
|
* ungetmouse - - -
|
|
*/
|
|
|
|
/****************************************************************************
|
|
* Included Files
|
|
****************************************************************************/
|
|
|
|
#include <string.h>
|
|
|
|
#include "curspriv.h"
|
|
|
|
/****************************************************************************
|
|
* Private Data
|
|
****************************************************************************/
|
|
|
|
#ifndef CONFIG_PDCURSES_MULTITHREAD
|
|
static bool ungot = false;
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
* Public Functions
|
|
****************************************************************************/
|
|
|
|
int mouse_set(unsigned long mbe)
|
|
{
|
|
#ifdef CONFIG_PDCURSES_MULTITHREAD
|
|
FAR struct pdc_context_s *ctx = PDC_ctx();
|
|
#endif
|
|
PDC_LOG(("mouse_set() - called: event %x\n", mbe));
|
|
|
|
SP->_trap_mbe = mbe;
|
|
return PDC_mouse_set();
|
|
}
|
|
|
|
int mouse_on(unsigned long mbe)
|
|
{
|
|
#ifdef CONFIG_PDCURSES_MULTITHREAD
|
|
FAR struct pdc_context_s *ctx = PDC_ctx();
|
|
#endif
|
|
PDC_LOG(("mouse_on() - called: event %x\n", mbe));
|
|
|
|
SP->_trap_mbe |= mbe;
|
|
return PDC_mouse_set();
|
|
}
|
|
|
|
int mouse_off(unsigned long mbe)
|
|
{
|
|
#ifdef CONFIG_PDCURSES_MULTITHREAD
|
|
FAR struct pdc_context_s *ctx = PDC_ctx();
|
|
#endif
|
|
PDC_LOG(("mouse_off() - called: event %x\n", mbe));
|
|
|
|
SP->_trap_mbe &= ~mbe;
|
|
return PDC_mouse_set();
|
|
}
|
|
|
|
int map_button(unsigned long button)
|
|
{
|
|
#ifdef CONFIG_PDCURSES_MULTITHREAD
|
|
FAR struct pdc_context_s *ctx = PDC_ctx();
|
|
#endif
|
|
PDC_LOG(("map_button() - called: button %x\n", button));
|
|
|
|
/* This does nothing at the moment */
|
|
|
|
SP->_map_mbe_to_key = button;
|
|
return OK;
|
|
}
|
|
|
|
int request_mouse_pos(void)
|
|
{
|
|
#ifdef CONFIG_PDCURSES_MULTITHREAD
|
|
FAR struct pdc_context_s *ctx = PDC_ctx();
|
|
#endif
|
|
PDC_LOG(("request_mouse_pos() - called\n"));
|
|
|
|
Mouse_status = pdc_mouse_status;
|
|
return OK;
|
|
}
|
|
|
|
void wmouse_position(WINDOW *win, int *y, int *x)
|
|
{
|
|
#ifdef CONFIG_PDCURSES_MULTITHREAD
|
|
FAR struct pdc_context_s *ctx = PDC_ctx();
|
|
#endif
|
|
PDC_LOG(("wmouse_position() - called\n"));
|
|
|
|
if (win && wenclose(win, MOUSE_Y_POS, MOUSE_X_POS))
|
|
{
|
|
if (y)
|
|
{
|
|
*y = MOUSE_Y_POS - win->_begy;
|
|
}
|
|
|
|
if (x)
|
|
{
|
|
*x = MOUSE_X_POS - win->_begx;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (y)
|
|
{
|
|
*y = -1;
|
|
}
|
|
|
|
if (x)
|
|
{
|
|
*x = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
unsigned long getmouse(void)
|
|
{
|
|
#ifdef CONFIG_PDCURSES_MULTITHREAD
|
|
FAR struct pdc_context_s *ctx = PDC_ctx();
|
|
#endif
|
|
PDC_LOG(("getmouse() - called\n"));
|
|
|
|
return SP->_trap_mbe;
|
|
}
|
|
|
|
unsigned long getbmap(void)
|
|
{
|
|
#ifdef CONFIG_PDCURSES_MULTITHREAD
|
|
FAR struct pdc_context_s *ctx = PDC_ctx();
|
|
#endif
|
|
PDC_LOG(("getbmap() - called\n"));
|
|
|
|
return SP->_map_mbe_to_key;
|
|
}
|
|
|
|
/* ncurses mouse interface */
|
|
|
|
int mouseinterval(int wait)
|
|
{
|
|
#ifdef CONFIG_PDCURSES_MULTITHREAD
|
|
FAR struct pdc_context_s *ctx = PDC_ctx();
|
|
#endif
|
|
int old_wait;
|
|
|
|
PDC_LOG(("mouseinterval() - called: %d\n", wait));
|
|
|
|
old_wait = SP->mouse_wait;
|
|
|
|
if (wait >= 0 && wait <= 1000)
|
|
{
|
|
SP->mouse_wait = wait;
|
|
}
|
|
|
|
return old_wait;
|
|
}
|
|
|
|
bool wenclose(const WINDOW *win, int y, int x)
|
|
{
|
|
PDC_LOG(("wenclose() - called: %p %d %d\n", win, y, x));
|
|
|
|
return (win && y >= win->_begy && y < win->_begy + win->_maxy &&
|
|
x >= win->_begx && x < win->_begx + win->_maxx);
|
|
}
|
|
|
|
bool wmouse_trafo(const WINDOW *win, int *y, int *x, bool to_screen)
|
|
{
|
|
int newy, newx;
|
|
|
|
PDC_LOG(("wmouse_trafo() - called\n"));
|
|
|
|
if (!win || !y || !x)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
newy = *y;
|
|
newx = *x;
|
|
|
|
if (to_screen)
|
|
{
|
|
newy += win->_begy;
|
|
newx += win->_begx;
|
|
|
|
if (!wenclose(win, newy, newx))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (wenclose(win, newy, newx))
|
|
{
|
|
newy -= win->_begy;
|
|
newx -= win->_begx;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
*y = newy;
|
|
*x = newx;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool mouse_trafo(int *y, int *x, bool to_screen)
|
|
{
|
|
#ifdef CONFIG_PDCURSES_MULTITHREAD
|
|
FAR struct pdc_context_s *ctx = PDC_ctx();
|
|
#endif
|
|
PDC_LOG(("mouse_trafo() - called\n"));
|
|
|
|
return wmouse_trafo(stdscr, y, x, to_screen);
|
|
}
|
|
|
|
mmask_t mousemask(mmask_t mask, mmask_t * oldmask)
|
|
{
|
|
#ifdef CONFIG_PDCURSES_MULTITHREAD
|
|
FAR struct pdc_context_s *ctx = PDC_ctx();
|
|
#endif
|
|
PDC_LOG(("mousemask() - called\n"));
|
|
|
|
if (oldmask)
|
|
{
|
|
*oldmask = SP->_trap_mbe;
|
|
}
|
|
|
|
/* The ncurses interface doesn't work with our move events, so filter them
|
|
* here */
|
|
|
|
mask &= ~(BUTTON1_MOVED | BUTTON2_MOVED | BUTTON3_MOVED);
|
|
mouse_set(mask);
|
|
return SP->_trap_mbe;
|
|
}
|
|
|
|
int nc_getmouse(MEVENT * event)
|
|
{
|
|
int i;
|
|
#ifdef CONFIG_PDCURSES_MULTITHREAD
|
|
FAR struct pdc_context_s *ctx = PDC_ctx();
|
|
#endif
|
|
mmask_t bstate = 0;
|
|
|
|
PDC_LOG(("nc_getmouse() - called\n"));
|
|
|
|
if (!event)
|
|
{
|
|
return ERR;
|
|
}
|
|
|
|
ungot = false;
|
|
|
|
request_mouse_pos();
|
|
|
|
event->id = 0;
|
|
|
|
event->x = Mouse_status.x;
|
|
event->y = Mouse_status.y;
|
|
event->z = 0;
|
|
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
if (Mouse_status.changes & (1 << i))
|
|
{
|
|
int shf = i * 5;
|
|
short button = Mouse_status.button[i] & BUTTON_ACTION_MASK;
|
|
|
|
if (button == BUTTON_RELEASED)
|
|
{
|
|
bstate |= (BUTTON1_RELEASED << shf);
|
|
}
|
|
else if (button == BUTTON_PRESSED)
|
|
{
|
|
bstate |= (BUTTON1_PRESSED << shf);
|
|
}
|
|
else if (button == BUTTON_CLICKED)
|
|
{
|
|
bstate |= (BUTTON1_CLICKED << shf);
|
|
}
|
|
else if (button == BUTTON_DOUBLE_CLICKED)
|
|
{
|
|
bstate |= (BUTTON1_DOUBLE_CLICKED << shf);
|
|
}
|
|
|
|
button = Mouse_status.button[i] & BUTTON_MODIFIER_MASK;
|
|
|
|
if (button & PDC_BUTTON_SHIFT)
|
|
{
|
|
bstate |= BUTTON_MODIFIER_SHIFT;
|
|
}
|
|
|
|
if (button & PDC_BUTTON_CONTROL)
|
|
{
|
|
bstate |= BUTTON_MODIFIER_CONTROL;
|
|
}
|
|
|
|
if (button & PDC_BUTTON_ALT)
|
|
{
|
|
bstate |= BUTTON_MODIFIER_ALT;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (MOUSE_WHEEL_UP)
|
|
{
|
|
bstate |= BUTTON4_PRESSED;
|
|
}
|
|
else if (MOUSE_WHEEL_DOWN)
|
|
{
|
|
bstate |= BUTTON5_PRESSED;
|
|
}
|
|
|
|
/* extra filter pass -- mainly for button modifiers */
|
|
|
|
event->bstate = bstate & SP->_trap_mbe;
|
|
return OK;
|
|
}
|
|
|
|
int ungetmouse(MEVENT * event)
|
|
{
|
|
int i;
|
|
unsigned long bstate;
|
|
#ifdef CONFIG_PDCURSES_MULTITHREAD
|
|
FAR struct pdc_context_s *ctx = PDC_ctx();
|
|
#endif
|
|
|
|
PDC_LOG(("ungetmouse() - called\n"));
|
|
|
|
if (!event || ungot)
|
|
{
|
|
return ERR;
|
|
}
|
|
|
|
ungot = true;
|
|
|
|
pdc_mouse_status.x = event->x;
|
|
pdc_mouse_status.y = event->y;
|
|
|
|
pdc_mouse_status.changes = 0;
|
|
bstate = event->bstate;
|
|
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
int shf = i * 5;
|
|
short button = 0;
|
|
|
|
if (bstate & ((BUTTON1_RELEASED | BUTTON1_PRESSED |
|
|
BUTTON1_CLICKED | BUTTON1_DOUBLE_CLICKED) << shf))
|
|
{
|
|
pdc_mouse_status.changes |= 1 << i;
|
|
|
|
if (bstate & (BUTTON1_PRESSED << shf))
|
|
{
|
|
button = BUTTON_PRESSED;
|
|
}
|
|
|
|
if (bstate & (BUTTON1_CLICKED << shf))
|
|
{
|
|
button = BUTTON_CLICKED;
|
|
}
|
|
|
|
if (bstate & (BUTTON1_DOUBLE_CLICKED << shf))
|
|
{
|
|
button = BUTTON_DOUBLE_CLICKED;
|
|
}
|
|
|
|
if (bstate & BUTTON_MODIFIER_SHIFT)
|
|
{
|
|
button |= PDC_BUTTON_SHIFT;
|
|
}
|
|
|
|
if (bstate & BUTTON_MODIFIER_CONTROL)
|
|
{
|
|
button |= PDC_BUTTON_CONTROL;
|
|
}
|
|
|
|
if (bstate & BUTTON_MODIFIER_ALT)
|
|
{
|
|
button |= PDC_BUTTON_ALT;
|
|
}
|
|
}
|
|
|
|
pdc_mouse_status.button[i] = button;
|
|
}
|
|
|
|
if (bstate & BUTTON4_PRESSED)
|
|
{
|
|
pdc_mouse_status.changes |= PDC_MOUSE_WHEEL_UP;
|
|
}
|
|
else if (bstate & BUTTON5_PRESSED)
|
|
{
|
|
pdc_mouse_status.changes |= PDC_MOUSE_WHEEL_DOWN;
|
|
}
|
|
|
|
return ungetch(KEY_MOUSE);
|
|
}
|