command.c

Mrxvt是一个小巧

			if( r->numlock_state ) shft = 0;

			if (AVTS(r)->PrivateModes & PrivMode_aplKP)
			{
				set_xterm_key_seq( kbuf, "\033O", "\033O%d%c",
						'y', ctrl, meta, shft );
				break;
			}
			/* FALLTHROUGH */
# endif	/* XK_KP_Prior */
		case XK_Prior:
			SET_TILDE_KEY_SEQ( kbuf, "\033[5");
			break;


# ifdef XK_KP_Next
		case XK_KP_Next:		/* \033Os */
			if( r->numlock_state ) shft = 0;

			if (AVTS(r)->PrivateModes & PrivMode_aplKP)
			{
				set_xterm_key_seq( kbuf, "\033O", "\033O%d%c",
						's', ctrl, meta, shft );
				break;
			}
			/* FALLTHROUGH */

# endif	/* XK_KP_Next */
		case XK_Next:
			SET_TILDE_KEY_SEQ(kbuf, "\033[6");
			break;


		case XK_KP_Enter:	/* \033OM */

			if (
					(AVTS(r)->PrivateModes & PrivMode_aplKP)
					&& ( !r->numlock_state || ctrl || meta || shft )
			   )
			{
#ifdef NUMLOCK_ALWAYS_IGNORES_SHIFT
				if( r->numlock_state ) shft = 0;
#endif
				set_xterm_key_seq( kbuf, "\033O", "\033O%d%c", 'M',
						ctrl, meta, shft );
			}
			else
			{
				kbuf[0] = '\r';
				kbuf[1] = '\0';
			}
			break;

#ifdef XK_KP_Begin
		case XK_KP_Begin:	/* \033Ou (This is keypad 5) */
			if( r->numlock_state ) shft = 0;

			if (AVTS(r)->PrivateModes & PrivMode_aplKP)
			{
				set_xterm_key_seq( kbuf, "\033O", "\033O%d%c", 'u',
						ctrl, meta, shft );
			}
			else
			{
				kbuf[0] = '5';
				kbuf[1] = '\0';
			}

			break;
#endif	/* XK_KP_Begin */


#ifdef XK_KP_Insert
		case XK_KP_Insert:	/* \033Op */
			if( r->numlock_state ) shft = 0;

			if (AVTS(r)->PrivateModes & PrivMode_aplKP)
			{
				set_xterm_key_seq( kbuf, "\033O", "\033O%d%c", 'p',
						ctrl, meta, shft );
				break;
			}
			/* FALLTHROUGH */
#endif /* XK_KP_Insert */

		case XK_Insert:
			SET_TILDE_KEY_SEQ( kbuf, "\033[2" );
			break;


#ifdef XK_KP_Delete
		case XK_KP_Delete:	/* \033On */
			if( r->numlock_state ) shft = 0;

			if (AVTS(r)->PrivateModes & PrivMode_aplKP)
			{
				set_xterm_key_seq( kbuf, "\033O", "\033O%d%c", 'n',
						ctrl, meta, shft );
				break;
			}
			/* FALLTHROUGH */
#endif

		case XK_Delete:
#ifndef NO_DELETE_KEY
			STRCPY( kbuf, r->h->key_delete);
#else
			SET_TILDE_KEY_SEQ( kbuf, "\033[3" );
#endif

#ifdef MULTICHAR_SET
			if (r->Options & Opt_mc_hack)
			{
				int			 col, row;

				newlen = STRLEN(kbuf);
				col = AVTS(r)->screen.cur.col;
				row = AVTS(r)->screen.cur.row + AVTS(r)->saveLines;

				if (IS_MULTI1(AVTS(r)->screen.rend[row][col]))
					MEMMOVE(kbuf + newlen, kbuf, newlen + 1);
			}
#endif	/* MULTICHAR_SET */
			break;


		case XK_KP_Multiply:	/* "\033Oj" : "*" */
		case XK_KP_Add:			/* "\033Ok" : "+" */
		case XK_KP_Separator:	/* "\033Ol" : "," */
		case XK_KP_Subtract:	/* "\033Om" : "-" */
		case XK_KP_Divide:		/* "\033Oo" : "/" */

		case XK_KP_Decimal:		/* "\033On" : "." */
		case XK_KP_0:			/* "\033Op" : "0" */
		case XK_KP_1:			/* "\033Oq" : "1" */
		case XK_KP_2:			/* "\033Or" : "2" */
		case XK_KP_3:			/* "\033Os" : "3" */
		case XK_KP_4:			/* "\033Ot" : "4" */
		case XK_KP_5:			/* "\033Ou" : "5" */
		case XK_KP_6:			/* "\033Ov" : "6" */
		case XK_KP_7:			/* "\033Ow" : "7" */
		case XK_KP_8:			/* "\033Ox" : "8" */
		case XK_KP_9:			/* "\033Oy" : "9" */

			/*
			 * If numlock is on, and no modifiers are presed, then we should
			 * send the actual number key. If modifiers are pressed, send the
			 * DEC sequence (after canceling shift ofcourse).
			 *
			 * If numlock is off, then send the DEC terminal sequence.
			 */
			if (
					(AVTS(r)->PrivateModes & PrivMode_aplKP)
					&& ( !r->numlock_state || ctrl || meta || shft )
			   )
			{
				if(
						r->numlock_state
#ifndef NUMLOCK_ALWAYS_IGNORES_SHIFT
						&& keysym >= XK_KP_Decimal && keysym <= XK_KP_9
#endif
				  )
					/*
					 * Cancel shift if numlock is pressed, but only cancel it
					 * for keys where shift has some meaning: 0-9 and Decimal.
					 * If NUMLOCK_ALWAYS_IGNORES_SHIFT is defined, then shift is
					 * always cancelled when numlock is on.
					 */
					shft = 0;

				set_xterm_key_seq( kbuf, "\033O", "\033O%d%c",
						'j' + (keysym - XK_KP_Multiply), ctrl, meta, shft );
			}
			else
			{
				kbuf[0] = ('*' + (keysym - XK_KP_Multiply));
				kbuf[1] = '\0';
			}
			break;

		case XK_Find:
			SET_TILDE_KEY_SEQ(kbuf, "\033[1");
			break;

#ifdef DXK_Remove		/* support for DEC remove like key */
		case DXK_Remove:
			/* FALLTHROUGH */
#endif	/* DXK_Remove */
		case XK_Execute:
			SET_TILDE_KEY_SEQ(kbuf, "\033[3");
			break;

		case XK_Select:
			SET_TILDE_KEY_SEQ(kbuf, "\033[4");
			break;

#ifdef XK_KP_End
		case XK_KP_End:	/* \033Oq */
			if( r->numlock_state ) shft = 0;

			if (AVTS(r)->PrivateModes & PrivMode_aplKP)
			{
				set_xterm_key_seq( kbuf, "\033O", "\033O%d%c", 'q',
						ctrl, meta, shft );
				break;
			}
			/* FALLTHROUGH */

#endif	/* XK_KP_End */

		case XK_End:
			if (r->Options2 & Opt2_linuxHomeEndKey)
				SET_TILDE_KEY_SEQ( kbuf, KS_END_LINUX);
			else
				SET_TILDE_KEY_SEQ( kbuf, KS_END);
			break;

#ifdef XK_KP_Home
		case XK_KP_Home: /* \033Ow */
			if( r->numlock_state ) shft = 0;

			if (AVTS(r)->PrivateModes & PrivMode_aplKP)
			{
				set_xterm_key_seq( kbuf, "\033O", "\033O%d%c", 'w',
						ctrl, meta, shft );
				break;
			}
			/* FALLTHROUGH */

#endif	/* XK_KP_Home */
		case XK_Home:
			if (r->Options2 & Opt2_linuxHomeEndKey)
				SET_TILDE_KEY_SEQ( kbuf, KS_HOME_LINUX);
			else
				SET_TILDE_KEY_SEQ( kbuf, KS_HOME);
			break;

#define FKEY_SEQ_START( n, fkey)	\
		sprintf( (char*) kbuf, "\033[%2d", (n) + (int) (keysym - (fkey)) );


		case XK_KP_F1:	/* "\033OP" */
		case XK_KP_F2:	/* "\033OQ" */
		case XK_KP_F3:	/* "\033OR" */
		case XK_KP_F4:	/* "\033OS" */
			/* XXX 2006-04-08 gi1242: Should we cancel shift here? */

			if ( AVTS(r)->PrivateModes & PrivMode_aplKP )
			{
				set_xterm_key_seq( kbuf, "\033O", "\033O%d%c",
						'P' + (keysym - XK_KP_F1), ctrl, meta, shft);
				break;
			}
			else
				keysym = XK_F1 + (keysym - XK_KP_F1);
			/* FALLTHROUGH */

		case XK_F1:	/* "\033[11~" */
		case XK_F2:	/* "\033[12~" */
		case XK_F3:	/* "\033[13~" */
		case XK_F4:	/* "\033[14~" */
			if (TERMENV_XTERM == AVTS(r)->termenv)
			{
				/* Xterm sends \eOP, \eOQ, \eOR, \eOS for f1 -- f4 */
				set_xterm_key_seq( kbuf, "\033O", "\033O%d%c",
						'P' + (keysym - XK_F1), ctrl, meta, shft);
				break;
			}
			/* else FALL THROUGH */
		case XK_F5:	/* "\033[15~" */
			FKEY_SEQ_START( 11, XK_F1);
			SET_TILDE_KEY_SEQ( kbuf + 4, "" );
			break;

		case XK_F6:		/* "\033[17~" */
		case XK_F7:		/* "\033[18~" */
		case XK_F8:		/* "\033[19~" */
		case XK_F9:		/* "\033[20~" */
		case XK_F10:	/* "\033[21~" */
			FKEY_SEQ_START(17, XK_F6);
			SET_TILDE_KEY_SEQ( kbuf + 4, "" );
			break;

		case XK_F11:	/* "\033[23~" */
		case XK_F12:	/* "\033[24~" */
		case XK_F13:	/* "\033[25~" */
		case XK_F14:	/* "\033[26~" */
			FKEY_SEQ_START(23, XK_F11);
			SET_TILDE_KEY_SEQ( kbuf + 4, "" );
			break;

		case XK_F15:	/* "\033[28~" */
		case XK_F16:	/* "\033[29~" */
			FKEY_SEQ_START(28, XK_F15);
			SET_TILDE_KEY_SEQ( kbuf + 4, "" );
			break;

		case XK_Help:	/* "\033[28~" */
			FKEY_SEQ_START(28, XK_Help);
			SET_TILDE_KEY_SEQ( kbuf + 4, "" );
			break;

		case XK_Menu:	/* "\033[29~" */
			FKEY_SEQ_START(29, XK_Menu);
			SET_TILDE_KEY_SEQ( kbuf + 4, "" );
			break;

		case XK_F17:	/* "\033[31~" */
		case XK_F18:	/* "\033[32~" */
		case XK_F19:	/* "\033[33~" */
		case XK_F20:	/* "\033[34~" */
		case XK_F21:	/* "\033[35~" */
		case XK_F22:	/* "\033[36~" */
		case XK_F23:	/* "\033[37~" */
		case XK_F24:	/* "\033[38~" */
		case XK_F25:	/* "\033[39~" */
		case XK_F26:	/* "\033[40~" */
		case XK_F27:	/* "\033[41~" */
		case XK_F28:	/* "\033[42~" */
		case XK_F29:	/* "\033[43~" */
		case XK_F30:	/* "\033[44~" */
		case XK_F31:	/* "\033[45~" */
		case XK_F32:	/* "\033[46~" */
		case XK_F33:	/* "\033[47~" */
		case XK_F34:	/* "\033[48~" */
		case XK_F35:	/* "\033[49~" */
			FKEY_SEQ_START(31, XK_F17);
			SET_TILDE_KEY_SEQ( kbuf + 4, "" );
			break;

#undef FKEY_SEQ_START
		default:
			newlen = 0;
			break;

	}	/* switch (keysym) */


	DBG_MSG( 5, ( stderr, "Returning %d\n", newlen ? STRLEN(kbuf) : -1 ));

	return newlen ? STRLEN(kbuf) : -1;
	/*
	 * B: end of a {} body
	 */
}
/* }}} */


/*{{{ Convert the keypress event into a string */
/* INTPROTO */
void
rxvt_process_keypress (rxvt_t* r, XKeyEvent *ev)
{
	int				ctrl, meta, shft, len;
	KeySym			keysym;
#ifdef USE_DEADKEY
	static KeySym	accent = 0;
#endif	/* USE_DEADKEY */
#ifdef DEBUG_CMD
	static int		debug_key = 1;	/* accessible by a debugger only */
#endif	/* DEBUG_CMD */
#ifdef USE_XIM
	int				valid_keysym = 0;
#endif	/* USE_XIM */
    /*
    ** kbuf should be static in order to avoid performance penalty
    ** on allocation in the stack. And we only define it inside this
    ** function to avoid potential abuse of this buffer at somewhere
    ** else.
    */
	static unsigned char kbuf[KBUFSZ];	/* was r->h->kbuf */


	DBG_MSG(2, (stderr, "KeyPress event\n"));
	shft = (ev->state & ShiftMask);
	ctrl = (ev->state & ControlMask);
	meta = (ev->state & r->h->ModMetaMask);

#if 0 /* {{{ Old numlock handling (conflicts with Xterm) */
	/*
	 * use Num_Lock to toggle Keypad on/off.  If Num_Lock is off,
	 * allow an escape sequence to toggle the Keypad. Always permit
	 * `shift' to override the current setting
	 */
	if (r->numlock_state || (ev->state & r->h->ModNumLockMask))
	{
		r->numlock_state = (ev->state & r->h->ModNumLockMask);
		PrivMode((!r->numlock_state), PrivMode_aplKP, ATAB(r));
	}
#endif /*}}}*/

	/*
	 * 2006-04-07 gi1242: Don't toggle the Keypad on pressing num lock. Only
	 * store the numlock state so that we can cancel shift if numlock is
	 * pressed, and we get an un-shifted keypad key.
	 */
	r->numlock_state = ( ev->state & r->h->ModNumLockMask );

#ifdef USE_XIM
	if (r->h->Input_Context != NULL)
	{
		Status		  status_return;

		kbuf[0] = '\0';
		len = XmbLookupString(r->h->Input_Context, ev, (char *)kbuf,
				  KBUFSZ, &keysym, &status_return);
		valid_keysym = ((status_return == XLookupKeySym) ||
						(status_return == XLookupBoth));
	}
	else
	{
		valid_keysym = 1;
#endif	/* USE_XIM */

		/*
		******************************************************
		** Begin of part that is used when XIM is disabled
		*/
		len = XLookupString(ev, (char *)kbuf, KBUFSZ, &keysym, NULL);
		/*
		** map unmapped Latin[2-4]/Katakana/Arabic/Cyrillic/Greek
		** entries -> Latin1. good for installations with correct
		** fonts, but without XLOCALE
		*/
		if (!len)
		{
			if ((keysym >= 0x0100) && (keysym < 0x0800))
			{
				kbuf[0] = (keysym & 0xFF);
				kbuf[1] = '\0';
				len = 1;
			}
			else
				kbuf[0] = '\0';
		}
		/*
		** End of part that is used when XIM is disabled
		******************************************************
		*/

#ifdef USE_XIM
	}
#endif	/* USE_XIM */


#ifdef USE_DEADKEY
	if (0 != accent)
	{
		if (
				!ctrl && !meta /* NO ctrl or meta */
				&& (
					XK_A == keysym || XK_a == keysym
					|| XK_C == keysym || XK_c == keysym
					|| XK_E == keysym || XK_e == keysym
					|| XK_I == keysym || XK_i == keysym
					|| XK_N == keysym || XK_n == keysym
					|| XK_O == keysym || XK_o == keysym
					|| XK_U == keysym || XK_u == keysym
					|| XK_Y == keysym || XK_y == keysym
				   )
		   )
		{
			register int	idx;
			KeySym	dk;

			/* dead key + space -> dead key itself */
			switch (accent)
			{
				case XK_dead_grave:			/* ` */
					dk = XK_grave;
					break;

				case XK_dead_acute:			/* ' */
					dk = XK_acute;
					break;

				case XK_dead_circumflex:	/* ^ */
					dk = XK_asciicircum;
					break;

				case XK_dead_diaeresis:		/* " */
					dk = XK_quotedbl;
					break;

				case XK_dead_tilde:			/* ~ */
					dk = XK_asciitilde;
					break;
			}	/* switch(accent) */

			for (idx = 0; idx < DEADKEY_CHAR_NUMBER; idx++)
			{
				if (keysym == dkc_tab[idx].ks && dk == dkc_tab[idx].dk)
				{
					kbuf[0] = (unsigned char) dkc_tab[idx].ach;
					break;
				}
			}
			assert (0 != kbuf[0]);	/* impossible */

			len = 1;
			accent = 0;	/* clear accent anyway */
		}	/* if */
		else if (
					!ctrl && !meta			/* NO ctrl or meta */
					&& (XK_space == keysym || accent == keysym)
				)