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

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

Telnet服务器

开发平台：

C#

TerminalDocument.cs：源码内容
  1. /*
  2. * Copyright (c) 2005 Poderosa Project, All Rights Reserved.
  3. * $Id: TerminalDocument.cs,v 1.2 2005/04/20 08:45:47 okajima Exp $
  4. */
  5. using System;
  6. using System.Collections;
  7. using System.Drawing;
  8. using System.Diagnostics;
  9. using Poderosa;
  10. using Poderosa.Text;
  12. using Poderosa.Communication;
  14. namespace Poderosa.Text
  15. {
  16. /// <summary>
  17. /// 僞乕儈僫儖偲偟偰摦偐偟偰偄傞偲偒偺
  18. /// </summary>
  19. public class TerminalDocument {
  20. private TerminalConnection _connection; //!!偙傟偼暆偲崅偝庢摼偺偨傔偵偺傒昁梫側僷儔儊僞側偺偱TerminalConnection偼傗傝偡偓
  22. private int _caretColumn;
  24. private int _scrollingTop;
  25. private int _scrollingBottom;
  27. //昤夋偺昁梫偺偁傞ID偺斖埻
  28. private int _invalidatedFrom;
  29. private int _invalidatedTo;
  30. private bool _invalidatedAll; //偙傟偑棫偭偰偄傞偲偒偼柍忦審偱慡昤夋丂惓偟偄Invalidate斖埻偺寁嶼偑柺搢側偲偒偼偙傟
  32. private GLine _firstLine;
  33. private GLine _lastLine;
  34. private GLine _currentLine;
  35. private GLine _topLine;
  36. private int _size; //僒僀僘偼_firstLine/lastLine偐傜寁嶼壜擻偩偑傛偔巊偆偺偱僉儍僢僔儏
  38. internal TerminalDocument(TerminalConnection con) {
  39. _connection = con;
  40. Clear();
  41. _scrollingTop = -1;
  42. _scrollingBottom = -1;
  43. }
  45. public int InvalidatedFrom {
  46. get {
  47. return _invalidatedFrom;
  48. }
  49. }
  50. public int InvalidatedTo {
  51. get {
  52. return _invalidatedTo;
  53. }
  54. }
  55. public bool InvalidatedAll {
  56. get {
  57. return _invalidatedAll;
  58. }
  59. }
  60. public void ResetInvalidatedRegion() {
  61. _invalidatedAll = false;
  62. _invalidatedFrom = -1;
  63. _invalidatedTo = -1;
  64. }
  65. public void InvalidateLine(int id) {
  66. if(_invalidatedFrom==-1 || _invalidatedFrom > id) _invalidatedFrom = id;
  67. if(_invalidatedTo==-1   || _invalidatedTo   < id) _invalidatedTo   = id;
  68. }
  69. public void InvalidateAll() {
  70. _invalidatedAll = true;
  71. }
  73. internal void Clear() {
  74. _caretColumn = 0;
  75. _firstLine = null;
  76. _lastLine = null;
  77. _size = 0;
  78. AddLine(new GLine(_connection.TerminalWidth));
  79. }
  81. public int Size {
  82. get {
  83. return _size;
  84. }
  85. }
  87. //枛旜偵捛壛偡傞
  88. internal void AddLine(GLine line) {
  89. if(_firstLine==null) { //嬻偩偭偨
  90. _firstLine = line;
  91. _lastLine = line;
  92. _currentLine = line;
  93. _topLine = line;
  94. _size = 1;
  95. line.ID = 0;
  96. InvalidateLine(0);
  97. }
  98. else { //捠忢偺捛壛
  99. Debug.Assert(_lastLine.NextLine==null);
  100. int lastID = _lastLine.ID;
  101. _lastLine.NextLine = line;
  102. line.PrevLine = _lastLine;
  103. _lastLine = line;
  104. line.ID = lastID+1;
  105. _size++;
  106. InvalidateLine(lastID+1);
  107. }
  109. }
  111. //惍悢僀儞僨僋僗偐傜尒偮偗傞丂CurrentLine偐傜偦偆墦偔側偄埵抲偩傠偆偲偁偨傝傪偮偗傞
  112. public GLine FindLine(int index) {
  113. //current偲top偺嬤偄曽偐傜弴偵傒偰偄偔
  114. int d1 = Math.Abs(index - _currentLine.ID);
  115. int d2 = Math.Abs(index - _topLine.ID);
  116. if(d1<d2)
  117. return FindLineByHint(index, _currentLine);
  118. else
  119. return FindLineByHint(index, _topLine);
  120. }
  122. public GLine FindLineOrNull(int index) {
  123. if(index < _firstLine.ID || index > _lastLine.ID) return null;
  124. else return FindLine(index);
  125. }
  126. public GLine FindLineOrEdge(int index) {
  127. if(index < _firstLine.ID) index = _firstLine.ID;
  128. else if(index > _lastLine.ID)  index = _lastLine.ID;
  130. return FindLine(index);
  131. }
  133. private GLine FindLineByHint(int index, GLine hintLine) {
  134. int h = hintLine.ID;
  135. GLine l = hintLine;
  136. if(index >= h) {
  137. for(int i=h; i<index; i++) {
  138. l = l.NextLine;
  139. if(l==null) FindLineByHintFailed(index, hintLine);
  140. }
  141. }
  142. else {
  143. for(int i=h; i>index; i--) {
  144. l = l.PrevLine;
  145. if(l==null) FindLineByHintFailed(index, hintLine);
  146. }
  147. }
  148. return l;
  149. }
  151. //FindLineByHint偼偟偽偟偽幐攕偡傞偺偱僨僶僢僌梡偵尰嵼忬懺傪僟儞僾
  152. private void FindLineByHintFailed(int index, GLine hintLine) {
  154. #if DEBUG
  155. Dump(String.Format("FindLine {0}, hint_id={1}", index, hintLine.ID));
  156. Debugger.Break();
  157. #endif
  158. GEnv.InterThreadUIService.InvalidDocumentOperation(this, GEnv.Strings.GetString("Message.TerminalDocument.UnexpectedCode"));
  159. }
  161. internal void SetScrollingRegion(int top_offset, int bottom_offset) {
  162. _scrollingTop = TopLineNumber+top_offset;
  163. _scrollingBottom = TopLineNumber+bottom_offset;
  164. //GLine l = FindLine(_scrollingTop);
  165. }
  166. internal void ClearScrollingRegion() {
  167. _scrollingTop = -1;
  168. _scrollingBottom = -1;
  169. }
  170. public void EnsureLine(int id) {
  171. while(id > _lastLine.ID) {
  172. AddLine(new GLine(_connection.TerminalWidth));
  173. }
  174. }
  176. public int CurrentLineNumber {
  177. get {
  178. return _currentLine.ID;
  179. }
  180. set {
  181. if(value < _firstLine.ID) value = _firstLine.ID; //儕僒僀僘帪偺旝柇側僞僀儈儞僌偱晧偵側偭偰偟傑偆偙偲偑偁偭偨傛偆偩
  182. if(value > _lastLine.ID+100) value = _lastLine.ID+100; //嬌抂偵戝偒側抣傪怘傜偭偰巰偸偙偲偑側偄傛偆偵偡傞
  184. while(value > _lastLine.ID) {
  185. AddLine(new GLine(_connection.TerminalWidth));
  186. }
  188. _currentLine = FindLineOrEdge(value); //奜晹偐傜曄側抣偑搉偝傟偨傝丄偁傞偄偼偳偙偐偵僶僌偑偁傞偣偄偱偙偺拞偱僋儔僢僔儏偡傞偙偲偑傑傟偵偁傞傛偆偩丅側偺偱OrEdge僶乕僕儑儞偵偟偰僋儔僢僔儏偼夞旔
  189. AssertValid();
  190. }
  191. }
  192. public int TopLineNumber {
  193. get {
  194. return _topLine.ID;
  195. }
  196. set {
  197. if(_topLine.ID!=value) _invalidatedAll = true;
  198. _topLine = FindLineOrEdge(value); //摨忋偺棟桼偱OrEdge僶乕僕儑儞偵曄峏
  199. AssertValid();
  200. }
  201. }
  202. public int FirstLineNumber {
  203. get {
  204. return _firstLine.ID;
  205. }
  206. }
  207. public int LastLineNumber {
  208. get {
  209. return _lastLine.ID;
  210. }
  211. }
  212. public int CaretColumn {
  213. get {
  214. return _caretColumn;
  215. }
  216. set {
  217. _caretColumn = value;
  218. }
  219. }
  221. public GLine CurrentLine {
  222. get {
  223. return _currentLine;
  224. }
  225. }
  226. public GLine TopLine {
  227. get {
  228. return _topLine;
  229. }
  230. }
  231. public GLine FirstLine {
  232. get {
  233. return _firstLine;
  234. }
  235. }
  236. public GLine LastLine {
  237. get {
  238. return _lastLine;
  239. }
  240. }
  241. public bool CurrentIsLast {
  242. get {
  243. return _currentLine.NextLine==null;
  244. }
  245. }
  247. public int ScrollingTop {
  248. get {
  249. return _scrollingTop;
  250. }
  251. }
  252. public int ScrollingBottom {
  253. get {
  254. return _scrollingBottom;
  255. }
  256. }
  258. internal void LineFeed() {
  259. if(_scrollingTop!=-1 && _currentLine.ID >= _scrollingBottom) { //儘僢僋偝傟偰偄偰壓傑偱峴偭偰偄傞
  260. ScrollDown(); 
  261. }
  262. else {
  263. if(_connection.TerminalHeight>1) { //嬌抂偵崅偝偑側偄偲偒偼偙傟偱曄側抣偵側偭偰偟傑偆偺偱僗僉僢僾
  264. if(_currentLine.ID >= _topLine.ID + _connection.TerminalHeight - 1)
  265. this.TopLineNumber = _currentLine.ID - _connection.TerminalHeight + 2; //偙傟偱師偺CurrentLineNumber++偲崌傢偣偰峴憲傝偵側傞
  266. }
  267. this.CurrentLineNumber++; //偙傟偱僾儘僷僥傿僙僢僩偑側偝傟丄昁梫側傜峴偺捛壛傕偝傟傞丅
  268. }
  269. AssertValid();
  271. //Debug.WriteLine(String.Format("c={0} t={1} f={2} l={3}", _currentLine.ID, _topLine.ID, _firstLine.ID, _lastLine.ID));
  272. }
  274. //僗僋儘乕儖斖埻偺嵟傕壓傪侾峴徚偟丄嵟傕忋偵侾峴捛壛丅尰嵼峴偼偦偺怴婯峴偵側傞丅
  275. internal void ScrollUp() {
  276. if(_scrollingTop!=-1 && _scrollingBottom!=-1)
  277. ScrollUp(_scrollingTop, _scrollingBottom);
  278. else
  279. ScrollUp(TopLineNumber, TopLineNumber + _connection.TerminalHeight - 1);
  280. }
  282. internal void ScrollUp(int from, int to) {
  283. GLine top = FindLineOrEdge(from);
  284. GLine bottom = FindLineOrEdge(to);
  285. if(top==null || bottom==null) return; //僄儔乕僴儞僪儕儞僌偼FindLine偺拞偱丅偙偙偱偼僋儔僢僔儏夞旔偩偗傪峴偆
  286. int bottom_id = bottom.ID;
  287. int topline_id = _topLine.ID;
  288. GLine nextbottom = bottom.NextLine;
  290. if(from==to) {
  291. _currentLine = top;
  292. _currentLine.Clear();
  293. }
  294. else {
  295. Remove(bottom);
  296. _currentLine = new GLine(_connection.TerminalWidth);
  298. InsertBefore(top, _currentLine);
  299. GLine c = _currentLine;
  300. do {
  301. c.ID = from++;
  302. c = c.NextLine;
  303. } while(c!=nextbottom);
  304. Debug.Assert(nextbottom==null || nextbottom.ID==from);
  305. }
  306. /*
  307. //id maintainance
  308. GLine c = newbottom;
  309. GLine end = _currentLine.PrevLine;
  310. while(c != end) {
  311. c.ID = bottom_id--;
  312. c = c.PrevLine;
  313. }
  314. */
  316. //!!師偺俀峴偼xterm傪傗偭偰偄傞娫偵敪尒偟偰廋惓丅 VT100偱偼壗偐偺昁梫偑偁偭偰偙偆側偭偨偼偢側偺偱屻偱挷傋傞偙偲
  317. //if(_scrollingTop<=_topLine.ID && _topLine.ID<=_scrollingBottom)
  318. // _topLine = _currentLine;
  319. while(topline_id<_topLine.ID)
  320. _topLine = _topLine.PrevLine;
  322. AssertValid();
  324. _invalidatedAll = true;
  325. }
  327. //僗僋儘乕儖斖埻偺嵟傕忋傪侾峴徚偟丄嵟傕壓偵侾峴捛壛丅尰嵼峴偼偦偺怴婯峴偵側傞丅
  328. internal void ScrollDown() {
  329. if(_scrollingTop!=-1 && _scrollingBottom!=-1)
  330. ScrollDown(_scrollingTop, _scrollingBottom);
  331. else
  332. ScrollDown(TopLineNumber, TopLineNumber + _connection.TerminalHeight - 1);
  333. }
  335. internal void ScrollDown(int from, int to) {
  336. GLine top = FindLineOrEdge(from);
  337. GLine bottom = FindLineOrEdge(to);
  338. int top_id = top.ID;
  339. GLine newtop = top.NextLine;
  341. if(from==to) {
  342. _currentLine = top;
  343. _currentLine.Clear();
  344. }
  345. else {
  346. Remove(top); //_topLine偺挷惍偼昁梫側傜偙偙偱峴傢傟傞
  347. _currentLine = new GLine(_connection.TerminalWidth);
  348. InsertAfter(bottom, _currentLine);
  350. //id maintainance
  351. GLine c = newtop;
  352. GLine end = _currentLine.NextLine;
  353. while(c != end) {
  354. c.ID = top_id++;
  355. c = c.NextLine;
  356. }
  357. }
  358. AssertValid();
  360. _invalidatedAll = true;
  361. }
  363. internal void Replace(GLine target, GLine newline) {
  364. newline.NextLine = target.NextLine;
  365. newline.PrevLine = target.PrevLine;
  366. if(target.NextLine!=null) target.NextLine.PrevLine = newline;
  367. if(target.PrevLine!=null) target.PrevLine.NextLine = newline;
  369. if(target==_firstLine) _firstLine = newline;
  370. if(target==_lastLine)  _lastLine = newline;
  371. if(target==_topLine)  _topLine  = newline;
  372. if(target==_currentLine) _currentLine = newline;
  374. newline.ID = target.ID;
  375. InvalidateLine(newline.ID);
  376. AssertValid();
  377. }
  378. internal void ReplaceCurrentLine(GLine line) {
  379. #if DEBUG
  380. Replace(_currentLine, line);
  381. AssertValid();
  382. #else
  383. if(_currentLine!=null) //僋儔僢僔儏儗億乕僩傪傒傞偲丄壗偐偺攺巕偵null偵側偭偰偄偨偲偟偐巚偊側偄
  384. Replace(_currentLine, line);
  385. #endif
  386. }
  390. internal void Remove(GLine line) {
  391. if(_size<=1) {
  392. Clear();
  393. return;
  394. }
  396. if(line.PrevLine!=null) {
  397. line.PrevLine.NextLine = line.NextLine;
  398. }
  399. if(line.NextLine!=null) {
  400. line.NextLine.PrevLine = line.PrevLine;
  401. }
  403. if(line==_firstLine) _firstLine = line.NextLine;
  404. if(line==_lastLine)  _lastLine = line.PrevLine;
  405. if(line==_topLine) {
  406. _topLine = line.NextLine;
  407. }
  408. if(line==_currentLine) {
  409. _currentLine = line.NextLine;
  410. if(_currentLine==null) _currentLine = _lastLine;
  411. }
  413. _size--;
  414. _invalidatedAll = true;
  415. }
  417. private void InsertBefore(GLine pos, GLine line) {
  418. if(pos.PrevLine!=null)
  419. pos.PrevLine.NextLine = line;
  421. line.PrevLine = pos.PrevLine;
  422. line.NextLine = pos;
  424. pos.PrevLine = line;
  426. if(pos==_firstLine)  _firstLine = line;
  427. _size++;
  428. _invalidatedAll = true;
  429. }
  430. private void InsertAfter(GLine pos, GLine line) {
  431. if(pos.NextLine!=null)
  432. pos.NextLine.PrevLine = line;
  434. line.NextLine = pos.NextLine;
  435. line.PrevLine = pos;
  437. pos.NextLine = line;
  439. if(pos==_lastLine)  _lastLine = line;
  440. _size++;
  441. _invalidatedAll = true;
  442. }
  444. internal void RemoveAfter(int from) {
  445. if(from > _lastLine.ID) return;
  446. GLine delete = FindLineOrEdge(from);
  447. if(delete==null) return;
  449. GLine remain = delete.PrevLine;
  450. delete.PrevLine = null;
  451. if(remain==null) {
  452. Clear();
  453. }
  454. else {
  455. remain.NextLine = null;
  456. _lastLine = remain;
  458. while(delete!=null) {
  459. _size--;
  460. if(delete==_topLine) _topLine = remain;
  461. if(delete==_currentLine) _currentLine = remain;
  462. delete = delete.NextLine;
  463. }
  464. }
  466. AssertValid();
  467. _invalidatedAll = true;
  468. }
  470. internal void ClearAfter(int from) {
  471. if(from > _lastLine.ID) return;
  472. GLine l = FindLineOrEdge(from);
  473. if(l==null) return;
  475. while(l!=null) {
  476. l.Clear();
  477. l = l.NextLine;
  478. }
  480. AssertValid();
  481. _invalidatedAll = true;
  482. }
  483. internal void ClearAfter(int from, TextDecoration dec) {
  484. if(from > _lastLine.ID) return;
  485. GLine l = FindLineOrEdge(from);
  486. if(l==null) return;
  488. while(l!=null) {
  489. l.Clear(dec);
  490. l = l.NextLine;
  491. }
  493. AssertValid();
  494. _invalidatedAll = true;
  495. }
  497. internal void ClearRange(int from, int to) {
  498. GLine l = FindLineOrEdge(from);
  499. if(l==null) return;
  501. while(l.ID < to) {
  502. l.Clear();
  503. InvalidateLine(l.ID);
  504. l = l.NextLine;
  505. }
  506. AssertValid();
  507. }
  508. internal void ClearRange(int from, int to, TextDecoration dec) {
  509. GLine l = FindLineOrEdge(from);
  510. if(l==null) return;
  512. while(l.ID < to) {
  513. l.Clear(dec);
  514. InvalidateLine(l.ID);
  515. l = l.NextLine;
  516. }
  517. AssertValid();
  518. }
  520. /// <summary>
  521. /// 嵟屻偺remain峴埲慜傪嶍彍偡傞
  522. /// </summary>
  523. internal int DiscardOldLines(int remain) {
  524. int delete_count = _size - remain;
  525. if(delete_count <= 0) return 0;
  527. GLine newfirst = _firstLine;
  528. for(int i=0; i<delete_count; i++)
  529. newfirst = newfirst.NextLine;
  531. //怴偟偄愭摢傪寛傔傞
  532. _firstLine = newfirst;
  533. newfirst.PrevLine.NextLine = null;
  534. newfirst.PrevLine = null;
  535. _size -= delete_count;
  536. Debug.Assert(_size==remain);
  538. AssertValid();
  540. if(_topLine.ID<_firstLine.ID) _topLine=_firstLine;
  541. if(_currentLine.ID<_firstLine.ID) {
  542. _currentLine = _firstLine;
  543. _caretColumn = 0;
  544. }
  546. return delete_count;
  547. }
  549. //嵞愙懕梡偵尰嵼僪僉儏儊儞僩偺慜偵憓擖
  550. public void InsertBefore(TerminalDocument olddoc, int paneheight) {
  551. lock(this) {
  552. GLine c = olddoc.LastLine;
  553. int offset = _currentLine.ID - _topLine.ID;
  554. bool flag = false;
  555. while(c!=null) {
  556. if(flag || c.Text[0]!='') {
  557. flag = true;
  558. GLine nl = c.Clone();
  559. nl.ID = _firstLine.ID-1;
  560. InsertBefore(_firstLine, nl); //嵟弶偵嬻偱側偄峴偑偁傟偽埲崀偼慡晹憓擖
  561. offset++;
  562. }
  563. c = c.PrevLine;
  564. }
  566. //ID偑晧偵側傞偺偼偪傚偭偲晐偄偺偱廋惓
  567. if(_firstLine.ID<0) {
  568. int t = -_firstLine.ID;
  569. c = _firstLine;
  570. while(c!=null) {
  571. c.ID += t;
  572. c = c.NextLine;
  573. }
  574. }
  576. _topLine = FindLineOrEdge(_currentLine.ID - Math.Min(offset, paneheight));
  577. //Dump("insert doc");
  578. }
  579. }
  582. public void Dump(string title) {
  583. Debug.WriteLine("<<<< DEBUG DUMP ["+title+"] >>>>");
  584. Debug.WriteLine(String.Format("[size={0} top={1} current={2} caret={3} first={4} last={5} region={6},{7}]", _size, TopLineNumber, CurrentLineNumber, _caretColumn, FirstLineNumber, LastLineNumber, _scrollingTop, _scrollingBottom));
  585. GLine gl = FindLineOrEdge(TopLineNumber);
  586. int count = 0;
  587. while(gl!=null && count++ < _connection.TerminalHeight) {
  588. Debug.Write(String.Format("{0,3}",gl.ID));
  589. Debug.Write(":");
  590. Debug.Write(GLineManipulator.SafeString(gl.Text));
  591. Debug.Write(":");
  592. Debug.WriteLine(gl.EOLType);
  593. gl = gl.NextLine;
  594. }
  595. }
  597. public virtual void AssertValid() {
  598. #if false
  599. Debug.Assert(_currentLine.ID>=0);
  600. Debug.Assert(_currentLine.ID>=_topLine.ID);
  601. GLine l = _topLine;
  602. GLine n = l.NextLine;
  603. while(n!=null) {
  604. Debug.Assert(l.ID+1==n.ID);
  605. Debug.Assert(l==n.PrevLine);
  606. l = n;
  607. n = n.NextLine;
  608. }
  609. #endif
  610. }
  612. }
  614. }