⟦ba1fd7c41⟧

TextFile

/*
 *	$XConsortium: input.c,v 1.5 88/09/06 17:08:05 jim Exp $
 */

#ifndef lint
static char *rcsid_input_c = "$XConsortium: input.c,v 1.5 88/09/06 17:08:05 jim Exp $";
#endif	/* lint */

#include <X11/copyright.h>

/*
 * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
 *
 *                         All Rights Reserved
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation 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 appear in
 * supporting documentation, and that the name of Digital Equipment
 * Corporation not be used in advertising or publicity pertaining to
 * distribution of the software without specific, written prior permission.
 *
 *
 * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
 * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
 * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
 * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 * SOFTWARE.
 */

/* input.c */

#ifndef lint
static char rcs_id[] = "$XConsortium: input.c,v 1.5 88/09/06 17:08:05 jim Exp $";
#endif	/* lint */

#include <X11/Xlib.h>
#include <X11/keysym.h>
#include <X11/DECkeysym.h>
#define XK_LATIN1
#include <X11/keysymdef.h>
#include <X11/Intrinsic.h>
#include <X11/Xutil.h>
#include <setjmp.h>
#include <stdio.h>
#include "ptyx.h"
#include "data.h"
#include "ratmenu.h"
#include "rcg.h"

extern Boolean KeyCodeTable_ShiftLock;	   /* Lock == ShiftLock (!= CapsLock)*/
extern Boolean KeyCodeTable_Inited;	   /* Are tables good? */
extern KeySym  KeyCodeTable_Shifted[];     /* Shifted KeySym for a given key */
extern KeySym  KeyCodeTable_Unshifted[];   /* Unshifted KeySym for given key */


static XComposeStatus compose_status = {NULL, 0};
static char *kypd_num = " XXXXXXXX\tXXX\rXXXxxxxXXXXXXXXXXXXXXXXXXXXX*+,-.\\0123456789XXX=";
static char *kypd_apl = " ABCDEFGHIJKLMNOPQRSTUVWXYZ??????abcdefghijklmnopqrstuvwxyzXXX";
static char *cur = "DACB";

static int funcvalue(), sunfuncvalue();
extern Boolean sunFunctionKeys;

void
AdjustAfterInput (screen)
register TScreen *screen;
{
	if(screen->scrollkey && screen->topline != 0)
		WindowScroll(screen, 0);
	if(screen->marginbell) {
		int col = screen->max_col - screen->nmarginbell;
		if(screen->bellarmed >= 0) {
			if(screen->bellarmed == screen->cur_row) {
				if(screen->cur_col >= col) {
					if(screen->cur_col == col)
						Bell();
					screen->bellarmed = -1;
				}
			} else
				screen->bellarmed = screen->cur_col <
				 col ? screen->cur_row : -1;
		} else if(screen->cur_col < col)
			screen->bellarmed = screen->cur_row;
	}
}

Input (keyboard, screen, event, eightbit)
register TKeyboard	*keyboard;
register TScreen		*screen;
register XKeyPressedEvent *event;
Bool eightbit;
{

#define STRBUFSIZE 100

    register int col, key = FALSE;
    int	pty	= screen->respond;

    if (term->misc.rational) {
	/* Rational Keyboard Mode. 
	 * Transmit up to 4 characters for each key stroke.
	 * Take the KeySym and split it into two 8 bit pieces; the upper 8
	 * and the lowere 8.
         * Between these two pieces we insert 3 bits; one each for Shift,
	 * Control, and Meta.  Take the resulting 19 bits and break it up
	 * into groups of 6 bits.  Non-zero groups get sent.  See ratmenu.h
	 * for the actual code.
	 * We ignore modifiers Mod2..Mod5 completely.  So far we don't have
	 * any customers that have more than Control/Meta/Shift as modifiers.
	 * If we ever get one that has more modifiers then there are the 2
	 * available bits at the top of the first character.  After than we
	 * could try xor'ing those bits with the high order bits of the KeySym
	 * value.  The rationale is that the high order bits differentiate the
	 * various character sets; one keyboard is unlikely to be able to
	 * transmit more than one disseparate sets at one moment.  (You also
	 * have to be an octopus to use 5 Meta keys plus Control and Shift at
	 * the same time.)  GEB 06/16/88 */

        register KeySym keycode;
	char  buf[4];
	char *bp = &buf[0];

	key = event->keycode;			/* key pressed */
	col = event->state;			/* modifier state */

	/*--If Shift is down; if Lock is set and we have ShiftLock;
	 *  if Lock is set and we are an English letter; then go for the
	 *  shifted KeySym.  If he isn't there then take his unshifted KeySym
	 *  and retain the ShiftMask flag.  The tables will have both forms
	 *  (A/a,B/b,...) for letter keys with one caption on them. */

	keycode = KeyCodeTable_Shifted[key];
	if (col & ShiftMask ||
	    (col & LockMask &&
	     (KeyCodeTable_ShiftLock ||
	      (keycode >= XK_A && keycode <= XK_Z)))) {
		if (keycode == NoSymbol) {
			if ((key = KeyCodeTable_Unshifted[key]) == NoSymbol) {
				return;  /* Modifier or an Unreal key */
			};
			col |= ShiftMask;
		} else {
			key = keycode;
			col &= ~ShiftMask;
		}
	} else {
		if ((key = KeyCodeTable_Unshifted[key]) == NoSymbol) {
			return;
		}
	}

	/*--Watch out for DEC's vendor-specific keysyms.  We remove the
	 *  funny high order bit(s) and also remove bit 15 (0x8000) in order
	 *  to keep their vendor-specific keysyms from conflicting with
	 *  our Rational Mouse fake-keys which have codes 0xFF00..0xFF08. */
	if (key & 0x10000000) {
	    key &= 0x7FFF;
	}

	/*--Figure the characters and put them out. */

	col = (col & ControlMask ? RControlMask : 0) |
	      (col & Mod1Mask    ? RMod1Mask    : 0) |
	      (col & ShiftMask   ? RShiftMask   : 0);
	DoRMaskChar( bp, col, key );
	v_write( pty, buf, (int)(bp-buf) );
	key = TRUE;

    } else {

	char strbuf[STRBUFSIZE];
	register char *string;
	int	nbytes;
	KeySym 	keycode;
	ANSI	reply;

	/*--Normal VT100 keystrokes. */

	nbytes = XLookupString ((XKeyEvent *)event, strbuf, STRBUFSIZE, 
		&keycode, &compose_status);

	string = &strbuf[0];
	reply.a_pintro = 0;
	reply.a_final = 0;
	reply.a_nparam = 0;
	reply.a_inters = 0;

	if (IsPFKey(keycode)) {
		reply.a_type = SS3;
		unparseseq(&reply, pty);
		unparseputc((char)(keycode-XK_KP_F1+'P'), pty);
		key = TRUE;
	} else if (IsKeypadKey(keycode)) {
	  	if (keyboard->flags & KYPD_APL)	{
			reply.a_type   = SS3;
			unparseseq(&reply, pty);
			unparseputc(kypd_apl[keycode-XK_KP_Space], pty);
		} else
			unparseputc(kypd_num[keycode-XK_KP_Space], pty);
		key = TRUE;
        } else if (IsCursorKey(keycode) &&
        	keycode != XK_Prior && keycode != XK_Next) {
       		if (keyboard->flags & CURSOR_APL) {
			reply.a_type = SS3;
			unparseseq(&reply, pty);
			unparseputc(cur[keycode-XK_Left], pty);
		} else {
			reply.a_type = CSI;
			reply.a_final = cur[keycode-XK_Left];
			unparseseq(&reply, pty);
		}
		key = TRUE;
	 } else if (IsFunctionKey(keycode) || IsMiscFunctionKey(keycode) ||
	 	keycode == XK_Prior || keycode == XK_Next ||
	 	keycode == DXK_Remove) {
		reply.a_type = CSI;
		reply.a_nparam = 1;
		if (sunFunctionKeys) {
		    reply.a_param[0] = sunfuncvalue (keycode);
		    reply.a_final = 'z';
		} else {
		    reply.a_param[0] = funcvalue (keycode);
		    reply.a_final = '~';
		}
		if (reply.a_param[0] > 0)
			unparseseq(&reply, pty);
		key = TRUE;
	} else if (nbytes > 0) {
		if ((nbytes == 1) && eightbit) {
		    if (screen->eight_bits)
		      *string |= 0x80;	/* turn on eighth bit */
		    else
		      unparseputc (033, pty);  /* escape */
		}
		while (nbytes-- > 0)
			unparseputc(*string++, pty);
		key = TRUE;
	}
    }
	if(key)
	        AdjustAfterInput(screen);
	return;
}

StringInput (screen, string)
register TScreen	*screen;
register char *string;
{
	int	pty	= screen->respond;
	int	nbytes;

	nbytes = strlen(string);
	while (nbytes-- > 0)
		unparseputc(*string++, pty);
	AdjustAfterInput(screen);
}

static int funcvalue (keycode)
	int keycode;
{
	switch (keycode) {
		case XK_F1:	return(11);
		case XK_F2:	return(12);
		case XK_F3:	return(13);
		case XK_F4:	return(14);
		case XK_F5:	return(15);
		case XK_F6:	return(17);
		case XK_F7:	return(18);
		case XK_F8:	return(19);
		case XK_F9:	return(20);
		case XK_F10:	return(21);
		case XK_F11:	return(23);
		case XK_F12:	return(24);
		case XK_F13:	return(25);
		case XK_F14:	return(26);
		case XK_F15:	return(28);
		case XK_Help:	return(28);
		case XK_F16:	return(29);
		case XK_Menu:	return(29);
		case XK_F17:	return(31);
		case XK_F18:	return(32);
		case XK_F19:	return(33);
		case XK_F20:	return(34);

		case XK_Find :	return(1);
		case XK_Insert:	return(2);
		case XK_Delete:	return(3);
		case DXK_Remove: return(3);
		case XK_Select:	return(4);
		case XK_Prior:	return(5);
		case XK_Next:	return(6);
		default:	return(-1);
	}
}


static int sunfuncvalue (keycode)
	int keycode;
  {
  	switch (keycode) {
		case XK_F1:	return(224);
		case XK_F2:	return(225);
		case XK_F3:	return(226);
		case XK_F4:	return(227);
		case XK_F5:	return(228);
		case XK_F6:	return(229);
		case XK_F7:	return(230);
		case XK_F8:	return(231);
		case XK_F9:	return(232);
		case XK_F10:	return(233);
		case XK_F11:	return(192);
		case XK_F12:	return(193);
		case XK_F13:	return(194);
		case XK_F14:	return(195);
		case XK_F15:	return(196);
		case XK_Help:	return(196);
		case XK_F16:	return(197);
		case XK_Menu:	return(197);
		case XK_F17:	return(198);
		case XK_F18:	return(199);
		case XK_F19:	return(200);
		case XK_F20:	return(201);

		case XK_R1:	return(208);
		case XK_R2:	return(209);
		case XK_R3:	return(210);
		case XK_R4:	return(211);
		case XK_R5:	return(212);
		case XK_R6:	return(213);
		case XK_R7:	return(214);
		case XK_R8:	return(215);
		case XK_R9:	return(216);
		case XK_R10:	return(217);
		case XK_R11:	return(218);
		case XK_R12:	return(219);
		case XK_R13:	return(220);
		case XK_R14:	return(221);
		case XK_R15:	return(222);
  
		case XK_Find :	return(1);
		case XK_Insert:	return(2);
		case XK_Delete:	return(3);
		case DXK_Remove: return(3);
		case XK_Select:	return(4);
		case XK_Prior:	return(5);
		case XK_Next:	return(6);
		default:	return(-1);
	}
}
DataMuseum.dk

Rational R1000/400 Tapes

⟦ba1fd7c41⟧ TextFile

Derivation

TextFile
