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

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

Telnet服务器

开发平台：

C#

MultiPaneControl.cs：源码内容
  1. /*
  2. * Copyright (c) 2005 Poderosa Project, All Rights Reserved.
  3. * $Id: MultiPaneControl.cs,v 1.2 2005/04/20 08:45:45 okajima Exp $
  4. */
  5. using System;
  6. using System.Diagnostics;
  7. using System.Drawing;
  8. using System.Collections;
  9. using System.ComponentModel;
  10. using System.Windows.Forms;
  12. using Poderosa.Connection;
  13. using Poderosa.Communication;
  14. using Poderosa.Terminal;
  15. using Poderosa.Config;
  16. using Poderosa.Text;
  18. namespace Poderosa.Forms
  19. {
  20. /// <summary>
  21. /// 暋悢屄偺TerminalPane傪儂僗僩偡傞僐儞僩儘乕儖
  22. /// </summary>
  23. internal class MultiPaneControl : UserControl
  24. {
  25. private Splitter[] _splitters;
  26. public TerminalPane[] _panes;
  27. private double[][] _splitterRatio; //[俀暘妱梡/俁暘妱梡][index]偱巜掕
  29. private bool _ignoreResize;
  31. /// <summary>
  32. /// 昁梫側僨僓僀僫曄悢偱偡丅
  33. /// </summary>
  34. private System.ComponentModel.Container components = null;
  36. public MultiPaneControl() {
  37. //
  38. // Windows 僼僅乕儉 僨僓僀僫 僒億乕僩偵昁梫偱偡丅
  39. //
  40. InitializeComponent();
  42. //
  43. // TODO: InitializeComponent 屇傃弌偟偺屻偵丄僐儞僗僩儔僋僞 僐乕僪傪捛壛偟偰偔偩偝偄丅
  44. //
  45. SetStyle(ControlStyles.AllPaintingInWmPaint|ControlStyles.UserPaint|ControlStyles.DoubleBuffer, true);
  47. _ignoreResize = false;
  48. _splitters = new Splitter[2];
  49. _splitterRatio = new double[2][];
  50. _splitterRatio[0] = new double[] { 0.5 };
  51. _splitterRatio[1] = new double[] { 0.33, 0.66 };
  52. _panes = new TerminalPane[3];
  53. }
  55. /// <summary>
  56. /// 巊梡偝傟偰偄傞儕僜乕僗偵屻張棟傪幚峴偟傑偡丅
  57. /// </summary>
  58. protected override void Dispose( bool disposing )
  59. {
  60. if( disposing )
  61. {
  62. if(components != null)
  63. {
  64. components.Dispose();
  65. }
  66. }
  67. base.Dispose( disposing );
  68. }
  70. #region Windows Form Designer generated code
  71. /// <summary>
  72. /// 僨僓僀僫 僒億乕僩偵昁梫側儊僜僢僪偱偡丅偙偺儊僜僢僪偺撪梕傪
  73. /// 僐乕僪 僄僨傿僞偱曄峏偟側偄偱偔偩偝偄丅
  74. /// </summary>
  75. private void InitializeComponent()
  76. {
  77. // 
  78. // MultiPaneControl
  79. // 
  80. this.BackColor = System.Drawing.SystemColors.AppWorkspace;
  81. this.Name = "MultiPaneControl";
  83. }
  84. #endregion
  87. public void InitUI(ContainerOptions prev, ContainerOptions opt) {
  88. ConnectionTag[] cons = new ConnectionTag[_panes.Length];
  89. for(int i=0; i<_panes.Length; i++) {
  90. cons[i] = (_panes[i]==null || !_panes[i].FakeVisible)? null : _panes[i].ConnectionTag;
  91. if(_panes[i]!=null) _panes[i].Detach();
  92. _panes[i] = null;
  93. }
  95. Controls.Clear();
  97. GFrameStyle style = opt.FrameStyle;
  98. int pane_count = StyleToPaneCount(style);
  99. int prev_pane_count = prev==null? 1 : StyleToPaneCount(prev.FrameStyle);
  100. bool is_vertical = style==GFrameStyle.DivVertical || style==GFrameStyle.DivVertical3;
  102. //Control偺弶婜壔
  103. this.SuspendLayout();
  104. for(int i = pane_count-1; i>=0; i--) {
  105. TerminalPane p = new TerminalPane();
  106. _panes[i] = p;
  107. p.Visible = true;
  108. p.Dock = i==pane_count-1? DockStyle.Fill : is_vertical? DockStyle.Left : DockStyle.Top;
  109. if(i<pane_count-1) {
  110. int a = (int)((is_vertical? this.Width : this.Height) * (i==0? 0 : _splitterRatio[pane_count-2][i-1]));
  111. int b = (int)((is_vertical? this.Width : this.Height) * (_splitterRatio[pane_count-2][i] - (i==0? 0 : _splitterRatio[pane_count-2][i-1])));
  112. if(is_vertical) {
  113. p.Left = a;
  114. p.Width = b;
  115. }
  116. else {
  117. p.Top = a;
  118. p.Height = b;
  119. }
  120. }
  121. this.Controls.Add(p);
  123. if(i>0) {
  124. Splitter s = new Splitter();
  125. _splitters[i-1] = s;
  126. s.SplitterMoving += new SplitterEventHandler(this.OnSplitterMoving);
  127. s.SplitterMoved  += new SplitterEventHandler(this.OnSplitterMoved);
  128. s.Dock = is_vertical? DockStyle.Left : DockStyle.Top;
  129. s.BorderStyle = BorderStyle.Fixed3D;
  130. s.MinSize = 8;
  131. s.SplitPosition = (int)((is_vertical? this.Width : this.Height) * _splitterRatio[pane_count-2][i-1]);
  132. this.Controls.Add(s);
  133. }
  134. }
  135. this.ResumeLayout(true);
  138. //昁梫側傕偺傪Attach
  139. foreach(ConnectionTag ct in GEnv.Connections.OrderedConnections) {
  140. int pos = ct.PositionIndex;
  141. if(prev_pane_count<pane_count && ct.PreservedPositionIndex>=prev_pane_count) { //憹偊偨儁僀儞傊偺嫮惂妱傝摉偰
  142. pos = ct.PreservedPositionIndex;
  143. if(pos >= pane_count) pos = pane_count-1;
  144. ct.PositionIndex = pos; 
  145. if(_panes[pos].ConnectionTag==null) {
  146. _panes[pos].Attach(ct);
  147. _panes[pos].FakeVisible = true;
  148. GEnv.Frame.RefreshConnection(ct);
  149. }
  150. }
  151. else if(pos < pane_count) { //暯榓側応崌
  152. if(_panes[pos].ConnectionTag==null) {
  153. _panes[pos].Attach(ct);
  154. _panes[pos].FakeVisible = true;
  155. GEnv.Frame.RefreshConnection(ct);
  156. }
  157. }
  158. else { //塀傟傞応崌
  159. ct.PositionIndex = pane_count-1;
  160. if(ct!=null && _panes[pane_count-1].ConnectionTag==null) {
  161. _panes[pane_count-1].Attach(ct);
  162. _panes[pane_count-1].FakeVisible = true;
  163. GEnv.Frame.RefreshConnection(ct);
  164. }
  165. }
  166. }
  167. }
  169. public void RemoveAllConnections() {
  170. for(int i=0; i<_panes.Length; i++) {
  171. if(_panes[i]!=null) {
  172. _panes[i].Detach();
  173. _panes[i].FakeVisible = false;
  174. }
  175. }
  176. }
  178. //
  179. public void ActivateConnection(ConnectionTag ct) {
  180. //ct.PaneType = CalcPaneType(ct);
  181. TerminalPane pane = GetPane(ct.PositionIndex);
  182. //婛偵僐僱僋僔儑儞偑偁傟偽偦傟偺UI傪儕僼儗僢僔儏
  183. if(pane.Connection!=null) {
  184. ConnectionTag k = GEnv.Connections.FindTag(pane.Connection);
  185. if(k!=null) { //偙偙偱婛偵暵偠偨愙懕偑摼傜傟偰偟傑偆偙偲偑偁傞丅杮摉偼愙懕傪暵偠傞偲偒偵嶲徠傪夝徚偡傋偒偩偑庤敳偒
  186. pane.Detach();
  187. GEnv.Frame.RefreshConnection(k);
  188. }
  189. }
  191. pane.FakeVisible = true;
  192. pane.Attach(ct);
  193. if(!pane.AsControl().Focused)
  194. pane.AsControl().Focus();
  195. GEnv.Frame.RefreshConnection(ct);
  196. }
  199. public bool MoveActivePane(Keys direction) {
  200. ConnectionTag ct = GEnv.Connections.ActiveTag;
  201. if(ct==null || ct.AttachedPane==null) return false; //!!杮棃偙偺忦審偵側傞偙偲偼側偄偼偢偩偑丄寖偟偔僞僽傪堏摦偝偣偰偄傞偲偙偆側傞偙偲偑偁偭偨丅
  202. Debug.Assert(ct.AttachedPane.FakeVisible);
  204. GFrameStyle style = GApp.Options.FrameStyle;
  205. if(style==GFrameStyle.Single) return false;
  207. int  pane_count  = style==GFrameStyle.DivVertical3 || style==GFrameStyle.DivHorizontal3? 3 : 2;
  208. bool is_vertical = style==GFrameStyle.DivVertical3 || style==GFrameStyle.DivVertical;
  209. int destinationIndex = ct.PositionIndex;
  210. switch(direction) {
  211. case Keys.Up:
  212. if(!is_vertical) destinationIndex--;
  213. else return false;
  214. break;
  215. case Keys.Down:
  216. if(!is_vertical) destinationIndex++;
  217. else return false;
  218. break;
  219. case Keys.Left:
  220. if(is_vertical) destinationIndex--;
  221. else return false;
  222. break;
  223. case Keys.Right:
  224. if(is_vertical) destinationIndex++;
  225. else return false;
  226. break;
  227. }
  229. if(destinationIndex<0) return false;
  230. if(destinationIndex>=pane_count) return false;
  232. MovePane(ct, destinationIndex);
  233. return true;
  234. }
  235. private void MovePane(ConnectionTag ct, int destinationIndex) {
  236. //埵抲偺曄峏
  237. //堏摦愭偵昞帵
  238. //Debug.WriteLine("--------");
  239. //GEnv.Connections.Dump();
  240. int originalPos = ct.PositionIndex;
  241. Debug.Assert(originalPos!=destinationIndex);
  242. ct.PositionIndex = destinationIndex;
  243. TerminalPane pane = GetPane(destinationIndex);
  244. if(ct.AttachedPane!=null) ct.AttachedPane.Detach();
  245. if(pane.FakeVisible) pane.Detach();
  246. pane.FakeVisible = true;
  247. pane.Attach(ct);
  248. pane.Focus();
  249. GEnv.Frame.RefreshConnection(ct);
  250. //GEnv.Connections.Dump();
  252. //偙偙偱PreservedPositionIndex傪愝掕
  253. ct.PreservedPositionIndex = destinationIndex;
  255. //堏摦尦偵暿偺岓曗偑偄傟偽偦傟傪昞帵
  256. ConnectionTag orig = GEnv.Connections.GetCandidateOfActivation(originalPos, ct);
  257. if(orig!=null) {
  258. //orig.PaneType = CalcPaneType(orig);
  259. GetPane(originalPos).Attach(orig);
  260. GEnv.Frame.RefreshConnection(orig);
  261. }
  262. else {
  263. GetPane(originalPos).FakeVisible = false;
  264. }
  265. }
  266. public void SetConnectionLocation(ConnectionTag ct, IPoderosaTerminalPane pane) {
  267. if(ct.AttachedPane==null) { //旕昞帵偺偲偒
  268. ct.PositionIndex = GetPaneIndex(pane);
  269. ct.PreservedPositionIndex = ct.PositionIndex; //庤摦偱愝掕偝傟偨偲偒偼偙偙傊傕婰榐
  270. ActivateConnection(ct);
  271. }
  272. else {
  273. ActivateConnection(ct);
  274. MovePane(ct, GetPaneIndex(pane));
  275. }
  276. }
  279. //師偵僞乕儈僫儖傪奐偔偲偳偺僒僀僘偵側傞偐傪曉偡
  280. public Size TerminalSizeForNextConnection {
  281. get {
  282. return GetPane(this.PositionForNextConnection).TerminalSize;
  283. }
  284. }
  285. public int PositionForNextConnection {
  286. get {
  287. if(GApp.Options.FrameStyle==GFrameStyle.Single)
  288. return 0;
  289. else {
  290. int i;
  291. for(i=0; i<_panes.Length; i++) {
  292. if(_panes[i]==null) break;
  293. if(!_panes[i].FakeVisible) return i;
  294. }
  296. return GEnv.Connections.Count % i; //i偑桳岠側屄悢偵側偭偰偄傞
  297. }
  298. }
  299. }
  302. private TerminalPane GetPane(int positionIndex) {
  303. return _panes[positionIndex];
  304. }
  305. private int GetPaneIndex(IPoderosaTerminalPane pane) {
  306. int i;
  307. for(i=0; i<_panes.Length; i++) {
  308. if(_panes[i]==pane) return i;
  309. }
  310. return -1;
  311. }
  313. public void ApplyOptions(CommonOptions opt) {
  314. int i;
  315. for(i=0; i<_panes.Length; i++) {
  316. if(_panes[i]!=null) _panes[i].ApplyOptions(opt);
  317. }
  318. }
  320. private void OnSplitterMoving(object sender, SplitterEventArgs args) {
  321. GFrameStyle s = GApp.Options.FrameStyle;
  322. bool is_vertical = s==GFrameStyle.DivVertical || s==GFrameStyle.DivVertical3;
  323. int[] ws = new int[_panes.Length];
  324. for(int i=0; i<_panes.Length; i++) {
  325. ws[i] = _panes[i]==null? 0 : is_vertical? _panes[i].Width : _panes[i].Height;
  326. }
  328. //僗僾儕僢僞偺僀儞僨僋僗
  329. int splitter_index = 0;
  330. for(int i=0; i<_panes.Length-1; i++) {
  331. if(_splitters[i]==sender) {
  332. splitter_index = i;
  333. break;
  334. }
  335. }
  337. int diff = (is_vertical? args.SplitX-_panes[splitter_index].Right : args.SplitY-_panes[splitter_index].Bottom);
  338. ws[splitter_index]   += diff;
  339. ws[splitter_index+1] -= diff;
  341. for(int i=0; i<_panes.Length; i++) {
  342. if(_panes[i]==null) break;
  343. if(is_vertical)
  344. _panes[i].SplitterDragging(ws[i], this.Height);
  345. else
  346. _panes[i].SplitterDragging(this.Width, ws[i]);
  347. }
  348. }
  350. private bool _ignoreSplitterMoveFlag; //OnResize偺拞偱SplitPosition傪僙僢僩偡傞偲OnSplitterMoved傕屇偽傟偰偟傑偆偺偱偙傟傪杊巭偡傞偨傔偵僼儔僌傪僙僢僩
  351. private void OnSplitterMoved(object sender, SplitterEventArgs args) {
  352. if(_ignoreSplitterMoveFlag) return;
  354. GFrameStyle s = GApp.Options.FrameStyle;
  355. bool is_vertical = (s==GFrameStyle.DivVertical || s==GFrameStyle.DivVertical3);
  356. int  pane_count  = StyleToPaneCount(s);
  357. for(int i=0; i<pane_count; i++) {
  358. _panes[i].SplitterDragging(_panes[i].Width, _panes[i].Height);
  359. }
  361. //僗僾儕僢僞偺僀儞僨僋僗
  362. int splitter_index = 0;
  363. int total = 0;
  364. for(int i=0; i<pane_count-1; i++) {
  365. total += _splitters[i].SplitPosition;
  366. if(_splitters[i]==sender) {
  367. splitter_index = i;
  368. break;
  369. }
  370. }
  372. double r = (double)(total) / (is_vertical? this.Width : this.Height);
  373. //Debug.WriteLine("Ratio="+r);
  374. _splitterRatio[pane_count-2][splitter_index] = r;
  375. }
  376. protected override void OnResize(EventArgs args) {
  377. base.OnResize(args);
  378. if(_splitters==null || _ignoreResize || !GApp.Options.SplitterPreservesRatio) return;
  379. GFrameStyle s = GApp.Options.FrameStyle;
  380. if(s==GFrameStyle.Single) return;
  381. if(_splitters[0]==null) return; //枹弶婜壔帪偼僗僉僢僾
  383. AdjustSplitters();
  384. }
  385. private void AdjustSplitters() {
  386. if(_ignoreSplitterMoveFlag) return;
  388. _ignoreSplitterMoveFlag = true;
  389. GFrameStyle s = GApp.Options.FrameStyle;
  391. bool is_vertical = IsVerticalFrameStyle(s);
  392. int  pane_count  = StyleToPaneCount(s);
  393. double offset = 0;
  394. for(int i=0; i<pane_count-1; i++) {
  395. double next = _splitterRatio[pane_count-2][i];
  396. if(is_vertical) {
  397. //Debug.WriteLine(String.Format("{0} {1}", i, (int)(this.Width * next)));
  398. _splitters[i].SplitPosition = (int)(this.Width * (next-offset));
  399. _panes[i].SplitterDragging((int)(this.Width * (next-offset)), this.Height);
  400. }
  401. else {
  402. _splitters[i].SplitPosition = (int)(this.Height * (next-offset));
  403. _panes[i].SplitterDragging(this.Width, (int)(this.Height * (next-offset)));
  404. }
  405. offset = next;
  406. }
  407. //儔僗僩
  408. if(is_vertical) {
  409. _panes[pane_count-1].SplitterDragging((int)(this.Width * (1-offset)), this.Height);
  410. }
  411. else {
  412. _panes[pane_count-1].SplitterDragging(this.Width, (int)(this.Height * (1-offset)));
  413. }
  414. _ignoreSplitterMoveFlag = false;
  415. }
  417. //僼僅乕僇僗偺偁傞儁僀儞傪奼戝傑偨偼弅彫偡傞
  418. public void ResizeSplitterByFocusedPane(bool expand) {
  419. ConnectionTag ct = GEnv.Connections.ActiveTag;
  420. RenderProfile prof = ct==null? GEnv.DefaultRenderProfile : ct.RenderProfile;
  421. if(prof==null) prof = GEnv.DefaultRenderProfile;
  422. double diff = IsVerticalFrameStyle(GApp.Options.FrameStyle)? prof.Pitch.Width / this.Width : prof.Pitch.Height / this.Height;
  425. int active_index = 0; //傾僋僥傿僽側偺偑側偔偰傕null
  426. if(ct!=null) {
  427. for(int i=0; i<_panes.Length; i++) {
  428. if(ct.AttachedPane==_panes[i]) {
  429. active_index = i;
  430. break;
  431. }
  432. }
  433. }
  435. int pane_count = StyleToPaneCount(GApp.Options.FrameStyle);
  436. double[] ratio = _splitterRatio[pane_count-2];
  437. if(active_index<pane_count-1) {
  438. double n0 = ratio[active_index] + (expand? diff : -diff);
  439. if(n0 < diff*2 || n0 > (active_index+1>=ratio.Length? 1 : ratio[active_index+1])-diff*2) return; //彫偝偡偓偰偟傑偆偲偒偼嫅斲
  440. ratio[active_index] = n0;
  441. }
  442. else {
  443. double n0 = ratio[active_index-1] + (expand? -diff : diff);
  444. if(n0 < diff*2 || n0 > 1-diff*2) return;
  445. ratio[active_index-1] = n0;
  446. }
  447. AdjustSplitters();
  448. }
  450. //暥帤悢傪巜掕偟偰偺儕僒僀僘丂偙傟偼儅僋儘偐傜屇偽傟傞偺傒
  451. //暆丄崅偝偑-1偺偲偒偼僒僀僘偺曄峏傪偟側偄偙偲傪堄枴偡傞
  452. public void ResizeByChar(int width1, int height1, int width2, int height2) {
  453. _ignoreSplitterMoveFlag = true;
  454. _ignoreResize = true;
  455. this.SuspendLayout();
  457. /*
  458. TerminalPane p1 = GetPane(0);
  459. TerminalPane p2 = GetPane(1);
  460. Size current_size = GApp.Frame.Size;
  461. GFrameStyle s = GApp.Options.FrameStyle;
  462. SizeF pitch = GEnv.DefaultRenderProfile.Pitch;
  463. if(s==GFrameStyle.Single) {
  464. Size sz = p1.TerminalSize;
  465. if(width1==-1) width1 = sz.Width;
  466. if(height1==-1) height1 = sz.Height;
  467. Size new_size = new Size(current_size.Width + (int)((width1 - sz.Width)*pitch.Width), current_size.Height + (int)((height1 - sz.Height)*pitch.Height));
  468. GApp.Frame.Size = new_size;
  469. }
  470. else if(s==GFrameStyle.DivHorizontal) {
  471. Size sz1 = p1.TerminalSize;
  472. Size sz2 = p2.TerminalSize;
  473. if(width1==-1) width1 = sz1.Width;
  474. if(height1==-1) height1 = sz1.Height;
  475. if(height2==-1) height2 = sz2.Height;
  476. Size new_size = new Size(current_size.Width + (int)((width1 - sz1.Width)*pitch.Width), current_size.Height + (int)((height1-sz1.Height + height2-sz2.Height)*pitch.Height));
  477. GApp.Frame.Size = new_size;
  479. int newpos = _splitter.SplitPosition + (int)((height1-sz1.Height) * pitch.Height);
  480. _splitter.SplitPosition = newpos;
  481. p1.SplitterDragging(this.Width, newpos);
  482. p2.SplitterDragging(this.Width, this.Height - _splitter.Height - newpos);
  483. _splitterRatio =  (double)newpos / (this.Height - _splitter.Height);
  484. }
  485. else if(s==GFrameStyle.DivVertical) {
  486. Size sz1 = p1.TerminalSize;
  487. Size sz2 = p2.TerminalSize;
  488. if(width1==-1) width1 = sz1.Width;
  489. if(width2==-1) width2 = sz2.Width;
  490. if(height1==-1) height1 = sz1.Height;
  491. Size new_size = new Size(current_size.Width + (int)((width1-sz1.Width + width2-sz2.Width)*pitch.Width), current_size.Height + (int)((height1-sz1.Height)*pitch.Height));
  492. GApp.Frame.Size = new_size;
  494. int newpos = _splitter.SplitPosition + (int)((width1-sz1.Width) * pitch.Width);
  495. _splitter.SplitPosition = newpos;
  496. p1.SplitterDragging(newpos, this.Height);
  497. p2.SplitterDragging(this.Width - _splitter.Width - newpos, this.Height);
  498. _splitterRatio =  (double)newpos / (this.Width - _splitter.Width);
  499. }
  500. */
  502. _ignoreSplitterMoveFlag = false;
  503. _ignoreResize = false;
  504. this.ResumeLayout(true);
  505. }
  507. protected override bool IsInputKey(Keys key) {
  508. //Debug.WriteLine("MultiPane IsInputKey " + key);
  509. return false;
  510. }
  511. protected override bool ProcessDialogKey(Keys keyData) {
  512. //Debug.WriteLine("MultiPane ProcessDialogKey " + keyData);
  513. //偍偦傜偔ContainerControl偑丄Shift+僇乕僜儖僉乕傪張棟偟偰僼僅乕僇僗傪堏摦偝偣傞傛偆偩
  514. if((keyData & Keys.Modifiers)==Keys.Shift && GUtil.IsCursorKey(keyData & Keys.KeyCode))
  515. return true;
  516. else
  517. return base.ProcessDialogKey(keyData);
  518. }
  520. private static int StyleToPaneCount(GFrameStyle style) {
  521. switch(style) {
  522. case GFrameStyle.Single:
  523. return 1;
  524. case GFrameStyle.DivVertical:
  525. case GFrameStyle.DivHorizontal:
  526. return 2;
  527. case GFrameStyle.DivVertical3:
  528. case GFrameStyle.DivHorizontal3:
  529. return 3;
  530. default:
  531. Debug.Assert(false);
  532. return 0;
  533. }
  534. }
  535. private static bool IsVerticalFrameStyle(GFrameStyle style) {
  536. return style==GFrameStyle.DivVertical || style==GFrameStyle.DivVertical3;
  537. }
  540. //PaneTag偲昞帵埵抲偑摍偟偔丄Visible偺抣偑摍偟偄偙偲傪敾掕偡傞
  541. private class PosCheck {
  542. private int _positionIndex;
  543. private TerminalConnection _ignore;
  544. public PosCheck(int pi) {
  545. _positionIndex = pi;
  546. _ignore = null;
  547. }
  548. //_ignore偵摍偟偄愙懕偼儅僢僠偟側偄偲敾掕
  549. public PosCheck(int pi, TerminalConnection ig) {
  550. _positionIndex = pi;
  551. _ignore = ig;
  552. }
  553. public bool Check(ConnectionTag ct) {
  554. return ct.PositionIndex==_positionIndex && _ignore!=ct.Connection;
  555. }
  556. }
  557. }
  560. }