开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet服务器 > 查看源码
VT100.cs
资源名称：Terminal_Control_jan_2009.zip　[点击查看]
上传用户：szltgg
上传日期：2019-05-16
资源大小：604k
文件大小：19k
源码类别：

Telnet服务器

开发平台：

C#

VT100.cs：源码内容
  1. /*
  2. * Copyright (c) 2005 Poderosa Project, All Rights Reserved.
  3. * $Id: VT100.cs,v 1.2 2005/04/20 08:45:48 okajima Exp $
  4. */
  5. using System;
  6. using System.IO;
  7. using System.Text;
  8. using System.Diagnostics;
  9. using System.Drawing;
  10. using System.Windows.Forms;
  12. using Poderosa.Connection;
  13. using Poderosa.ConnectionParam;
  14. using Poderosa.Text;
  15. using Poderosa.UI;
  17. namespace Poderosa.Terminal
  18. {
  19. internal class VT100Terminal : EscapeSequenceTerminal {
  21. protected int _savedRow;
  22. protected int _savedCol;
  23. protected bool _insertMode;
  24. protected bool _scrollRegionRelative;
  26. //愙懕偺庬椶偵傛偭偰僄僗働乕僾僔乕働儞僗偺夝庍傪曄偊傞晹暘
  27. protected bool _homePositionOnCSIJ2;
  29. public VT100Terminal(ConnectionTag tag, ICharDecoder decoder) : base(tag, decoder) {
  30. _insertMode = false;
  31. _scrollRegionRelative = false;
  32. bool sfu = tag.Connection.Param is SFUTerminalParam;
  33. _homePositionOnCSIJ2 = sfu;
  34. }
  35. protected override void ResetInternal() {
  36. base.ResetInternal();
  37. _insertMode = false;
  38. _scrollRegionRelative = false;
  39. }
  42. protected override ProcessCharResult ProcessEscapeSequence(char code, char[] seq, int offset) {
  43. string param;
  44. switch(code) {
  45. case '[':
  46. if(seq.Length-offset-1>=0) {
  47. param = new string(seq, offset, seq.Length-offset-1);
  48. return ProcessAfterCSI(param, seq[seq.Length-1]);
  49. }
  50. break;
  51. //throw new UnknownEscapeSequenceException(String.Format("unknown command after CSI {0}", code));
  52. case ']':
  53. if(seq.Length-offset-1>=0) {
  54. param = new string(seq, offset, seq.Length-offset-1);
  55. return ProcessAfterOSC(param, seq[seq.Length-1]);
  56. }
  57. break;
  58. case '=':
  59. ChangeMode(TerminalMode.Application);
  60. return ProcessCharResult.Processed;
  61. case '>':
  62. ChangeMode(TerminalMode.Normal);
  63. return ProcessCharResult.Processed;
  64. case 'E':
  65. ProcessNextLine();
  66. return ProcessCharResult.Processed;
  67. case 'M': 
  68. ReverseIndex();
  69. return ProcessCharResult.Processed;
  70. case 'D': 
  71. Index();
  72. return ProcessCharResult.Processed;
  73. case '7':
  74. SaveCursor();
  75. return ProcessCharResult.Processed;
  76. case '8':
  77. RestoreCursor();
  78. return ProcessCharResult.Processed;
  79. case 'c':
  80. FullReset();
  81. return ProcessCharResult.Processed;
  82. }
  83. return ProcessCharResult.Unsupported;
  84. }
  86. protected virtual ProcessCharResult ProcessAfterCSI(string param, char code) {
  88. switch(code) {
  89. case 'c':
  90. ProcessDeviceAttributes(param);
  91. break;
  92. case 'm': //SGR
  93. ProcessSGR(param);
  94. break;
  95. case 'h':
  96. case 'l':
  97. return ProcessDECSETMulti(param, code);
  98. case 'r':
  99. if(param.Length>0 && param[0]=='?')
  100. return ProcessRestoreDECSET(param, code);
  101. else
  102. ProcessSetScrollingRegion(param);
  103. break;
  104. case 's':
  105. return ProcessSaveDECSET(param, code);
  106. case 'n':
  107. ProcessDeviceStatusReport(param);
  108. break;
  109. case 'A':
  110. case 'B':
  111. case 'C':
  112. case 'D':
  113. case 'E':
  114. case 'F':
  115. ProcessCursorMove(param, code);
  116. break;
  117. case 'H':
  118. case 'f': //f偼杮摉偼xterm屌桳
  119. ProcessCursorPosition(param);
  120. break;
  121. case 'J':
  122. ProcessEraseInDisplay(param);
  123. break;
  124. case 'K':
  125. ProcessEraseInLine(param);
  126. break;
  127. case 'L':
  128. ProcessInsertLines(param);
  129. break;
  130. case 'M':
  131. ProcessDeleteLines(param);
  132. break;
  133. default:
  134. return ProcessCharResult.Unsupported; 
  135. }
  137. return ProcessCharResult.Processed;
  138. }
  139. protected virtual ProcessCharResult ProcessAfterOSC(string param, char code) {
  140. return ProcessCharResult.Unsupported;
  141. }
  143. protected void ProcessSGR(string param) {
  144. string[] ps = param.Split(';');
  146. foreach(string cmd in ps) {
  148. TextDecoration dec = (TextDecoration)_currentdecoration.Clone();
  149. int code = ParseSGRCode(cmd);
  150. if(code>=30 && code<=37) {
  151. //偙傟偩偲怓傪曄峏偟偨偲偒婛偵夋柺偵偁傞傕偺偼楢摦偟側偔側傞偑丄偦偙傪偪傖傫偲偡傞偺偼崲擄偱偁傞
  152. dec.TextColor = _tag.GetCurrentRenderProfile().ESColorSet[code % 10];
  153. }
  154. else if(code>=40 && code<=47) {
  155. Color c = _tag.GetCurrentRenderProfile().ESColorSet[code % 10];
  156. dec.BackColor = DrawUtil.DarkColor(c); //攚宨怓偼埫傔偵
  157. }
  158. else {
  159. switch(code) {
  160. case 0:
  161. dec = TextDecoration.ClonedDefault();
  162. break;
  163. case 1:
  164. case 5:
  165. dec.Bold = true;
  166. break;
  167. case 4:
  168. dec.Underline = true;
  169. break;
  170. case 7:
  171. dec.Inverse();
  172. break;
  173. case 2:
  174. dec = TextDecoration.ClonedDefault(); //晄柧偩偑SGR 2偱廔傢偭偰偄傞椺偑偁偭偨
  175. break;
  176. case 22:
  177. case 25:
  178. case 27:
  179. case 28:
  180. dec = TextDecoration.ClonedDefault();
  181. break;
  182. case 24:
  183. dec.Underline = false;
  184. break;
  185. case 39:
  186. dec.TextColorType = ColorType.DefaultText;
  187. break;
  188. case 49:
  189. dec.BackColorType = ColorType.DefaultBack;
  190. break;
  191. case 10:
  192. case 11:
  193. case 12:
  194. break; //'konsole'偲偄偆傗偮傜偟偄丅柍帇偱栤戣側偝偦偆
  195. default:
  196. throw new UnknownEscapeSequenceException(String.Format("unknown SGR command {0}", param));
  197. }
  198. }
  200. _currentdecoration = dec;
  201. //_manipulator.SetDecoration(dec);
  202. }
  203. }
  204. private static int ParseSGRCode(string param) {
  205. if(param.Length==0)
  206. return 0;
  207. else if(param.Length==1)
  208. return param[0]-'0';
  209. else if(param.Length==2)
  210. return (param[0]-'0')*10 + (param[1]-'0');
  211. else
  212. throw new UnknownEscapeSequenceException(String.Format("unknown SGR parameter {0}", param));
  213. }
  215. protected virtual void ProcessDeviceAttributes(string param) {
  216. byte[] data = Encoding.ASCII.GetBytes(" [?1;2c"); //側傫偐傛偔傢偐傜側偄偑MindTerm摍傪傒傞偲偙傟偱偄偄傜偟偄
  217. data[0] = 0x1B; //ESC
  218. GetConnection().Write(data);
  219. }
  220. protected virtual void ProcessDeviceStatusReport(string param) {
  221. string response;
  222. if(param=="5")
  223. response = " [0n"; //偙傟偱OK偺堄枴傜偟偄
  224. else if(param=="6")
  225. response = String.Format(" [{0};{1}R", GetDocument().CurrentLineNumber-GetDocument().TopLineNumber+1, _manipulator.CaretColumn+1);
  226. else
  227. throw new UnknownEscapeSequenceException("DSR " + param);
  229. byte[] data = Encoding.ASCII.GetBytes(response);
  230. data[0] = 0x1B; //ESC
  231. GetConnection().Write(data);
  232. }
  234. protected void ProcessCursorMove(string param, char method) {
  235. int count = ParseInt(param, 1); //僷儔儊乕僞偑徣棯偝傟偨偲偒偺堏摦検偼侾
  237. int column = _manipulator.CaretColumn;
  238. switch(method) {
  239. case 'A':
  240. GetDocument().ReplaceCurrentLine(_manipulator.Export());
  241. GetDocument().CurrentLineNumber = (GetDocument().CurrentLineNumber - count);
  242. _manipulator.Load(GetDocument().CurrentLine, column);
  243. break;
  244. case 'B':
  245. GetDocument().ReplaceCurrentLine(_manipulator.Export());
  246. GetDocument().CurrentLineNumber = (GetDocument().CurrentLineNumber + count);
  247. _manipulator.Load(GetDocument().CurrentLine, column);
  248. break;
  249. case 'C': {
  250. int newvalue = column + count;
  251. if(newvalue >= GetConnection().TerminalWidth) newvalue = GetConnection().TerminalWidth-1;
  252. _manipulator.ExpandBuffer(newvalue);
  253. _manipulator.CaretColumn = newvalue;
  254. }
  255. break;
  256. case 'D': {
  257. int newvalue = column - count;
  258. if(newvalue < 0) newvalue = 0;
  259. _manipulator.CaretColumn = newvalue;
  260. }
  261. break;
  262. }
  263. }
  265. //CSI H
  266. protected void ProcessCursorPosition(string param) {
  267. IntPair t = ParseIntPair(param, 1, 1);
  268. int row = t.first, col = t.second;
  269. if(_scrollRegionRelative && GetDocument().ScrollingTop!=-1) {
  270. row += GetDocument().ScrollingTop;
  271. }
  273. if(row<1) row=1;
  274. else if(row>GetConnection().TerminalHeight) row = GetConnection().TerminalHeight;
  275. if(col<1) col=1;
  276. else if(col>GetConnection().TerminalWidth) col = GetConnection().TerminalWidth;
  277. ProcessCursorPosition(row, col);
  278. }
  279. protected void ProcessCursorPosition(int row, int col) {
  280. GetDocument().ReplaceCurrentLine(_manipulator.Export());
  281. GetDocument().CurrentLineNumber = (GetDocument().TopLineNumber + row - 1);
  282. //int cc = GetDocument().CurrentLine.DisplayPosToCharPos(col-1);
  283. //Debug.Assert(cc>=0);
  284. _manipulator.Load(GetDocument().CurrentLine, col-1);
  285. }
  287. //CSI J
  288. protected void ProcessEraseInDisplay(string param) {
  289. int d = ParseInt(param, 0);
  291. TerminalDocument doc = GetDocument();
  292. int col = _manipulator.CaretColumn;
  293. switch(d) {
  294. case 0: //erase below
  295. _manipulator.RemoveAfterCaret(); 
  296. doc.ReplaceCurrentLine(_manipulator.Export());
  297. doc.RemoveAfter(doc.TopLineNumber+GetConnection().TerminalHeight);
  298. if(_currentdecoration.IsDefault)
  299. doc.ClearAfter(doc.CurrentLineNumber+1);
  300. else
  301. doc.ClearAfter(doc.CurrentLineNumber+1, _currentdecoration);
  302. _manipulator.Load(doc.CurrentLine, col);
  303. break;
  304. case 1: //erase above
  305. _manipulator.FillSpace(0, _manipulator.CaretColumn);
  306. doc.ReplaceCurrentLine(_manipulator.Export());
  307. if(_currentdecoration.IsDefault)
  308. doc.ClearRange(doc.TopLineNumber, doc.CurrentLineNumber);
  309. else
  310. doc.ClearRange(doc.TopLineNumber, doc.CurrentLineNumber, _currentdecoration);
  311. _manipulator.Load(doc.CurrentLine, col);
  312. break;
  313. case 2: //erase all
  314. doc.ReplaceCurrentLine(_manipulator.Export());
  315. if(_homePositionOnCSIJ2) { //SFU偱偼偙偆側傞
  316. ProcessCursorPosition(1,1); 
  317. col = 0;
  318. }
  319. if(_currentdecoration.IsDefault)
  320. doc.ClearAfter(doc.TopLineNumber);
  321. else
  322. doc.ClearAfter(doc.TopLineNumber, _currentdecoration);
  323. _manipulator.Load(doc.CurrentLine, col);
  324. break;
  325. default:
  326. throw new UnknownEscapeSequenceException(String.Format("unknown ED option {0}", param));
  327. }
  329. }
  331. //CSI K
  332. private void ProcessEraseInLine(string param) {
  333. int d = ParseInt(param, 0);
  335. switch(d) {
  336. case 0: //erase right
  337. if(_currentdecoration.IsDefault)
  338. _manipulator.RemoveAfterCaret();
  339. else 
  340. _manipulator.FillSpace(_manipulator.CaretColumn, _tag.Connection.TerminalWidth, _currentdecoration);
  341. break;
  342. case 1: //erase left
  343. _manipulator.FillSpace(0, _manipulator.CaretColumn);
  344. break;
  345. case 2: //erase all
  346. _manipulator.Clear(_tag.Connection.TerminalWidth);
  347. break;
  348. default:
  349. throw new UnknownEscapeSequenceException(String.Format("unknown EL option {0}", param));
  350. }
  351. }
  353. protected void SaveCursor() {
  354. _savedRow = GetDocument().CurrentLineNumber - GetDocument().TopLineNumber;
  355. _savedCol = _manipulator.CaretColumn;
  356. }
  357. protected void RestoreCursor() {
  358. GLine nl = _manipulator.Export();
  359. GetDocument().ReplaceCurrentLine(nl);
  360. GetDocument().CurrentLineNumber = GetDocument().TopLineNumber + _savedRow;
  361. _manipulator.Load(GetDocument().CurrentLine, _savedCol);
  362. }
  364. protected void Index() {
  365. GLine nl = _manipulator.Export();
  366. GetDocument().ReplaceCurrentLine(nl);
  367. int current = GetDocument().CurrentLineNumber;
  368. if(current==GetDocument().TopLineNumber+GetConnection().TerminalHeight-1 || current==GetDocument().ScrollingBottom)
  369. GetDocument().ScrollDown();
  370. else
  371. GetDocument().CurrentLineNumber = current+1;
  372. _manipulator.Load(GetDocument().CurrentLine, _manipulator.CaretColumn);
  373. }
  374. protected void ReverseIndex() {
  375. GLine nl = _manipulator.Export();
  376. GetDocument().ReplaceCurrentLine(nl);
  377. int current = GetDocument().CurrentLineNumber;
  378. if(current==GetDocument().TopLineNumber || current==GetDocument().ScrollingTop)
  379. GetDocument().ScrollUp();
  380. else
  381. GetDocument().CurrentLineNumber = current-1;
  382. _manipulator.Load(GetDocument().CurrentLine, _manipulator.CaretColumn);
  383. }
  385. protected void ProcessSetScrollingRegion(string param) {
  386. int height = _tag.Connection.TerminalHeight;
  387. IntPair v = ParseIntPair(param, 1, height);
  389. if(v.first<1) v.first = 1;
  390. else if(v.first>height) v.first = height;
  391. if(v.second<1) v.second = 1;
  392. else if(v.second>height) v.second = height;
  393. if(v.first>v.second) { //栤摎柍梡偱僄儔乕偑椙偄傛偆偵傕巚偆偑
  394. int t = v.first;
  395. v.first = v.second;
  396. v.second = t;
  397. }
  399. //巜掕偼1-origin偩偑張棟偼0-origin
  400. GetDocument().SetScrollingRegion(v.first-1, v.second-1);
  401. }
  403. protected void ProcessNextLine() {
  404. GetDocument().ReplaceCurrentLine(_manipulator.Export());
  405. GetDocument().CurrentLineNumber = (GetDocument().CurrentLineNumber + 1);
  406. _manipulator.Load(GetDocument().CurrentLine, 0);
  407. }
  409. protected override void ChangeMode(TerminalMode mode) {
  410. if(_terminalMode==mode) return;
  412. if(mode==TerminalMode.Normal) {
  413. GetDocument().ClearScrollingRegion();
  414. GetConnection().Resize(GetConnection().TerminalWidth, GetConnection().TerminalHeight); //偨偲偊偽emacs婲摦拞偵儕僒僀僘偟丄僔僃儖傊栠傞偲僔僃儖偼怴偟偄僒僀僘傪擣幆偟偰偄側偄
  415. //RMBox偱妋擣偝傟偨偙偲偩偑丄柍梡偵屻曽偵僪僉儏儊儞僩傪峀偘偰偔傞搝偑偄傞丅僇乕僜儖傪123夞屻曽傊丄側偳丅
  416. //応摉偨傝揑偩偑丄僲乕儅儖儌乕僪偵栠傞嵺偵屻傠偺嬻峴傪嶍彍偡傞偙偲偱懳墳偡傞丅
  417. GLine l = GetDocument().LastLine;
  418. while(l!=null && l.DisplayLength==0 && l.ID>GetDocument().CurrentLineNumber)
  419. l = l.PrevLine;
  421. if(l!=null) l = l.NextLine;
  422. if(l!=null) GetDocument().RemoveAfter(l.ID);
  423. }
  424. else
  425. GetDocument().SetScrollingRegion(0, _tag.Connection.TerminalHeight-1);
  427. _terminalMode = mode;
  428. }
  430. private ProcessCharResult ProcessDECSETMulti(string param, char code) {
  431. if(param.Length==0) return ProcessCharResult.Processed;
  432. bool question = param[0]=='?';
  433. string[] ps = question? param.Substring(1).Split(';') : param.Split(';');
  434. bool unsupported = false;
  435. foreach(string p in ps) {
  436. ProcessCharResult r = question? ProcessDECSET(p, code) : ProcessSetMode(p, code);
  437. if(r==ProcessCharResult.Unsupported) unsupported = true;
  438. }
  439. return unsupported? ProcessCharResult.Unsupported : ProcessCharResult.Processed;
  440. }
  442. //CSI ? Pm h, CSI ? Pm l
  443. protected virtual ProcessCharResult ProcessDECSET(string param, char code) {
  444. //Debug.WriteLine(String.Format("DECSET {0} {1}", param, code));
  445. if(param=="25") {
  446. return ProcessCharResult.Processed; //!!Show/Hide Cursor偩偑偲傝偁偊偢柍帇
  447. }
  448. else if(param=="1") {
  449. ChangeCursorKeyMode(code=='h'? TerminalMode.Application : TerminalMode.Normal);
  450. return ProcessCharResult.Processed;
  451. }
  452. else
  453. return ProcessCharResult.Unsupported;
  454. }
  455. protected virtual ProcessCharResult ProcessSetMode(string param, char code) {
  456. if(param=="4") {
  457. _insertMode = code=='h'; //h偱巒傑偭偰l偱廔傢傞
  458. return ProcessCharResult.Processed;
  459. }
  460. else if(param=="20") {
  461. return ProcessCharResult.Processed; //!!WinXP偺Telnet偱妋擣偟偨
  462. }
  463. else
  464. return ProcessCharResult.Unsupported;
  465. }
  467. //偙傟偼偝傏傝丅偪傖傫偲曐懚偟側偄偲偄偗側偄忬懺偼傎偲傫偳側偄偺偱
  468. protected virtual ProcessCharResult ProcessSaveDECSET(string param, char code) {
  469. //偙偺param偼暋悢屄僷儔儊乕僞
  470. return ProcessCharResult.Processed;
  471. }
  472. protected virtual ProcessCharResult ProcessRestoreDECSET(string param, char code) {
  473. //偙偺param偼暋悢屄僷儔儊乕僞
  474. return ProcessCharResult.Processed;
  475. }
  477. //偙傟傪憲偭偰偔傞傾僾儕働乕僔儑儞偼 vi偱忋曽僗僋儘乕儖
  478. protected void ProcessInsertLines(string param) {
  479. int d = ParseInt(param, 1);
  481. /*
  482. TerminalDocument doc = GetDocument();
  483. for(int i=0; i<d; i++)
  484. doc.InsertAfter(doc.CurrentLine, new GLine(GetConnection().TerminalWidth));
  485. */
  486. TerminalDocument doc = GetDocument();
  487. int caret_pos = _manipulator.CaretColumn;
  488. int offset = doc.CurrentLineNumber - doc.TopLineNumber;
  489. GLine nl = _manipulator.Export();
  490. doc.ReplaceCurrentLine(nl);
  491. if(doc.ScrollingBottom==-1)
  492. doc.SetScrollingRegion(0, GetConnection().TerminalHeight-1);
  494. for(int i=0; i<d; i++) {
  495. doc.ScrollUp(doc.CurrentLineNumber, doc.ScrollingBottom);
  496. doc.CurrentLineNumber = doc.TopLineNumber + offset;
  497. }
  498. _manipulator.Load(doc.CurrentLine, caret_pos);
  499. }
  501. //偙傟傪憲偭偰偔傞傾僾儕働乕僔儑儞偼 vi偱壓曽僗僋儘乕儖
  502. protected void ProcessDeleteLines(string param) {
  503. int d = ParseInt(param, 1);
  505. /*
  506. TerminalDocument doc = GetDocument();
  507. _manipulator.Clear(GetConnection().TerminalWidth);
  508. GLine target = doc.CurrentLine;
  509. for(int i=0; i<d; i++) {
  510. target.Clear();
  511. target = target.NextLine;
  512. }
  513. */
  515. TerminalDocument doc = GetDocument();
  516. int caret_col = _manipulator.CaretColumn;
  517. int offset = doc.CurrentLineNumber - doc.TopLineNumber;
  518. GLine nl = _manipulator.Export();
  519. doc.ReplaceCurrentLine(nl);
  520. if(doc.ScrollingBottom==-1)
  521. doc.SetScrollingRegion(0, GetConnection().TerminalHeight-1);
  523. for(int i=0; i<d; i++) {
  524. doc.ScrollDown(doc.CurrentLineNumber, doc.ScrollingBottom);
  525. doc.CurrentLineNumber = doc.TopLineNumber + offset;
  526. }
  527. _manipulator.Load(doc.CurrentLine, caret_col);
  528. }
  532. private static string[] FUNCTIONKEY_MAP = { 
  533. //     F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11  F12
  534.   "11", "12", "13", "14", "15", "17", "18", "19", "20", "21", "23", "24",
  535.     //     F13   F14   F15   F16   F17  F18   F19   F20   F21   F22
  536.               "25", "26", "28", "29", "31", "32", "33", "34", "23", "24" };
  537. //摿掕偺僨乕僞傪棳偡僞僀僾丅尰嵼丄僇乕僜儖僉乕偲僼傽儞僋僔儑儞僉乕偑奩摉偡傞         
  538. public override byte[] SequenceKeyData(Keys modifier, Keys body) {
  539. if((int)Keys.F1 <= (int)body && (int)body <= (int)Keys.F12) {
  540. byte[] r = new byte[5];
  541. r[0] = 0x1B;
  542. r[1] = (byte)'[';
  543. int n = (int)body - (int)Keys.F1;
  544. if((modifier & Keys.Shift) != Keys.None) n += 10; //shift偼抣傪10偢傜偡
  545. char tail;
  546. if(n>=20)
  547. tail = (modifier & Keys.Control) != Keys.None? '@' : '$';
  548. else
  549. tail = (modifier & Keys.Control) != Keys.None? '^' : '~';
  550. string f = FUNCTIONKEY_MAP[n];
  551. r[2] = (byte)f[0];
  552. r[3] = (byte)f[1];
  553. r[4] = (byte)tail;
  554. return r;
  555. }
  556. else if(GUtil.IsCursorKey(body)) {
  557. byte[] r = new byte[3];
  558. r[0] = 0x1B;
  559. if(_cursorKeyMode==TerminalMode.Normal)
  560. r[1] = (byte)'[';
  561. else
  562. r[1] = (byte)'O';
  564. switch(body) {
  565. case Keys.Up:
  566. r[2] = (byte)'A';
  567. break;
  568. case Keys.Down:
  569. r[2] = (byte)'B';
  570. break;
  571. case Keys.Right:
  572. r[2] = (byte)'C';
  573. break;
  574. case Keys.Left:
  575. r[2] = (byte)'D';
  576. break;
  577. default:
  578. throw new ArgumentException("unknown cursor key code", "key");
  579. }
  580. return r;
  581. }
  582. else {
  583. byte[] r = new byte[4];
  584. r[0] = 0x1B;
  585. r[1] = (byte)'[';
  586. r[3] = (byte)'~';
  587. if(body==Keys.Insert)
  588. r[2] = (byte)'1';
  589. else if(body==Keys.Home)
  590. r[2] = (byte)'2';
  591. else if(body==Keys.PageUp)
  592. r[2] = (byte)'3';
  593. else if(body==Keys.Delete)
  594. r[2] = (byte)'4';
  595. else if(body==Keys.End)
  596. r[2] = (byte)'5';
  597. else if(body==Keys.PageDown)
  598. r[2] = (byte)'6';
  599. else
  600. throw new ArgumentException("unknown key " + body.ToString());
  601. return r;
  602. }
  603. }
  604. }
  605. }