Context Navigation

source: ogBrowser-Git/qtermwidget/lib/Vt102Emulation.cpp @ c0cec9d

jenkinsmain

Last change on this file since c0cec9d was fedf2a2, checked in by Vadim Troshchinskiy Shmelev <vtroshchinskiy@…>, 18 months ago
Update Qtermwidget to Qt6 version Remove build files
Property mode set to `100644`
File size: 58.4 KB

Rev	Line
[050d67a]	1	/*
	2	This file is part of Konsole, an X terminal.
	3
[64efc22]	4	Copyright 2007-2008 by Robert Knight <robert.knight@gmail.com>
	5	Copyright 1997,1998 by Lars Doelle <lars.doelle@on-line.de>
[050d67a]	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
	20	02110-1301 USA.
	21	*/
	22
	23	// Own
	24	#include "Vt102Emulation.h"
[64efc22]	25	#include "tools.h"
[050d67a]	26
[64efc22]	27	// XKB
[050d67a]	28	//#include <config-konsole.h>
	29
	30	// this allows konsole to be compiled without XKB and XTEST extensions
	31	// even though it might be available on a particular system.
	32	#if defined(AVOID_XKB)
[64efc22]	33	#undef HAVE_XKB
	34	#endif
	35
	36	#if defined(HAVE_XKB)
	37	void scrolllock_set_off();
	38	void scrolllock_set_on();
[050d67a]	39	#endif
	40
[64efc22]	41	// Standard
	42	#include <cstdio>
[050d67a]	43	#include <unistd.h>
	44
	45	// Qt
[64efc22]	46	#include <QEvent>
	47	#include <QKeyEvent>
[fedf2a2]	48	#if QT_VERSION >= 0x060000
	49	#include <QByteArrayView>
	50	#include <QtCore5Compat/QTextCodec>
	51	#else
[64efc22]	52	#include <QByteRef>
[fedf2a2]	53	#endif
[64efc22]	54	#include <QDebug>
[050d67a]	55
	56	// KDE
	57	//#include <kdebug.h>
	58	//#include <klocale.h>
	59
	60	// Konsole
	61	#include "KeyboardTranslator.h"
	62	#include "Screen.h"
	63
	64
	65	using namespace Konsole;
	66
[64efc22]	67	Vt102Emulation::Vt102Emulation()
[050d67a]	68	: Emulation(),
[64efc22]	69	prevCC(0),
	70	_titleUpdateTimer(new QTimer(this)),
	71	_reportFocusEvents(false)
[050d67a]	72	{
	73	_titleUpdateTimer->setSingleShot(true);
	74	QObject::connect(_titleUpdateTimer , SIGNAL(timeout()) , this , SLOT(updateTitle()));
	75
	76	initTokenizer();
	77	reset();
	78	}
	79
	80	Vt102Emulation::~Vt102Emulation()
[64efc22]	81	{}
[050d67a]	82
	83	void Vt102Emulation::clearEntireScreen()
	84	{
	85	_currentScreen->clearEntireScreen();
[64efc22]	86	bufferedUpdate();
[050d67a]	87	}
	88
	89	void Vt102Emulation::reset()
	90	{
[64efc22]	91	resetTokenizer();
[050d67a]	92	resetModes();
	93	resetCharset(0);
	94	_screen[0]->reset();
	95	resetCharset(1);
	96	_screen[1]->reset();
	97	setCodec(LocaleCodec);
[64efc22]	98
[050d67a]	99	bufferedUpdate();
	100	}
	101
	102	/* ------------------------------------------------------------------------- */
	103	/* */
	104	/* Processing the incoming byte stream */
	105	/* */
	106	/* ------------------------------------------------------------------------- */
	107
	108	/* Incoming Bytes Event pipeline
	109
	110	This section deals with decoding the incoming character stream.
	111	Decoding means here, that the stream is first separated into `tokens'
	112	which are then mapped to a `meaning' provided as operations by the
	113	`Screen' class or by the emulation class itself.
	114
	115	The pipeline proceeds as follows:
	116
	117	- Tokenizing the ESC codes (onReceiveChar)
	118	- VT100 code page translation of plain characters (applyCharset)
[64efc22]	119	- Interpretation of ESC codes (processToken)
[050d67a]	120
	121	The escape codes and their meaning are described in the
	122	technical reference of this program.
	123	*/
	124
	125	// Tokens ------------------------------------------------------------------ --
	126
	127	/*
	128	Since the tokens are the central notion if this section, we've put them
	129	in front. They provide the syntactical elements used to represent the
	130	terminals operations as byte sequences.
	131
	132	They are encodes here into a single machine word, so that we can later
	133	switch over them easily. Depending on the token itself, additional
	134	argument variables are filled with parameter values.
	135
	136	The tokens are defined below:
	137
	138	- CHR - Printable characters (32..255 but DEL (=127))
	139	- CTL - Control characters (0..31 but ESC (= 27), DEL)
	140	- ESC - Escape codes of the form <ESC><CHR but `[]()+*#'>
	141	- ESC_DE - Escape codes of the form <ESC><any of `()+*#%'> C
	142	- CSI_PN - Escape codes of the form <ESC>'[' {Pn} ';' {Pn} C
	143	- CSI_PS - Escape codes of the form <ESC>'[' {Pn} ';' ... C
[64efc22]	144	- CSI_PS_SP - Escape codes of the form <ESC>'[' {Pn} ';' ... {Space} C
[050d67a]	145	- CSI_PR - Escape codes of the form <ESC>'[' '?' {Pn} ';' ... C
	146	- CSI_PE - Escape codes of the form <ESC>'[' '!' {Pn} ';' ... C
	147	- VT52 - VT52 escape codes
	148	- <ESC><Chr>
	149	- <ESC>'Y'{Pc}{Pc}
[64efc22]	150	- XTE_HA - Xterm window/terminal attribute commands
	151	of the form <ESC>`]' {Pn} `;' {Text} <BEL>
	152	(Note that these are handled differently to the other formats)
[050d67a]	153
	154	The last two forms allow list of arguments. Since the elements of
	155	the lists are treated individually the same way, they are passed
	156	as individual tokens to the interpretation. Further, because the
[64efc22]	157	meaning of the parameters are names (although represented as numbers),
[050d67a]	158	they are includes within the token ('N').
	159
	160	*/
	161
[64efc22]	162	#define TY_CONSTRUCT(T,A,N) ( ((((int)N) & 0xffff) << 16) \| ((((int)A) & 0xff) << 8) \| (((int)T) & 0xff) )
[050d67a]	163
[64efc22]	164	#define TY_CHR( ) TY_CONSTRUCT(0,0,0)
	165	#define TY_CTL(A ) TY_CONSTRUCT(1,A,0)
	166	#define TY_ESC(A ) TY_CONSTRUCT(2,A,0)
	167	#define TY_ESC_CS(A,B) TY_CONSTRUCT(3,A,B)
	168	#define TY_ESC_DE(A ) TY_CONSTRUCT(4,A,0)
	169	#define TY_CSI_PS(A,N) TY_CONSTRUCT(5,A,N)
	170	#define TY_CSI_PN(A ) TY_CONSTRUCT(6,A,0)
	171	#define TY_CSI_PR(A,N) TY_CONSTRUCT(7,A,N)
	172	#define TY_CSI_PS_SP(A,N) TY_CONSTRUCT(11,A,N)
[050d67a]	173
[64efc22]	174	#define TY_VT52(A) TY_CONSTRUCT(8,A,0)
	175	#define TY_CSI_PG(A) TY_CONSTRUCT(9,A,0)
	176	#define TY_CSI_PE(A) TY_CONSTRUCT(10,A,0)
[050d67a]	177
[64efc22]	178	#define MAX_ARGUMENT 4096
[050d67a]	179
	180	// Tokenizer --------------------------------------------------------------- --
	181
[64efc22]	182	/* The tokenizer's state
[050d67a]	183
[64efc22]	184	The state is represented by the buffer (tokenBuffer, tokenBufferPos),
[050d67a]	185	and accompanied by decoded arguments kept in (argv,argc).
	186	Note that they are kept internal in the tokenizer.
	187	*/
	188
[64efc22]	189	void Vt102Emulation::resetTokenizer()
[050d67a]	190	{
[64efc22]	191	tokenBufferPos = 0;
	192	argc = 0;
	193	argv[0] = 0;
	194	argv[1] = 0;
	195	prevCC = 0;
[050d67a]	196	}
	197
[64efc22]	198	void Vt102Emulation::addDigit(int digit)
[050d67a]	199	{
[64efc22]	200	if (argv[argc] < MAX_ARGUMENT)
	201	argv[argc] = 10*argv[argc] + digit;
[050d67a]	202	}
	203
	204	void Vt102Emulation::addArgument()
	205	{
	206	argc = qMin(argc+1,MAXARGS-1);
	207	argv[argc] = 0;
	208	}
	209
[64efc22]	210	void Vt102Emulation::addToCurrentToken(wchar_t cc)
[050d67a]	211	{
[64efc22]	212	tokenBuffer[tokenBufferPos] = cc;
	213	tokenBufferPos = qMin(tokenBufferPos+1,MAX_TOKEN_LENGTH-1);
[050d67a]	214	}
	215
[64efc22]	216	// Character Class flags used while decoding
	217	#define CTL 1 // Control character
	218	#define CHR 2 // Printable character
	219	#define CPN 4 // TODO: Document me
	220	#define DIG 8 // Digit
	221	#define SCS 16 // TODO: Document me
	222	#define GRP 32 // TODO: Document me
	223	#define CPS 64 // Character which indicates end of window resize
	224	// escape sequence '\e[8;<row>;<col>t'
[050d67a]	225
	226	void Vt102Emulation::initTokenizer()
[64efc22]	227	{
	228	int i;
	229	quint8* s;
	230	for(i = 0;i < 256; ++i)
	231	charClass[i] = 0;
	232	for(i = 0;i < 32; ++i)
	233	charClass[i] \|= CTL;
	234	for(i = 32;i < 256; ++i)
	235	charClass[i] \|= CHR;
	236	for(s = (quint8)"@ABCDEFGHILMPSTXZbcdfry"; s; ++s)
	237	charClass[*s] \|= CPN;
	238	// resize = \e[8;<row>;<col>t
	239	for(s = (quint8)"t"; s; ++s)
	240	charClass[*s] \|= CPS;
	241	for(s = (quint8)"0123456789"; s; ++s)
	242	charClass[*s] \|= DIG;
	243	for(s = (quint8)"()+%"; *s; ++s)
	244	charClass[*s] \|= SCS;
	245	for(s = (quint8)"()+#[]%"; *s; ++s)
	246	charClass[*s] \|= GRP;
	247
	248	resetTokenizer();
[050d67a]	249	}
	250
	251	/* Ok, here comes the nasty part of the decoder.
	252
	253	Instead of keeping an explicit state, we deduce it from the
	254	token scanned so far. It is then immediately combined with
	255	the current character to form a scanning decision.
	256
	257	This is done by the following defines.
	258
	259	- P is the length of the token scanned so far.
	260	- L (often P-1) is the position on which contents we base a decision.
[64efc22]	261	- C is a character or a group of characters (taken from 'charClass').
	262
	263	- 'cc' is the current character
	264	- 's' is a pointer to the start of the token buffer
	265	- 'p' is the current position within the token buffer
[050d67a]	266
	267	Note that they need to applied in proper order.
	268	*/
	269
[64efc22]	270	#define lec(P,L,C) (p == (P) && s[(L)] == (C))
	271	#define lun( ) (p == 1 && cc >= 32 )
	272	#define les(P,L,C) (p == (P) && s[L] < 256 && (charClass[s[(L)]] & (C)) == (C))
	273	#define eec(C) (p >= 3 && cc == (C))
	274	#define ees(C) (p >= 3 && cc < 256 && (charClass[cc] & (C)) == (C))
	275	#define eps(C) (p >= 3 && s[2] != '?' && s[2] != '!' && s[2] != '>' && cc < 256 && (charClass[cc] & (C)) == (C))
	276	#define epp( ) (p >= 3 && s[2] == '?')
	277	#define epe( ) (p >= 3 && s[2] == '!')
	278	#define egt( ) (p >= 3 && s[2] == '>')
	279	#define esp( ) (p == 4 && s[3] == ' ')
	280	#define Xpe (tokenBufferPos >= 2 && tokenBuffer[1] == ']')
	281	#define Xte (Xpe && (cc == 7 \|\| (prevCC == 27 && cc == 92) )) // 27, 92 => "\e\\" (ST, String Terminator)
	282	#define ces(C) (cc < 256 && (charClass[cc] & (C)) == (C) && !Xte)
[050d67a]	283
	284	#define CNTL(c) ((c)-'@')
[64efc22]	285	#define ESC 27
	286	#define DEL 127
[050d67a]	287
	288	// process an incoming unicode character
[64efc22]	289	void Vt102Emulation::receiveChar(wchar_t cc)
	290	{
	291	if (cc == DEL)
	292	return; //VT100: ignore.
[050d67a]	293
[64efc22]	294	if (ces(CTL))
	295	{
	296	// ignore control characters in the text part of Xpe (aka OSC) "ESC]"
	297	// escape sequences; this matches what XTERM docs say
	298	if (Xpe) {
	299	prevCC = cc;
	300	return;
	301	}
[050d67a]	302
[64efc22]	303	// DEC HACK ALERT! Control Characters are allowed within esc sequences in VT100
	304	// This means, they do neither a resetTokenizer() nor a pushToToken(). Some of them, do
[050d67a]	305	// of course. Guess this originates from a weakly layered handling of the X-on
	306	// X-off protocol, which comes really below this level.
[64efc22]	307	if (cc == CNTL('X') \|\| cc == CNTL('Z') \|\| cc == ESC)
	308	resetTokenizer(); //VT100: CAN or SUB
	309	if (cc != ESC)
	310	{
	311	processToken(TY_CTL(cc+'@' ),0,0);
	312	return;
	313	}
[050d67a]	314	}
[64efc22]	315	// advance the state
	316	addToCurrentToken(cc);
[050d67a]	317
[64efc22]	318	wchar_t* s = tokenBuffer;
	319	int p = tokenBufferPos;
[050d67a]	320
[64efc22]	321	if (getMode(MODE_Ansi))
[050d67a]	322	{
[64efc22]	323	if (lec(1,0,ESC)) { return; }
	324	if (lec(1,0,ESC+128)) { s[0] = ESC; receiveChar('['); return; }
	325	if (les(2,1,GRP)) { return; }
	326	if (Xte ) { processWindowAttributeChange(); resetTokenizer(); return; }
	327	if (Xpe ) { prevCC = cc; return; }
	328	if (lec(3,2,'?')) { return; }
	329	if (lec(3,2,'>')) { return; }
	330	if (lec(3,2,'!')) { return; }
	331	if (lun( )) { processToken( TY_CHR(), applyCharset(cc), 0); resetTokenizer(); return; }
	332	if (lec(2,0,ESC)) { processToken( TY_ESC(s[1]), 0, 0); resetTokenizer(); return; }
	333	if (les(3,1,SCS)) { processToken( TY_ESC_CS(s[1],s[2]), 0, 0); resetTokenizer(); return; }
	334	if (lec(3,1,'#')) { processToken( TY_ESC_DE(s[2]), 0, 0); resetTokenizer(); return; }
	335	if (eps( CPN)) { processToken( TY_CSI_PN(cc), argv[0],argv[1]); resetTokenizer(); return; }
	336	if (esp( )) { return; }
	337	if (lec(5, 4, 'q') && s[3] == ' ') {
	338	processToken( TY_CSI_PS_SP(cc, argv[0]), argv[0], 0);
	339	resetTokenizer();
	340	return;
	341	}
[050d67a]	342
[64efc22]	343	// resize = \e[8;<row>;<col>t
	344	if (eps(CPS))
	345	{
	346	processToken( TY_CSI_PS(cc, argv[0]), argv[1], argv[2]);
	347	resetTokenizer();
	348	return;
[050d67a]	349	}
[64efc22]	350
	351	if (epe( )) { processToken( TY_CSI_PE(cc), 0, 0); resetTokenizer(); return; }
	352	if (ees(DIG)) { addDigit(cc-'0'); return; }
	353	if (eec(';') \|\| eec(':')) { addArgument(); return; }
	354	for (int i=0;i<=argc;i++)
	355	{
	356	if (epp())
	357	processToken( TY_CSI_PR(cc,argv[i]), 0, 0);
	358	else if (egt())
	359	processToken( TY_CSI_PG(cc), 0, 0); // spec. case for ESC]>0c or ESC]>c
	360	else if (cc == 'm' && argc - i >= 4 && (argv[i] == 38 \|\| argv[i] == 48) && argv[i+1] == 2)
	361	{
	362	// ESC[ ... 48;2;<red>;<green>;<blue> ... m -or- ESC[ ... 38;2;<red>;<green>;<blue> ... m
	363	i += 2;
	364	processToken( TY_CSI_PS(cc, argv[i-2]), COLOR_SPACE_RGB, (argv[i] << 16) \| (argv[i+1] << 8) \| argv[i+2]);
	365	i += 2;
	366	}
	367	else if (cc == 'm' && argc - i >= 2 && (argv[i] == 38 \|\| argv[i] == 48) && argv[i+1] == 5)
	368	{
	369	// ESC[ ... 48;5;<index> ... m -or- ESC[ ... 38;5;<index> ... m
	370	i += 2;
	371	processToken( TY_CSI_PS(cc, argv[i-2]), COLOR_SPACE_256, argv[i]);
	372	}
	373	else
	374	processToken( TY_CSI_PS(cc,argv[i]), 0, 0);
[050d67a]	375	}
[64efc22]	376	resetTokenizer();
[050d67a]	377	}
[64efc22]	378	else
[050d67a]	379	{
[64efc22]	380	// VT52 Mode
	381	if (lec(1,0,ESC))
	382	return;
	383	if (les(1,0,CHR))
	384	{
	385	processToken( TY_CHR(), s[0], 0);
	386	resetTokenizer();
	387	return;
	388	}
	389	if (lec(2,1,'Y'))
	390	return;
	391	if (lec(3,1,'Y'))
	392	return;
	393	if (p < 4)
	394	{
	395	processToken( TY_VT52(s[1] ), 0, 0);
	396	resetTokenizer();
	397	return;
	398	}
	399	processToken( TY_VT52(s[1]), s[2], s[3]);
	400	resetTokenizer();
	401	return;
[050d67a]	402	}
	403	}
[64efc22]	404	void Vt102Emulation::processWindowAttributeChange()
	405	{
	406	// Describes the window or terminal session attribute to change
	407	// See Session::UserTitleChange for possible values
	408	int attributeToChange = 0;
	409	int i;
	410	for (i = 2; i < tokenBufferPos &&
	411	tokenBuffer[i] >= '0' &&
	412	tokenBuffer[i] <= '9'; i++)
	413	{
	414	attributeToChange = 10 * attributeToChange + (tokenBuffer[i]-'0');
	415	}
[050d67a]	416
[64efc22]	417	if (tokenBuffer[i] != ';')
	418	{
	419	reportDecodingError();
	420	return;
	421	}
[050d67a]	422
[64efc22]	423	// copy from the first char after ';', and skipping the ending delimiter
	424	// 0x07 or 0x92. Note that as control characters in OSC text parts are
	425	// ignored, only the second char in ST ("\e\\") is appended to tokenBuffer.
	426	QString newValue = QString::fromWCharArray(tokenBuffer + i + 1, tokenBufferPos-i-2);
	427
	428	_pendingTitleUpdates[attributeToChange] = newValue;
	429	_titleUpdateTimer->start(20);
[050d67a]	430	}
	431
	432	void Vt102Emulation::updateTitle()
	433	{
[64efc22]	434	QListIterator<int> iter( _pendingTitleUpdates.keys() );
	435	while (iter.hasNext()) {
	436	int arg = iter.next();
	437	emit titleChanged( arg , _pendingTitleUpdates[arg] );
	438	}
	439	_pendingTitleUpdates.clear();
[050d67a]	440	}
	441
	442	// Interpreting Codes ---------------------------------------------------------
	443
	444	/*
	445	Now that the incoming character stream is properly tokenized,
	446	meaning is assigned to them. These are either operations of
	447	the current _screen, or of the emulation class itself.
	448
	449	The token to be interpreteted comes in as a machine word
	450	possibly accompanied by two parameters.
	451
	452	Likewise, the operations assigned to, come with up to two
	453	arguments. One could consider to make up a proper table
	454	from the function below.
	455
	456	The technical reference manual provides more information
	457	about this mapping.
	458	*/
	459
[64efc22]	460	void Vt102Emulation::processToken(int token, wchar_t p, int q)
[050d67a]	461	{
	462	switch (token)
	463	{
	464
[64efc22]	465	case TY_CHR( ) : _currentScreen->displayCharacter (p ); break; //UTF16
[050d67a]	466
	467	// 127 DEL : ignored on input
	468
	469	case TY_CTL('@' ) : /* NUL: ignored */ break;
	470	case TY_CTL('A' ) : /* SOH: ignored */ break;
	471	case TY_CTL('B' ) : /* STX: ignored */ break;
	472	case TY_CTL('C' ) : /* ETX: ignored */ break;
	473	case TY_CTL('D' ) : /* EOT: ignored */ break;
	474	case TY_CTL('E' ) : reportAnswerBack ( ); break; //VT100
	475	case TY_CTL('F' ) : /* ACK: ignored */ break;
	476	case TY_CTL('G' ) : emit stateSet(NOTIFYBELL);
	477	break; //VT100
[64efc22]	478	case TY_CTL('H' ) : _currentScreen->backspace ( ); break; //VT100
	479	case TY_CTL('I' ) : _currentScreen->tab ( ); break; //VT100
	480	case TY_CTL('J' ) : _currentScreen->newLine ( ); break; //VT100
	481	case TY_CTL('K' ) : _currentScreen->newLine ( ); break; //VT100
	482	case TY_CTL('L' ) : _currentScreen->newLine ( ); break; //VT100
	483	case TY_CTL('M' ) : _currentScreen->toStartOfLine ( ); break; //VT100
[050d67a]	484
	485	case TY_CTL('N' ) : useCharset ( 1); break; //VT100
	486	case TY_CTL('O' ) : useCharset ( 0); break; //VT100
	487
	488	case TY_CTL('P' ) : /* DLE: ignored */ break;
	489	case TY_CTL('Q' ) : /* DC1: XON continue */ break; //VT100
	490	case TY_CTL('R' ) : /* DC2: ignored */ break;
	491	case TY_CTL('S' ) : /* DC3: XOFF halt */ break; //VT100
	492	case TY_CTL('T' ) : /* DC4: ignored */ break;
	493	case TY_CTL('U' ) : /* NAK: ignored */ break;
	494	case TY_CTL('V' ) : /* SYN: ignored */ break;
	495	case TY_CTL('W' ) : /* ETB: ignored */ break;
[64efc22]	496	case TY_CTL('X' ) : _currentScreen->displayCharacter ( 0x2592); break; //VT100
[050d67a]	497	case TY_CTL('Y' ) : /* EM : ignored */ break;
[64efc22]	498	case TY_CTL('Z' ) : _currentScreen->displayCharacter ( 0x2592); break; //VT100
[050d67a]	499	case TY_CTL('[' ) : /* ESC: cannot be seen here. */ break;
	500	case TY_CTL('\\' ) : /* FS : ignored */ break;
	501	case TY_CTL(']' ) : /* GS : ignored */ break;
	502	case TY_CTL('^' ) : /* RS : ignored */ break;
	503	case TY_CTL('_' ) : /* US : ignored */ break;
	504
	505	case TY_ESC('D' ) : _currentScreen->index ( ); break; //VT100
[64efc22]	506	case TY_ESC('E' ) : _currentScreen->nextLine ( ); break; //VT100
[050d67a]	507	case TY_ESC('H' ) : _currentScreen->changeTabStop (true ); break; //VT100
	508	case TY_ESC('M' ) : _currentScreen->reverseIndex ( ); break; //VT100
	509	case TY_ESC('Z' ) : reportTerminalType ( ); break;
	510	case TY_ESC('c' ) : reset ( ); break;
	511
	512	case TY_ESC('n' ) : useCharset ( 2); break;
	513	case TY_ESC('o' ) : useCharset ( 3); break;
	514	case TY_ESC('7' ) : saveCursor ( ); break;
	515	case TY_ESC('8' ) : restoreCursor ( ); break;
	516
	517	case TY_ESC('=' ) : setMode (MODE_AppKeyPad); break;
	518	case TY_ESC('>' ) : resetMode (MODE_AppKeyPad); break;
	519	case TY_ESC('<' ) : setMode (MODE_Ansi ); break; //VT100
	520
	521	case TY_ESC_CS('(', '0') : setCharset (0, '0'); break; //VT100
	522	case TY_ESC_CS('(', 'A') : setCharset (0, 'A'); break; //VT100
	523	case TY_ESC_CS('(', 'B') : setCharset (0, 'B'); break; //VT100
	524
	525	case TY_ESC_CS(')', '0') : setCharset (1, '0'); break; //VT100
	526	case TY_ESC_CS(')', 'A') : setCharset (1, 'A'); break; //VT100
	527	case TY_ESC_CS(')', 'B') : setCharset (1, 'B'); break; //VT100
	528
	529	case TY_ESC_CS('*', '0') : setCharset (2, '0'); break; //VT100
	530	case TY_ESC_CS('*', 'A') : setCharset (2, 'A'); break; //VT100
	531	case TY_ESC_CS('*', 'B') : setCharset (2, 'B'); break; //VT100
	532
	533	case TY_ESC_CS('+', '0') : setCharset (3, '0'); break; //VT100
	534	case TY_ESC_CS('+', 'A') : setCharset (3, 'A'); break; //VT100
	535	case TY_ESC_CS('+', 'B') : setCharset (3, 'B'); break; //VT100
	536
	537	case TY_ESC_CS('%', 'G') : setCodec (Utf8Codec ); break; //LINUX
	538	case TY_ESC_CS('%', '@') : setCodec (LocaleCodec ); break; //LINUX
	539
[64efc22]	540	case TY_ESC_DE('3' ) : /* Double height line, top half */
	541	_currentScreen->setLineProperty( LINE_DOUBLEWIDTH , true );
	542	_currentScreen->setLineProperty( LINE_DOUBLEHEIGHT , true );
	543	break;
	544	case TY_ESC_DE('4' ) : /* Double height line, bottom half */
	545	_currentScreen->setLineProperty( LINE_DOUBLEWIDTH , true );
	546	_currentScreen->setLineProperty( LINE_DOUBLEHEIGHT , true );
	547	break;
[050d67a]	548	case TY_ESC_DE('5' ) : /* Single width, single height line*/
[64efc22]	549	_currentScreen->setLineProperty( LINE_DOUBLEWIDTH , false);
	550	_currentScreen->setLineProperty( LINE_DOUBLEHEIGHT , false);
	551	break;
	552	case TY_ESC_DE('6' ) : /* Double width, single height line*/
	553	_currentScreen->setLineProperty( LINE_DOUBLEWIDTH , true);
	554	_currentScreen->setLineProperty( LINE_DOUBLEHEIGHT , false);
	555	break;
[050d67a]	556	case TY_ESC_DE('8' ) : _currentScreen->helpAlign ( ); break;
	557
	558	// resize = \e[8;<row>;<col>t
[64efc22]	559	case TY_CSI_PS('t', 8) : setImageSize( p /lines /, q /* columns */ );
	560	emit imageResizeRequest(QSize(q, p));
	561	break;
[050d67a]	562
	563	// change tab text color : \e[28;<color>t color: 0-16,777,215
	564	case TY_CSI_PS('t', 28) : emit changeTabTextColorRequest ( p ); break;
	565
	566	case TY_CSI_PS('K', 0) : _currentScreen->clearToEndOfLine ( ); break;
	567	case TY_CSI_PS('K', 1) : _currentScreen->clearToBeginOfLine ( ); break;
	568	case TY_CSI_PS('K', 2) : _currentScreen->clearEntireLine ( ); break;
	569	case TY_CSI_PS('J', 0) : _currentScreen->clearToEndOfScreen ( ); break;
	570	case TY_CSI_PS('J', 1) : _currentScreen->clearToBeginOfScreen ( ); break;
	571	case TY_CSI_PS('J', 2) : _currentScreen->clearEntireScreen ( ); break;
[64efc22]	572	case TY_CSI_PS('J', 3) : clearHistory(); break;
[050d67a]	573	case TY_CSI_PS('g', 0) : _currentScreen->changeTabStop (false ); break; //VT100
	574	case TY_CSI_PS('g', 3) : _currentScreen->clearTabStops ( ); break; //VT100
	575	case TY_CSI_PS('h', 4) : _currentScreen-> setMode (MODE_Insert ); break;
	576	case TY_CSI_PS('h', 20) : setMode (MODE_NewLine ); break;
	577	case TY_CSI_PS('i', 0) : /* IGNORE: attached printer */ break; //VT100
	578	case TY_CSI_PS('l', 4) : _currentScreen-> resetMode (MODE_Insert ); break;
	579	case TY_CSI_PS('l', 20) : resetMode (MODE_NewLine ); break;
	580	case TY_CSI_PS('s', 0) : saveCursor ( ); break;
	581	case TY_CSI_PS('u', 0) : restoreCursor ( ); break;
	582
	583	case TY_CSI_PS('m', 0) : _currentScreen->setDefaultRendition ( ); break;
	584	case TY_CSI_PS('m', 1) : _currentScreen-> setRendition (RE_BOLD ); break; //VT100
[64efc22]	585	case TY_CSI_PS('m', 2) : _currentScreen-> setRendition (RE_FAINT ); break;
	586	case TY_CSI_PS('m', 3) : _currentScreen-> setRendition (RE_ITALIC ); break; //VT100
[050d67a]	587	case TY_CSI_PS('m', 4) : _currentScreen-> setRendition (RE_UNDERLINE); break; //VT100
	588	case TY_CSI_PS('m', 5) : _currentScreen-> setRendition (RE_BLINK ); break; //VT100
	589	case TY_CSI_PS('m', 7) : _currentScreen-> setRendition (RE_REVERSE ); break;
[64efc22]	590	case TY_CSI_PS('m', 8) : _currentScreen-> setRendition (RE_CONCEAL ); break;
	591	case TY_CSI_PS('m', 9) : _currentScreen-> setRendition (RE_STRIKEOUT); break;
	592	case TY_CSI_PS('m', 53) : _currentScreen-> setRendition (RE_OVERLINE ); break;
[050d67a]	593	case TY_CSI_PS('m', 10) : /* IGNORED: mapping related */ break; //LINUX
	594	case TY_CSI_PS('m', 11) : /* IGNORED: mapping related */ break; //LINUX
	595	case TY_CSI_PS('m', 12) : /* IGNORED: mapping related */ break; //LINUX
[64efc22]	596	case TY_CSI_PS('m', 21) : _currentScreen->resetRendition (RE_BOLD ); break;
	597	case TY_CSI_PS('m', 22) : _currentScreen->resetRendition (RE_BOLD );
	598	_currentScreen->resetRendition (RE_FAINT ); break;
	599	case TY_CSI_PS('m', 23) : _currentScreen->resetRendition (RE_ITALIC ); break; //VT100
[050d67a]	600	case TY_CSI_PS('m', 24) : _currentScreen->resetRendition (RE_UNDERLINE); break;
	601	case TY_CSI_PS('m', 25) : _currentScreen->resetRendition (RE_BLINK ); break;
	602	case TY_CSI_PS('m', 27) : _currentScreen->resetRendition (RE_REVERSE ); break;
[64efc22]	603	case TY_CSI_PS('m', 28) : _currentScreen->resetRendition (RE_CONCEAL ); break;
	604	case TY_CSI_PS('m', 29) : _currentScreen->resetRendition (RE_STRIKEOUT); break;
	605	case TY_CSI_PS('m', 55) : _currentScreen->resetRendition (RE_OVERLINE ); break;
[050d67a]	606
	607	case TY_CSI_PS('m', 30) : _currentScreen->setForeColor (COLOR_SPACE_SYSTEM, 0); break;
	608	case TY_CSI_PS('m', 31) : _currentScreen->setForeColor (COLOR_SPACE_SYSTEM, 1); break;
	609	case TY_CSI_PS('m', 32) : _currentScreen->setForeColor (COLOR_SPACE_SYSTEM, 2); break;
	610	case TY_CSI_PS('m', 33) : _currentScreen->setForeColor (COLOR_SPACE_SYSTEM, 3); break;
	611	case TY_CSI_PS('m', 34) : _currentScreen->setForeColor (COLOR_SPACE_SYSTEM, 4); break;
	612	case TY_CSI_PS('m', 35) : _currentScreen->setForeColor (COLOR_SPACE_SYSTEM, 5); break;
	613	case TY_CSI_PS('m', 36) : _currentScreen->setForeColor (COLOR_SPACE_SYSTEM, 6); break;
	614	case TY_CSI_PS('m', 37) : _currentScreen->setForeColor (COLOR_SPACE_SYSTEM, 7); break;
	615
	616	case TY_CSI_PS('m', 38) : _currentScreen->setForeColor (p, q); break;
	617
	618	case TY_CSI_PS('m', 39) : _currentScreen->setForeColor (COLOR_SPACE_DEFAULT, 0); break;
	619
	620	case TY_CSI_PS('m', 40) : _currentScreen->setBackColor (COLOR_SPACE_SYSTEM, 0); break;
	621	case TY_CSI_PS('m', 41) : _currentScreen->setBackColor (COLOR_SPACE_SYSTEM, 1); break;
	622	case TY_CSI_PS('m', 42) : _currentScreen->setBackColor (COLOR_SPACE_SYSTEM, 2); break;
	623	case TY_CSI_PS('m', 43) : _currentScreen->setBackColor (COLOR_SPACE_SYSTEM, 3); break;
	624	case TY_CSI_PS('m', 44) : _currentScreen->setBackColor (COLOR_SPACE_SYSTEM, 4); break;
	625	case TY_CSI_PS('m', 45) : _currentScreen->setBackColor (COLOR_SPACE_SYSTEM, 5); break;
	626	case TY_CSI_PS('m', 46) : _currentScreen->setBackColor (COLOR_SPACE_SYSTEM, 6); break;
	627	case TY_CSI_PS('m', 47) : _currentScreen->setBackColor (COLOR_SPACE_SYSTEM, 7); break;
	628
	629	case TY_CSI_PS('m', 48) : _currentScreen->setBackColor (p, q); break;
	630
	631	case TY_CSI_PS('m', 49) : _currentScreen->setBackColor (COLOR_SPACE_DEFAULT, 1); break;
	632
	633	case TY_CSI_PS('m', 90) : _currentScreen->setForeColor (COLOR_SPACE_SYSTEM, 8); break;
	634	case TY_CSI_PS('m', 91) : _currentScreen->setForeColor (COLOR_SPACE_SYSTEM, 9); break;
	635	case TY_CSI_PS('m', 92) : _currentScreen->setForeColor (COLOR_SPACE_SYSTEM, 10); break;
	636	case TY_CSI_PS('m', 93) : _currentScreen->setForeColor (COLOR_SPACE_SYSTEM, 11); break;
	637	case TY_CSI_PS('m', 94) : _currentScreen->setForeColor (COLOR_SPACE_SYSTEM, 12); break;
	638	case TY_CSI_PS('m', 95) : _currentScreen->setForeColor (COLOR_SPACE_SYSTEM, 13); break;
	639	case TY_CSI_PS('m', 96) : _currentScreen->setForeColor (COLOR_SPACE_SYSTEM, 14); break;
	640	case TY_CSI_PS('m', 97) : _currentScreen->setForeColor (COLOR_SPACE_SYSTEM, 15); break;
	641
	642	case TY_CSI_PS('m', 100) : _currentScreen->setBackColor (COLOR_SPACE_SYSTEM, 8); break;
	643	case TY_CSI_PS('m', 101) : _currentScreen->setBackColor (COLOR_SPACE_SYSTEM, 9); break;
	644	case TY_CSI_PS('m', 102) : _currentScreen->setBackColor (COLOR_SPACE_SYSTEM, 10); break;
	645	case TY_CSI_PS('m', 103) : _currentScreen->setBackColor (COLOR_SPACE_SYSTEM, 11); break;
	646	case TY_CSI_PS('m', 104) : _currentScreen->setBackColor (COLOR_SPACE_SYSTEM, 12); break;
	647	case TY_CSI_PS('m', 105) : _currentScreen->setBackColor (COLOR_SPACE_SYSTEM, 13); break;
	648	case TY_CSI_PS('m', 106) : _currentScreen->setBackColor (COLOR_SPACE_SYSTEM, 14); break;
	649	case TY_CSI_PS('m', 107) : _currentScreen->setBackColor (COLOR_SPACE_SYSTEM, 15); break;
	650
	651	case TY_CSI_PS('n', 5) : reportStatus ( ); break;
	652	case TY_CSI_PS('n', 6) : reportCursorPosition ( ); break;
	653	case TY_CSI_PS('q', 0) : /* IGNORED: LEDs off */ break; //VT100
	654	case TY_CSI_PS('q', 1) : /* IGNORED: LED1 on */ break; //VT100
	655	case TY_CSI_PS('q', 2) : /* IGNORED: LED2 on */ break; //VT100
	656	case TY_CSI_PS('q', 3) : /* IGNORED: LED3 on */ break; //VT100
	657	case TY_CSI_PS('q', 4) : /* IGNORED: LED4 on */ break; //VT100
	658	case TY_CSI_PS('x', 0) : reportTerminalParms ( 2); break; //VT100
	659	case TY_CSI_PS('x', 1) : reportTerminalParms ( 3); break; //VT100
	660
[64efc22]	661	case TY_CSI_PS_SP('q', 0) : /* fall through */
	662	case TY_CSI_PS_SP('q', 1) : emit cursorChanged(KeyboardCursorShape::BlockCursor, true ); break;
	663	case TY_CSI_PS_SP('q', 2) : emit cursorChanged(KeyboardCursorShape::BlockCursor, false); break;
	664	case TY_CSI_PS_SP('q', 3) : emit cursorChanged(KeyboardCursorShape::UnderlineCursor, true ); break;
	665	case TY_CSI_PS_SP('q', 4) : emit cursorChanged(KeyboardCursorShape::UnderlineCursor, false); break;
	666	case TY_CSI_PS_SP('q', 5) : emit cursorChanged(KeyboardCursorShape::IBeamCursor, true ); break;
	667	case TY_CSI_PS_SP('q', 6) : emit cursorChanged(KeyboardCursorShape::IBeamCursor, false); break;
	668
[050d67a]	669	case TY_CSI_PN('@' ) : _currentScreen->insertChars (p ); break;
	670	case TY_CSI_PN('A' ) : _currentScreen->cursorUp (p ); break; //VT100
	671	case TY_CSI_PN('B' ) : _currentScreen->cursorDown (p ); break; //VT100
	672	case TY_CSI_PN('C' ) : _currentScreen->cursorRight (p ); break; //VT100
	673	case TY_CSI_PN('D' ) : _currentScreen->cursorLeft (p ); break; //VT100
[64efc22]	674	case TY_CSI_PN('E' ) : _currentScreen->cursorNextLine (p ); break; //VT100
	675	case TY_CSI_PN('F' ) : _currentScreen->cursorPreviousLine (p ); break; //VT100
[050d67a]	676	case TY_CSI_PN('G' ) : _currentScreen->setCursorX (p ); break; //LINUX
	677	case TY_CSI_PN('H' ) : _currentScreen->setCursorYX (p, q); break; //VT100
[64efc22]	678	case TY_CSI_PN('I' ) : _currentScreen->tab (p ); break;
[050d67a]	679	case TY_CSI_PN('L' ) : _currentScreen->insertLines (p ); break;
	680	case TY_CSI_PN('M' ) : _currentScreen->deleteLines (p ); break;
	681	case TY_CSI_PN('P' ) : _currentScreen->deleteChars (p ); break;
	682	case TY_CSI_PN('S' ) : _currentScreen->scrollUp (p ); break;
	683	case TY_CSI_PN('T' ) : _currentScreen->scrollDown (p ); break;
	684	case TY_CSI_PN('X' ) : _currentScreen->eraseChars (p ); break;
[64efc22]	685	case TY_CSI_PN('Z' ) : _currentScreen->backtab (p ); break;
	686	case TY_CSI_PN('b' ) : _currentScreen->repeatChars (p ); break;
[050d67a]	687	case TY_CSI_PN('c' ) : reportTerminalType ( ); break; //VT100
	688	case TY_CSI_PN('d' ) : _currentScreen->setCursorY (p ); break; //LINUX
	689	case TY_CSI_PN('f' ) : _currentScreen->setCursorYX (p, q); break; //VT100
	690	case TY_CSI_PN('r' ) : setMargins (p, q); break; //VT100
	691	case TY_CSI_PN('y' ) : /* IGNORED: Confidence test */ break; //VT100
	692
	693	case TY_CSI_PR('h', 1) : setMode (MODE_AppCuKeys); break; //VT100
	694	case TY_CSI_PR('l', 1) : resetMode (MODE_AppCuKeys); break; //VT100
	695	case TY_CSI_PR('s', 1) : saveMode (MODE_AppCuKeys); break; //FIXME
	696	case TY_CSI_PR('r', 1) : restoreMode (MODE_AppCuKeys); break; //FIXME
	697
	698	case TY_CSI_PR('l', 2) : resetMode (MODE_Ansi ); break; //VT100
	699
[64efc22]	700	case TY_CSI_PR('h', 3) : setMode (MODE_132Columns);break; //VT100
	701	case TY_CSI_PR('l', 3) : resetMode (MODE_132Columns);break; //VT100
[050d67a]	702
	703	case TY_CSI_PR('h', 4) : /* IGNORED: soft scrolling */ break; //VT100
	704	case TY_CSI_PR('l', 4) : /* IGNORED: soft scrolling */ break; //VT100
	705
	706	case TY_CSI_PR('h', 5) : _currentScreen-> setMode (MODE_Screen ); break; //VT100
	707	case TY_CSI_PR('l', 5) : _currentScreen-> resetMode (MODE_Screen ); break; //VT100
	708
	709	case TY_CSI_PR('h', 6) : _currentScreen-> setMode (MODE_Origin ); break; //VT100
	710	case TY_CSI_PR('l', 6) : _currentScreen-> resetMode (MODE_Origin ); break; //VT100
	711	case TY_CSI_PR('s', 6) : _currentScreen-> saveMode (MODE_Origin ); break; //FIXME
	712	case TY_CSI_PR('r', 6) : _currentScreen->restoreMode (MODE_Origin ); break; //FIXME
	713
	714	case TY_CSI_PR('h', 7) : _currentScreen-> setMode (MODE_Wrap ); break; //VT100
	715	case TY_CSI_PR('l', 7) : _currentScreen-> resetMode (MODE_Wrap ); break; //VT100
	716	case TY_CSI_PR('s', 7) : _currentScreen-> saveMode (MODE_Wrap ); break; //FIXME
	717	case TY_CSI_PR('r', 7) : _currentScreen->restoreMode (MODE_Wrap ); break; //FIXME
	718
	719	case TY_CSI_PR('h', 8) : /* IGNORED: autorepeat on */ break; //VT100
	720	case TY_CSI_PR('l', 8) : /* IGNORED: autorepeat off */ break; //VT100
	721	case TY_CSI_PR('s', 8) : /* IGNORED: autorepeat on */ break; //VT100
	722	case TY_CSI_PR('r', 8) : /* IGNORED: autorepeat off */ break; //VT100
	723
	724	case TY_CSI_PR('h', 9) : /* IGNORED: interlace */ break; //VT100
	725	case TY_CSI_PR('l', 9) : /* IGNORED: interlace */ break; //VT100
	726	case TY_CSI_PR('s', 9) : /* IGNORED: interlace */ break; //VT100
	727	case TY_CSI_PR('r', 9) : /* IGNORED: interlace */ break; //VT100
	728
	729	case TY_CSI_PR('h', 12) : /* IGNORED: Cursor blink */ break; //att610
	730	case TY_CSI_PR('l', 12) : /* IGNORED: Cursor blink */ break; //att610
	731	case TY_CSI_PR('s', 12) : /* IGNORED: Cursor blink */ break; //att610
	732	case TY_CSI_PR('r', 12) : /* IGNORED: Cursor blink */ break; //att610
	733
	734	case TY_CSI_PR('h', 25) : setMode (MODE_Cursor ); break; //VT100
	735	case TY_CSI_PR('l', 25) : resetMode (MODE_Cursor ); break; //VT100
	736	case TY_CSI_PR('s', 25) : saveMode (MODE_Cursor ); break; //VT100
	737	case TY_CSI_PR('r', 25) : restoreMode (MODE_Cursor ); break; //VT100
	738
[64efc22]	739	case TY_CSI_PR('h', 40) : setMode(MODE_Allow132Columns ); break; // XTERM
	740	case TY_CSI_PR('l', 40) : resetMode(MODE_Allow132Columns ); break; // XTERM
	741
[050d67a]	742	case TY_CSI_PR('h', 41) : /* IGNORED: obsolete more(1) fix */ break; //XTERM
	743	case TY_CSI_PR('l', 41) : /* IGNORED: obsolete more(1) fix */ break; //XTERM
	744	case TY_CSI_PR('s', 41) : /* IGNORED: obsolete more(1) fix */ break; //XTERM
	745	case TY_CSI_PR('r', 41) : /* IGNORED: obsolete more(1) fix */ break; //XTERM
	746
	747	case TY_CSI_PR('h', 47) : setMode (MODE_AppScreen); break; //VT100
	748	case TY_CSI_PR('l', 47) : resetMode (MODE_AppScreen); break; //VT100
	749	case TY_CSI_PR('s', 47) : saveMode (MODE_AppScreen); break; //XTERM
	750	case TY_CSI_PR('r', 47) : restoreMode (MODE_AppScreen); break; //XTERM
	751
	752	case TY_CSI_PR('h', 67) : /* IGNORED: DECBKM */ break; //XTERM
	753	case TY_CSI_PR('l', 67) : /* IGNORED: DECBKM */ break; //XTERM
	754	case TY_CSI_PR('s', 67) : /* IGNORED: DECBKM */ break; //XTERM
	755	case TY_CSI_PR('r', 67) : /* IGNORED: DECBKM */ break; //XTERM
	756
	757	// XTerm defines the following modes:
	758	// SET_VT200_MOUSE 1000
	759	// SET_VT200_HIGHLIGHT_MOUSE 1001
	760	// SET_BTN_EVENT_MOUSE 1002
	761	// SET_ANY_EVENT_MOUSE 1003
	762	//
[64efc22]	763
[050d67a]	764	//Note about mouse modes:
	765	//There are four mouse modes which xterm-compatible terminals can support - 1000,1001,1002,1003
	766	//Konsole currently supports mode 1000 (basic mouse press and release) and mode 1002 (dragging the mouse).
[64efc22]	767	//TODO: Implementation of mouse modes 1001 (something called highlight tracking) and
[050d67a]	768	//1003 (a slight variation on dragging the mouse)
	769	//
[64efc22]	770
[050d67a]	771	case TY_CSI_PR('h', 1000) : setMode (MODE_Mouse1000); break; //XTERM
	772	case TY_CSI_PR('l', 1000) : resetMode (MODE_Mouse1000); break; //XTERM
	773	case TY_CSI_PR('s', 1000) : saveMode (MODE_Mouse1000); break; //XTERM
	774	case TY_CSI_PR('r', 1000) : restoreMode (MODE_Mouse1000); break; //XTERM
	775
	776	case TY_CSI_PR('h', 1001) : /* IGNORED: hilite mouse tracking */ break; //XTERM
	777	case TY_CSI_PR('l', 1001) : resetMode (MODE_Mouse1001); break; //XTERM
	778	case TY_CSI_PR('s', 1001) : /* IGNORED: hilite mouse tracking */ break; //XTERM
	779	case TY_CSI_PR('r', 1001) : /* IGNORED: hilite mouse tracking */ break; //XTERM
	780
	781	case TY_CSI_PR('h', 1002) : setMode (MODE_Mouse1002); break; //XTERM
	782	case TY_CSI_PR('l', 1002) : resetMode (MODE_Mouse1002); break; //XTERM
	783	case TY_CSI_PR('s', 1002) : saveMode (MODE_Mouse1002); break; //XTERM
	784	case TY_CSI_PR('r', 1002) : restoreMode (MODE_Mouse1002); break; //XTERM
	785
	786	case TY_CSI_PR('h', 1003) : setMode (MODE_Mouse1003); break; //XTERM
	787	case TY_CSI_PR('l', 1003) : resetMode (MODE_Mouse1003); break; //XTERM
	788	case TY_CSI_PR('s', 1003) : saveMode (MODE_Mouse1003); break; //XTERM
	789	case TY_CSI_PR('r', 1003) : restoreMode (MODE_Mouse1003); break; //XTERM
	790
[64efc22]	791	case TY_CSI_PR('h', 1004) : _reportFocusEvents = true; break;
	792	case TY_CSI_PR('l', 1004) : _reportFocusEvents = false; break;
	793
	794	case TY_CSI_PR('h', 1005) : setMode (MODE_Mouse1005); break; //XTERM
	795	case TY_CSI_PR('l', 1005) : resetMode (MODE_Mouse1005); break; //XTERM
	796	case TY_CSI_PR('s', 1005) : saveMode (MODE_Mouse1005); break; //XTERM
	797	case TY_CSI_PR('r', 1005) : restoreMode (MODE_Mouse1005); break; //XTERM
	798
	799	case TY_CSI_PR('h', 1006) : setMode (MODE_Mouse1006); break; //XTERM
	800	case TY_CSI_PR('l', 1006) : resetMode (MODE_Mouse1006); break; //XTERM
	801	case TY_CSI_PR('s', 1006) : saveMode (MODE_Mouse1006); break; //XTERM
	802	case TY_CSI_PR('r', 1006) : restoreMode (MODE_Mouse1006); break; //XTERM
	803
	804	case TY_CSI_PR('h', 1015) : setMode (MODE_Mouse1015); break; //URXVT
	805	case TY_CSI_PR('l', 1015) : resetMode (MODE_Mouse1015); break; //URXVT
	806	case TY_CSI_PR('s', 1015) : saveMode (MODE_Mouse1015); break; //URXVT
	807	case TY_CSI_PR('r', 1015) : restoreMode (MODE_Mouse1015); break; //URXVT
	808
	809	case TY_CSI_PR('h', 1034) : /* IGNORED: 8bitinput activation */ break; //XTERM
	810
[050d67a]	811	case TY_CSI_PR('h', 1047) : setMode (MODE_AppScreen); break; //XTERM
	812	case TY_CSI_PR('l', 1047) : _screen[1]->clearEntireScreen(); resetMode(MODE_AppScreen); break; //XTERM
	813	case TY_CSI_PR('s', 1047) : saveMode (MODE_AppScreen); break; //XTERM
	814	case TY_CSI_PR('r', 1047) : restoreMode (MODE_AppScreen); break; //XTERM
	815
	816	//FIXME: Unitoken: save translations
	817	case TY_CSI_PR('h', 1048) : saveCursor ( ); break; //XTERM
	818	case TY_CSI_PR('l', 1048) : restoreCursor ( ); break; //XTERM
	819	case TY_CSI_PR('s', 1048) : saveCursor ( ); break; //XTERM
	820	case TY_CSI_PR('r', 1048) : restoreCursor ( ); break; //XTERM
	821
	822	//FIXME: every once new sequences like this pop up in xterm.
	823	// Here's a guess of what they could mean.
	824	case TY_CSI_PR('h', 1049) : saveCursor(); _screen[1]->clearEntireScreen(); setMode(MODE_AppScreen); break; //XTERM
	825	case TY_CSI_PR('l', 1049) : resetMode(MODE_AppScreen); restoreCursor(); break; //XTERM
	826
[64efc22]	827	case TY_CSI_PR('h', 2004) : setMode (MODE_BracketedPaste); break; //XTERM
	828	case TY_CSI_PR('l', 2004) : resetMode (MODE_BracketedPaste); break; //XTERM
	829	case TY_CSI_PR('s', 2004) : saveMode (MODE_BracketedPaste); break; //XTERM
	830	case TY_CSI_PR('r', 2004) : restoreMode (MODE_BracketedPaste); break; //XTERM
	831
[050d67a]	832	//FIXME: weird DEC reset sequence
	833	case TY_CSI_PE('p' ) : /* IGNORED: reset ( ) */ break;
	834
	835	//FIXME: when changing between vt52 and ansi mode evtl do some resetting.
	836	case TY_VT52('A' ) : _currentScreen->cursorUp ( 1); break; //VT52
	837	case TY_VT52('B' ) : _currentScreen->cursorDown ( 1); break; //VT52
	838	case TY_VT52('C' ) : _currentScreen->cursorRight ( 1); break; //VT52
	839	case TY_VT52('D' ) : _currentScreen->cursorLeft ( 1); break; //VT52
	840
	841	case TY_VT52('F' ) : setAndUseCharset (0, '0'); break; //VT52
	842	case TY_VT52('G' ) : setAndUseCharset (0, 'B'); break; //VT52
	843
	844	case TY_VT52('H' ) : _currentScreen->setCursorYX (1,1 ); break; //VT52
	845	case TY_VT52('I' ) : _currentScreen->reverseIndex ( ); break; //VT52
	846	case TY_VT52('J' ) : _currentScreen->clearToEndOfScreen ( ); break; //VT52
	847	case TY_VT52('K' ) : _currentScreen->clearToEndOfLine ( ); break; //VT52
	848	case TY_VT52('Y' ) : _currentScreen->setCursorYX (p-31,q-31 ); break; //VT52
	849	case TY_VT52('Z' ) : reportTerminalType ( ); break; //VT52
	850	case TY_VT52('<' ) : setMode (MODE_Ansi ); break; //VT52
	851	case TY_VT52('=' ) : setMode (MODE_AppKeyPad); break; //VT52
	852	case TY_VT52('>' ) : resetMode (MODE_AppKeyPad); break; //VT52
	853
	854	case TY_CSI_PG('c' ) : reportSecondaryAttributes( ); break; //VT100
	855
[64efc22]	856	default:
	857	reportDecodingError();
	858	break;
[050d67a]	859	};
	860	}
	861
	862	void Vt102Emulation::clearScreenAndSetColumns(int columnCount)
	863	{
[64efc22]	864	setImageSize(_currentScreen->getLines(),columnCount);
[050d67a]	865	clearEntireScreen();
[64efc22]	866	setDefaultMargins();
[050d67a]	867	_currentScreen->setCursorYX(0,0);
	868	}
	869
	870	void Vt102Emulation::sendString(const char* s , int length)
	871	{
	872	if ( length >= 0 )
	873	emit sendData(s,length);
	874	else
	875	emit sendData(s,strlen(s));
	876	}
	877
	878	void Vt102Emulation::reportCursorPosition()
[64efc22]	879	{
	880	const size_t sz = 20;
	881	char tmp[sz];
	882	const size_t r = snprintf(tmp, sz, "\033[%d;%dR",_currentScreen->getCursorY()+1,_currentScreen->getCursorX()+1);
	883	if (sz <= r) {
	884	qWarning("Vt102Emulation::reportCursorPosition: Buffer too small\n");
	885	}
[050d67a]	886	sendString(tmp);
	887	}
	888
	889	void Vt102Emulation::reportTerminalType()
	890	{
	891	// Primary device attribute response (Request was: ^[[0c or ^[[c (from TT321 Users Guide))
[64efc22]	892	// VT220: ^[[?63;1;2;3;6;7;8c (list deps on emul. capabilities)
	893	// VT100: ^[[?1;2c
	894	// VT101: ^[[?1;0c
	895	// VT102: ^[[?6v
[050d67a]	896	if (getMode(MODE_Ansi))
[64efc22]	897	sendString("\033[?1;2c"); // I'm a VT100
[050d67a]	898	else
[64efc22]	899	sendString("\033/Z"); // I'm a VT52
[050d67a]	900	}
	901
	902	void Vt102Emulation::reportSecondaryAttributes()
	903	{
[64efc22]	904	// Secondary device attribute response (Request was: ^[[>0c or ^[[>c)
[050d67a]	905	if (getMode(MODE_Ansi))
	906	sendString("\033[>0;115;0c"); // Why 115? ;)
	907	else
	908	sendString("\033/Z"); // FIXME I don't think VT52 knows about it but kept for
	909	// konsoles backward compatibility.
	910	}
	911
	912	void Vt102Emulation::reportTerminalParms(int p)
	913	// DECREPTPARM
[64efc22]	914	{
	915	const size_t sz = 100;
	916	char tmp[sz];
	917	const size_t r = snprintf(tmp, sz, "\033[%d;1;1;112;112;1;0x",p); // not really true.
	918	if (sz <= r) {
	919	qWarning("Vt102Emulation::reportTerminalParms: Buffer too small\n");
	920	}
[050d67a]	921	sendString(tmp);
	922	}
	923
	924	void Vt102Emulation::reportStatus()
	925	{
	926	sendString("\033[0n"); //VT100. Device status report. 0 = Ready.
	927	}
	928
	929	void Vt102Emulation::reportAnswerBack()
	930	{
[64efc22]	931	// FIXME - Test this with VTTEST
	932	// This is really obsolete VT100 stuff.
	933	const char* ANSWER_BACK = "";
[050d67a]	934	sendString(ANSWER_BACK);
	935	}
	936
	937	/*!
[64efc22]	938	`cx',`cy' are 1-based.
	939	`cb' indicates the button pressed or released (0-2) or scroll event (4-5).
[050d67a]	940
	941	eventType represents the kind of mouse action that occurred:
[64efc22]	942	0 = Mouse button press
	943	1 = Mouse drag
	944	2 = Mouse button release
[050d67a]	945	*/
	946
	947	void Vt102Emulation::sendMouseEvent( int cb, int cx, int cy , int eventType )
[64efc22]	948	{
	949	if (cx < 1 \|\| cy < 1)
	950	return;
	951
	952	// With the exception of the 1006 mode, button release is encoded in cb.
	953	// Note that if multiple extensions are enabled, the 1006 is used, so it's okay to check for only that.
	954	if (eventType == 2 && !getMode(MODE_Mouse1006))
	955	cb = 3;
	956
	957	// normal buttons are passed as 0x20 + button,
	958	// mouse wheel (buttons 4,5) as 0x5c + button
	959	if (cb >= 4)
	960	cb += 0x3c;
	961
	962	//Mouse motion handling
	963	if ((getMode(MODE_Mouse1002) \|\| getMode(MODE_Mouse1003)) && eventType == 1)
	964	cb += 0x20; //add 32 to signify motion event
	965
[fedf2a2]	966	char command[64];
[64efc22]	967	command[0] = '\0';
	968	// Check the extensions in decreasing order of preference. Encoding the release event above assumes that 1006 comes first.
	969	if (getMode(MODE_Mouse1006)) {
	970	snprintf(command, sizeof(command), "\033[<%d;%d;%d%c", cb, cx, cy, eventType == 2 ? 'm' : 'M');
	971	} else if (getMode(MODE_Mouse1015)) {
	972	snprintf(command, sizeof(command), "\033[%d;%d;%dM", cb + 0x20, cx, cy);
	973	} else if (getMode(MODE_Mouse1005)) {
	974	if (cx <= 2015 && cy <= 2015) {
	975	// The xterm extension uses UTF-8 (up to 2 bytes) to encode
	976	// coordinate+32, no matter what the locale is. We could easily
	977	// convert manually, but QString can also do it for us.
	978	QChar coords[2];
[fedf2a2]	979	coords[0] = QChar(cx + 0x20);
	980	coords[1] = QChar(cy + 0x20);
[64efc22]	981	QString coordsStr = QString(coords, 2);
	982	QByteArray utf8 = coordsStr.toUtf8();
	983	snprintf(command, sizeof(command), "\033[M%c%s", cb + 0x20, utf8.constData());
	984	}
	985	} else if (cx <= 223 && cy <= 223) {
	986	snprintf(command, sizeof(command), "\033[M%c%c%c", cb + 0x20, cx + 0x20, cy + 0x20);
	987	}
[050d67a]	988
[64efc22]	989	sendString(command);
[050d67a]	990	}
	991
[64efc22]	992	/**
	993	* The focus lost event can be used by Vim (or other terminal applications)
	994	* to recognize that the konsole window has lost focus.
	995	* The escape sequence is also used by iTerm2.
	996	* Vim needs the following plugin to be installed to convert the escape
	997	* sequence into the FocusLost autocmd: https://github.com/sjl/vitality.vim
	998	*/
	999	void Vt102Emulation::focusLost(void)
	1000	{
	1001	if (_reportFocusEvents)
	1002	sendString("\033[O");
	1003	}
[050d67a]	1004
[64efc22]	1005	/**
	1006	* The focus gained event can be used by Vim (or other terminal applications)
	1007	* to recognize that the konsole window has gained focus again.
	1008	* The escape sequence is also used by iTerm2.
	1009	* Vim needs the following plugin to be installed to convert the escape
	1010	* sequence into the FocusGained autocmd: https://github.com/sjl/vitality.vim
	1011	*/
	1012	void Vt102Emulation::focusGained(void)
	1013	{
	1014	if (_reportFocusEvents)
	1015	sendString("\033[I");
	1016	}
[050d67a]	1017
	1018	void Vt102Emulation::sendText( const QString& text )
	1019	{
[64efc22]	1020	if (!text.isEmpty())
	1021	{
	1022	QKeyEvent event(QEvent::KeyPress,
	1023	0,
	1024	Qt::NoModifier,
[050d67a]	1025	text);
[64efc22]	1026	sendKeyEvent(&event, false); // expose as a big fat keypress event
[050d67a]	1027	}
	1028	}
[64efc22]	1029	void Vt102Emulation::sendKeyEvent(QKeyEvent* event, bool fromPaste)
[050d67a]	1030	{
	1031	Qt::KeyboardModifiers modifiers = event->modifiers();
	1032	KeyboardTranslator::States states = KeyboardTranslator::NoState;
	1033
	1034	// get current states
[64efc22]	1035	if (getMode(MODE_NewLine) ) states \|= KeyboardTranslator::NewLineState;
	1036	if (getMode(MODE_Ansi) ) states \|= KeyboardTranslator::AnsiState;
	1037	if (getMode(MODE_AppCuKeys)) states \|= KeyboardTranslator::CursorKeysState;
	1038	if (getMode(MODE_AppScreen)) states \|= KeyboardTranslator::AlternateScreenState;
	1039	if (getMode(MODE_AppKeyPad) && (modifiers & Qt::KeypadModifier))
	1040	states \|= KeyboardTranslator::ApplicationKeypadState;
	1041
	1042	// check flow control state
	1043	if (modifiers & KeyboardTranslator::CTRL_MOD)
	1044	{
	1045	switch (event->key()) {
	1046	case Qt::Key_S:
	1047	emit flowControlKeyPressed(true);
	1048	break;
	1049	case Qt::Key_Q:
	1050	case Qt::Key_C: // cancel flow control
	1051	emit flowControlKeyPressed(false);
	1052	break;
	1053	}
	1054	}
[050d67a]	1055
	1056	// lookup key binding
	1057	if ( _keyTranslator )
	1058	{
[64efc22]	1059	KeyboardTranslator::Entry entry = _keyTranslator->findEntry(
	1060	event->key() ,
[050d67a]	1061	modifiers,
	1062	states );
	1063
	1064	// send result to terminal
	1065	QByteArray textToSend;
	1066
	1067	// special handling for the Alt (aka. Meta) modifier. pressing
	1068	// Alt+[Character] results in Esc+[Character] being sent
	1069	// (unless there is an entry defined for this particular combination
	1070	// in the keyboard modifier)
	1071	bool wantsAltModifier = entry.modifiers() & entry.modifierMask() & Qt::AltModifier;
[64efc22]	1072	bool wantsMetaModifier = entry.modifiers() & entry.modifierMask() & Qt::MetaModifier;
	1073	bool wantsAnyModifier = entry.state() &
	1074	entry.stateMask() & KeyboardTranslator::AnyModifierState;
[050d67a]	1075
[64efc22]	1076	if ( modifiers & Qt::AltModifier && !(wantsAltModifier \|\| wantsAnyModifier)
[050d67a]	1077	&& !event->text().isEmpty() )
	1078	{
	1079	textToSend.prepend("\033");
	1080	}
[64efc22]	1081	if ( modifiers & Qt::MetaModifier && !(wantsMetaModifier \|\| wantsAnyModifier)
	1082	&& !event->text().isEmpty() )
	1083	{
	1084	textToSend.prepend("\030@s");
	1085	}
[050d67a]	1086
	1087	if ( entry.command() != KeyboardTranslator::NoCommand )
	1088	{
[64efc22]	1089	if (entry.command() & KeyboardTranslator::EraseCommand) {
	1090	textToSend += eraseChar();
	1091	} else {
	1092	Q_EMIT handleCommandFromKeyboard(entry.command());
	1093	}
	1094
[050d67a]	1095	// TODO command handling
	1096	}
[64efc22]	1097	else if ( !entry.text().isEmpty() )
[050d67a]	1098	{
[64efc22]	1099	textToSend += _codec->fromUnicode(QString::fromUtf8(entry.text(true,modifiers)));
[050d67a]	1100	}
[64efc22]	1101	else if((modifiers & KeyboardTranslator::CTRL_MOD) && event->key() >= 0x40 && event->key() < 0x5f) {
	1102	textToSend += (event->key() & 0x1f);
	1103	}
	1104	else if(event->key() == Qt::Key_Tab) {
	1105	textToSend += 0x09;
	1106	}
	1107	else if (event->key() == Qt::Key_PageUp) {
	1108	textToSend += "\033[5~";
	1109	}
	1110	else if (event->key() == Qt::Key_PageDown) {
	1111	textToSend += "\033[6~";
	1112	}
	1113	else {
[050d67a]	1114	textToSend += _codec->fromUnicode(event->text());
[64efc22]	1115	}
[050d67a]	1116
[64efc22]	1117	if (!fromPaste && textToSend.length()) {
	1118	Q_EMIT outputFromKeypressEvent();
	1119	}
	1120	Q_EMIT sendData( textToSend.constData() , textToSend.length() );
[050d67a]	1121	}
	1122	else
	1123	{
	1124	// print an error message to the terminal if no key translator has been
	1125	// set
[64efc22]	1126	QString translatorError = tr("No keyboard translator available. "
[050d67a]	1127	"The information needed to convert key presses "
[64efc22]	1128	"into characters to send to the terminal "
[050d67a]	1129	"is missing.");
	1130	reset();
[fedf2a2]	1131	receiveData( translatorError.toUtf8().constData() , translatorError.length() );
[050d67a]	1132	}
	1133	}
	1134
	1135	/* ------------------------------------------------------------------------- */
	1136	/* */
	1137	/* VT100 Charsets */
	1138	/* */
	1139	/* ------------------------------------------------------------------------- */
	1140
	1141	// Character Set Conversion ------------------------------------------------ --
	1142
[64efc22]	1143	/*
[050d67a]	1144	The processing contains a VT100 specific code translation layer.
	1145	It's still in use and mainly responsible for the line drawing graphics.
	1146
	1147	These and some other glyphs are assigned to codes (0x5f-0xfe)
	1148	normally occupied by the latin letters. Since this codes also
	1149	appear within control sequences, the extra code conversion
	1150	does not permute with the tokenizer and is placed behind it
	1151	in the pipeline. It only applies to tokens, which represent
	1152	plain characters.
	1153
[64efc22]	1154	This conversion it eventually continued in TerminalDisplay.C, since
[050d67a]	1155	it might involve VT100 enhanced fonts, which have these
	1156	particular glyphs allocated in (0x00-0x1f) in their code page.
	1157	*/
	1158
	1159	#define CHARSET _charset[_currentScreen==_screen[1]]
	1160
	1161	// Apply current character map.
	1162
[64efc22]	1163	wchar_t Vt102Emulation::applyCharset(wchar_t c)
[050d67a]	1164	{
	1165	if (CHARSET.graphic && 0x5f <= c && c <= 0x7e) return vt100_graphics[c-0x5f];
[64efc22]	1166	if (CHARSET.pound && c == '#' ) return 0xa3; //This mode is obsolete
[050d67a]	1167	return c;
	1168	}
	1169
	1170	/*
	1171	"Charset" related part of the emulation state.
[64efc22]	1172	This configures the VT100 charset filter.
[050d67a]	1173
	1174	While most operation work on the current _screen,
	1175	the following two are different.
	1176	*/
	1177
	1178	void Vt102Emulation::resetCharset(int scrno)
	1179	{
[64efc22]	1180	_charset[scrno].cu_cs = 0;
	1181	qstrncpy(_charset[scrno].charset,"BBBB",4);
[050d67a]	1182	_charset[scrno].sa_graphic = false;
[64efc22]	1183	_charset[scrno].sa_pound = false;
[050d67a]	1184	_charset[scrno].graphic = false;
[64efc22]	1185	_charset[scrno].pound = false;
[050d67a]	1186	}
	1187
	1188	void Vt102Emulation::setCharset(int n, int cs) // on both screens.
	1189	{
	1190	_charset[0].charset[n&3] = cs; useCharset(_charset[0].cu_cs);
	1191	_charset[1].charset[n&3] = cs; useCharset(_charset[1].cu_cs);
	1192	}
	1193
	1194	void Vt102Emulation::setAndUseCharset(int n, int cs)
	1195	{
	1196	CHARSET.charset[n&3] = cs;
	1197	useCharset(n&3);
	1198	}
	1199
	1200	void Vt102Emulation::useCharset(int n)
	1201	{
	1202	CHARSET.cu_cs = n&3;
	1203	CHARSET.graphic = (CHARSET.charset[n&3] == '0');
	1204	CHARSET.pound = (CHARSET.charset[n&3] == 'A'); //This mode is obsolete
	1205	}
	1206
	1207	void Vt102Emulation::setDefaultMargins()
	1208	{
[64efc22]	1209	_screen[0]->setDefaultMargins();
	1210	_screen[1]->setDefaultMargins();
[050d67a]	1211	}
	1212
	1213	void Vt102Emulation::setMargins(int t, int b)
	1214	{
	1215	_screen[0]->setMargins(t, b);
	1216	_screen[1]->setMargins(t, b);
	1217	}
	1218
	1219	void Vt102Emulation::saveCursor()
	1220	{
	1221	CHARSET.sa_graphic = CHARSET.graphic;
	1222	CHARSET.sa_pound = CHARSET.pound; //This mode is obsolete
	1223	// we are not clear about these
	1224	//sa_charset = charsets[cScreen->_charset];
	1225	//sa_charset_num = cScreen->_charset;
	1226	_currentScreen->saveCursor();
	1227	}
	1228
	1229	void Vt102Emulation::restoreCursor()
	1230	{
	1231	CHARSET.graphic = CHARSET.sa_graphic;
	1232	CHARSET.pound = CHARSET.sa_pound; //This mode is obsolete
	1233	_currentScreen->restoreCursor();
	1234	}
	1235
	1236	/* ------------------------------------------------------------------------- */
	1237	/* */
	1238	/* Mode Operations */
	1239	/* */
	1240	/* ------------------------------------------------------------------------- */
	1241
	1242	/*
	1243	Some of the emulations state is either added to the state of the screens.
	1244
	1245	This causes some scoping problems, since different emulations choose to
	1246	located the mode either to the current _screen or to both.
	1247
	1248	For strange reasons, the extend of the rendition attributes ranges over
	1249	all screens and not over the actual _screen.
	1250
	1251	We decided on the precise precise extend, somehow.
	1252	*/
	1253
	1254	// "Mode" related part of the state. These are all booleans.
	1255
	1256	void Vt102Emulation::resetModes()
	1257	{
[64efc22]	1258	// MODE_Allow132Columns is not reset here
	1259	// to match Xterm's behaviour (see Xterm's VTReset() function)
	1260
	1261	resetMode(MODE_132Columns); saveMode(MODE_132Columns);
	1262	resetMode(MODE_Mouse1000); saveMode(MODE_Mouse1000);
	1263	resetMode(MODE_Mouse1001); saveMode(MODE_Mouse1001);
	1264	resetMode(MODE_Mouse1002); saveMode(MODE_Mouse1002);
	1265	resetMode(MODE_Mouse1003); saveMode(MODE_Mouse1003);
	1266	resetMode(MODE_Mouse1005); saveMode(MODE_Mouse1005);
	1267	resetMode(MODE_Mouse1006); saveMode(MODE_Mouse1006);
	1268	resetMode(MODE_Mouse1015); saveMode(MODE_Mouse1015);
	1269	resetMode(MODE_BracketedPaste); saveMode(MODE_BracketedPaste);
	1270
	1271	resetMode(MODE_AppScreen); saveMode(MODE_AppScreen);
	1272	resetMode(MODE_AppCuKeys); saveMode(MODE_AppCuKeys);
	1273	resetMode(MODE_AppKeyPad); saveMode(MODE_AppKeyPad);
	1274	resetMode(MODE_NewLine);
	1275	setMode(MODE_Ansi);
[050d67a]	1276	}
	1277
	1278	void Vt102Emulation::setMode(int m)
	1279	{
[64efc22]	1280	_currentModes.mode[m] = true;
[050d67a]	1281	switch (m)
	1282	{
[64efc22]	1283	case MODE_132Columns:
	1284	if (getMode(MODE_Allow132Columns))
	1285	clearScreenAndSetColumns(132);
	1286	else
	1287	_currentModes.mode[m] = false;
	1288	break;
[050d67a]	1289	case MODE_Mouse1000:
	1290	case MODE_Mouse1001:
	1291	case MODE_Mouse1002:
	1292	case MODE_Mouse1003:
[64efc22]	1293	emit programUsesMouseChanged(false);
	1294	break;
	1295
	1296	case MODE_BracketedPaste:
	1297	emit programBracketedPasteModeChanged(true);
[050d67a]	1298	break;
	1299
	1300	case MODE_AppScreen : _screen[1]->clearSelection();
	1301	setScreen(1);
	1302	break;
	1303	}
	1304	if (m < MODES_SCREEN \|\| m == MODE_NewLine)
	1305	{
	1306	_screen[0]->setMode(m);
	1307	_screen[1]->setMode(m);
	1308	}
	1309	}
	1310
	1311	void Vt102Emulation::resetMode(int m)
	1312	{
[64efc22]	1313	_currentModes.mode[m] = false;
[050d67a]	1314	switch (m)
	1315	{
[64efc22]	1316	case MODE_132Columns:
	1317	if (getMode(MODE_Allow132Columns))
	1318	clearScreenAndSetColumns(80);
	1319	break;
	1320	case MODE_Mouse1000 :
[050d67a]	1321	case MODE_Mouse1001 :
	1322	case MODE_Mouse1002 :
	1323	case MODE_Mouse1003 :
[64efc22]	1324	emit programUsesMouseChanged(true);
	1325	break;
	1326
	1327	case MODE_BracketedPaste:
	1328	emit programBracketedPasteModeChanged(false);
[050d67a]	1329	break;
	1330
[64efc22]	1331	case MODE_AppScreen :
	1332	_screen[0]->clearSelection();
	1333	setScreen(0);
[050d67a]	1334	break;
	1335	}
	1336	if (m < MODES_SCREEN \|\| m == MODE_NewLine)
	1337	{
	1338	_screen[0]->resetMode(m);
	1339	_screen[1]->resetMode(m);
	1340	}
	1341	}
	1342
	1343	void Vt102Emulation::saveMode(int m)
	1344	{
[64efc22]	1345	_savedModes.mode[m] = _currentModes.mode[m];
[050d67a]	1346	}
	1347
	1348	void Vt102Emulation::restoreMode(int m)
	1349	{
[64efc22]	1350	if (_savedModes.mode[m])
	1351	setMode(m);
	1352	else
[050d67a]	1353	resetMode(m);
	1354	}
	1355
	1356	bool Vt102Emulation::getMode(int m)
	1357	{
[64efc22]	1358	return _currentModes.mode[m];
[050d67a]	1359	}
	1360
[64efc22]	1361	char Vt102Emulation::eraseChar() const
[050d67a]	1362	{
	1363	KeyboardTranslator::Entry entry = _keyTranslator->findEntry(
	1364	Qt::Key_Backspace,
[64efc22]	1365	Qt::NoModifier,
	1366	KeyboardTranslator::NoState);
[fedf2a2]	1367	if ( entry.text().length() > 0 )
[64efc22]	1368	return entry.text().at(0);
[050d67a]	1369	else
	1370	return '\b';
	1371	}
	1372
[64efc22]	1373	void Vt102Emulation::reportDecodingError()
[050d67a]	1374	{
[64efc22]	1375	if (tokenBufferPos == 0 \|\| ( tokenBufferPos == 1 && (tokenBuffer[0] & 0xff) >= 32) )
	1376	return;
	1377	qCDebug(qtermwidgetLogger) << "Undecodable sequence:" << QString::fromWCharArray(tokenBuffer, tokenBufferPos);
[050d67a]	1378	}
	1379
[64efc22]	1380	//#include "Vt102Emulation.moc"
[050d67a]	1381

Note: See TracBrowser for help on using the repository browser.

Download in other formats: