ncurses 5.7 - patch 20090530
[ncurses.git] / ncurses / base / lib_mouse.c
index b6229cf4a8a7f2bf5bc88026989352d30385a813..f0ad82fc40d5b574c7547c7b0fd4f438f767bcf2 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            *
  *                                                                          *
  * Permission is hereby granted, free of charge, to any person obtaining a  *
  * copy of this software and associated documentation files (the            *
 
 #include <curses.priv.h>
 
 
 #include <curses.priv.h>
 
-MODULE_ID("$Id: lib_mouse.c,v 1.97 2008/08/16 18:55:01 tom Exp $")
+#ifndef CUR
+#define CUR SP_TERMTYPE 
+#endif
+
+MODULE_ID("$Id: lib_mouse.c,v 1.107 2009/05/10 00:48:29 tom Exp $")
 
 
-#include <term.h>
 #include <tic.h>
 
 #if USE_GPM_SUPPORT
 #include <tic.h>
 
 #if USE_GPM_SUPPORT
@@ -150,7 +153,7 @@ make an error
 #define LIBGPM_SONAME "libgpm.so"
 #endif
 
 #define LIBGPM_SONAME "libgpm.so"
 #endif
 
-#define GET_DLSYM(name) (my_##name = (TYPE_##name) dlsym(obj, #name))
+#define GET_DLSYM(name) (my_##name = (TYPE_##name) dlsym(SP_PARM->_dlopen_gpm, #name))
 
 #endif                         /* USE_GPM_SUPPORT */
 
 
 #endif                         /* USE_GPM_SUPPORT */
 
@@ -164,13 +167,13 @@ static void _nc_mouse_wrap(SCREEN *);
 #define LastEV(sp)     ((sp)->_mouse_events + EV_MAX - 1)
 
 #undef  NEXT
 #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
                         : 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))
                         : ep - 1)
 
 #define IndexEV(sp, ep)        (ep - FirstEV(sp))
@@ -255,13 +258,13 @@ mouse_server(unsigned long param)
                 *      3 = middle.
                 */
                if ((mouev.fs ^ oldstate) & MOUSE_BN1_DOWN)
                 *      3 = middle.
                 */
                if ((mouev.fs ^ oldstate) & MOUSE_BN1_DOWN)
-                   write_event(mouev.fs & MOUSE_BN1_DOWN,
+                   write_event(sp, mouev.fs & MOUSE_BN1_DOWN,
                                sp->_emxmouse_buttons[1], mouev.col, mouev.row);
                if ((mouev.fs ^ oldstate) & MOUSE_BN2_DOWN)
                                sp->_emxmouse_buttons[1], mouev.col, mouev.row);
                if ((mouev.fs ^ oldstate) & MOUSE_BN2_DOWN)
-                   write_event(mouev.fs & MOUSE_BN2_DOWN,
+                   write_event(sp, mouev.fs & MOUSE_BN2_DOWN,
                                sp->_emxmouse_buttons[3], mouev.col, mouev.row);
                if ((mouev.fs ^ oldstate) & MOUSE_BN3_DOWN)
                                sp->_emxmouse_buttons[3], mouev.col, mouev.row);
                if ((mouev.fs ^ oldstate) & MOUSE_BN3_DOWN)
-                   write_event(mouev.fs & MOUSE_BN3_DOWN,
+                   write_event(sp, mouev.fs & MOUSE_BN3_DOWN,
                                sp->_emxmouse_buttons[2], mouev.col, mouev.row);
 
              finish:
                                sp->_emxmouse_buttons[2], mouev.col, mouev.row);
 
              finish:
@@ -340,7 +343,7 @@ sysmouse_server(SCREEN *sp)
 static void
 handle_sysmouse(int sig GCC_UNUSED)
 {
 static void
 handle_sysmouse(int sig GCC_UNUSED)
 {
-    sysmouse_server(SP);
+    sysmouse_server(CURRENT_SCREEN);
 }
 #endif /* USE_SYSMOUSE */
 
 }
 #endif /* USE_SYSMOUSE */
 
@@ -359,51 +362,107 @@ enable_xterm_mouse(SCREEN *sp, int enable)
 #if USE_EMX_MOUSE
     sp->_emxmouse_activated = enable;
 #else
 #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;
 }
 
 #if USE_GPM_SUPPORT
 #endif
     sp->_mouse_active = enable;
 }
 
 #if USE_GPM_SUPPORT
-static int
+static bool
 allow_gpm_mouse(void)
 {
 allow_gpm_mouse(void)
 {
+    bool result = FALSE;
+
     /* GPM does printf's without checking if stdout is a terminal */
     if (isatty(fileno(stdout))) {
     /* GPM does printf's without checking if stdout is a terminal */
     if (isatty(fileno(stdout))) {
+       char *list = getenv("NCURSES_GPM_TERMS");
        char *env = getenv("TERM");
        char *env = getenv("TERM");
-       /* GPM checks the beginning of the $TERM variable to decide if
-        * it should pass xterm events through.  There is no real advantage
-        * in allowing GPM to do this.
-        */
-       if (env == 0 || strncmp(env, "xterm", 5))
-           return TRUE;
+       if (list != 0) {
+           if (env != 0) {
+               result = _nc_name_match(list, env, "|:");
+           }
+       } else {
+           /* GPM checks the beginning of the $TERM variable to decide if it
+            * should pass xterm events through.  There is no real advantage in
+            * allowing GPM to do this.  Recent versions relax that check, and
+            * pretend that GPM can work with any terminal having the kmous
+            * capability.  Perhaps that works for someone.  If so, they can
+            * set the environment variable (above).
+            */
+           if (env != 0 && strstr(env, "linux") != 0) {
+               result = TRUE;
+           }
+       }
+    }
+    return result;
+}
+
+#ifdef HAVE_LIBDL
+static void
+unload_gpm_library(SCREEN *sp)
+{
+    if (sp->_dlopen_gpm != 0) {
+       T(("unload GPM library"));
+       sp->_mouse_gpm_loaded = FALSE;
+       sp->_mouse_fd = -1;
+       dlclose(sp->_dlopen_gpm);
+       sp->_dlopen_gpm = 0;
+    }
+}
+
+static void
+load_gpm_library(SCREEN *sp)
+{
+    sp->_mouse_gpm_found = FALSE;
+    if ((sp->_dlopen_gpm = dlopen(LIBGPM_SONAME, my_RTLD)) != 0) {
+       if (GET_DLSYM(gpm_fd) == 0 ||
+           GET_DLSYM(Gpm_Open) == 0 ||
+           GET_DLSYM(Gpm_Close) == 0 ||
+           GET_DLSYM(Gpm_GetEvent) == 0) {
+           T(("GPM initialization failed: %s", dlerror()));
+           unload_gpm_library(sp);
+       } else {
+           sp->_mouse_gpm_found = TRUE;
+           sp->_mouse_gpm_loaded = TRUE;
+       }
     }
     }
-    return FALSE;
 }
 }
+#endif
 
 static bool
 
 static bool
-enable_gpm_mouse(SCREEN *sp, int enable)
+enable_gpm_mouse(SCREEN *sp, bool enable)
 {
     bool result;
 
     T((T_CALLED("enable_gpm_mouse(%d)"), enable));
 
     if (enable && !sp->_mouse_active) {
 {
     bool result;
 
     T((T_CALLED("enable_gpm_mouse(%d)"), enable));
 
     if (enable && !sp->_mouse_active) {
-       /* GPM: initialize connection to gpm server */
-       sp->_mouse_gpm_connect.eventMask = GPM_DOWN | GPM_UP;
-       sp->_mouse_gpm_connect.defaultMask =
-           (unsigned short) (~(sp->_mouse_gpm_connect.eventMask | GPM_HARD));
-       sp->_mouse_gpm_connect.minMod = 0;
-       sp->_mouse_gpm_connect.maxMod =
-           (unsigned short) (~((1 << KG_SHIFT) |
-                               (1 << KG_SHIFTL) |
-                               (1 << KG_SHIFTR)));
-       /*
-        * Note: GPM hardcodes \E[?1001s and \E[?1000h during its open.
-        * The former is recognized by wscons (SunOS), and the latter by
-        * xterm.  Those will not show up in ncurses' traces.
-        */
-       result = (my_Gpm_Open(&sp->_mouse_gpm_connect, 0) >= 0);
+#ifdef HAVE_LIBDL
+       if (sp->_mouse_gpm_found && !sp->_mouse_gpm_loaded) {
+           load_gpm_library(sp);
+       }
+#endif
+       if (sp->_mouse_gpm_loaded) {
+           /* GPM: initialize connection to gpm server */
+           sp->_mouse_gpm_connect.eventMask = GPM_DOWN | GPM_UP;
+           sp->_mouse_gpm_connect.defaultMask =
+               (unsigned short) (~(sp->_mouse_gpm_connect.eventMask | GPM_HARD));
+           sp->_mouse_gpm_connect.minMod = 0;
+           sp->_mouse_gpm_connect.maxMod =
+               (unsigned short) (~((1 << KG_SHIFT) |
+                                   (1 << KG_SHIFTL) |
+                                   (1 << KG_SHIFTR)));
+           /*
+            * Note: GPM hardcodes \E[?1001s and \E[?1000h during its open.
+            * The former is recognized by wscons (SunOS), and the latter by
+            * xterm.  Those will not show up in ncurses' traces.
+            */
+           result = (my_Gpm_Open(&sp->_mouse_gpm_connect, 0) >= 0);
+       } else {
+           result = FALSE;
+       }
        sp->_mouse_active = result;
        T(("GPM open %s", result ? "succeeded" : "failed"));
     } else {
        sp->_mouse_active = result;
        T(("GPM open %s", result ? "succeeded" : "failed"));
     } else {
@@ -413,8 +472,13 @@ enable_gpm_mouse(SCREEN *sp, int enable)
            sp->_mouse_active = FALSE;
            T(("GPM closed"));
        }
            sp->_mouse_active = FALSE;
            T(("GPM closed"));
        }
-       result = FALSE;
+       result = enable;
+    }
+#ifdef HAVE_LIBDL
+    if (!result) {
+       unload_gpm_library(sp);
     }
     }
+#endif
     returnBool(result);
 }
 #endif /* USE_GPM_SUPPORT */
     returnBool(result);
 }
 #endif /* USE_GPM_SUPPORT */
@@ -431,23 +495,11 @@ initialize_mousetype(SCREEN *sp)
     if (allow_gpm_mouse()) {
        if (!sp->_mouse_gpm_loaded) {
 #ifdef HAVE_LIBDL
     if (allow_gpm_mouse()) {
        if (!sp->_mouse_gpm_loaded) {
 #ifdef HAVE_LIBDL
-           void *obj;
-
-           if ((obj = dlopen(LIBGPM_SONAME, my_RTLD)) != 0) {
-               if (GET_DLSYM(gpm_fd) == 0 ||
-                   GET_DLSYM(Gpm_Open) == 0 ||
-                   GET_DLSYM(Gpm_Close) == 0 ||
-                   GET_DLSYM(Gpm_GetEvent) == 0) {
-                   T(("GPM initialization failed: %s", dlerror()));
-                   dlclose(obj);
-               } else {
-                   sp->_mouse_gpm_found = TRUE;
-               }
-           }
+           load_gpm_library(sp);
 #else /* !HAVE_LIBDL */
            sp->_mouse_gpm_found = TRUE;
 #else /* !HAVE_LIBDL */
            sp->_mouse_gpm_found = TRUE;
-#endif
            sp->_mouse_gpm_loaded = TRUE;
            sp->_mouse_gpm_loaded = TRUE;
+#endif
        }
 
        /*
        }
 
        /*
@@ -498,7 +550,7 @@ initialize_mousetype(SCREEN *sp)
            setmode(handles[1], O_BINARY);
            /* Do not use CRT functions, we may single-threaded. */
            rc = DosCreateThread((unsigned long *) &sp->_emxmouse_thread,
            setmode(handles[1], O_BINARY);
            /* Do not use CRT functions, we may single-threaded. */
            rc = DosCreateThread((unsigned long *) &sp->_emxmouse_thread,
-                                mouse_server, sp, 0, 8192);
+                                mouse_server, (long) sp, 0, 8192);
            if (rc) {
                printf("mouse thread error %d=%#x", rc, rc);
            } else {
            if (rc) {
                printf("mouse thread error %d=%#x", rc, rc);
            } else {
@@ -647,11 +699,16 @@ _nc_mouse_event(SCREEN *sp GCC_UNUSED)
 
 #if USE_GPM_SUPPORT
     case M_GPM:
 
 #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;
 
            /* 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;
 
                /* there's only one mouse... */
                eventp->id = NORMAL_EVENT;
 
@@ -684,6 +741,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;
                /* bump the next-free pointer into the circular list */
                sp->_mouse_eventp = eventp = NEXT(eventp);
                result = TRUE;
+               break;
            }
        }
        break;
            }
        }
        break;
@@ -890,14 +948,14 @@ mouse_activate(SCREEN *sp, bool on)
        switch (sp->_mouse_type) {
        case M_XTERM:
 #if NCURSES_EXT_FUNCS
        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);
            break;
 #if USE_GPM_SUPPORT
        case M_GPM:
 #endif
            TPUTS_TRACE("xterm mouse initialization");
            enable_xterm_mouse(sp, 1);
            break;
 #if USE_GPM_SUPPORT
        case M_GPM:
-           if (enable_gpm_mouse(sp, 1)) {
+           if (enable_gpm_mouse(sp, TRUE)) {
                sp->_mouse_fd = *(my_gpm_fd);
                T(("GPM mouse_fd %d", sp->_mouse_fd));
            }
                sp->_mouse_fd = *(my_gpm_fd);
                T(("GPM mouse_fd %d", sp->_mouse_fd));
            }
@@ -929,7 +987,7 @@ mouse_activate(SCREEN *sp, bool on)
            break;
 #if USE_GPM_SUPPORT
        case M_GPM:
            break;
 #if USE_GPM_SUPPORT
        case M_GPM:
-           enable_gpm_mouse(sp, 0);
+           enable_gpm_mouse(sp, FALSE);
            break;
 #endif
 #if USE_SYSMOUSE
            break;
 #endif
 #if USE_SYSMOUSE
@@ -942,7 +1000,7 @@ mouse_activate(SCREEN *sp, bool on)
            return;
        }
     }
            return;
        }
     }
-    _nc_flush();
+    NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_ARG);
 }
 
 /**************************************************************************
 }
 
 /**************************************************************************
@@ -1217,13 +1275,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)"), SP_PARM, 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);
 
        /* compute the current-event pointer */
        MEVENT *prev = PREV(eventp);
 
@@ -1231,8 +1289,8 @@ _nc_getmouse(SCREEN *sp, MEVENT * aevent)
        *aevent = *prev;
 
        TR(TRACE_IEVENT, ("getmouse: returning event %s from slot %ld",
        *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);
 
        prev->id = INVALID_EVENT;       /* so the queue slot becomes free */
        returnCode(OK);
@@ -1240,57 +1298,61 @@ _nc_getmouse(SCREEN *sp, MEVENT * aevent)
     returnCode(ERR);
 }
 
     returnCode(ERR);
 }
 
+#if NCURSES_SP_FUNCS
 /* grab a copy of the current mouse event */
 NCURSES_EXPORT(int)
 getmouse(MEVENT * aevent)
 {
 /* 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;
 
 {
     int result = ERR;
 
-    T((T_CALLED("ungetmouse(%p)"), aevent));
+    T((T_CALLED("ungetmouse(%p,%p)"), SP_PARM, 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 */
 
        /* 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 */
 
        /* 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);
 }
 
     }
     returnCode(result);
 }
 
+#if NCURSES_SP_FUNCS
 /* enqueue a synthesized mouse event to be seen by the next wgetch() */
 NCURSES_EXPORT(int)
 ungetmouse(MEVENT * aevent)
 {
 /* 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)
 
 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;
 
 /* 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)"), SP_PARM, (unsigned long) newmask, oldmask));
 
 
-    if (SP != 0) {
+    if (SP_PARM != 0) {
        if (oldmask)
        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
                result = newmask &
                    (REPORT_MOUSE_POSITION
                     | BUTTON_ALT
@@ -1302,15 +1364,23 @@ mousemask(mmask_t newmask, mmask_t * oldmask)
                     | BUTTON_DOUBLE_CLICKED
                     | BUTTON_TRIPLE_CLICKED);
 
                     | 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);
 }
 
            }
        }
     }
     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 */
 NCURSES_EXPORT(bool)
 wenclose(const WINDOW *win, int y, int x)
 /* check to see if given window encloses given screen location */
@@ -1330,17 +1400,17 @@ wenclose(const WINDOW *win, int y, int x)
 }
 
 NCURSES_EXPORT(int)
 }
 
 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;
 
 /* 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)"), SP_PARM, maxclick));
 
 
-    if (SP != 0) {
-       oldval = SP->_maxclick;
+    if (SP_PARM != 0) {
+       oldval = SP_PARM->_maxclick;
        if (maxclick >= 0)
        if (maxclick >= 0)
-           SP->_maxclick = maxclick;
+           SP_PARM->_maxclick = maxclick;
     } else {
        oldval = DEFAULT_MAXCLICK;
     }
     } else {
        oldval = DEFAULT_MAXCLICK;
     }
@@ -1348,14 +1418,36 @@ mouseinterval(int maxclick)
     returnCode(oldval);
 }
 
     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 */
 /* 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)
 {
 NCURSES_EXPORT(bool)
 wmouse_trafo(const WINDOW *win, int *pY, int *pX, bool to_screen)
 {