806 lines
24 KiB
C
806 lines
24 KiB
C
#ifndef lint
|
|
static char sccsid[] = "@(#)input.c 1.1 94/10/31 Copyr 1985-9 Sun Micro";
|
|
#endif
|
|
|
|
/*
|
|
* Copyright (c) 1985, 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.
|
|
*/
|
|
/*
|
|
* CGI Input functions
|
|
*/
|
|
|
|
/*
|
|
initialize_lid
|
|
release_input_device
|
|
track_on
|
|
track_off
|
|
set_initial_value
|
|
set_valuator_range
|
|
request_input
|
|
_cgi_err_check_inrep
|
|
_cgi_err_check_echo
|
|
*/
|
|
|
|
#include "cgipriv.h"
|
|
#include <signal.h>
|
|
|
|
View_surface *_cgi_vws; /* current view surface */
|
|
Outatt *_cgi_att; /* current attributes */
|
|
View_surface *_cgi_view_surfaces[MAXVWS]; /* view surface information */
|
|
int _cgi_vwsurf_count; /* number of view surfaces */
|
|
int _cgi_num_chars;
|
|
Outatt *_cgi_att; /* structure containing current attributes */
|
|
struct locatstr *_cgi_locator[_CGI_LOCATORS];
|
|
struct keybstr *_cgi_keybord[_CGI_KEYBORDS];
|
|
struct strokstr *_cgi_stroker[_CGI_STROKES];
|
|
struct valstr *_cgi_valuatr[_CGI_VALUATRS];
|
|
struct choicestr *_cgi_button[_CGI_CHOICES];
|
|
struct pickstr *_cgi_pick[_CGI_PICKS];
|
|
int _cgi_event_occurred; /* event flag */
|
|
int _cgi_alarm_occurred; /* alarm flag */
|
|
|
|
extern char *strcpy(), *strncpy();;
|
|
|
|
/* lastdefaultcursor is the cursor in use before track_on was issued */
|
|
static short default_cursor_shape[16];
|
|
mpr_static(_cgi_last_defcursor, 16, 16, 1, default_cursor_shape);
|
|
static struct cursor lastdefaultcursor =
|
|
{
|
|
0, 15, PIX_SRC ^ PIX_DST, &_cgi_last_defcursor
|
|
};
|
|
|
|
static short cursor_shape[] =
|
|
{
|
|
0x0020, 0x0070, 0x009c, 0x0106,
|
|
0x0083, 0x01c9, 0x03e2, 0x07fe,
|
|
0x0ff0, 0x1ff0, 0x3ff0, 0x3fe0,
|
|
0x77e0, 0x6140, 0xe000, 0xc000
|
|
};
|
|
mpr_static(_cgi_cursor_mpr, 16, 16, 1, cursor_shape);
|
|
static struct cursor _cgi_cursor =
|
|
{
|
|
0, 15, PIX_SRC ^ PIX_DST, &_cgi_cursor_mpr
|
|
};
|
|
static struct cursor _cgi_cursor_null =
|
|
{
|
|
0, 15, PIX_SRC ^ PIX_DST, NULL
|
|
};
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* FUNCTION: initialize_lid */
|
|
/* */
|
|
/* initializes specific input devices. */
|
|
/****************************************************************************/
|
|
|
|
Cerror initialize_lid(devclass, devnum, ival)
|
|
Cdevoff devclass;
|
|
Cint devnum; /* device type, device number */
|
|
Cinrep *ival; /* initial value of device measure */
|
|
|
|
{
|
|
int fd, i, terr;
|
|
struct screen screen;
|
|
static struct keybstr *keybptr;
|
|
static struct strokstr *strokptr;
|
|
static struct locatstr *locatptr;
|
|
static struct valstr *valptr;
|
|
static struct choicestr *butnptr;
|
|
static struct pickstr *pickptr;
|
|
static struct device idev =
|
|
{
|
|
NO_EVENTS, 1, 0, 0, ACK_OFF
|
|
};
|
|
|
|
/* Check that the input device exists (err 80 == EINDNOEX) */
|
|
terr = _cgi_err_check_480(devclass, devnum);
|
|
if (!terr && (devclass != IC_VALUATOR))
|
|
terr = _cgi_err_check_inrep(devclass, devnum, ival);
|
|
if (!terr)
|
|
{
|
|
switch (devclass)
|
|
{
|
|
case IC_STRING:
|
|
if (_cgi_keybord[devnum - 1])
|
|
{
|
|
if (_cgi_keybord[devnum - 1]->subkey.enable != RELEASE)
|
|
terr = EINDALIN;
|
|
}
|
|
else
|
|
{
|
|
keybptr = (struct keybstr *) malloc(sizeof(struct keybstr));
|
|
keybptr->initstring =
|
|
(char *) malloc((MAXCHAR + 1) * sizeof(char));
|
|
keybptr->rinitstring =
|
|
(char *) malloc((MAXCHAR + 1) * sizeof(char));
|
|
}
|
|
if (terr == 0)
|
|
{
|
|
keybptr->subkey = idev;
|
|
_cgi_keybord[devnum - 1] = keybptr;
|
|
(void) strcpy(_cgi_keybord[devnum - 1]->initstring,
|
|
ival->string);
|
|
(void) strcpy(_cgi_keybord[devnum - 1]->rinitstring,
|
|
ival->string);
|
|
}
|
|
break;
|
|
case IC_STROKE:
|
|
if (_cgi_stroker[devnum - 1])
|
|
{
|
|
if (_cgi_stroker[devnum - 1]->substroke.enable != RELEASE)
|
|
terr = 82;
|
|
}
|
|
else
|
|
{
|
|
strokptr = (struct strokstr *)
|
|
malloc(sizeof(struct strokstr));
|
|
strokptr->sarray = (Ccoorlist *) malloc(sizeof(Ccoorlist));
|
|
strokptr->sarray->ptlist =
|
|
(Ccoor *) malloc(MAXPTS * sizeof(Ccoor));
|
|
strokptr->rsarray = (Ccoorlist *) malloc(sizeof(Ccoorlist));
|
|
strokptr->rsarray->ptlist =
|
|
(Ccoor *) malloc(MAXPTS * sizeof(Ccoor));
|
|
}
|
|
if (terr == 0)
|
|
{
|
|
strokptr->substroke = idev;
|
|
_cgi_stroker[devnum - 1] = strokptr;
|
|
for (i = 0; i < ival->points->n; i++)
|
|
{
|
|
_cgi_stroker[devnum - 1]->sarray->ptlist[i] =
|
|
ival->points->ptlist[i];
|
|
_cgi_stroker[devnum - 1]->rsarray->ptlist[i] =
|
|
ival->points->ptlist[i];
|
|
}
|
|
_cgi_stroker[devnum - 1]->sarray->n =
|
|
ival->points->n;
|
|
_cgi_stroker[devnum - 1]->rsarray->n =
|
|
ival->points->n;
|
|
}
|
|
break;
|
|
case IC_LOCATOR:
|
|
if (_cgi_locator[devnum - 1])
|
|
{
|
|
if (_cgi_locator[devnum - 1]->subloc.enable != RELEASE)
|
|
terr = 82;
|
|
}
|
|
else
|
|
{
|
|
locatptr = (struct locatstr *)
|
|
malloc(sizeof(struct locatstr));
|
|
}
|
|
if (terr == 0)
|
|
{
|
|
locatptr->subloc = idev;
|
|
_cgi_locator[devnum - 1] = locatptr;
|
|
_cgi_locator[devnum - 1]->x = ival->xypt->x;
|
|
_cgi_locator[devnum - 1]->y = ival->xypt->y;
|
|
_cgi_locator[devnum - 1]->rx = ival->xypt->x;
|
|
_cgi_locator[devnum - 1]->ry = ival->xypt->y;
|
|
}
|
|
break;
|
|
case IC_PICK:
|
|
if (_cgi_pick[devnum - 1])
|
|
{
|
|
if (_cgi_pick[devnum - 1]->subpick.enable != RELEASE)
|
|
terr = 82;
|
|
}
|
|
else
|
|
pickptr = (struct pickstr *)
|
|
malloc(sizeof(struct pickstr));
|
|
if (terr == 0)
|
|
{
|
|
pickptr->subpick = idev;
|
|
_cgi_pick[devnum - 1] = pickptr;
|
|
_cgi_pick[devnum - 1]->pck = ival->pick;
|
|
_cgi_pick[devnum - 1]->rpck = ival->pick;
|
|
}
|
|
break;
|
|
case IC_VALUATOR:
|
|
if (_cgi_valuatr[devnum - 1])
|
|
{
|
|
if (_cgi_valuatr[devnum - 1]->subval.enable != RELEASE)
|
|
terr = 82;
|
|
}
|
|
else
|
|
valptr = (struct valstr *) malloc(sizeof(struct valstr));
|
|
if (terr == 0)
|
|
{
|
|
valptr->subval = idev;
|
|
valptr->vlmin = 0.0;
|
|
valptr->vlmax = 1.0;
|
|
_cgi_valuatr[devnum - 1] = valptr;
|
|
if ((ival->val < _cgi_valuatr[devnum - 1]->vlmin)
|
|
|| (ival->val > _cgi_valuatr[devnum - 1]->vlmax)
|
|
)
|
|
terr = EBADDATA;
|
|
else
|
|
{
|
|
_cgi_valuatr[devnum - 1]->curval = ival->val;
|
|
_cgi_valuatr[devnum - 1]->rcurval = ival->val;
|
|
}
|
|
}
|
|
break;
|
|
case IC_CHOICE:
|
|
if (_cgi_button[devnum - 1])
|
|
{
|
|
if (_cgi_button[devnum - 1]->subchoice.enable != RELEASE)
|
|
terr = 82;
|
|
}
|
|
else
|
|
butnptr = (struct choicestr *)
|
|
malloc(sizeof(struct choicestr));
|
|
if (terr == 0)
|
|
{
|
|
butnptr->subchoice = idev;
|
|
_cgi_button[devnum - 1] = butnptr;
|
|
_cgi_button[devnum - 1]->curval = ival->choice;
|
|
_cgi_button[devnum - 1]->rcurval = ival->choice;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (!terr)
|
|
{
|
|
for (i = 0; i < _cgi_vwsurf_count; i++)
|
|
{
|
|
switch (_cgi_view_surfaces[i]->device)
|
|
{
|
|
case BW1DD:
|
|
case BW2DD:
|
|
case CG1DD:
|
|
case CG2DD:
|
|
case CG3DD:
|
|
case CG4DD:
|
|
#ifndef NO_CG6
|
|
case CG6DD:
|
|
#endif NO_CG6
|
|
case GP1DD:
|
|
fd = _cgi_view_surfaces[i]->sunview.windowfd;
|
|
win_screenget(fd, &screen);
|
|
(void) strncpy(screen.scr_kbdname, "/dev/kbd",
|
|
SCR_NAMESIZE);
|
|
(void) strncpy(screen.scr_msname, "/dev/mouse",
|
|
SCR_NAMESIZE);
|
|
(void) win_setms(fd, &screen);
|
|
(void) win_setkbd(fd, &screen);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return (_cgi_errhand(terr));
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* FUNCTION: release_input_device */
|
|
/* */
|
|
/* Makes device unable to detect input until device */
|
|
/* is reinitialized. */
|
|
/****************************************************************************/
|
|
|
|
Cerror release_input_device(devclass, devnum)
|
|
Cdevoff devclass;
|
|
Cint devnum; /* device type, device number */
|
|
{
|
|
int i, terr, err;
|
|
static struct device idev =
|
|
{
|
|
RELEASE, -1, 0, 0, ACK_OFF
|
|
};
|
|
err = _cgi_err_check_481(devclass, devnum);
|
|
if (!err)
|
|
{
|
|
/* get rid of pending events */
|
|
err = selective_flush_of_event_queue(devclass, devnum);
|
|
/* dissociate from associated triggers */
|
|
if (!err)
|
|
{
|
|
for (i = 1; i < MAXTRIG + 1; i++)
|
|
{
|
|
terr = _cgi_err_is_trig_assoc(devclass, devnum, i);
|
|
if (terr)
|
|
{ /* trigger is associated */
|
|
err = dissociate(i, devclass, devnum);
|
|
}
|
|
}
|
|
}
|
|
if (!err)
|
|
{
|
|
switch (devclass)
|
|
{ /* change state of device */
|
|
case IC_STRING:
|
|
_cgi_keybord[devnum - 1]->subkey = idev;
|
|
break;
|
|
case IC_STROKE:
|
|
_cgi_stroker[devnum - 1]->substroke = idev;
|
|
break;
|
|
case IC_LOCATOR:
|
|
_cgi_locator[devnum - 1]->subloc = idev;
|
|
break;
|
|
case IC_PICK:
|
|
_cgi_pick[devnum - 1]->subpick = idev;
|
|
break;
|
|
case IC_VALUATOR:
|
|
_cgi_valuatr[devnum - 1]->subval = idev;
|
|
break;
|
|
case IC_CHOICE:
|
|
_cgi_button[devnum - 1]->subchoice = idev;
|
|
}
|
|
}
|
|
}
|
|
return (_cgi_errhand(err));
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* FUNCTION: track_on */
|
|
/* */
|
|
/* Deterimines whether input device movement is displayed on */
|
|
/* the screen */
|
|
/****************************************************************************/
|
|
|
|
/* ARGSUSED WDS: As documented, the echoregion argument is ignored */
|
|
Cerror track_on(devclass, devnum, echotype, echoregion, value)
|
|
Cdevoff devclass;
|
|
Cint devnum;
|
|
Cint echotype; /* type of echo */
|
|
Ccoorpair *echoregion; /* window where echo is enabled */
|
|
Cinrep *value; /* device value */
|
|
{
|
|
int terr;
|
|
int mousex, mousey;
|
|
int ivw;
|
|
|
|
terr = _cgi_err_check_481(devclass, devnum);
|
|
if (!terr)
|
|
terr = _cgi_err_check_echo(devclass, devnum, echotype);
|
|
if (!terr)
|
|
terr = _cgi_err_check_inrep(devclass, devnum, value);
|
|
if (!terr && value->xypt == (Ccoor *) NULL)
|
|
terr = EBADDATA; /* used for mouse initial position */
|
|
if (!terr)
|
|
{
|
|
ivw = 0;
|
|
(void) _cgi_bump_vws(&ivw); /* already checked for VSAC above */
|
|
switch (devclass)
|
|
{
|
|
case IC_STRING:
|
|
_cgi_keybord[devnum - 1]->subkey.echo = (short) echotype;
|
|
_cgi_keybord[devnum - 1]->echo_base =
|
|
_cgi_keybord[devnum - 1]->echo_pt =
|
|
_cgi_att->text.concat_pt;
|
|
/* win_setcursor (_cgi_vws->sunview.windowfd, &_cgi_cursor);
|
|
_cgi_devscale (value->xypt->x, value->xypt->y,
|
|
mousex, mousey);
|
|
win_setmouseposition (_cgi_vws->sunview.windowfd, mousex, mousey); */
|
|
break;
|
|
case IC_STROKE:
|
|
_cgi_stroker[devnum - 1]->substroke.echo =
|
|
(short) echotype;
|
|
/* win_setcursor (_cgi_vws->sunview.windowfd, &_cgi_cursor);
|
|
_cgi_devscale (value->xypt->x, value->xypt->y,
|
|
mousex, mousey);
|
|
win_setmouseposition (_cgi_vws->sunview.windowfd, mousex, mousey); */
|
|
break;
|
|
case IC_LOCATOR:
|
|
_cgi_locator[devnum - 1]->subloc.echo = (short) echotype;
|
|
/* win_setcursor (_cgi_vws->sunview.windowfd, &_cgi_cursor);
|
|
_cgi_devscale (value->xypt->x, value->xypt->y,
|
|
mousex, mousey);
|
|
win_setmouseposition (_cgi_vws->sunview.windowfd, mousex, mousey); */
|
|
break;
|
|
case IC_PICK:
|
|
_cgi_pick[devnum - 1]->subpick.echo = (short) echotype;
|
|
/* win_setcursor (_cgi_vws->sunview.windowfd, &_cgi_cursor);
|
|
_cgi_devscale (value->xypt->x, value->xypt->y,
|
|
mousex, mousey);
|
|
win_setmouseposition (_cgi_vws->sunview.windowfd, mousex, mousey); */
|
|
break;
|
|
case IC_VALUATOR:
|
|
_cgi_valuatr[devnum - 1]->subval.echo = (short) echotype;
|
|
_cgi_valuatr[devnum - 1]->echo_flag = 0;
|
|
_cgi_valuatr[devnum - 1]->echo_base =
|
|
_cgi_att->text.concat_pt;
|
|
/* win_setcursor (_cgi_vws->sunview.windowfd, &_cgi_cursor);
|
|
_cgi_devscale (value->xypt->x, value->xypt->y,
|
|
mousex, mousey);
|
|
win_setmouseposition (_cgi_vws->sunview.windowfd, mousex, mousey);
|
|
*/ break;
|
|
case IC_CHOICE:
|
|
_cgi_button[devnum - 1]->subchoice.echo =
|
|
(short) echotype;
|
|
break;
|
|
}
|
|
win_getcursor(_cgi_vws->sunview.windowfd, &lastdefaultcursor);
|
|
if ((devclass == IC_STRING) && (echotype == 2))/* set a NULL cursor */
|
|
win_setcursor(_cgi_vws->sunview.windowfd, &_cgi_cursor_null);
|
|
else
|
|
win_setcursor(_cgi_vws->sunview.windowfd, &_cgi_cursor);
|
|
_cgi_devscale(value->xypt->x, value->xypt->y,
|
|
mousex, mousey);
|
|
win_setmouseposition(_cgi_vws->sunview.windowfd, mousex, mousey);
|
|
}
|
|
return (_cgi_errhand(terr));
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* FUNCTION: track_off */
|
|
/* */
|
|
/* Terminates echo. */
|
|
/****************************************************************************/
|
|
/* ARGSUSED WDS: As documented, the tracktype & action arguments are ignored*/
|
|
Cerror track_off(devclass, devnum, tracktype, action)
|
|
Cdevoff devclass;
|
|
Cint devnum; /* device type, device number */
|
|
Cint tracktype; /* Unused arg */
|
|
Cfreeze action; /* Unused arg */
|
|
{
|
|
int terr;
|
|
|
|
terr = _cgi_err_check_481(devclass, devnum);
|
|
if (!terr)
|
|
{
|
|
switch (devclass)
|
|
{
|
|
case IC_STRING:
|
|
if (_cgi_num_chars != 0)
|
|
_cgi_echo_dis(_cgi_keybord[devnum - 1]->subkey.echo,
|
|
0, 0, devclass, devnum, ERASE);
|
|
_cgi_keybord[devnum - 1]->subkey.echo = -1;
|
|
break;
|
|
case IC_STROKE:
|
|
_cgi_stroker[devnum - 1]->substroke.echo = -1;
|
|
break;
|
|
case IC_LOCATOR:
|
|
_cgi_locator[devnum - 1]->subloc.echo = -1;
|
|
break;
|
|
case IC_PICK:
|
|
_cgi_pick[devnum - 1]->subpick.echo = -1;
|
|
break;
|
|
case IC_VALUATOR:
|
|
if (_cgi_valuatr[devnum - 1]->echo_flag)
|
|
_cgi_echo_dis(_cgi_valuatr[devnum - 1]->subval.echo,
|
|
0, 0, devclass, devnum, ERASE);
|
|
_cgi_valuatr[devnum - 1]->subval.echo = -1;
|
|
break;
|
|
case IC_CHOICE:
|
|
_cgi_button[devnum - 1]->subchoice.echo = -1;
|
|
break;
|
|
}
|
|
}
|
|
/* set the cursor back to the default in place before the latest track_on */
|
|
win_setcursor(_cgi_vws->sunview.windowfd, &lastdefaultcursor);
|
|
return (_cgi_errhand(terr));
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* FUNCTION: set_initial_value */
|
|
/* */
|
|
/* set measure of device. */
|
|
/****************************************************************************/
|
|
|
|
Cerror set_initial_value(devclass, devnum, value)
|
|
Cdevoff devclass; /* device type */
|
|
Cint devnum; /* device number */
|
|
Cinrep *value; /* device value */
|
|
{
|
|
int terr;
|
|
terr = _cgi_err_check_481(devclass, devnum);
|
|
if (!terr)
|
|
terr = _cgi_err_check_inrep(devclass, devnum, value);
|
|
if (!terr)
|
|
{
|
|
switch (devclass)
|
|
{
|
|
case IC_STRING:
|
|
(void) strcpy(_cgi_keybord[devnum - 1]->initstring, value->string);
|
|
(void) strcpy(_cgi_keybord[devnum - 1]->rinitstring, value->string);
|
|
break;
|
|
case IC_STROKE:
|
|
/* WCL 860911 These should copy pts, not use client's data space */
|
|
_cgi_stroker[devnum - 1]->sarray = value->points;
|
|
_cgi_stroker[devnum - 1]->rsarray = value->points;
|
|
break;
|
|
case IC_LOCATOR:
|
|
_cgi_locator[devnum - 1]->x = value->xypt->x;
|
|
_cgi_locator[devnum - 1]->y = value->xypt->y;
|
|
_cgi_locator[devnum - 1]->rx = value->xypt->x;
|
|
_cgi_locator[devnum - 1]->ry = value->xypt->y;
|
|
break;
|
|
case IC_VALUATOR:
|
|
_cgi_valuatr[devnum - 1]->curval = value->val;
|
|
_cgi_valuatr[devnum - 1]->rcurval = value->val;
|
|
break;
|
|
case IC_CHOICE:
|
|
_cgi_button[devnum - 1]->curval = value->choice;
|
|
_cgi_button[devnum - 1]->rcurval = value->choice;
|
|
break;
|
|
}
|
|
}
|
|
return (_cgi_errhand(terr));
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* FUNCTION: set_valuator_range */
|
|
/* */
|
|
/* Moves echo. */
|
|
/****************************************************************************/
|
|
|
|
Cerror set_valuator_range(devnum, mn, mx)
|
|
Cint devnum; /* device number */
|
|
Cfloat mn, mx; /* limits of valuator */
|
|
{
|
|
int err;
|
|
err = _cgi_err_check_4();
|
|
if (!err)
|
|
{
|
|
if (devnum > 0 && devnum <= _CGI_VALUATRS)
|
|
{
|
|
if (_cgi_valuatr[devnum - 1]->subval.enable != RELEASE)
|
|
{
|
|
_cgi_valuatr[devnum - 1]->vlmin = mn;
|
|
_cgi_valuatr[devnum - 1]->vlmax = mx;
|
|
}
|
|
else
|
|
err = 81;
|
|
}
|
|
else
|
|
err = 80;
|
|
}
|
|
return (_cgi_errhand(err));
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* FUNCTION: request_input */
|
|
/* */
|
|
/* Awaits input and reports trigger number and value. */
|
|
/****************************************************************************/
|
|
|
|
Cerror request_input(devclass, devnum, timeout, valid, sample, trigger)
|
|
Cdevoff devclass;
|
|
Cint devnum; /* device type, device number */
|
|
Cint timeout; /* amount of time to wait for input */
|
|
Cawresult *valid; /* device status */
|
|
Cinrep *sample; /* device value */
|
|
Cint *trigger; /* trigger number */
|
|
{
|
|
int err;
|
|
int cnt;
|
|
int *trig_p;
|
|
Clidstate *enable_p;
|
|
/* Ccoor pts[MAXPTS]; */
|
|
|
|
err = _cgi_err_check_481(devclass, devnum);
|
|
*trigger = 0;
|
|
|
|
if (!err)
|
|
{
|
|
switch (devclass)
|
|
{
|
|
case IC_STRING:
|
|
if (sample->string == (char *) NULL)
|
|
{
|
|
err = EBADDATA;
|
|
break;
|
|
}
|
|
enable_p = &_cgi_keybord[devnum - 1]->subkey.enable;
|
|
trig_p = &_cgi_keybord[devnum - 1]->trig;
|
|
break;
|
|
case IC_CHOICE:
|
|
enable_p = &_cgi_button[devnum - 1]->subchoice.enable;
|
|
trig_p = &_cgi_button[devnum - 1]->trig;
|
|
break;
|
|
case IC_LOCATOR:
|
|
if (sample->xypt == (Ccoor *) NULL)
|
|
{
|
|
err = EBADDATA;
|
|
break;
|
|
}
|
|
enable_p = &_cgi_locator[devnum - 1]->subloc.enable;
|
|
trig_p = &_cgi_locator[devnum - 1]->trig;
|
|
break;
|
|
case IC_PICK:
|
|
if (sample->pick == (Cpick *) NULL)
|
|
{
|
|
err = EBADDATA;
|
|
break;
|
|
}
|
|
enable_p = &_cgi_pick[devnum - 1]->subpick.enable;
|
|
trig_p = &_cgi_pick[devnum - 1]->trig;
|
|
break;
|
|
case IC_VALUATOR:
|
|
enable_p = &_cgi_valuatr[devnum - 1]->subval.enable;
|
|
trig_p = &_cgi_valuatr[devnum - 1]->trig;
|
|
break;
|
|
case IC_STROKE:
|
|
if (sample->points == (Ccoorlist *) NULL)
|
|
{
|
|
err = EBADDATA;
|
|
break;
|
|
}
|
|
enable_p = &_cgi_stroker[devnum - 1]->substroke.enable;
|
|
trig_p = &_cgi_stroker[devnum - 1]->trig;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!err)
|
|
{
|
|
if (_cgi_event_occurred)
|
|
(void) _cgi_ioint_handle();
|
|
else
|
|
{
|
|
/* Set an itimer for the user-specified timeout */
|
|
if (timeout >= 0)
|
|
(void) _cgi_set_timeout((unsigned) timeout);
|
|
|
|
/* Pause loop that waits for the IO to complete. */
|
|
*enable_p = RESPOND_EVENT;
|
|
do
|
|
{
|
|
if (! (_cgi_event_occurred || _cgi_alarm_occurred))
|
|
(void) _cgi_timeout(timeout);
|
|
if (_cgi_event_occurred)
|
|
(void) _cgi_ioint_handle();
|
|
} while (!_cgi_alarm_occurred && *enable_p == RESPOND_EVENT);
|
|
}
|
|
|
|
switch (devclass)
|
|
{
|
|
case IC_STRING:
|
|
(void) strcpy(sample->string, _cgi_keybord[devnum - 1]->rinitstring);
|
|
break;
|
|
case IC_CHOICE:
|
|
sample->choice = _cgi_button[devnum - 1]->rcurval;
|
|
break;
|
|
case IC_LOCATOR:
|
|
sample->xypt->x = _cgi_locator[devnum - 1]->rx;
|
|
sample->xypt->y = _cgi_locator[devnum - 1]->ry;
|
|
break;
|
|
case IC_PICK:
|
|
sample->pick->segid = _cgi_pick[devnum - 1]->rpck->segid;
|
|
sample->pick->pickid = _cgi_pick[devnum - 1]->rpck->pickid;
|
|
break;
|
|
case IC_VALUATOR:
|
|
sample->val = _cgi_valuatr[devnum - 1]->rcurval;
|
|
break;
|
|
case IC_STROKE:
|
|
cnt = _cgi_stroker[devnum - 1]->rsarray->n;
|
|
if (cnt > sample->points->n)
|
|
cnt = sample->points->n;
|
|
bcopy((char *) _cgi_stroker[devnum - 1]->rsarray->ptlist,
|
|
(char *) sample->points->ptlist,
|
|
cnt * sizeof(*sample->points->ptlist));
|
|
break;
|
|
}
|
|
|
|
if (*enable_p == RESPOND_EVENT)
|
|
*trigger = 0;
|
|
else
|
|
*trigger = *trig_p;
|
|
}
|
|
if (!err)
|
|
{
|
|
if (*trigger)
|
|
*valid = VALID_DATA;
|
|
else
|
|
*valid = TIMED_OUT;
|
|
}
|
|
else
|
|
{
|
|
if (err == 4 || err == 81)
|
|
*valid = WRONG_STATE;
|
|
if (err == 80)
|
|
*valid = NOT_SUPPORTED;
|
|
if (err == 94)
|
|
*valid = DISABLED;
|
|
}
|
|
return (_cgi_errhand(err));
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* FUNCTION: _cgi_err_check_inrep */
|
|
/* */
|
|
/* */
|
|
/****************************************************************************/
|
|
int _cgi_err_check_inrep(devclass, devnum, ival)
|
|
Cdevoff devclass;
|
|
Cint devnum; /* device type, device number */
|
|
Cinrep *ival; /* initial value of device measure */
|
|
{
|
|
int err;
|
|
if (ival == (Cinrep *) NULL)
|
|
err = EBADDATA;
|
|
else
|
|
{
|
|
err = NO_ERROR;
|
|
switch (devclass)
|
|
{
|
|
case IC_STRING:
|
|
if (ival->string == (char *) NULL)
|
|
err = EBADDATA;
|
|
if (strlen(ival->string) > MAXCHAR)
|
|
err = ESTRSIZE;
|
|
break;
|
|
case IC_STROKE:
|
|
if (!ival->points)
|
|
err = EBADDATA;
|
|
break;
|
|
case IC_LOCATOR:
|
|
if (!ival->xypt)
|
|
err = EBADDATA;
|
|
break;
|
|
case IC_VALUATOR:
|
|
if ((ival->val < _cgi_valuatr[devnum - 1]->vlmin)
|
|
|| (ival->val > _cgi_valuatr[devnum - 1]->vlmax))
|
|
err = EBADDATA;
|
|
break;
|
|
case IC_CHOICE:
|
|
/* if ((ival->choice != 0) && (ival->choice != 1)) */
|
|
if ((ival->choice < 2) && (ival->choice > 4))
|
|
err = EBADDATA;
|
|
break;
|
|
}
|
|
}
|
|
return (err);
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* FUNCTION: _cgi_err_check_echo */
|
|
/* */
|
|
/* */
|
|
/* (echo <= 0) means NO_ECHO, is okay 870319 MDH */
|
|
/****************************************************************************/
|
|
/* ARGSUSED The devnum argument is ignored: all devs same for one devclass. */
|
|
int _cgi_err_check_echo(devclass, devnum, echo)
|
|
Cdevoff devclass;
|
|
Cint devnum; /* device type, device number */
|
|
short echo;
|
|
{
|
|
int err;
|
|
err = NO_ERROR;
|
|
switch (devclass)
|
|
{
|
|
case IC_STRING:
|
|
if (echo > 2)
|
|
err = EINETNSU;
|
|
break;
|
|
case IC_STROKE:
|
|
if (echo > 5)
|
|
err = EINETNSU;
|
|
break;
|
|
case IC_LOCATOR:
|
|
if (echo > 1)
|
|
err = EINETNSU;
|
|
break;
|
|
case IC_VALUATOR:
|
|
if (echo > 2)
|
|
err = EINETNSU;
|
|
break;
|
|
case IC_CHOICE:
|
|
if (echo > 1)
|
|
err = EINETNSU;
|
|
break;
|
|
}
|
|
return (err);
|
|
}
|