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

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

Telnet服务器

开发平台：

C#

GLine.cs：源码内容
  1. /*
  2. * Copyright (c) 2005 Poderosa Project, All Rights Reserved.
  3. * $Id: GLine.cs,v 1.3 2005/04/27 08:48:50 okajima Exp $
  4. */
  5. using System;
  6. using System.Collections;
  7. using System.Drawing;
  8. using System.Diagnostics;
  9. using System.Text;
  10. using Poderosa.Forms;
  12. using Poderosa.Terminal;
  13. using Poderosa.UI;
  15. namespace Poderosa.Text
  16. {
  17. internal class RenderParameter {
  18. private int _linefrom;
  19. private int _linecount;
  20. private Rectangle _targetRect;
  22. public int LineFrom { 
  23. get {
  24. return _linefrom;
  25. }
  26. set {
  27. _linefrom=value;
  28. }
  29. }
  31. public int LineCount { 
  32. get {
  33. return _linecount;
  34. }
  35. set {
  36. _linecount=value;
  37. }
  38. }
  39. public Rectangle TargetRect { 
  40. get {
  41. return _targetRect;
  42. }
  43. set {
  44. _targetRect=value;
  45. }
  46. }
  47. }
  49. /// <summary>
  50. /// 峴枛偺庬椶
  51. /// </summary>
  52. public enum EOLType {
  53. Continue,
  54. CRLF,
  55. CR,
  56. LF
  57. }
  59. public enum CharGroup {
  60. SingleByte, //unicode偱0x100枹枮偺暥帤
  61. TwoBytes    //0x100埲忋偺暥帤
  62. }
  64. /// <summary>
  65. /// GLine偺峔惉梫慺丅GWord偼TextDecoration側偳傪嫟桳偡傞丅
  66. /// </summary>
  67. public class GWord
  68. {
  69. private TextDecoration _decoration;
  70. private int _offset;
  71. private CharGroup _charGroup;
  72. private GWord _next;
  74. //偟偽偟偽嶲徠偡傞偺偱僉儍僢僔儏偡傞抣
  75. internal int nextOffsetCache;
  76. internal int displayLengthCache;
  78. /// <summary>
  79. /// 昞帵梡偺憰忺
  80. /// </summary>
  81. internal TextDecoration Decoration {
  82. get {
  83. return _decoration;
  84. }
  85. }
  86. /// <summary>
  87. /// 強懏偡傞GLine偺拞偱壗暥帤栚偐傜巒傑偭偰偄傞偐
  88. /// </summary>
  89. public int Offset {
  90. get {
  91. return _offset;
  92. }
  93. }
  95. ///師偺Word
  96. public GWord Next {
  97. get {
  98. return _next;
  99. }
  100. set {
  101. _next = value;
  102. }
  103. }
  105. public CharGroup CharGroup {
  106. get {
  107. return _charGroup;
  108. }
  109. set {
  110. _charGroup = value;
  111. }
  112. }
  114. /// <summary>
  115. /// 暥帤楍丄僨僐儗乕僔儑儞丄僆僼僙僢僩傪巜掕偡傞僐儞僗僩儔僋僞丅Type偼Normal偵側傞丅
  116. /// </summary>
  117. internal GWord(TextDecoration d, int o, CharGroup chargroup) {
  118. Debug.Assert(d!=null);
  119. _offset = o;
  120. _decoration = d;
  121. _next = null;
  122. _charGroup = chargroup;
  123. nextOffsetCache = -1;
  124. displayLengthCache = -1;
  125. }
  127. //Next偺抣埲奜傪僐僺乕偡傞
  128. public GWord StandAloneClone() {
  129. return new GWord(_decoration, _offset, _charGroup);
  130. }
  132. public GWord DeepClone() {
  133. GWord w = new GWord(_decoration, _offset, _charGroup);
  134. if(_next!=null)
  135. w._next = _next.DeepClone();
  136. return w;
  137. }
  139. }
  142. /// <summary>
  143. /// 侾峴偺僨乕僞
  144. /// GWord傊偺暘夝偼抶墑昡壙偝傟傞丅
  145. /// </summary>
  146. public class GLine {
  147. static GLine() {
  148. InitLengthMap();
  149. }
  151. public const char WIDECHAR_PAD = 'uFFFF';
  153. private char[] _text;
  154. private EOLType _eolType;
  155. private int _id;
  157. private GWord _firstWord;
  159. private GLine _nextLine;
  160. private GLine _prevLine;
  162. public GLine(int length) {
  163. Debug.Assert(length>0);
  164. _text = new char[length];
  165. _firstWord = new GWord(TextDecoration.ClonedDefault(), 0, CharGroup.SingleByte);
  166. _id = -1;
  167. }
  168. public GLine(char[] data, GWord firstWord) {
  169. _text = (char[])data.Clone();
  170. _firstWord = firstWord;
  171. _id = -1;
  172. }
  173. public GLine Clone() {
  174. GLine nl = new GLine(_text, _firstWord.DeepClone());
  175. nl._eolType = _eolType;
  176. nl._id = _id;
  177. return nl;
  178. }
  181. public void Clear() {
  182. for(int i=0; i<_text.Length; i++)
  183. _text[i] = '';
  184. _firstWord = new GWord(TextDecoration.ClonedDefault(), 0, CharGroup.SingleByte);
  185. }
  186. internal void Clear(TextDecoration dec) {
  187. for(int i=0; i<_text.Length; i++)
  188. _text[i] = ' ';
  189. _firstWord = new GWord(dec, 0, CharGroup.SingleByte);
  190. }
  191. public int Length {
  192. get {
  193. return _text.Length;
  194. }
  195. }
  197. /// <summary>
  198. /// 僀儞僨僋僗傪巜掕偟偰GWord傪曉偡丅儗儞僟儕儞僌嵪傒偐偳偆偐偼峫椂偟偰偄側偄丅
  199. /// </summary>
  200. public GWord FirstWord { 
  201. get {
  202. return _firstWord;
  203. }
  204. }
  205. public char[] Text {
  206. get {
  207. return _text;
  208. }
  209. }
  211. public int DisplayLength {
  212. get {
  213. int i = 0;
  214. int m = _text.Length;
  215. for(i=0; i<m; i++) {
  216. if(_text[i]=='') break;
  217. }
  218. return i;
  219. }
  220. }
  221. public int CharLength {
  222. get {
  223. int n = _text.Length-1;
  224. while(n>=0 && _text[n]=='') n--;
  225. return n+1;
  226. }
  227. }
  229. //慜屻偺扨岅嬫愗傝傪尒偮偗傞丅曉偡埵抲偼丄pos偲GetWordBreakGroup偺抣偑堦抳偡傞拞偱墦偄抧揰
  230. public int FindPrevWordBreak(int pos) {
  231. int v = ToCharGroupForWordBreak(_text[pos]);
  232. while(pos>=0) {
  233. if(v!=ToCharGroupForWordBreak(_text[pos])) return pos;
  234. pos--;
  235. }
  236. return -1;
  237. }
  238. public int FindNextWordBreak(int pos) {
  239. int v = ToCharGroupForWordBreak(_text[pos]);
  240. while(pos<_text.Length) {
  241. if(v!=ToCharGroupForWordBreak(_text[pos])) return pos;
  242. pos++;
  243. }
  244. return _text.Length;
  245. }
  246. private static int ToCharGroupForWordBreak(char ch) {
  247. if(('0'<=ch && ch<='9') || ('a'<=ch && ch<='z') || ('A'<=ch && ch<='Z') || ch=='_' || GEnv.Options.AdditionalWordElement.IndexOf(ch)!=-1)
  248. return 1;
  249. else if(ch<=0x20 || ch==0x40)
  250. return 2;
  251. else if(ch<=0x100)
  252. return 3;
  253. else //偝傜偵偙偙傪UnicodeCategory摍傪傒偰揔摉偵偙偟傜偊傞偙偲傕偱偒傞偑
  254. return 4;
  255. }
  258. public int ID {
  259. get {
  260. return _id;
  261. }
  262. set {
  263. _id = value;
  264. }
  265. }
  267. //椬愙峴偺愝掕丂偙偺曄峏偼TerminalDocument偐傜偺傒峴偆偙偲両
  268. public GLine NextLine {
  269. get {
  270. return _nextLine;
  271. }
  272. set {
  273. _nextLine = value;
  274. }
  275. }
  276. public GLine PrevLine {
  277. get {
  278. return _prevLine;
  279. }
  280. set {
  281. _prevLine = value;
  282. }
  283. }
  285. public EOLType EOLType {
  286. get {
  287. return _eolType;
  288. }
  289. set {
  290. _eolType = value;
  291. }
  292. }
  294. internal void ExpandBuffer(int length) {
  295. if(length<=_text.Length) return;
  297. char[] current = _text;
  298. _text = new char[length];
  299. Array.Copy(current, 0, _text, 0, current.Length);
  300. }
  302. internal void Render(IntPtr hdc, RenderParameter param, RenderProfile prof, int y) {
  303. if(_text[0]=='') return; //壗傕昤偐側偔偰傛偄
  304. float fx = (float)param.TargetRect.Left;
  306. RectangleF rect = new RectangleF();
  307. rect.Y = param.TargetRect.Top+y;
  308. rect.Height = prof.Pitch.Height;
  310. GWord word = _firstWord;
  311. while(word != null) {
  313. rect.X = fx /*- prof.CharGap*/; //Native側昤夋偱偼晄梫丠
  314. rect.Width = param.TargetRect.Right - rect.X;
  315. int ix = (int)rect.X;
  316. int iy = (int)rect.Y;
  318. TextDecoration dec = word.Decoration;
  320. //Brush brush = prof.CalcTextBrush(dec);
  321. uint forecolorref = DrawUtil.ToCOLORREF(prof.CalcTextColor(dec));
  322. Color bkcolor = prof.CalcBackColor(dec);
  323. uint bkcolorref   = DrawUtil.ToCOLORREF(bkcolor);
  324. IntPtr hfont = prof.CalcHFONT_NoUnderline(dec, word.CharGroup);
  325. Win32.SelectObject(hdc, hfont);
  326. Win32.SetTextColor(hdc, forecolorref);
  327. Win32.SetBkColor(hdc, bkcolorref);
  328. Win32.SetBkMode(hdc, bkcolor==prof.BackColor? 1 : 2); //婎杮攚宨怓偲堦弿側傜TRANSPARENT, 堎側傟偽OPAQUE
  329. IntPtr bkbrush = bkcolor==prof.BackColor? IntPtr.Zero : Win32.CreateSolidBrush(bkcolorref);
  331. int display_length = WordDisplayLength(word);
  332. if(word.Decoration==null) { //憰忺側偟
  333. //g.DrawString(WordText(word), font, brush, rect);
  334. DrawWord(hdc, ix, iy, word);
  335. }
  336. else {
  337. //if(dec.Bold || (!prof.UsingIdenticalFont && word.CharGroup==CharGroup.TwoBytes))
  338. if(dec.Bold || word.CharGroup==CharGroup.TwoBytes) //摨偠僼僅儞僩巜掕偱傕擔杮岅偑敿妏偺俀攞偱側偄応崌偁傝丅僷僼僅乕儅儞僗栤戣偼僋儕傾偝傟偮偮偁傞偺偱妋幚偵侾暥帤偢偮昤夋
  339. DrawStringByOneChar2(hdc, word, display_length, bkbrush, rect.X, iy, prof);
  340. else
  341. DrawWord(hdc, ix, iy, word); //偄傑傗傾儂側昤夋僄儞僕儞偺栤戣偐傜偼夝曻偝傟偨両
  342. }
  343. //Debug.WriteLine("PW="+p.Pitch.Width+",TL="+(pb.Text.Length*p.Pitch.Width)+", real="+g.MeasureString(pb.Text, p.Font).Width);
  344. if(dec.Underline)
  345. DrawUnderline(hdc, forecolorref, ix, iy+(int)prof.Pitch.Height-1, (int)(prof.Pitch.Width * display_length));
  347. fx += prof.Pitch.Width * display_length;
  348. word = word.Next;
  349. if(bkbrush!=IntPtr.Zero) Win32.DeleteObject(bkbrush);
  350. }
  352. }
  354. private void DrawUnderline(IntPtr hdc, uint col, int x, int y, int length) {
  355. //Underline偑偮偔偙偲偼偁傑傝側偄偩傠偆偐傜枅夞Pen傪嶌傞丅栤戣偵側傝偦偆偩偭偨傜偦偺偲偒偵峫偊傛偆
  356. IntPtr pen = Win32.CreatePen(0, 1, col);
  357. IntPtr prev = Win32.SelectObject(hdc, pen);
  358. Win32.POINT pt = new Win32.POINT();
  359. Win32.MoveToEx(hdc, x, y, out pt);
  360. Win32.LineTo(hdc, x+length, y);
  361. Win32.SelectObject(hdc, prev);
  362. Win32.DeleteObject(pen);
  363. }
  365. private void DrawWord(IntPtr hdc, int x, int y, GWord word) {
  366. unsafe {
  367. int len;
  369. if(word.CharGroup==CharGroup.SingleByte) {
  370. fixed(char* p = &_text[0]) {
  371. len = WordNextOffset(word) - word.Offset;
  372. Win32.TextOut(hdc, x, y, p+word.Offset, len);
  373. //Win32.ExtTextOut(hdc, x, y, 4, null, p+word.Offset, len, null);
  374. }
  375. }
  376. else {
  377. string t = WordText(word);
  378. fixed(char* p = t) {
  379. len = t.Length;
  380. Win32.TextOut(hdc, x, y, p, len);
  381. //Win32.ExtTextOut(hdc, x, y, 4, null, p, len, null);
  382. }
  383. }
  385. }
  386. }
  387. private void DrawStringByOneChar2(IntPtr hdc, GWord word, int display_length, IntPtr bkbrush, float fx, int y, RenderProfile prof) {
  388. float pitch = prof.Pitch.Width;
  389. int nextoffset = WordNextOffset(word);
  390. if(bkbrush!=IntPtr.Zero) { //偙傟偑側偄偲擔杮岅暥帤僺僢僠偑彫偝偄偲偒慖戰帪偺偡偒傑偑偱偒傞応崌偑偁傞
  391. Win32.RECT rect = new Win32.RECT();
  392. rect.left = (int)fx;
  393. rect.top  = y;
  394. rect.right = (int)(fx + pitch*display_length);
  395. rect.bottom = y + (int)prof.Pitch.Height;
  396. Win32.FillRect(hdc, ref rect, bkbrush);
  397. }
  398. for(int i=word.Offset; i<nextoffset; i++) {
  399. char ch = _text[i];
  400. if(ch=='') break;
  401. if(ch==GLine.WIDECHAR_PAD) continue;
  402. unsafe {
  403. Win32.TextOut(hdc, (int)fx, y, &ch, 1);
  404. }
  405. fx += pitch * CalcDisplayLength(ch);
  406. }
  407. }
  409. /*
  410.  * //!!.NET偺昤夋僶僌
  411.  * Graphics#DrawString偵搉偡暥帤楍偼丄僗儁乕僗偺傒偱峔惉偝傟偰偄傞偲柍帇偝傟偰偟傑偆傛偆偩丅
  412.  * 偙傟偩偲傾儞僟乕儔僀儞偩偗傪堷偒偨偄偲偒側偳偵崲傞丅挷傋偨偲偙傠丄枛旜偵僞僽傪偮偗傞偲偙偺巇慻傒傪偩傑偡偙偲偑偱偒傞偙偲偑敾柧
  413.  * .NET偺師偺僶乕僕儑儞偱偼捈偭偰偄傞偙偲傪婜懸
  414.  */
  415. private string WordTextForFuckingDotNet(GWord word) {
  416. int nextoffset = WordNextOffset(word);
  417. if(nextoffset==0)
  418. return "";
  419. else {
  420. bool last_is_space = false;
  421. Debug.Assert(nextoffset-word.Offset >= 0);
  422. if(word.CharGroup==CharGroup.SingleByte) {
  423. last_is_space = _text[nextoffset-1]==' ';
  424. if(last_is_space)
  425. return new string(_text, word.Offset, nextoffset-word.Offset)+'t';
  426. else
  427. return new string(_text, word.Offset, nextoffset-word.Offset);
  428. }
  429. else {
  430. char[] buf = new char[256];
  431. int o = word.Offset, i=0;
  432. while(o < nextoffset) {
  433. char ch = _text[o];
  434. if(ch!=GLine.WIDECHAR_PAD) {
  435. last_is_space = ch==' ';
  436. buf[i++] = ch;
  437. }
  438. o++;
  439. }
  441. if(last_is_space)
  442. buf[i++] = (char)'t';
  444. return new string(buf, 0, i);
  445. }
  446. }
  447. }
  449. private string WordText(GWord word) {
  450. int nextoffset = WordNextOffset(word);
  451. if(nextoffset==0)
  452. return "";
  453. else {
  454. Debug.Assert(nextoffset-word.Offset >= 0);
  455. if(word.CharGroup==CharGroup.SingleByte)
  456. return new string(_text, word.Offset, nextoffset-word.Offset);
  457. else {
  458. char[] buf = new char[256];
  459. int o = word.Offset, i=0;
  460. while(o < nextoffset) {
  461. char ch = _text[o];
  462. if(ch!=GLine.WIDECHAR_PAD)
  463. buf[i++] = ch;
  464. o++;
  465. }
  466. return new string(buf, 0, i);
  467. }
  468. }
  469. }
  470. private int WordDisplayLength(GWord word) {
  471. //偙偙偼屇偽傟傞偙偲偑偲偰傕懡偄偺偱僉儍僢僔儏傪愝偗傞
  472. int cache = word.displayLengthCache;
  473. if(cache < 0) {
  474. int nextoffset = WordNextOffset(word);
  475. int l = nextoffset - word.Offset;
  476. word.displayLengthCache = l;
  477. return l;
  478. }
  479. else
  480. return cache;
  481. }
  483. internal int WordNextOffset(GWord word) {
  484. //偙偙偼屇偽傟傞偙偲偑偲偰傕懡偄偺偱僉儍僢僔儏傪愝偗傞
  485. int cache = word.nextOffsetCache;
  486. if(cache < 0) {
  487. if(word.Next==null) {
  488. int i = _text.Length-1;
  489. while(i>=0 && _text[i]=='')
  490. i--;
  491. word.nextOffsetCache = i+1;
  492. return i+1;
  493. }
  494. else {
  495. word.nextOffsetCache = word.Next.Offset;
  496. return word.Next.Offset;
  497. }
  498. }
  499. else
  500. return cache;
  501. }
  502. internal void Append(GWord w) {
  503. if(_firstWord==null)
  504. _firstWord = w;
  505. else
  506. this.LastWord.Next = w;
  507. }
  508. public GWord LastWord {
  509. get {
  510. GWord w = _firstWord;
  511. while(w.Next!=null)
  512. w = w.Next;
  513. return w;
  514. }
  515. }
  518. //index偺埵抲偺昞帵傪斀揮偟偨怴偟偄GLine傪曉偡
  519. //inverse偑false偩偲丄GWord偺暘妱偼偡傞偑Decoration偺斀揮偼偟側偄丅僸僋僸僋栤戣偺懳張偲偟偰幚憰丅
  520. internal GLine InverseCaret(int index, bool inverse, bool underline) {
  521. ExpandBuffer(index+1);
  522. if(_text[index]==WIDECHAR_PAD) index--;
  523. GLine ret = new GLine(_text, null);
  524. ret.ID = _id;
  525. ret.EOLType = _eolType;
  527. GWord w = _firstWord;
  528. int nextoffset = 0;
  529. while(w!=null) {
  530. nextoffset = WordNextOffset(w);
  531. if(w.Offset<=index && index<nextoffset) {
  532. //!!tail偐傜弴偵楢寢偟偨曽偑岠棪偼傛偄
  533. if(w.Offset<index) {
  534. GWord head = new GWord(w.Decoration, w.Offset, w.CharGroup);
  535. ret.Append(head);
  536. }
  538. TextDecoration dec = (TextDecoration)w.Decoration.Clone();
  539. if(inverse) {
  540. //怓偮偒僉儍儗僢僩偺僒億乕僩
  541. dec.ToCaretStyle();
  542. }
  543. if(underline) dec.Underline = true;
  544. GWord mid = new GWord(dec, index, w.CharGroup);
  545. ret.Append(mid);
  547. if(index+CalcDisplayLength(_text[index]) < nextoffset) {
  548. GWord tail = new GWord(w.Decoration, index+CalcDisplayLength(_text[index]), w.CharGroup);
  549. ret.Append(tail);
  550. }
  551. }
  552. else
  553. ret.Append(w.StandAloneClone());
  555. w = w.Next;
  556. }
  558. //!!偙偺丄僉儍儗僢僩埵抲偵僗儁乕僗傪擖傟傞偺偼Inverse偲偼堘偆張棟偱偁傞偐傜暘棧偡傞偙偲
  559. if(nextoffset<=index) {
  560. while(nextoffset<=index) {
  561. Debug.Assert(nextoffset < ret.Text.Length);
  562. ret.Text[nextoffset++] = ' ';
  563. }
  564. TextDecoration dec = TextDecoration.ClonedDefault();
  565. if(inverse) {
  566. dec.ToCaretStyle();
  567. }
  568. if(underline) dec.Underline = true;
  569. ret.Append(new GWord(dec, index, CharGroup.SingleByte));
  570. }
  572. return ret;
  574. }
  576. internal GLine InverseRange(int from, int to) {
  577. ExpandBuffer(Math.Max(from+1,to)); //寖偟偔儕僒僀僘偟偨偲偒側偳偵偙偺忦審偑枮偨偣側偄偙偲偑偁傞
  578. Debug.Assert(from>=0 && from<_text.Length);
  579. if(from<_text.Length && _text[from]==WIDECHAR_PAD) from--;
  580. if(to>0 && to-1<_text.Length && _text[to-1]==WIDECHAR_PAD) to--;
  582. GLine ret = new GLine(_text, null);
  583. ret.ID = _id;
  584. ret.EOLType = _eolType;
  585. //憰忺偺攝楍傪僙僢僩
  586. TextDecoration[] dec = new TextDecoration[_text.Length];
  587. GWord w = _firstWord;
  588. while(w!=null) {
  589. Debug.Assert(w.Decoration!=null);
  590. dec[w.Offset] = w.Decoration;
  591. w = w.Next;
  592. }
  594. //斀揮奐巒揰
  595. TextDecoration original = null;
  596. TextDecoration inverse = null;
  597. for(int i=from; i>=0; i--) {
  598. if(dec[i]!=null) {
  599. original = dec[i];
  600. break;
  601. }
  602. }
  603. Debug.Assert(original!=null);
  604. inverse = (TextDecoration)original.Clone();
  605. inverse.Inverse();
  606. dec[from] = inverse;
  608. //斖埻偵搉偭偰斀揮嶌嬈
  609. for(int i=from+1; i<to; i++) {
  610. if(i<dec.Length && dec[i]!=null) {
  611. original = dec[i];
  612. inverse = (TextDecoration)original.Clone();
  613. inverse.Inverse();
  614. dec[i] = inverse;
  615. }
  616. }
  618. if(to<dec.Length && dec[to]==null) dec[to] = original;
  620. //偙傟偵廬偭偰GWord傪嶌傞
  621. w = null;
  622. for(int i=dec.Length-1; i>=0; i--) {
  623. char ch = _text[i];
  624. if(dec[i]!=null && ch!='') {
  625. int j = i;
  626. if(ch==WIDECHAR_PAD) j++;
  627. GWord ww = new GWord(dec[i], j, CalcCharGroup(ch));
  628. ww.Next = w;
  629. w = ww;
  630. }
  631. }
  632. ret.Append(w);
  634. return ret;
  635. }
  637. //偙偺椞堟偺暥帤偺暆偼杮摉偼僼僅儞僩埶懚偩偑丄懡偔偺擔杮岅娐嫬偱偼慡妏偲偟偰埖傢傟傞柾條丅BS偱徚偡偲俀屄棃偨傝偡傞
  638. private static byte[] _length_map_0x80_0xFF;
  639. private static byte[] _length_map_0x2500_0x25FF;
  641. private static void InitLengthMap() {
  642. _length_map_0x80_0xFF = new byte[0x80];
  643. for(int i=0; i<_length_map_0x80_0xFF.Length; i++) {
  644. int t = i+0x80;
  645. //    仒         丯         亱         亇         丩         侘          亊         亐
  646. if(t==0xA7 || t==0xA8 || t==0xB0 || t==0xB1 || t==0xB4 || t==0xB6 || t==0xD7 || t==0xF7)
  647. _length_map_0x80_0xFF[i] = 2;
  648. else
  649. _length_map_0x80_0xFF[i] = 1;
  650. }
  652.             //慡妏敿妏崿嵼僝乕儞
  653. _length_map_0x2500_0x25FF = new byte[] {
  654.               //劅 劒 劆 劔                        劇       劕
  655.                 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, //2500-0F
  656.               //劉       劖 劋       劘 劊       劗 劌 労
  657.                 2, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, 2, 1, 1, //2510-1F
  658.               //劦       劙 劎 劶       劮       劜 劍       劧
  659.                 2, 1, 1, 2, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 1, 2, //2520-2F
  660.               //劵       劚 劏       劯 劷       劤 劑       劰
  661.                 2, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, //2530-3F
  662.               //      劸                         劥
  663.                 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, //2540-4F
  664.               //
  665.                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, //2550-5F
  666.               //
  667.                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, //2560-6F
  668.               //
  669.                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, //2570-7F
  670.               //
  671.                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, //2580-8F
  672.               //
  673.                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, //2590-9F
  674.               //仭 仩
  675.                 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, //25A0-AF
  676.               //      仯 仮                         仴 仱
  677.                 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, //25B0-BF
  678.               //                  仧 仦          仜       仢 仠
  679.                 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 2, 1, 1, 2, 2, //25C0-CF
  680.               //
  681.                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, //25D0-DF
  682.               //                                             侟
  683.                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, //25E0-EF
  684.               //
  685.                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1  //25F0-FF
  686. };
  687. Debug.Assert(_length_map_0x2500_0x25FF.Length==256);
  689. }
  691. //暥帤偵傛偭偰昤夋暆傪寛傔傞
  692. internal static int CalcDisplayLength(char ch) {
  693. if(ch >= 0x100) {
  694. if(0xFF61<=ch && ch<=0xFF9F) //敿妏僇僫
  695. return 1;
  696. else if(0x2500<=ch && ch<=0x25FF) //宺慄摍摿庩婰崋
  697. return _length_map_0x2500_0x25FF[ch-0x2500];
  698. else
  699. return 2;
  700. }
  701. else if(ch >= 0x80) {
  702. return _length_map_0x80_0xFF[ch-0x80];
  703. }
  704. else
  705. return 1; //杮摉偼tab側偳偁傞偐傕偟傟側偄偺偱傕偆彮偟恀柺栚偵寁嶼偡傋偒
  706. }
  707. //ASCII偐擔杮岅暥帤偐 僼僅儞僩偺慖戰偵巊偆
  708. internal static CharGroup CalcCharGroup(char ch) {
  709. if(ch < 0x80)
  710. return CharGroup.SingleByte; 
  711. else if(ch < 0x100)
  712. return _length_map_0x80_0xFF[ch-0x80]==1? CharGroup.SingleByte : CharGroup.TwoBytes;
  713. else {
  714. if(0x2500 <= ch && ch <= 0x25FF) //宺慄偼擔杮岅僼僅儞僩偼巊傢側偄
  715. return _length_map_0x2500_0x25FF[ch-0x2500]==1? CharGroup.SingleByte : CharGroup.TwoBytes; 
  716. else
  717. return CharGroup.TwoBytes;
  718. }
  719. }
  720. }
  722. /// <summary>
  723. /// 暥帤偺捛壛嶍彍側偳傪偟偰GLine傪憖嶌偡傞丅椺偊偽僞乕儈僫儖偑偙偺僋儔僗傪宱桼偟偰僪僉儏儊儞僩偺摿掕偺GLine傪彂偒姺偊傞偺偵巊偆丅
  724. /// </summary>
  725. internal class GLineManipulator {
  727. private char[] _text;
  728. private TextDecoration[] _decorations;
  730. private int _caretColumn;
  732. private TextDecoration _defaultDecoration;
  734. private EOLType _eolType;
  736. /// <summary>
  737. /// 嬻偱峔抸
  738. /// </summary>
  739. public GLineManipulator(int length) {
  740. _decorations = new TextDecoration[length];
  741. _text = new char[length];
  742. Clear(length);
  743. }
  744. /// <summary>
  745. /// 慡撪梕傪攋婞偡傞
  746. /// </summary>
  747. public void Clear(int length) {
  748. if(length!=_text.Length) {
  749. _decorations = new TextDecoration[length];
  750. _text = new char[length];
  751. }
  752. else {
  753. for(int i=0; i<_decorations.Length; i++) _decorations[i] = null;
  754. for(int i=0; i<_text.Length;        i++) _text[i] = '';
  755. }
  756. _caretColumn = 0;
  757. _eolType = EOLType.Continue;
  758. }
  760. public int CaretColumn {
  761. get {
  762. return _caretColumn;
  763. }
  764. set {
  765. Debug.Assert(value>=0 && value<=_text.Length);
  766. _caretColumn = value;
  767. value--;
  768. while(value>=0 && _text[value]=='')
  769. _text[value--] = ' ';
  770. }
  771. }
  773. public void CarriageReturn() {
  774. _caretColumn = 0;
  775. _eolType = EOLType.CR;
  776. }
  778. public bool IsEmpty {
  779. get {
  780. //_text傪慡晹尒傞昁梫偼側偄偩傠偆
  781. return _caretColumn==0 && _text[0]=='';
  782. }
  783. }
  784. public TextDecoration DefaultDecoration {
  785. get {
  786. return _defaultDecoration;
  787. }
  788. set {
  789. _defaultDecoration = value;
  790. }
  791. }
  793. /// <summary>
  794. /// 堷悢偲摨偠撪梕偱弶婜壔偡傞丅line偺撪梕偼攋夡偝傟側偄丅
  795. /// 堷悢偑null偺偲偒偼堷悢側偟偺僐儞僗僩儔僋僞偲摨偠寢壥偵側傞丅
  796. /// </summary>
  797. public void Load(GLine line, int cc) {
  798. if(line==null) { //偙傟偑null偵側偭偰偄傞偲偟偐巚偊側偄僋儔僢僔儏儗億乕僩偑偁偭偨丅杮棃偼側偄偼偢側傫偩偑...
  799. Clear(80);
  800. return;
  801. }
  803. Clear(line.Length);
  804. GWord w = line.FirstWord;
  805. Debug.Assert(line.Text.Length==_text.Length);
  806. Array.Copy(line.Text, 0, _text, 0, _text.Length);
  808. int n = 0;
  809. while(w != null) {
  810. int nextoffset = line.WordNextOffset(w);
  811. while(n < nextoffset)
  812. _decorations[n++] = w.Decoration;
  813. w = w.Next;
  814. }
  816. _eolType = line.EOLType;
  817. ExpandBuffer(cc+1);
  818. this.CaretColumn = cc; //' '偱杽傔傞偙偲傕偁傞偺偱僾儘僷僥傿僙僢僩傪巊偆
  819. }
  820. public int BufferSize {
  821. get {
  822. return _text.Length;
  823. }
  824. }
  826. public void ExpandBuffer(int length) {
  827. if(length<=_text.Length) return;
  829. char[] current = _text;
  830. _text = new char[length];
  831. Array.Copy(current, 0, _text, 0, current.Length);
  832. TextDecoration[] current2 = _decorations;
  833. _decorations = new TextDecoration[length];
  834. Array.Copy(current2, 0, _decorations, 0, current2.Length);
  835. }
  837. public void PutChar(char ch, TextDecoration dec) {
  838. Debug.Assert(dec!=null);
  839. Debug.Assert(_caretColumn>=0);
  840. Debug.Assert(_caretColumn<_text.Length);
  842. //埲壓傢偐傝偵偔偄偑丄梫偼応崌暘偗丅偙傟偺巇條傪彂偄偨帒椏偁傝
  843. bool onZenkakuRight = (_text[_caretColumn] == GLine.WIDECHAR_PAD);
  844. bool onZenkaku = onZenkakuRight || (_text.Length>_caretColumn+1 && _text[_caretColumn+1] == GLine.WIDECHAR_PAD);
  846. if(onZenkaku) {
  847. //慡妏偺忋偵彂偔
  848. if(!onZenkakuRight) {
  849. _text[_caretColumn] = ch;
  850. _decorations[_caretColumn] = dec;
  851. if(GLine.CalcDisplayLength(ch)==1) {
  852. //慡妏偺忋偵敿妏傪彂偄偨応崌丄椬偵僗儁乕僗傪擖傟側偄偲昞帵偑棎傟傞
  853. if(_caretColumn+1<_text.Length) _text[_caretColumn+1] = ' ';
  854. _caretColumn++;
  855. }
  856. else {
  857. _decorations[_caretColumn+1] = dec;
  858. _caretColumn+=2;
  859. }
  860. }
  861. else {
  862. _text[_caretColumn-1] = ' ';
  863. _text[_caretColumn]   = ch;
  864. _decorations[_caretColumn] = dec;
  865. if(GLine.CalcDisplayLength(ch)==2) {
  866. if(GLine.CalcDisplayLength(_text[_caretColumn+1])==2)
  867. if(_caretColumn+2<_text.Length) _text[_caretColumn+2] = ' ';
  868. _text[_caretColumn+1] = GLine.WIDECHAR_PAD;
  869. _decorations[_caretColumn+1] = _decorations[_caretColumn];
  870. _caretColumn += 2;
  871. }
  872. else
  873. _caretColumn++;
  874. }
  875. }
  876. else { //敿妏偺忋偵彂偔
  877. _text[_caretColumn] = ch;
  878. _decorations[_caretColumn] = dec;
  879. if(GLine.CalcDisplayLength(ch)==2) {
  880. if(GLine.CalcDisplayLength(_text[_caretColumn+1])==2) //敿妏丄慡妏偲側偭偰偄傞偲偙傠偵慡妏傪彂偄偨傜
  881. if(_caretColumn+2<_text.Length) _text[_caretColumn+2] = ' ';
  882. _text[_caretColumn+1] = GLine.WIDECHAR_PAD;
  883. _decorations[_caretColumn+1] = _decorations[_caretColumn];
  884. _caretColumn += 2;
  885. }
  886. else
  887. _caretColumn++; //偙傟偑嵟傕common側働乕僗偩偑
  888. }
  889. }
  890. public void SetDecoration(TextDecoration dec) {
  891. if(_caretColumn<_decorations.Length)
  892. _decorations[_caretColumn] = dec;
  893. }
  895. public char CharAt(int index) {
  896. return _text[index];
  897. }
  899. public void BackCaret() {
  900. if(_caretColumn>0) { //嵟嵍抂偵偁傞偲偒偼壗傕偟側偄
  901. _caretColumn--;
  902. }
  903. }
  905. public void RemoveAfterCaret() {
  906. for(int i=_caretColumn; i<_text.Length; i++) {
  907. _text[i] = '';
  908. _decorations[i] = null;
  909. }
  910. }
  911. public void FillSpace(int from, int to) {
  912. if(to>_text.Length) to = _text.Length;
  913. for(int i=from; i<to; i++) {
  914. _text[i] = ' ';
  915. _decorations[i] = null;
  916. }
  917. }
  918. public void FillSpace(int from, int to, TextDecoration dec) {
  919. if(to>_text.Length) to = _text.Length;
  920. for(int i=from; i<to; i++) {
  921. _text[i] = ' ';
  922. _decorations[i] = dec;
  923. }
  924. }
  925. //start偐傜count暥帤傪徚嫀偟偰媗傔傞丅塃抂偵偼null傪擖傟傞
  926. public void DeleteChars(int start, int count) {
  927. for(int i = start; i<_text.Length; i++) {
  928. int j = i + count;
  929. if(j < _text.Length) {
  930. _text[i] = _text[j];
  931. _decorations[i] = _decorations[j];
  932. }
  933. else {
  934. _text[i] = '';
  935. _decorations[i] = null;
  936. }
  937. }
  938. }
  939. public void InsertBlanks(int start, int count) {
  940. for(int i=_text.Length-1; i>=_caretColumn; i--) {
  941. int j = i - count;
  942. if(j >= _caretColumn) {
  943. _text[i] = _text[j];
  944. _decorations[i] = _decorations[j];
  945. }
  946. else {
  947. _text[i] = ' ';
  948. _decorations[i] = null;
  949. }
  950. }
  951. }
  953. public GLine Export() {
  954. GWord w = new GWord(_decorations[0]==null? TextDecoration.ClonedDefault() : _decorations[0], 0, GLine.CalcCharGroup(_text[0]));
  956. GLine line = new GLine(_text, w);
  957. line.EOLType = _eolType;
  958. int m = _text.Length;
  959. for(int offset=1; offset<m; offset++) {
  960. char ch = _text[offset];
  961. if(ch=='') break;
  962. else if(ch==GLine.WIDECHAR_PAD) continue;
  964. TextDecoration dec = _decorations[offset];
  965. if(_decorations[offset-1]!=dec || w.CharGroup!=GLine.CalcCharGroup(ch)) {
  966. if(dec==null) dec = TextDecoration.ClonedDefault(); //!!杮摉偼偙偙偑null偵側偭偰偄傞偺偼偁傝偊側偄偼偢丅屻偱挷嵏偡傞偙偲
  967. GWord ww = new GWord(dec, offset, GLine.CalcCharGroup(ch));
  968. w.Next = ww;
  969. w = ww;
  970. }
  971. }
  972. return line;
  973. }
  975. public override string ToString() {
  976. StringBuilder b = new StringBuilder();
  977. b.Append(_text);
  978. //傾僩儕價儏乕僩傑傢傝偺昞帵偼傑偩偟偰偄側偄
  979. return b.ToString();
  980. }
  981.         /*
  982. public static void TestPutChar() {
  983. TestPutChar(1, "aaaaz ", 0, '偄');
  984. TestPutChar(2, "a偁uFFFFaz ", 0, '偄');
  985. TestPutChar(3, "偁uFFFF偁uFFFFz ", 0, 'b');
  986. TestPutChar(4, "偁uFFFF偁uFFFFz ", 0, '偄');
  987. TestPutChar(5, "偁uFFFF偁uFFFFz ", 1, 'b');
  988. TestPutChar(6, "偁uFFFFaaz ", 1, '偄');
  989. TestPutChar(7, "偁uFFFF偁uFFFFz ", 1, '偄');
  990. }*/
  991. private static void TestPutChar(int num, string initial, int col, char ch) {
  992. GLineManipulator m = new GLineManipulator(10);
  993. m._text = initial.ToCharArray();
  994. m.CaretColumn = col;
  995. Debug.WriteLine(String.Format("Test{0}  [{1}] col={2} char={3}", num, SafeString(m._text), m.CaretColumn, ch));
  996. m.PutChar(ch, TextDecoration.Default);
  997. Debug.WriteLine(String.Format("Result [{0}] col={1}", SafeString(m._text), m.CaretColumn));
  998. }
  999. public static string SafeString(char[] d) {
  1000. StringBuilder bld = new StringBuilder();
  1001. for(int i=0; i<d.Length; i++) {
  1002. char ch = d[i];
  1003. if(ch=='') break;
  1004. if(ch!=GLine.WIDECHAR_PAD) bld.Append(ch);
  1005. }
  1006. return bld.ToString();
  1007. }
  1009. }
  1010. }