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

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

Telnet服务器

开发平台：

C#

XTerm.cs：源码内容
  1. /*
  2. * Copyright (c) 2005 Poderosa Project, All Rights Reserved.
  3. * $Id: XTerm.cs,v 1.2 2005/04/20 08:45:48 okajima Exp $
  4. */
  5. using System;
  6. using System.Collections;
  7. using System.IO;
  8. using System.Text;
  9. using System.Diagnostics;
  10. using System.Drawing;
  11. using System.Windows.Forms;
  13. using Poderosa.Connection;
  14. using Poderosa.Text;
  16. namespace Poderosa.Terminal
  17. {
  18. internal class XTerm : VT100Terminal
  19. {
  20. protected bool _wrapAroundMode;
  21. protected bool[] _tabStops;
  22. protected ArrayList _savedScreen; //暿偺僶僢僼傽偵埲崀偟偨偲偒偵GLine傪戅旔偟偰偍偔
  24. public XTerm(ConnectionTag tag, ICharDecoder decoder) : base(tag, decoder) {
  25. _wrapAroundMode = true;
  26. _tabStops = new bool[tag.Connection.TerminalWidth];
  27. InitTabStops();
  28. }
  30. protected override ProcessCharResult ProcessNormalChar(char ch) {
  31. //WrapAround偑false偱丄僉儍儗僢僩偑塃抂偺偲偒偼壗傕偟側偄
  32. if(!_wrapAroundMode && _manipulator.CaretColumn>=GetConnection().TerminalWidth-1)
  33. return ProcessCharResult.Processed;
  35. if(_insertMode)
  36. _manipulator.InsertBlanks(_manipulator.CaretColumn, GLine.CalcDisplayLength(ch));
  37. return base.ProcessNormalChar(ch);
  38. }
  39. protected override ProcessCharResult ProcessControlChar(char ch) {
  40. return base.ProcessControlChar(ch);
  41. /* 暥帤僐乕僪偑岆偭偰偄傞偲偙偺偁偨傝傪晄堄偵幚峴偟偰偟傑偆偙偲偑偁傝丄傛傠偟偔側偄丅
  42. switch(ch) {
  43. //扨弮側曄姺側傜懠偵傕偱偒傞偑丄僒億乕僩偟偰偄傞偺偼偄傑偺偲偙傠偙傟偟偐側偄
  44. case (char)0x8D:
  45. base.ProcessChar((char)0x1B);
  46. base.ProcessChar('M');
  47. return ProcessCharResult.Processed;
  48. case (char)0x9B:
  49. base.ProcessChar((char)0x1B);
  50. base.ProcessChar('[');
  51. return ProcessCharResult.Processed;
  52. case (char)0x9D:
  53. base.ProcessChar((char)0x1B);
  54. base.ProcessChar(']');
  55. return ProcessCharResult.Processed;
  56. default:
  57. return base.ProcessControlChar(ch);
  58. }
  59. */
  60. }
  62. protected override ProcessCharResult ProcessEscapeSequence(char code, char[] seq, int offset) {
  63. ProcessCharResult v = base.ProcessEscapeSequence(code, seq, offset);
  64. if(v!=ProcessCharResult.Unsupported) return v;
  66. switch(code) {
  67. case 'F':
  68. if(seq.Length==offset) { //僷儔儊乕僞側偟偺応崌
  69. ProcessCursorPosition(1, 1);
  70. return ProcessCharResult.Processed;
  71. }
  72. else if(seq.Length>offset && seq[offset]==' ')
  73. return ProcessCharResult.Processed; //7/8價僢僩僐儞僩儘乕儖偼忢偵椉曽傪僒億乕僩
  74. break;
  75. case 'G':
  76. if(seq.Length>offset && seq[offset]==' ')
  77. return ProcessCharResult.Processed; //7/8價僢僩僐儞僩儘乕儖偼忢偵椉曽傪僒億乕僩
  78. break;
  79. case 'L':
  80. if(seq.Length>offset && seq[offset]==' ')
  81. return ProcessCharResult.Processed; //VT100偼嵟弶偐傜OK
  82. break;
  83. case 'H':
  84. SetTabStop(_manipulator.CaretColumn, true);
  85. return ProcessCharResult.Processed;
  86. }
  88. return ProcessCharResult.Unsupported;
  89. }
  90. protected override ProcessCharResult ProcessAfterCSI(string param, char code) {
  91. ProcessCharResult v = base.ProcessAfterCSI(param, code);
  92. if(v!=ProcessCharResult.Unsupported) return v;
  94. switch(code) {
  95. case 'd':
  96. ProcessLinePositionAbsolute(param);
  97. return ProcessCharResult.Processed;
  98. case 'G':
  99. case '`': //CSI G偼幚嵺偵棃偨偙偲偑偁傞偑丄偙傟偼棃偨偙偲偑側偄丅偄偄偺偐丠
  100. ProcessLineColumnAbsolute(param);
  101. return ProcessCharResult.Processed;
  102. case 'X':
  103. ProcessEraseChars(param);
  104. return ProcessCharResult.Processed;
  105. case 'P':
  106. _manipulator.DeleteChars(_manipulator.CaretColumn, ParseInt(param,1));
  107. return ProcessCharResult.Processed;
  108. case 'p':
  109. return SoftTerminalReset(param);
  110. case '@':
  111. _manipulator.InsertBlanks(_manipulator.CaretColumn, ParseInt(param,1));
  112. return ProcessCharResult.Processed;
  113. case 'I':
  114. ProcessForwardTab(param);
  115. return ProcessCharResult.Processed;
  116. case 'Z':
  117. ProcessBackwardTab(param);
  118. return ProcessCharResult.Processed;
  119. case 'S':
  120. ProcessScrollUp(param);
  121. return ProcessCharResult.Processed;
  122. case 'T':
  123. ProcessScrollDown(param);
  124. return ProcessCharResult.Processed;
  125. case 'g':
  126. ProcessTabClear(param);
  127. return ProcessCharResult.Processed;
  128. case 't':
  129. //!!僷儔儊乕僞偵傛偭偰柍帇偟偰傛偄応崌偲丄墳摎傪曉偡傋偒応崌偑偁傞丅墳摎偺曉偟曽偑傛偔傢偐傜側偄偺偱曐棷拞
  130. return ProcessCharResult.Processed;
  131. case 'U': //偙傟偼SFU偱偟偐妋擣偱偒偰側偄
  132. base.ProcessCursorPosition(GetConnection().TerminalHeight, 1);
  133. return ProcessCharResult.Processed;
  134. case 'u': //SFU偱偺傒妋擣丅摿偵b偼懕偔暥帤傪孞傝曉偡傜偟偄偑丄堄枴偺偁傞摦嶌偵側偭偰偄傞偲偙傠傪尒偰偄側偄
  135. case 'b':
  136. return ProcessCharResult.Processed;
  137. default:
  138. return ProcessCharResult.Unsupported;
  139. }
  140. }
  142. protected override void ProcessDeviceAttributes(string param) {
  143. if(param.StartsWith(">")) {
  144. byte[] data = Encoding.ASCII.GetBytes(" [>82;1;0c");
  145. data[0] = 0x1B; //ESC
  146. GetConnection().Write(data);
  147. }
  148. else
  149. base.ProcessDeviceAttributes(param);
  150. }
  153. protected override ProcessCharResult ProcessAfterOSC(string param, char code) {
  154. ProcessCharResult v = base.ProcessAfterOSC(param, code);
  155. if(v!=ProcessCharResult.Unsupported) return v;
  157. int semicolon = param.IndexOf(';');
  158. if(semicolon==-1) return ProcessCharResult.Unsupported;
  160. string ps = param.Substring(0, semicolon);
  161. string pt = param.Substring(semicolon+1);
  162. if(ps=="0" || ps=="2") {
  163. if(pt!=_tag.WindowTitle) {
  164. _tag.WindowTitle = pt;
  165. if(GEnv.Options.AdjustsTabTitleToWindowTitle)
  166. _tag.Connection.Param.Caption = pt;
  168. GEnv.InterThreadUIService.RefreshConnection(_tag);
  169. }
  170. return ProcessCharResult.Processed;
  171. }
  172. else if(ps=="1")
  173. return ProcessCharResult.Processed; //Set Icon Name偲偄偆傗偮偩偑柍帇偱傛偝偦偆
  174. else
  175. return ProcessCharResult.Unsupported;
  177. }
  179. protected override ProcessCharResult ProcessDECSET(string param, char code) {
  180. ProcessCharResult v = base.ProcessDECSET(param, code);
  181. if(v!=ProcessCharResult.Unsupported) return v;
  183. if(param=="1047") { //Screen Buffer: 偲偔偵摿暿側偙偲偼偟側偄
  184. return ProcessCharResult.Processed;
  185. }
  186. else if(param=="1048" || param=="1049") { //Save/Restore Cursor
  187. return ProcessCharResult.Processed;
  188. }
  189. else if(param=="1000" || param=="1001" || param=="1002" || param=="1003") { //儅僂僗娭學偼柍帇
  190. return ProcessCharResult.Processed;
  191. }
  192. else if(param=="3") { //132 Column Mode
  193. return ProcessCharResult.Processed;
  194. }
  195. else if(param=="4") { //Smooth Scroll 側傫偺偙偲傗傜
  196. return ProcessCharResult.Processed;
  197. }
  198. else if(param=="6") { //Origin Mode
  199. _scrollRegionRelative = code=='h';
  200. return ProcessCharResult.Processed;
  201. }
  202. else if(param=="7") {
  203. _wrapAroundMode = code=='h';
  204. return ProcessCharResult.Processed;
  205. }
  206. else if(param=="47") {
  207. if(code=='h')
  208. SaveScreen();
  209. else
  210. RestoreScreen();
  211. return ProcessCharResult.Processed;
  212. }
  213. else
  214. return ProcessCharResult.Unsupported;
  215. }
  218. private void ProcessLinePositionAbsolute(string param) {
  219. foreach(string p in param.Split(';')) {
  220. int row = ParseInt(p,1);
  221. if(row<1) row = 1;
  222. if(row>GetConnection().TerminalHeight) row = GetConnection().TerminalHeight;
  224. int col = _manipulator.CaretColumn;
  226. //埲壓偼CSI H偲傎傏摨偠
  227. GetDocument().ReplaceCurrentLine(_manipulator.Export());
  228. GetDocument().CurrentLineNumber = (GetDocument().TopLineNumber + row - 1);
  229. _manipulator.Load(GetDocument().CurrentLine, col);
  230. }
  231. }
  232. private void ProcessLineColumnAbsolute(string param) {
  233. foreach(string p in param.Split(';')) {
  234. int n = ParseInt(p,1);
  235. if(n<1) n = 1;
  236. if(n>GetConnection().TerminalWidth) n = GetConnection().TerminalWidth;
  237. _manipulator.CaretColumn = n-1;
  238. }
  239. }
  240. private void ProcessEraseChars(string param) {
  241. int n = ParseInt(param, 1);
  242. int s = _manipulator.CaretColumn;
  243. for(int i=0; i<n; i++) {
  244. _manipulator.PutChar(' ', _currentdecoration);
  245. if(_manipulator.CaretColumn>=_manipulator.BufferSize)
  246. break;
  247. }
  248. _manipulator.CaretColumn = s;
  249. }
  250. private void ProcessScrollUp(string param) {
  251. int d = ParseInt(param, 1);
  253. TerminalDocument doc = GetDocument();
  254. int caret_col = _manipulator.CaretColumn;
  255. int offset = doc.CurrentLineNumber - doc.TopLineNumber;
  256. GLine nl = _manipulator.Export();
  257. doc.ReplaceCurrentLine(nl);
  258. if(doc.ScrollingBottom==-1)
  259. doc.SetScrollingRegion(0, GetConnection().TerminalHeight-1);
  260. for(int i=0; i<d; i++) {
  261. doc.ScrollUp(doc.CurrentLineNumber, doc.ScrollingBottom);
  262. doc.CurrentLineNumber = doc.TopLineNumber + offset;
  263. }
  264. _manipulator.Load(doc.CurrentLine, caret_col);
  265. }
  266. private void ProcessScrollDown(string param) {
  267. int d = ParseInt(param, 1);
  269. TerminalDocument doc = GetDocument();
  270. int caret_col = _manipulator.CaretColumn;
  271. int offset = doc.CurrentLineNumber - doc.TopLineNumber;
  272. GLine nl = _manipulator.Export();
  273. doc.ReplaceCurrentLine(nl);
  274. if(doc.ScrollingBottom==-1)
  275. doc.SetScrollingRegion(0, GetConnection().TerminalHeight-1);
  276. for(int i=0; i<d; i++) {
  277. doc.ScrollDown(doc.CurrentLineNumber, doc.ScrollingBottom);
  278. doc.CurrentLineNumber = doc.TopLineNumber + offset;
  279. }
  280. _manipulator.Load(doc.CurrentLine, caret_col);
  281. }
  282. private void ProcessForwardTab(string param) {
  283. int n = ParseInt(param, 1);
  285. int t = _manipulator.CaretColumn;
  286. for(int i=0; i<n; i++)
  287. t = GetNextTabStop(t);
  288. if(t >= GetConnection().TerminalWidth) t = GetConnection().TerminalWidth-1;
  289. _manipulator.CaretColumn = t;
  290. }
  291. private void ProcessBackwardTab(string param) {
  292. int n = ParseInt(param, 1);
  294. int t = _manipulator.CaretColumn;
  295. for(int i=0; i<n; i++)
  296. t = GetPrevTabStop(t);
  297. if(t < 0) t = 0;
  298. _manipulator.CaretColumn = t;
  299. }
  300. private void ProcessTabClear(string param) {
  301. if(param=="0")
  302. SetTabStop(_manipulator.CaretColumn, false);
  303. else if(param=="3")
  304. ClearAllTabStop();
  305. }
  307. private void InitTabStops() {
  308. for(int i=0; i<_tabStops.Length; i++) {
  309. _tabStops[i] = (i % 8)==0;
  310. }
  311. }
  312. private void EnsureTabStops(int length) {
  313. if(length>=_tabStops.Length) {
  314. bool[] newarray = new bool[Math.Max(length, _tabStops.Length*2)];
  315. Array.Copy(_tabStops, 0, newarray, 0, _tabStops.Length);
  316. for(int i=_tabStops.Length; i<newarray.Length; i++) {
  317. newarray[i] = (i % 8)==0;
  318. }
  319. _tabStops = newarray;
  320. }
  321. }
  322. private void SetTabStop(int index, bool value) {
  323. EnsureTabStops(index+1);
  324. _tabStops[index] = value;
  325. }
  326. private void ClearAllTabStop() {
  327. for(int i=0; i<_tabStops.Length; i++) {
  328. _tabStops[i] = false;
  329. }
  330. }
  331. protected override int GetNextTabStop(int start) {
  332. EnsureTabStops(Math.Max(start+1, _tag.Connection.TerminalWidth));
  334. int index = start+1;
  335. while(index<_tag.Connection.TerminalWidth) {
  336. if(_tabStops[index]) return index;
  337. index++;
  338. }
  339. return _tag.Connection.TerminalWidth-1;
  340. }
  341. //偙傟偼vt100偵偼側偄偺偱override偟側偄
  342. protected int GetPrevTabStop(int start) {
  343. EnsureTabStops(start+1);
  345. int index = start-1;
  346. while(index>0) {
  347. if(_tabStops[index]) return index;
  348. index--;
  349. }
  350. return 0;
  351. }
  353. protected void SaveScreen() {
  354. _savedScreen = new ArrayList();
  355. GLine l = GetDocument().TopLine;
  356. int m = l.ID + GetConnection().TerminalHeight;
  357. while(l!=null && l.ID<m) {
  358. _savedScreen.Add(l.Clone());
  359. l = l.NextLine;
  360. }
  361. }
  362. protected void RestoreScreen() {
  363. if(_savedScreen==null) return;
  364. TerminalDocument doc = GetDocument();
  365. int w = GetConnection().TerminalWidth;
  366. int m = GetConnection().TerminalHeight;
  367. GLine t = doc.TopLine;
  368. foreach(GLine l in _savedScreen) {
  369. l.ExpandBuffer(w);
  370. if(t==null)
  371. doc.AddLine(l);
  372. else {
  373. doc.Replace(t, l);
  374. t = l.NextLine;
  375. }
  376. if(--m == 0) break;
  377. }
  379. _savedScreen = null;
  380. }
  381. private ProcessCharResult SoftTerminalReset(string param){
  382. if(param=="!") {
  383. FullReset();
  384. return ProcessCharResult.Processed;
  385. }
  386. else
  387. return ProcessCharResult.Unsupported;
  388. }
  390. public override byte[] SequenceKeyData(Keys modifier, Keys key) {
  391. if((int)Keys.F1 <= (int)key && (int)key <= (int)Keys.F12)
  392. return base.SequenceKeyData(modifier, key);
  393. else if(GUtil.IsCursorKey(key))
  394. return base.SequenceKeyData(modifier, key);
  395. else {
  396. byte[] r = new byte[4];
  397. r[0] = 0x1B;
  398. r[1] = (byte)'[';
  399. r[3] = (byte)'~';
  400. //偙偺偁偨傝偼xterm偱偼妱偲堘偆傛偆偩
  401. if(key==Keys.Insert)
  402. r[2] = (byte)'2';
  403. else if(key==Keys.Home)
  404. r[2] = (byte)'7';
  405. else if(key==Keys.PageUp)
  406. r[2] = (byte)'5';
  407. else if(key==Keys.Delete)
  408. r[2] = (byte)'3';
  409. else if(key==Keys.End)
  410. r[2] = (byte)'8';
  411. else if(key==Keys.PageDown)
  412. r[2] = (byte)'6';
  413. else
  414. throw new ArgumentException("unknown key " + key.ToString());
  415. return r;
  416. }
  417. }
  419. public override void FullReset() {
  420. InitTabStops();
  421. base.FullReset();
  422. }
  423. }
  424. }