/// <summary>
/// Update UI when media state changes.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void gxTerminal1_OnMediaStateChange(object sender, MediaStateEventArgs e)
{
try
{
bool bOpen;
bOpen = e.State == Gurux.Common.MediaState.Open;
HexCB.Enabled = ! bOpen;
OpenBtn.Enabled = ! bOpen;
SendText.Enabled = bOpen;
SendBtn.Enabled = bOpen;
CloseBtn.Enabled = bOpen;
ReceivedText.Enabled = bOpen;
StatusTimer.Enabled = bOpen;
PacketCounterTimer.Enabled = bOpen;
//Close interval timer if media is closed.
if (!bOpen)
{
IntervalTB.Enabled = false;
IntervalTimer.Enabled = false;
IntervalBtn.Enabled = false;
}
else
{
IntervalTB.Enabled = true;
IntervalBtn.Enabled = true;
}
//Read network status if media is opened.
if (bOpen)
{
StatusTimer_Tick(StatusTimer, new System.EventArgs());
}
else
{
RSSITB.Text = "";
BERTB.Text = "";
BatteryCapacityTB.Text = "";
PowerConsumptionTB.Text = "";
NetworkStatusTB.Text = "";
}
}
catch (Exception Ex)
{
MessageBox.Show(Ex.Message);
}
}
/// <summary>
/// Update UI when media state changes.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void gxSerial1_OnMediaStateChange(object sender, MediaStateEventArgs e)
{
try
{
bool bOpen = e.State == Gurux.Common.MediaState.Open;
OpenBtn.Enabled = !bOpen;
SendText.Enabled = bOpen;
SendBtn.Enabled = bOpen;
CloseBtn.Enabled = bOpen;
ReceivedText.Enabled = bOpen;
PacketCounterTimer.Enabled = bOpen;
// Close interval timer if media is closed.
if (!bOpen)
{
IntervalTB.Enabled = false;
IntervalTimer.Enabled = false;
IntervalBtn.Enabled = false;
}
else
{
IntervalTB.Enabled = true;
IntervalBtn.Enabled = true;
}
}
catch (Exception Ex)
{
MessageBox.Show(Ex.Message);
}
}
void OnMediaStateChange(object sender, MediaStateEventArgs e)
{
try
{
if (e.State == MediaState.Opening)
{
lock (m_SendPackets.SyncRoot)
{
m_SendPackets.Clear();
}
m_ReceicedPackets.Clear();
m_replyBuffer.Clear();
}
else if (e.State == MediaState.Closed)
{
Cancel();
}
//TODO: clients are removed when device list is cleared.
foreach (GXClient it in Clients)
{
try
{
it.NotifyMediaStateChange(e.State);
}
catch (Exception Ex)
{
it.NotifyError(it, Ex);
if (e.State == MediaState.Open)
{
if (Media != null)
{
Media.Close();
}
}
}
}
}
catch (Exception ex)
{
foreach (GXClient it in Clients)
{
it.NotifyError(this, ex);
}
}
}
/// <summary>
/// Report Media state change.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void media_OnMediaStateChange(object sender, MediaStateEventArgs e)
{
if (DC != null && (e.State == MediaState.Open || e.State == MediaState.Closing))
{
IGXMedia media = sender as IGXMedia;
GXAmiTask t = media.Tag as GXAmiTask;
ulong replyId = 0;
if (t != null)
{
replyId = t.Id;
}
DC.MediaStateChange(DC.DataCollectorGuid, media.MediaType, media.Name, e.State, replyId);
}
}
private void Net1_OnMediaStateChange(object sender, MediaStateEventArgs e)
{
try
{
if (this.InvokeRequired)
{
this.BeginInvoke(new MediaStateChangeEventHandler(Net1_OnMediaStateChange), new object[] { sender, e });
}
else
{
bool bOpen;
bOpen = e.State == Gurux.Common.MediaState.Open;
HexCB.Enabled = !bOpen;
OpenBtn.Enabled = !bOpen;
SendText.Enabled = bOpen;
SendBtn.Enabled = bOpen;
CloseBtn.Enabled = bOpen;
ReceivedText.Enabled = bOpen;
//Close interval timer if media is closed.
if (!bOpen)
{
IntervalTB.Enabled = false;
}
else
{
IntervalTB.Enabled = true;
}
//Enable echo if media is open and server.
EchoCB.Enabled = Net1.Server && bOpen;
}
}
catch (Exception Ex)
{
MessageBox.Show(Ex.Message);
}
}
/// <summary>
/// Show reconnect text if connection is closed.
/// Otherwice show clear text.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void OnMediaStateChange(object sender, MediaStateEventArgs e)
{
this.CommandPromptTB.Enabled = e.State == MediaState.Open;
if (e.State == MediaState.Open)
{
CommandPromptClearBtn.Text = "Clear";
}
else
{
CommandPromptClearBtn.Text = "Reconnect";
}
}
/// <summary>
/// Use Remote serial is only available for network media.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void GXClient_OnMediaStateChange(object sender, MediaStateEventArgs e)
{
UseRemoteSerialCB.Enabled = m_Device.GXClient.Media is GXNet;
}
void OnMediaStateChange(object sender, MediaStateEventArgs e)
{
//If user has selected new media.
if (e.State == MediaState.Changed)
{
//There is no need to update those values on load.
if (!GXDeviceList.IsLoading)
{
//Update wait time and resend count here to the GXClient
this.GXClient.WaitTime = this.WaitTime;
this.GXClient.ResendCount = this.ResendCount;
OnDirty(this, this, true);
}
UpdateCommunicationSettings(this.GXClient.Media);
return;
}
//Do not notify if media is opening.
if (e.State == MediaState.Opening)
{
return;
}
//Stop monitoring and execute initial actions.
if (e.State == MediaState.Closing)
{
try
{
StopMonitoring();
ExecuteInitialAction(InitialActionType.Disconnecting);
}
finally
{
if (m_PacketHandler != null)
{
m_PacketHandler.Disconnect(this);
}
}
return;
}
if (e.State == MediaState.Open)
{
this.Status |= DeviceStates.Connected | DeviceStates.MediaConnected;
//Reset error flag.
this.Status &= ~DeviceStates.Error;
if (m_PacketHandler != null)
{
m_PacketHandler.Connect(this);
}
ExecuteInitialAction(InitialActionType.Connected);
if (IsCancelled)
{
Disconnect();
}
else
{
NotifyUpdated(this, new GXDeviceEventArgs(this, DeviceStates.Connected));
}
}
else if (e.State == MediaState.Closed)
{
StopMonitoring();
this.Status &= ~(DeviceStates.Reading | DeviceStates.Writing | DeviceStates.Connected | DeviceStates.MediaConnected);
NotifyUpdated(this, new GXDeviceEventArgs(this, DeviceStates.Disconnected));
}
else
{
throw new Exception(Resources.InvalidMediaState);
}
return;
}
