/// <summary>
/// 异步在指定的端口开始监听网络
/// </summary>
/// <param name="ip">指定远程的计算机IP</param>
/// <param name="port">指定远程计算机端口</param>
public void AsyncStartListen(IPAddress ip, int port)
{
_localTcpStruct.IP = ip;
_localTcpStruct.Port = port;
Threads.ExecAsync(async_th_listen);
}
protected override void OnFormClosing(FormClosingEventArgs e)
{
if (CloseStyle == WindowCloseStyle.Undefined)
{
if (!realClose)
{
realClose = !realClose;
if (this.Height > 50)
{
closeArgs = e;
e.Cancel = true;
Threads.ExecAsync(closeProc);
this.Text = "";
if (this.WindowState == FormWindowState.Maximized)
{
this.WindowState = FormWindowState.Normal;
}
}
else
{
e.Cancel = false;
}
}
}
base.OnFormClosing(e);
}
/// <summary>
/// 异步连接到一个支持SM协议的计算机端口
/// </summary>
/// <param name="tstr">远程TcpStruct</param>
public void AsyncConnectTo(TcpStruct tstr)
{
_remoteTcpStruct.IP = tstr.IP;
_remoteTcpStruct.Port = tstr.Port;
Threads.ExecAsync(async_th_connect);
}
/// <summary>
/// 异步连接到远程服务器
/// </summary>
/// <param name="endPoint">远程终结点</param>
public void AsyncConnectTo(IPEndPoint endPoint)
{
_remoteTcpStruct.IP = endPoint.Address;
_remoteTcpStruct.Port = endPoint.Port;
Threads.ExecAsync(async_th_connect);
}
/// <summary>
/// 异步连接到一个支持SM协议的计算机端口
/// </summary>
/// <param name="ip">目标IP</param>
/// <param name="port">目标端口</param>
public void AsyncConnectTo(IPAddress ip, int port)
{
_remoteTcpStruct.IP = ip;
_remoteTcpStruct.Port = port;
Threads.ExecAsync(async_th_connect);
}
public void ShowControl(Control control, bool changColor, int afterStart)
{
if (changColor)
{
Threads.ExecAsync(colorProc, new object[] { control, afterStart }, null);
}
Threads.ExecAsync(scrollProc, new object[] { control, afterStart }, null);
}
public virtual void ShowEx()
{
this.Show();
this.Opacity = 0;
this.Width = 1;
this.Visible = true;
Threads.ExecAsync(_start_scroll_thread_proc);
}
public void SetWidthEx(int newWidth, bool center)
{
if (Width == newWidth)
{
return;
}
extToH = newWidth;
extCenter = center;
Threads.ExecAsync(_resizeH_scroll_thread_proc);
}
public void SetHeightEx(int newHeight, bool center)
{
if (Height == newHeight)
{
return;
}
extToW = newHeight;
extCenter = center;
Threads.ExecAsync(_resizeW_scroll_thread_proc);
}
public void AsyncValidateLicense()
{
Threads.ExecAsync(delegate()
{
if (OnValidateLicense != null)
{
var result = MyConfigure.GetRemoteVersion(_productString, _userIdentity);
OnValidateLicense(result);
}
});
}
public void FocusSlide(Control control, int maxSize, int minSize, int sleep)
{
object obj = (object)new object[] { control, maxSize, minSize, sleep };
control.GotFocus += new EventHandler(delegate(object sender, EventArgs e)
{
Threads.ExecAsync(gotFocus, obj, null);
});
control.LostFocus += new EventHandler(delegate(object sender, EventArgs e)
{
Threads.ExecAsync(lostFocus, obj, null);
});
}
public bool RegisterSessionChangedEvent()
{
if (messageForm != null)
{
return(false);
}
MessageThread = Threads.ExecAsync(() =>
{
messageForm = new MessageForm(this);
messageForm.Start();
Application.Run();
});
return(true);
}
private void ReadDataFromListen()
{
_listenWork = true;
while (_listenWork)
{
try
{
TcpClient _tc = _tl.AcceptTcpClient();
__listen__readSmtcp reader = new __listen__readSmtcp(this, ref _tc, _protocol);
lock (_tcp_Reader_Array)
_tcp_Reader_Array.Add(reader);
Threads.ExecAsync(reader.Start);
}
catch { }
}
}
protected override void WndProc(ref Message m)
{
try
{
if (m.Msg == 0x02B1)
{
int sessionid = (int)m.LParam;
WM_WTSSESSION_CHANGE para2 = (WM_WTSSESSION_CHANGE)m.WParam;
Threads.ExecAsync(() =>
{
rdc.onSessionChanged(sessionid, para2);
});
}
}
catch { }
base.WndProc(ref m);
}
/// <summary>
/// 连接到一个支持SM协议的计算机端口
/// </summary>
/// <param name="tstr">指定远程的计算机Tcp结构</param>
public TcpResult ConnectTo(TcpStruct tstr)
{
TcpResult result = new TcpResult();
result.Success = false;
onTcpEvents(this._localTcpStruct, this._remoteTcpStruct, TcpOptionType.Connecting, null);
if (Connected)
{
onError(_localTcpStruct, _remoteTcpStruct, TcpError.TcpClientIsConnected, null, TcpOptionType.Connecting, null);
result.Success = false;
result.Error = TcpError.TcpClientIsConnected;
return(result);
}
_tc = new TcpClient();
try
{
_tc.Connect(tstr.IP, tstr.Port);
_tcpMode = TcpMode.Client;
_ns = _tc.GetStream();
result.Success = true;
}
catch (Exception ex)
{
onError(_localTcpStruct, _remoteTcpStruct, TcpError.ServerOffline, ex, TcpOptionType.Connecting, null);
result.Error = TcpError.ServerOffline;
result.Success = false;
return(result);
}
_remoteTcpStruct.IP = tstr.IP;
_remoteTcpStruct.Port = tstr.Port;
FormatIPStringToTcpStruct(_tc.Client.LocalEndPoint.ToString(), ref _localTcpStruct);
onTcpEvents(_localTcpStruct, _remoteTcpStruct, TcpOptionType.Connected, null);
if (!UseBlockRead)
{
Threads.ExecAsync(ReadDataFromConnectRemote);
}
return(result);
}
/// <summary>
/// 在使用阻断模式的时候读取列队和缓存中的所有数据。
/// </summary>
/// <returns></returns>
public byte[] Read(int timeoutSpan, int totalCount)
{
byte[] result = null;
Threads.ExecAsync(_readByBlockInReadMethodHasTimeout);
int count = 0;
while (_blockReadBufferField == null && count < totalCount)
{
Thread.Sleep(timeoutSpan);
count++;
}
if (_blockReadBufferField == null)
{
readTimeout = true;
}
else
{
readTimeout = false;
result = _blockReadBufferField;
_blockReadBufferField = null;
}
return(result);
}
public virtual void HideEx()
{
refreshStateParam();
Threads.ExecAsync(hideProc);
}
