777 lines
21 KiB
C
777 lines
21 KiB
C
/*
|
|
* Copyright (c) 1986, 1987, 1988, 1989 by Sun Microsystems, Inc.
|
|
* Permission to use, copy, modify, and distribute this software for any
|
|
* purpose and without fee is hereby granted, provided that the above
|
|
* copyright notice appear in all copies and that both that copyright
|
|
* notice and this permission notice are retained, and that the name
|
|
* of Sun Microsystems, Inc., not be used in advertising or publicity
|
|
* pertaining to this software without specific, written prior permission.
|
|
* Sun Microsystems, Inc., makes no representations about the suitability
|
|
* of this software or the interface defined in this software for any
|
|
* purpose. It is provided "as is" without express or implied warranty.
|
|
*/
|
|
#ifndef lint
|
|
static char sccsid[] = "@(#)inputctrl.c 1.1 94/10/31 Copyr 1986 Sun Micro";
|
|
#endif
|
|
|
|
/*
|
|
* Copyright (c) 1986 by Sun Microsystems, Inc.
|
|
*/
|
|
|
|
#include "coretypes.h"
|
|
#include "corevars.h"
|
|
#include <strings.h>
|
|
#define NULL 0
|
|
|
|
int _core_mousedd();
|
|
int _core_keybrdd();
|
|
|
|
pickstr *_core_check_pick();
|
|
keybstr *_core_check_keyboard();
|
|
strokstr *_core_check_stroke();
|
|
locatstr *_core_check_locator();
|
|
valstr *_core_check_valuator();
|
|
butnstr *_core_check_button();
|
|
|
|
initialize_device(devclass, devnum)
|
|
int devclass, devnum;
|
|
{
|
|
static char funcname[] = "initialize_device";
|
|
pickstr *pickptr;
|
|
locatstr *locatptr;
|
|
keybstr *keybptr;
|
|
strokstr *strokptr;
|
|
valstr *valptr;
|
|
butnstr *butnptr;
|
|
ddargtype ddstruct;
|
|
viewsurf *surfp;
|
|
|
|
_core_ndcset |= 1;
|
|
switch (devclass) {
|
|
case PICK:
|
|
if ((pickptr = _core_check_pick(funcname, devnum, FALSE)) == 0)
|
|
return (1);
|
|
pickptr->subpick.enable = 1;
|
|
pickptr->subpick.echo = FALSE;
|
|
pickptr->subpick.echopos[0] = 0;
|
|
pickptr->subpick.echopos[1] = 0;
|
|
pickptr->subpick.echosurfp = NULL;
|
|
pickptr->subpick.instance = 0;
|
|
pickptr->subpick.devdrive = _core_mousedd;
|
|
/* init pick aperture 0 */
|
|
/* will be set differently when an echo surface is specified */
|
|
pickptr->aperture = 0;
|
|
break;
|
|
case KEYBOARD:
|
|
if ((keybptr = _core_check_keyboard(funcname, devnum, FALSE)) == 0)
|
|
return (1);
|
|
keybptr->subkey.enable = 1;
|
|
keybptr->subkey.echo = FALSE;
|
|
keybptr->subkey.echopos[0] = 0;
|
|
keybptr->subkey.echopos[1] = 0;
|
|
keybptr->subkey.echosurfp = NULL;
|
|
keybptr->subkey.instance = 0;
|
|
keybptr->subkey.devdrive = _core_keybrdd;
|
|
keybptr->initpos = 7;
|
|
keybptr->initstring = "enter:";
|
|
keybptr->bufsize = 80;
|
|
keybptr->maxbufsz = 80;
|
|
ddstruct.opcode = INITIAL;
|
|
(*keybptr->subkey.devdrive) (&ddstruct);
|
|
if (_core_winsys)
|
|
for (surfp = &_core_surface[0];
|
|
surfp < &_core_surface[MAXVSURF]; surfp++)
|
|
if (surfp->vinit) {
|
|
ddstruct.opcode = CLRKMASK;
|
|
ddstruct.int1 = surfp->vsurf.windowfd;
|
|
(*keybptr->subkey.devdrive)
|
|
(&ddstruct);
|
|
}
|
|
break;
|
|
case STROKE:
|
|
if ((strokptr = _core_check_stroke(funcname, devnum, FALSE)) == 0)
|
|
return (1);
|
|
strokptr->substroke.enable = 1;
|
|
strokptr->substroke.echo = FALSE;
|
|
strokptr->substroke.echopos[0] = 0;
|
|
strokptr->substroke.echopos[1] = 0;
|
|
strokptr->substroke.echosurfp = NULL;
|
|
strokptr->substroke.instance = 0;
|
|
strokptr->substroke.devdrive = _core_mousedd;
|
|
strokptr->bufsize = 80;
|
|
strokptr->distance = 0.01 * MAX_NDC_COORD;
|
|
strokptr->time = 10000;
|
|
break;
|
|
case LOCATOR:
|
|
if ((locatptr = _core_check_locator(funcname, devnum, FALSE)) == 0)
|
|
return (1);
|
|
locatptr->subloc.enable = 1;
|
|
locatptr->subloc.echo = FALSE;
|
|
locatptr->subloc.echopos[0] = 0;
|
|
locatptr->subloc.echopos[1] = 0;
|
|
locatptr->subloc.echosurfp = NULL;
|
|
locatptr->subloc.instance = 0;
|
|
locatptr->subloc.devdrive = _core_mousedd;
|
|
locatptr->setpos[0] = 0;
|
|
locatptr->setpos[1] = 0;
|
|
break;
|
|
case VALUATOR:
|
|
if ((valptr = _core_check_valuator(funcname, devnum, FALSE)) == 0)
|
|
return (1);
|
|
valptr->subval.enable = 1;
|
|
valptr->subval.echo = FALSE;
|
|
valptr->subval.echopos[0] = 0;
|
|
valptr->subval.echopos[1] = 0;
|
|
valptr->subval.echosurfp = NULL;
|
|
valptr->subval.instance = 0;
|
|
valptr->subval.devdrive = _core_mousedd;
|
|
valptr->vlinit = 0.0;
|
|
valptr->vlmin = 0.0;
|
|
valptr->vlmax = 1.0;
|
|
break;
|
|
case BUTTON:
|
|
if ((butnptr = _core_check_button(funcname, devnum, FALSE)) == 0)
|
|
return (1);
|
|
butnptr->subbut.enable = 1;
|
|
butnptr->subbut.echo = FALSE;
|
|
butnptr->subbut.echopos[0] = 0;
|
|
butnptr->subbut.echopos[1] = 0;
|
|
butnptr->subbut.echosurfp = NULL;
|
|
butnptr->subbut.instance = 0;
|
|
butnptr->subbut.devdrive = _core_mousedd;
|
|
butnptr->prompt = 0;
|
|
ddstruct.opcode = INITBUT;
|
|
ddstruct.int1 = 4 >> (devnum - 1);
|
|
(*butnptr->subbut.devdrive) (&ddstruct);
|
|
break;
|
|
default:
|
|
_core_errhand(funcname, 105);
|
|
return (1);
|
|
break;
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
terminate_device(devclass, devnum)
|
|
int devclass, devnum;
|
|
{
|
|
static char funcname[] = "terminate_device";
|
|
pickstr *pickptr;
|
|
locatstr *locatptr;
|
|
keybstr *keybptr;
|
|
strokstr *strokptr;
|
|
valstr *valptr;
|
|
butnstr *butnptr;
|
|
viewsurf *surfp;
|
|
ddargtype ddstruct;
|
|
|
|
switch (devclass) {
|
|
case PICK:
|
|
if ((pickptr = _core_check_pick(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
if (pickptr->subpick.echosurfp != NULL)
|
|
(void) set_echo_surface(devclass, devnum, (struct vwsurf *) 0);
|
|
pickptr->subpick.enable = FALSE;
|
|
break;
|
|
case KEYBOARD:
|
|
if ((keybptr = _core_check_keyboard(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
if (keybptr->subkey.echosurfp != NULL)
|
|
(void) set_echo_surface(devclass, devnum, (struct vwsurf *) 0);
|
|
keybptr->subkey.enable = FALSE;
|
|
ddstruct.opcode = TERMINATE;
|
|
(*keybptr->subkey.devdrive) (&ddstruct);
|
|
if (_core_winsys)
|
|
for (surfp = &_core_surface[0];
|
|
surfp < &_core_surface[MAXVSURF]; surfp++)
|
|
if (surfp->vinit) {
|
|
ddstruct.opcode = SETKMASK;
|
|
ddstruct.int1 = surfp->vsurf.windowfd;
|
|
(*keybptr->subkey.devdrive)
|
|
(&ddstruct);
|
|
}
|
|
break;
|
|
case STROKE:
|
|
if ((strokptr = _core_check_stroke(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
if (strokptr->substroke.echosurfp != NULL)
|
|
(void) set_echo_surface(devclass, devnum, (struct vwsurf *) 0);
|
|
strokptr->substroke.enable = FALSE;
|
|
break;
|
|
case LOCATOR:
|
|
if ((locatptr = _core_check_locator(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
if (locatptr->subloc.echosurfp != NULL)
|
|
(void) set_echo_surface(devclass, devnum, (struct vwsurf *) 0);
|
|
locatptr->subloc.enable = FALSE;
|
|
break;
|
|
case VALUATOR:
|
|
if ((valptr = _core_check_valuator(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
if (valptr->subval.echosurfp != NULL)
|
|
(void) set_echo_surface(devclass, devnum, (struct vwsurf *) 0);
|
|
valptr->subval.enable = FALSE;
|
|
break;
|
|
case BUTTON:
|
|
if ((butnptr = _core_check_button(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
if (butnptr->subbut.echosurfp != NULL)
|
|
(void) set_echo_surface(devclass, devnum, (struct vwsurf *) 0);
|
|
butnptr->subbut.enable = FALSE;
|
|
ddstruct.opcode = TERMBUT;
|
|
ddstruct.int1 = 4 >> (devnum - 1);
|
|
(*butnptr->subbut.devdrive) (&ddstruct);
|
|
break;
|
|
default:
|
|
_core_errhand(funcname, 105);
|
|
return (1);
|
|
break;
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
/* Set echoing Parameters */
|
|
set_echo_group(class, devnum, n, echotype)
|
|
int class, devnum[], n, echotype;
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < n; i++) {
|
|
(void) set_echo(class, devnum[i], echotype);
|
|
}
|
|
}
|
|
|
|
set_echo(devclass, devnum, echotype)
|
|
int devclass, devnum, echotype;
|
|
{
|
|
static char funcname[] = "set_echo";
|
|
pickstr *pickptr;
|
|
locatstr *locatptr;
|
|
keybstr *keybptr;
|
|
strokstr *strokptr;
|
|
valstr *valptr;
|
|
butnstr *butnptr;
|
|
ddargtype ddstruct;
|
|
|
|
switch (devclass) {
|
|
case PICK:
|
|
if ((pickptr = _core_check_pick(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
if (echotype < 0 || echotype > 2) {
|
|
_core_errhand(funcname, 106);
|
|
return (1);
|
|
}
|
|
if (pickptr->subpick.echosurfp == NULL || pickptr->subpick.echo == echotype) {
|
|
pickptr->subpick.echo = echotype;
|
|
break;
|
|
}
|
|
if (pickptr->subpick.echo == FALSE || echotype == FALSE) {
|
|
ddstruct.opcode = echotype ? ICURSTRKON : ICURSTRKOFF;
|
|
ddstruct.instance = pickptr->subpick.instance;
|
|
(*pickptr->subpick.devdrive) (&ddstruct);
|
|
}
|
|
pickptr->subpick.echo = echotype;
|
|
break;
|
|
case KEYBOARD:
|
|
if ((keybptr = _core_check_keyboard(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
if (echotype < 0 || echotype > 1) {
|
|
_core_errhand(funcname, 107);
|
|
return (1);
|
|
}
|
|
keybptr->subkey.echo = echotype;
|
|
break;
|
|
case STROKE:
|
|
if ((strokptr = _core_check_stroke(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
if (echotype < 0 || echotype > 1) {
|
|
_core_errhand(funcname, 108);
|
|
return (1);
|
|
}
|
|
if (strokptr->substroke.echosurfp == NULL ||
|
|
strokptr->substroke.echo == echotype) {
|
|
strokptr->substroke.echo = echotype;
|
|
break;
|
|
}
|
|
ddstruct.opcode = echotype ? ICURSTRKON : ICURSTRKOFF;
|
|
ddstruct.instance = strokptr->substroke.instance;
|
|
(*strokptr->substroke.devdrive) (&ddstruct);
|
|
strokptr->substroke.echo = echotype;
|
|
break;
|
|
case LOCATOR:
|
|
if ((locatptr = _core_check_locator(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
if (echotype < 0 || echotype > 6) {
|
|
_core_errhand(funcname, 109);
|
|
return (1);
|
|
}
|
|
if (locatptr->subloc.echosurfp == NULL ||
|
|
locatptr->subloc.echo == echotype) {
|
|
locatptr->subloc.echo = echotype;
|
|
break;
|
|
}
|
|
if (locatptr->subloc.echo == 1 || echotype == 1) {
|
|
ddstruct.opcode = (echotype == 1) ? ICURSTRKON : ICURSTRKOFF;
|
|
ddstruct.instance = locatptr->subloc.instance;
|
|
(*locatptr->subloc.devdrive) (&ddstruct);
|
|
}
|
|
locatptr->subloc.echo = echotype;
|
|
break;
|
|
case VALUATOR:
|
|
if ((valptr = _core_check_valuator(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
if (echotype < 0 || echotype > 1) {
|
|
_core_errhand(funcname, 110);
|
|
return (1);
|
|
}
|
|
valptr->subval.echo = echotype;
|
|
break;
|
|
case BUTTON:
|
|
if ((butnptr = _core_check_button(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
if (echotype < 0 || echotype > 1) {
|
|
_core_errhand(funcname, 111);
|
|
return (1);
|
|
}
|
|
butnptr->subbut.echo = echotype;
|
|
break;
|
|
default:
|
|
_core_errhand(funcname, 105);
|
|
return (1);
|
|
break;
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
set_echo_position(devclass, devnum, x, y)
|
|
int devclass, devnum;
|
|
float x, y;
|
|
{
|
|
static char funcname[] = "set_echo_position";
|
|
int ix, iy;
|
|
float f;
|
|
pickstr *pickptr;
|
|
locatstr *locatptr;
|
|
keybstr *keybptr;
|
|
strokstr *strokptr;
|
|
valstr *valptr;
|
|
butnstr *butnptr;
|
|
|
|
if (x < 0.0 || x > _core_ndc.width || y < 0.0 || y > _core_ndc.height) {
|
|
_core_errhand(funcname, 112);
|
|
return (1);
|
|
}
|
|
f = x;
|
|
f *= MAX_NDC_COORD;
|
|
ix = _core_roundf(&f);
|
|
f = y;
|
|
f *= MAX_NDC_COORD;
|
|
iy = _core_roundf(&f);
|
|
switch (devclass) {
|
|
case PICK:
|
|
if ((pickptr = _core_check_pick(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
pickptr->subpick.echopos[0] = ix;
|
|
pickptr->subpick.echopos[1] = iy;
|
|
break;
|
|
case KEYBOARD:
|
|
if ((keybptr = _core_check_keyboard(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
keybptr->subkey.echopos[0] = ix;
|
|
keybptr->subkey.echopos[1] = iy;
|
|
break;
|
|
case STROKE:
|
|
if ((strokptr = _core_check_stroke(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
strokptr->substroke.echopos[0] = ix;
|
|
strokptr->substroke.echopos[1] = iy;
|
|
break;
|
|
case LOCATOR:
|
|
if ((locatptr = _core_check_locator(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
locatptr->subloc.echopos[0] = ix;
|
|
locatptr->subloc.echopos[1] = iy;
|
|
break;
|
|
case VALUATOR:
|
|
if ((valptr = _core_check_valuator(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
valptr->subval.echopos[0] = ix;
|
|
valptr->subval.echopos[1] = iy;
|
|
break;
|
|
case BUTTON:
|
|
if ((butnptr = _core_check_button(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
butnptr->subbut.echopos[0] = ix;
|
|
butnptr->subbut.echopos[1] = iy;
|
|
break;
|
|
default:
|
|
_core_errhand(funcname, 105);
|
|
return (1);
|
|
break;
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
set_echo_surface(devclass, devnum, surfname)
|
|
int devclass, devnum;
|
|
struct vwsurf *surfname;
|
|
{
|
|
viewsurf *surfp, *_core_VSnsrch();
|
|
static char funcname[] = "set_echo_surface";
|
|
pickstr *pickptr;
|
|
locatstr *locatptr;
|
|
keybstr *keybptr;
|
|
strokstr *strokptr;
|
|
valstr *valptr;
|
|
butnstr *butnptr;
|
|
int savecho;
|
|
|
|
if (surfname == NULL)
|
|
surfp = NULL;
|
|
else {
|
|
if (!surfname->dd) {
|
|
_core_errhand(funcname, 83);
|
|
return (1);
|
|
}
|
|
if (!(surfp = _core_VSnsrch(surfname))) {
|
|
_core_errhand(funcname, 5);
|
|
return (1);
|
|
}
|
|
}
|
|
switch (devclass) {
|
|
case PICK:
|
|
if ((pickptr = _core_check_pick(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
if (pickptr->aperture == 0) { /* non initialized aperture */
|
|
if (surfp->windptr) {
|
|
/* Initial aperture has 2 pixels on each side */
|
|
pickptr->aperture = (4 * surfp->windptr->ndcxmax) /
|
|
surfp->windptr->winwidth;
|
|
}
|
|
}
|
|
|
|
if ((savecho = pickptr->subpick.echo) != FALSE)
|
|
(void) set_echo(devclass, devnum, FALSE);
|
|
if (pickptr->subpick.echosurfp != NULL)
|
|
term_mouse(&pickptr->subpick, TRUE);
|
|
if ((pickptr->subpick.echosurfp = surfp) != NULL)
|
|
init_mouse(&pickptr->subpick, TRUE);
|
|
if (savecho != FALSE)
|
|
(void) set_echo(devclass, devnum, savecho);
|
|
break;
|
|
case KEYBOARD:
|
|
if ((keybptr = _core_check_keyboard(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
keybptr->subkey.echosurfp = surfp;
|
|
break;
|
|
case STROKE:
|
|
if ((strokptr = _core_check_stroke(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
if ((savecho = strokptr->substroke.echo) != FALSE)
|
|
(void) set_echo(devclass, devnum, FALSE);
|
|
if (strokptr->substroke.echosurfp != NULL)
|
|
term_mouse(&strokptr->substroke, TRUE);
|
|
if ((strokptr->substroke.echosurfp = surfp) != NULL)
|
|
init_mouse(&strokptr->substroke, TRUE);
|
|
if (savecho != FALSE)
|
|
(void) set_echo(devclass, devnum, savecho);
|
|
break;
|
|
case LOCATOR:
|
|
if ((locatptr = _core_check_locator(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
if ((savecho = locatptr->subloc.echo) != FALSE)
|
|
(void) set_echo(devclass, devnum, FALSE);
|
|
if (locatptr->subloc.echosurfp != NULL)
|
|
term_mouse(&locatptr->subloc, TRUE);
|
|
if ((locatptr->subloc.echosurfp = surfp) != NULL)
|
|
init_mouse(&locatptr->subloc, TRUE);
|
|
if (savecho != FALSE)
|
|
(void) set_echo(devclass, devnum, savecho);
|
|
break;
|
|
case VALUATOR:
|
|
if ((valptr = _core_check_valuator(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
if (valptr->subval.echosurfp != NULL)
|
|
term_mouse(&valptr->subval, TRUE);
|
|
if ((valptr->subval.echosurfp = surfp) != NULL)
|
|
init_mouse(&valptr->subval, TRUE);
|
|
break;
|
|
case BUTTON:
|
|
if ((butnptr = _core_check_button(funcname, devnum, TRUE)) == 0)
|
|
return (1);
|
|
if (butnptr->subbut.echosurfp != NULL)
|
|
term_mouse(&butnptr->subbut, FALSE);
|
|
if ((butnptr->subbut.echosurfp = surfp) != NULL)
|
|
init_mouse(&butnptr->subbut, FALSE);
|
|
break;
|
|
default:
|
|
_core_errhand(funcname, 105);
|
|
return (1);
|
|
break;
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
set_pick(picknum, aperture)
|
|
int picknum;
|
|
float aperture;
|
|
{
|
|
static char funcname[] = "set_pick";
|
|
pickstr *pickptr;
|
|
|
|
if ((pickptr = _core_check_pick(funcname, picknum, TRUE)) == 0)
|
|
return (1);
|
|
if (aperture <= 0) {
|
|
_core_errhand(funcname, 22);
|
|
return (1);
|
|
}
|
|
pickptr->aperture = (int) (aperture * (float) MAX_NDC_COORD);
|
|
return (0);
|
|
}
|
|
|
|
set_locator_2(locnum, x, y)
|
|
int locnum;
|
|
float x, y;
|
|
{
|
|
ddargtype ddstruct;
|
|
float f;
|
|
static char funcname[] = "set_locator_2";
|
|
locatstr *locatptr;
|
|
|
|
if ((locatptr = _core_check_locator(funcname, locnum, TRUE)) == 0)
|
|
return (1);
|
|
if (x < 0.0 || x > _core_ndc.width || y < 0.0 || y > _core_ndc.height) {
|
|
_core_errhand(funcname, 112);
|
|
return (1);
|
|
}
|
|
f = x;
|
|
f *= MAX_NDC_COORD;
|
|
ddstruct.int1 = _core_roundf(&f);
|
|
f = y;
|
|
f *= MAX_NDC_COORD;
|
|
ddstruct.int2 = _core_roundf(&f);
|
|
locatptr->setpos[0] = ddstruct.int1;
|
|
locatptr->setpos[1] = ddstruct.int2;
|
|
ddstruct.opcode = XYWRITE;
|
|
ddstruct.instance = locatptr->subloc.instance;
|
|
(*locatptr->subloc.devdrive) (&ddstruct);
|
|
return (0);
|
|
}
|
|
|
|
set_valuator(valnum, init, low, high)
|
|
int valnum;
|
|
float init, low, high;
|
|
{
|
|
static char funcname[] = "set_valuator";
|
|
valstr *valptr;
|
|
|
|
if ((valptr = _core_check_valuator(funcname, valnum, TRUE)) == 0)
|
|
return (1);
|
|
valptr->vlinit = init;
|
|
valptr->vlmin = low;
|
|
valptr->vlmax = high;
|
|
return (0);
|
|
}
|
|
|
|
set_stroke(strokenum, bufsize, dist, time)
|
|
int strokenum, bufsize, time;
|
|
float dist;
|
|
{
|
|
static char funcname[] = "set_stroke";
|
|
strokstr *strokptr;
|
|
|
|
if ((strokptr = _core_check_stroke(funcname, strokenum, TRUE)) == 0)
|
|
return (1);
|
|
strokptr->bufsize = bufsize;
|
|
strokptr->distance = dist * MAX_NDC_COORD;
|
|
return (0);
|
|
}
|
|
|
|
static char initstr[81 * KEYBORDS];
|
|
|
|
set_keyboard(keynum, bufsize, istr, pos)
|
|
int keynum, bufsize, pos;
|
|
char *istr;
|
|
{
|
|
int l;
|
|
static char funcname[] = "set_keyboard";
|
|
keybstr *keybptr;
|
|
int offset;
|
|
|
|
if ((keybptr = _core_check_keyboard(funcname, keynum, TRUE)) == 0)
|
|
return (1);
|
|
if (bufsize > 0 && bufsize <= keybptr->maxbufsz) {
|
|
offset = (keynum - 1) * 81;
|
|
keybptr->bufsize = bufsize;
|
|
l = strlen(istr);
|
|
if (l > 80)
|
|
l = 80;
|
|
(void) strncpy(&initstr[offset], istr, l);
|
|
initstr[offset + l] = '\0';
|
|
keybptr->initstring = &initstr[offset];
|
|
keybptr->initpos = pos;
|
|
} else {
|
|
_core_errhand(funcname, 76);
|
|
return (1);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
static
|
|
init_mouse(devptr, useloc)
|
|
device *devptr;
|
|
int useloc;
|
|
{
|
|
ddargtype ddstruct;
|
|
|
|
ddstruct.opcode = INITIAL;
|
|
ddstruct.ptr1 = (char *) devptr;
|
|
ddstruct.logical = useloc;
|
|
(*devptr->devdrive) (&ddstruct);
|
|
}
|
|
|
|
static
|
|
term_mouse(devptr, useloc)
|
|
device *devptr;
|
|
int useloc;
|
|
{
|
|
ddargtype ddstruct;
|
|
|
|
ddstruct.opcode = TERMINATE;
|
|
ddstruct.instance = devptr->instance;
|
|
ddstruct.logical = useloc;
|
|
(*devptr->devdrive) (&ddstruct);
|
|
}
|
|
|
|
pickstr *
|
|
_core_check_pick(funcname, picknum, wantinit)
|
|
char *funcname;
|
|
int picknum, wantinit;
|
|
{
|
|
pickstr *pickptr;
|
|
|
|
if (--picknum < 0 || picknum >= PICKS) {
|
|
_core_errhand(funcname, 69);
|
|
return (0);
|
|
}
|
|
pickptr = &_core_pick[picknum];
|
|
if (wantinit && !(pickptr->subpick.enable & 1)) {
|
|
_core_errhand(funcname, 104);
|
|
return (0);
|
|
} else if (!wantinit && (pickptr->subpick.enable & 1)) {
|
|
_core_errhand(funcname, 103);
|
|
return (0);
|
|
}
|
|
return (pickptr);
|
|
}
|
|
|
|
keybstr *
|
|
_core_check_keyboard(funcname, keynum, wantinit)
|
|
char *funcname;
|
|
int keynum, wantinit;
|
|
{
|
|
keybstr *keybptr;
|
|
|
|
if (--keynum < 0 || keynum >= KEYBORDS) {
|
|
_core_errhand(funcname, 75);
|
|
return (0);
|
|
}
|
|
keybptr = &_core_keybord[keynum];
|
|
if (wantinit && !(keybptr->subkey.enable & 1)) {
|
|
_core_errhand(funcname, 104);
|
|
return (0);
|
|
} else if (!wantinit && (keybptr->subkey.enable & 1)) {
|
|
_core_errhand(funcname, 103);
|
|
return (0);
|
|
}
|
|
return (keybptr);
|
|
}
|
|
|
|
strokstr *
|
|
_core_check_stroke(funcname, strokenum, wantinit)
|
|
char *funcname;
|
|
int strokenum, wantinit;
|
|
{
|
|
strokstr *strokptr;
|
|
|
|
if (--strokenum < 0 || strokenum >= STROKES) {
|
|
_core_errhand(funcname, 102);
|
|
return (0);
|
|
}
|
|
strokptr = &_core_stroker[strokenum];
|
|
if (wantinit && !(strokptr->substroke.enable & 1)) {
|
|
_core_errhand(funcname, 104);
|
|
return (0);
|
|
} else if (!wantinit && (strokptr->substroke.enable & 1)) {
|
|
_core_errhand(funcname, 103);
|
|
return (0);
|
|
}
|
|
return (strokptr);
|
|
}
|
|
|
|
locatstr *
|
|
_core_check_locator(funcname, locnum, wantinit)
|
|
char *funcname;
|
|
int locnum, wantinit;
|
|
{
|
|
locatstr *locatptr;
|
|
|
|
if (--locnum < 0 || locnum >= LOCATORS) {
|
|
_core_errhand(funcname, 70);
|
|
return (0);
|
|
}
|
|
locatptr = &_core_locator[locnum];
|
|
if (wantinit && !(locatptr->subloc.enable & 1)) {
|
|
_core_errhand(funcname, 104);
|
|
return (0);
|
|
} else if (!wantinit && (locatptr->subloc.enable & 1)) {
|
|
_core_errhand(funcname, 103);
|
|
return (0);
|
|
}
|
|
return (locatptr);
|
|
}
|
|
|
|
valstr *
|
|
_core_check_valuator(funcname, valnum, wantinit)
|
|
char *funcname;
|
|
int valnum, wantinit;
|
|
{
|
|
valstr *valptr;
|
|
|
|
if (--valnum < 0 || valnum >= VALUATRS) {
|
|
_core_errhand(funcname, 72);
|
|
return (0);
|
|
}
|
|
valptr = &_core_valuatr[valnum];
|
|
if (wantinit && !(valptr->subval.enable & 1)) {
|
|
_core_errhand(funcname, 104);
|
|
return (0);
|
|
} else if (!wantinit && (valptr->subval.enable & 1)) {
|
|
_core_errhand(funcname, 103);
|
|
return (0);
|
|
}
|
|
return (valptr);
|
|
}
|
|
|
|
butnstr *
|
|
_core_check_button(funcname, butnum, wantinit)
|
|
char *funcname;
|
|
int butnum, wantinit;
|
|
{
|
|
butnstr *butnptr;
|
|
|
|
if (--butnum < 0 || butnum >= BUTTONS) {
|
|
_core_errhand(funcname, 77);
|
|
return (0);
|
|
}
|
|
butnptr = &_core_button[butnum];
|
|
if (wantinit && !(butnptr->subbut.enable & 1)) {
|
|
_core_errhand(funcname, 104);
|
|
return (0);
|
|
} else if (!wantinit && (butnptr->subbut.enable & 1)) {
|
|
_core_errhand(funcname, 103);
|
|
return (0);
|
|
}
|
|
return (butnptr);
|
|
}
|