]> ncurses.scripts.mit.edu Git - ncurses.git/blobdiff - ncurses/base/lib_mouse.c
ncurses 5.7 - patch 20091205
[ncurses.git] / ncurses / base / lib_mouse.c
index 95f29aa69111a47c8577536b921c31d823efa3cc..4034c9a77726247e3a0c02afec8c5bb692c960db 100644 (file)
@@ -1,5 +1,5 @@
 /****************************************************************************
- * Copyright (c) 1998-2007,2008 Free Software Foundation, Inc.              *
+ * Copyright (c) 1998-2008,2009 Free Software Foundation, Inc.              *
  *                                                                          *
  * Permission is hereby granted, free of charge, to any person obtaining a  *
  * copy of this software and associated documentation files (the            *
@@ -30,6 +30,7 @@
  *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
  *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
  *     and: Thomas E. Dickey                        1996-on                 *
+ *     and: Juergen Pfeifer                         2008                    *
  ****************************************************************************/
 
 /*
 
 #include <curses.priv.h>
 
-MODULE_ID("$Id: lib_mouse.c,v 1.102 2008/10/18 21:48:55 tom Exp $")
+#ifndef CUR
+#define CUR SP_TERMTYPE
+#endif
+
+MODULE_ID("$Id: lib_mouse.c,v 1.110 2009/10/24 23:21:31 tom Exp $")
 
-#include <term.h>
 #include <tic.h>
 
 #if USE_GPM_SUPPORT
@@ -150,7 +154,7 @@ make an error
 #define LIBGPM_SONAME "libgpm.so"
 #endif
 
-#define GET_DLSYM(name) (my_##name = (TYPE_##name) dlsym(SP->_dlopen_gpm, #name))
+#define GET_DLSYM(name) (my_##name = (TYPE_##name) dlsym(sp->_dlopen_gpm, #name))
 
 #endif                         /* USE_GPM_SUPPORT */
 
@@ -164,13 +168,13 @@ static void _nc_mouse_wrap(SCREEN *);
 #define LastEV(sp)     ((sp)->_mouse_events + EV_MAX - 1)
 
 #undef  NEXT
-#define NEXT(ep)       ((ep >= LastEV(sp)) \
-                        ? FirstEV(sp) \
+#define NEXT(ep)       ((ep >= LastEV(SP_PARM)) \
+                        ? FirstEV(SP_PARM) \
                         : ep + 1)
 
 #undef  PREV
-#define PREV(ep)       ((ep <= FirstEV(sp)) \
-                        ? LastEV(sp) \
+#define PREV(ep)       ((ep <= FirstEV(SP_PARM)) \
+                        ? LastEV(SP_PARM) \
                         : ep - 1)
 
 #define IndexEV(sp, ep)        (ep - FirstEV(sp))
@@ -340,10 +344,13 @@ sysmouse_server(SCREEN *sp)
 static void
 handle_sysmouse(int sig GCC_UNUSED)
 {
-    sysmouse_server(SP);
+    sysmouse_server(CURRENT_SCREEN);
 }
 #endif /* USE_SYSMOUSE */
 
+#ifndef USE_TERM_DRIVER
+#define xterm_kmous "\033[M"
+
 static void
 init_xterm_mouse(SCREEN *sp)
 {
@@ -352,6 +359,7 @@ init_xterm_mouse(SCREEN *sp)
     if (!VALID_STRING(sp->_mouse_xtermcap))
        sp->_mouse_xtermcap = "\033[?1000%?%p1%{1}%=%th%el%;";
 }
+#endif
 
 static void
 enable_xterm_mouse(SCREEN *sp, int enable)
@@ -359,7 +367,9 @@ enable_xterm_mouse(SCREEN *sp, int enable)
 #if USE_EMX_MOUSE
     sp->_emxmouse_activated = enable;
 #else
-    putp(TPARM_1(sp->_mouse_xtermcap, enable));
+    NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx
+                              "xterm-mouse",
+                              TPARM_1(sp->_mouse_xtermcap, enable));
 #endif
     sp->_mouse_active = enable;
 }
@@ -398,7 +408,7 @@ allow_gpm_mouse(void)
 static void
 unload_gpm_library(SCREEN *sp)
 {
-    if (SP->_dlopen_gpm != 0) {
+    if (sp->_dlopen_gpm != 0) {
        T(("unload GPM library"));
        sp->_mouse_gpm_loaded = FALSE;
        sp->_mouse_fd = -1;
@@ -478,8 +488,6 @@ enable_gpm_mouse(SCREEN *sp, bool enable)
 }
 #endif /* USE_GPM_SUPPORT */
 
-#define xterm_kmous "\033[M"
-
 static void
 initialize_mousetype(SCREEN *sp)
 {
@@ -514,7 +522,7 @@ initialize_mousetype(SCREEN *sp)
     /* OS/2 VIO */
 #if USE_EMX_MOUSE
     if (!sp->_emxmouse_thread
-       && strstr(cur_term->type.term_names, "xterm") == 0
+       && strstr(TerminalOf(sp)->type.term_names, "xterm") == 0
        && key_mouse) {
        int handles[2];
 
@@ -621,16 +629,21 @@ initialize_mousetype(SCREEN *sp)
     }
 #endif /* USE_SYSMOUSE */
 
+#ifdef USE_TERM_DRIVER
+    CallDriver(sp, initmouse);
+#else
     /* we know how to recognize mouse events under "xterm" */
     if (key_mouse != 0) {
        if (!strcmp(key_mouse, xterm_kmous)
-           || strstr(cur_term->type.term_names, "xterm") != 0) {
+           || strstr(TerminalOf(sp)->type.term_names, "xterm") != 0) {
            init_xterm_mouse(sp);
        }
-    } else if (strstr(cur_term->type.term_names, "xterm") != 0) {
+    } else if (strstr(TerminalOf(sp)->type.term_names, "xterm") != 0) {
        if (_nc_add_to_try(&(sp->_keytry), xterm_kmous, KEY_MOUSE) == OK)
            init_xterm_mouse(sp);
     }
+#endif
+
     returnVoid;
 }
 
@@ -694,11 +707,16 @@ _nc_mouse_event(SCREEN *sp GCC_UNUSED)
 
 #if USE_GPM_SUPPORT
     case M_GPM:
-       {
+       if (sp->_mouse_fd >= 0) {
            /* query server for event, return TRUE if we find one */
            Gpm_Event ev;
 
-           if (my_Gpm_GetEvent(&ev) == 1) {
+           switch (my_Gpm_GetEvent(&ev)) {
+           case 0:
+               /* Connection closed, drop the mouse. */
+               sp->_mouse_fd = -1;
+               break;
+           case 1:
                /* there's only one mouse... */
                eventp->id = NORMAL_EVENT;
 
@@ -731,6 +749,7 @@ _nc_mouse_event(SCREEN *sp GCC_UNUSED)
                /* bump the next-free pointer into the circular list */
                sp->_mouse_eventp = eventp = NEXT(eventp);
                result = TRUE;
+               break;
            }
        }
        break;
@@ -937,7 +956,7 @@ mouse_activate(SCREEN *sp, bool on)
        switch (sp->_mouse_type) {
        case M_XTERM:
 #if NCURSES_EXT_FUNCS
-           keyok(KEY_MOUSE, on);
+           NCURSES_SP_NAME(keyok) (NCURSES_SP_ARGx KEY_MOUSE, on);
 #endif
            TPUTS_TRACE("xterm mouse initialization");
            enable_xterm_mouse(sp, 1);
@@ -989,7 +1008,7 @@ mouse_activate(SCREEN *sp, bool on)
            return;
        }
     }
-    _nc_flush();
+    NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_ARG);
 }
 
 /**************************************************************************
@@ -1264,13 +1283,13 @@ _nc_mouse_resume(SCREEN *sp)
  *
  **************************************************************************/
 
-static int
-_nc_getmouse(SCREEN *sp, MEVENT * aevent)
+NCURSES_EXPORT(int)
+NCURSES_SP_NAME(getmouse) (NCURSES_SP_DCLx MEVENT * aevent)
 {
-    T((T_CALLED("getmouse(%p)"), aevent));
+    T((T_CALLED("getmouse(%p,%p)"), (void *) SP_PARM, (void *) aevent));
 
-    if ((aevent != 0) && (sp != 0) && (sp->_mouse_type != M_NONE)) {
-       MEVENT *eventp = sp->_mouse_eventp;
+    if ((aevent != 0) && (SP_PARM != 0) && (SP_PARM->_mouse_type != M_NONE)) {
+       MEVENT *eventp = SP_PARM->_mouse_eventp;
        /* compute the current-event pointer */
        MEVENT *prev = PREV(eventp);
 
@@ -1278,8 +1297,8 @@ _nc_getmouse(SCREEN *sp, MEVENT * aevent)
        *aevent = *prev;
 
        TR(TRACE_IEVENT, ("getmouse: returning event %s from slot %ld",
-                         _nc_tracemouse(sp, prev),
-                         (long) IndexEV(sp, prev)));
+                         _nc_tracemouse(SP_PARM, prev),
+                         (long) IndexEV(SP_PARM, prev)));
 
        prev->id = INVALID_EVENT;       /* so the queue slot becomes free */
        returnCode(OK);
@@ -1287,57 +1306,64 @@ _nc_getmouse(SCREEN *sp, MEVENT * aevent)
     returnCode(ERR);
 }
 
+#if NCURSES_SP_FUNCS
 /* grab a copy of the current mouse event */
 NCURSES_EXPORT(int)
 getmouse(MEVENT * aevent)
 {
-    return _nc_getmouse(SP, aevent);
+    return NCURSES_SP_NAME(getmouse) (CURRENT_SCREEN, aevent);
 }
+#endif
 
-static int
-_nc_ungetmouse(SCREEN *sp, MEVENT * aevent)
+NCURSES_EXPORT(int)
+NCURSES_SP_NAME(ungetmouse) (NCURSES_SP_DCLx MEVENT * aevent)
 {
     int result = ERR;
 
-    T((T_CALLED("ungetmouse(%p)"), aevent));
+    T((T_CALLED("ungetmouse(%p,%p)"), (void *) SP_PARM, (void *) aevent));
 
-    if (aevent != 0 && sp != 0) {
-       MEVENT *eventp = sp->_mouse_eventp;
+    if (aevent != 0 && SP_PARM != 0) {
+       MEVENT *eventp = SP_PARM->_mouse_eventp;
 
        /* stick the given event in the next-free slot */
        *eventp = *aevent;
 
        /* bump the next-free pointer into the circular list */
-       sp->_mouse_eventp = NEXT(eventp);
+       SP_PARM->_mouse_eventp = NEXT(eventp);
 
        /* push back the notification event on the keyboard queue */
-       result = _nc_ungetch(sp, KEY_MOUSE);
+       result = NCURSES_SP_NAME(ungetch) (NCURSES_SP_ARGx KEY_MOUSE);
     }
     returnCode(result);
 }
 
+#if NCURSES_SP_FUNCS
 /* enqueue a synthesized mouse event to be seen by the next wgetch() */
 NCURSES_EXPORT(int)
 ungetmouse(MEVENT * aevent)
 {
-    return _nc_ungetmouse(SP, aevent);
+    return NCURSES_SP_NAME(ungetmouse) (CURRENT_SCREEN, aevent);
 }
+#endif
 
 NCURSES_EXPORT(mmask_t)
-mousemask(mmask_t newmask, mmask_t * oldmask)
+NCURSES_SP_NAME(mousemask) (NCURSES_SP_DCLx mmask_t newmask, mmask_t * oldmask)
 /* set the mouse event mask */
 {
     mmask_t result = 0;
 
-    T((T_CALLED("mousemask(%#lx,%p)"), (unsigned long) newmask, oldmask));
+    T((T_CALLED("mousemask(%p,%#lx,%p)"),
+       (void *) SP_PARM,
+       (unsigned long) newmask,
+       (void *) oldmask));
 
-    if (SP != 0) {
+    if (SP_PARM != 0) {
        if (oldmask)
-           *oldmask = SP->_mouse_mask;
+           *oldmask = SP_PARM->_mouse_mask;
 
-       if (newmask || SP->_mouse_initialized) {
-           _nc_mouse_init(SP);
-           if (SP->_mouse_type != M_NONE) {
+       if (newmask || SP_PARM->_mouse_initialized) {
+           _nc_mouse_init(SP_PARM);
+           if (SP_PARM->_mouse_type != M_NONE) {
                result = newmask &
                    (REPORT_MOUSE_POSITION
                     | BUTTON_ALT
@@ -1349,22 +1375,30 @@ mousemask(mmask_t newmask, mmask_t * oldmask)
                     | BUTTON_DOUBLE_CLICKED
                     | BUTTON_TRIPLE_CLICKED);
 
-               mouse_activate(SP, (bool) (result != 0));
+               mouse_activate(SP_PARM, (bool) (result != 0));
 
-               SP->_mouse_mask = result;
+               SP_PARM->_mouse_mask = result;
            }
        }
     }
     returnBits(result);
 }
 
+#if NCURSES_SP_FUNCS
+NCURSES_EXPORT(mmask_t)
+mousemask(mmask_t newmask, mmask_t * oldmask)
+{
+    return NCURSES_SP_NAME(mousemask) (CURRENT_SCREEN, newmask, oldmask);
+}
+#endif
+
 NCURSES_EXPORT(bool)
 wenclose(const WINDOW *win, int y, int x)
 /* check to see if given window encloses given screen location */
 {
     bool result = FALSE;
 
-    T((T_CALLED("wenclose(%p,%d,%d)"), win, y, x));
+    T((T_CALLED("wenclose(%p,%d,%d)"), (const void *) win, y, x));
 
     if (win != 0) {
        y -= win->_yoffset;
@@ -1377,17 +1411,17 @@ wenclose(const WINDOW *win, int y, int x)
 }
 
 NCURSES_EXPORT(int)
-mouseinterval(int maxclick)
+NCURSES_SP_NAME(mouseinterval) (NCURSES_SP_DCLx int maxclick)
 /* set the maximum mouse interval within which to recognize a click */
 {
     int oldval;
 
-    T((T_CALLED("mouseinterval(%d)"), maxclick));
+    T((T_CALLED("mouseinterval(%p,%d)"), (void *) SP_PARM, maxclick));
 
-    if (SP != 0) {
-       oldval = SP->_maxclick;
+    if (SP_PARM != 0) {
+       oldval = SP_PARM->_maxclick;
        if (maxclick >= 0)
-           SP->_maxclick = maxclick;
+           SP_PARM->_maxclick = maxclick;
     } else {
        oldval = DEFAULT_MAXCLICK;
     }
@@ -1395,20 +1429,46 @@ mouseinterval(int maxclick)
     returnCode(oldval);
 }
 
+#if NCURSES_SP_FUNCS
+NCURSES_EXPORT(int)
+mouseinterval(int maxclick)
+{
+    return NCURSES_SP_NAME(mouseinterval) (CURRENT_SCREEN, maxclick);
+}
+#endif
+
 /* This may be used by other routines to ask for the existence of mouse
    support */
-NCURSES_EXPORT(int)
-_nc_has_mouse(void)
+NCURSES_EXPORT(bool)
+_nc_has_mouse(SCREEN *sp)
+{
+    return (((0 == sp) || (sp->_mouse_type == M_NONE)) ? FALSE : TRUE);
+}
+
+NCURSES_EXPORT(bool)
+NCURSES_SP_NAME(has_mouse) (NCURSES_SP_DCL0)
 {
-    return (SP->_mouse_type == M_NONE ? 0 : 1);
+    return _nc_has_mouse(SP_PARM);
 }
 
+#if NCURSES_SP_FUNCS
+NCURSES_EXPORT(bool)
+has_mouse(void)
+{
+    return _nc_has_mouse(CURRENT_SCREEN);
+}
+#endif
+
 NCURSES_EXPORT(bool)
 wmouse_trafo(const WINDOW *win, int *pY, int *pX, bool to_screen)
 {
     bool result = FALSE;
 
-    T((T_CALLED("wmouse_trafo(%p,%p,%p,%d)"), win, pY, pX, to_screen));
+    T((T_CALLED("wmouse_trafo(%p,%p,%p,%d)"),
+       (const void *) win,
+       (void *) pY,
+       (void *) pX,
+       to_screen));
 
     if (win && pY && pX) {
        int y = *pY;