mirror of
https://github.com/OPCFoundation/UA-.NETStandard.git
synced 2026-10-23 10:23:13 +08:00
Erich Barnstedt
2901d8e5bb
2. Removed client cert validation from HTTPS client and server as this is not supported on all platforms, e.g. .Net4.6. 3. Reverted back to XmlDocument from XDocument as this is now supported via a NuGet package on UWP and XDocument is not supported on .Net4.6. 4. Baseline .Net4.6 samples and assoc. controls project check-in, not working yet. 5. Moved UWP client controls from SDK to Samples directly.
998 lines
32 KiB
C#
998 lines
32 KiB
C#
/* ========================================================================
|
|
* Copyright (c) 2005-2013 The OPC Foundation, Inc. All rights reserved.
|
|
*
|
|
* OPC Foundation MIT License 1.00
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person
|
|
* obtaining a copy of this software and associated documentation
|
|
* files (the "Software"), to deal in the Software without
|
|
* restriction, including without limitation the rights to use,
|
|
* copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following
|
|
* conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* The complete license agreement can be found here:
|
|
* http://opcfoundation.org/License/MIT/1.00/
|
|
* ======================================================================*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Windows.Forms;
|
|
using System.Text;
|
|
using System.Data;
|
|
using System.Drawing;
|
|
using Opc.Ua;
|
|
using Opc.Ua.Client;
|
|
using Opc.Ua.Client.Controls;
|
|
|
|
namespace Opc.Ua.Client.Controls
|
|
{
|
|
/// <summary>
|
|
/// Prompts the user to select an area to use as an event filter.
|
|
/// </summary>
|
|
public partial class SubscribeEventsDlg : Form, ISessionForm
|
|
{
|
|
#region Constructors
|
|
/// <summary>
|
|
/// Creates an empty form.
|
|
/// </summary>
|
|
public SubscribeEventsDlg()
|
|
{
|
|
InitializeComponent();
|
|
this.Icon = ClientUtils.GetAppIcon();
|
|
|
|
BrowseCTRL.BrowseTV.CheckBoxes = true;
|
|
BrowseCTRL.BrowseTV.AfterCheck += new TreeViewEventHandler(BrowseTV_AfterCheck);
|
|
|
|
m_PublishStatusChanged = new EventHandler(OnPublishStatusChanged);
|
|
ItemsDV.AutoGenerateColumns = false;
|
|
ImageList = new ClientUtils().ImageList;
|
|
|
|
m_dataset = new DataSet();
|
|
m_dataset.Tables.Add("Items");
|
|
|
|
m_dataset.Tables[0].Columns.Add("MonitoredItem", typeof(MonitoredItem));
|
|
m_dataset.Tables[0].Columns.Add("Icon", typeof(Image));
|
|
m_dataset.Tables[0].Columns.Add("NodeAttribute", typeof(string));
|
|
m_dataset.Tables[0].Columns.Add("MonitoringMode", typeof(MonitoringMode));
|
|
m_dataset.Tables[0].Columns.Add("SamplingInterval", typeof(double));
|
|
m_dataset.Tables[0].Columns.Add("DiscardOldest", typeof(bool));
|
|
m_dataset.Tables[0].Columns.Add("OperationStatus", typeof(StatusCode));
|
|
|
|
ItemsDV.DataSource = m_dataset.Tables[0];
|
|
}
|
|
#endregion
|
|
|
|
#region Private Fields
|
|
private DataSet m_dataset;
|
|
private FilterDeclaration m_filter;
|
|
private DisplayState m_state;
|
|
private Session m_session;
|
|
private Subscription m_subscription;
|
|
private EventHandler m_PublishStatusChanged;
|
|
#endregion
|
|
|
|
private enum DisplayState
|
|
{
|
|
EditItems,
|
|
SelectEventType,
|
|
SelectEventFields,
|
|
ApplyChanges,
|
|
ViewUpdates
|
|
}
|
|
|
|
#region Public Interface
|
|
/// <summary>
|
|
/// Changes the session used.
|
|
/// </summary>
|
|
public void ChangeSession(Session session)
|
|
{
|
|
if (!Object.ReferenceEquals(session, m_session))
|
|
{
|
|
m_session = session;
|
|
|
|
BrowseCTRL.ChangeSession(m_session);
|
|
EventTypeCTRL.ChangeSession(m_session);
|
|
EventFilterCTRL.ChangeSession(m_session);
|
|
EventsCTRL.ChangeSession(m_session);
|
|
|
|
if (m_subscription != null)
|
|
{
|
|
m_subscription.PublishStatusChanged -= m_PublishStatusChanged;
|
|
m_subscription.FastEventCallback = null;
|
|
m_subscription = null;
|
|
}
|
|
|
|
if (m_session != null)
|
|
{
|
|
// find new subscription.
|
|
foreach (Subscription subscription in m_session.Subscriptions)
|
|
{
|
|
if (Object.ReferenceEquals(subscription.Handle, this))
|
|
{
|
|
m_subscription = subscription;
|
|
m_subscription.PublishStatusChanged += m_PublishStatusChanged;
|
|
m_subscription.FastEventCallback = OnEvent;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if the dialog has an active subscription assigned.
|
|
/// </summary>
|
|
public bool HasSubscription
|
|
{
|
|
get
|
|
{
|
|
return m_subscription != null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the subscription used with the control.
|
|
/// </summary>
|
|
public void SetSubscription(Subscription subscription)
|
|
{
|
|
if (m_subscription != null)
|
|
{
|
|
m_subscription.PublishStatusChanged -= m_PublishStatusChanged;
|
|
m_subscription.FastDataChangeCallback = null;
|
|
m_subscription = null;
|
|
}
|
|
|
|
m_session = null;
|
|
m_subscription = subscription;
|
|
m_subscription.DisableMonitoredItemCache = true;
|
|
m_subscription.PublishStatusChanged += m_PublishStatusChanged;
|
|
m_subscription.FastEventCallback = OnEvent;
|
|
m_dataset.Tables[0].Rows.Clear();
|
|
|
|
if (m_subscription != null)
|
|
{
|
|
m_session = subscription.Session;
|
|
m_subscription.Handle = this;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds items to the subscription.
|
|
/// </summary>
|
|
public void AddItems(params NodeId[] itemsToMonitor)
|
|
{
|
|
if (itemsToMonitor != null)
|
|
{
|
|
SetDisplayState(DisplayState.EditItems);
|
|
|
|
for (int ii = 0; ii < itemsToMonitor.Length; ii++)
|
|
{
|
|
if (itemsToMonitor[ii] == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
DataRow row = m_dataset.Tables[0].NewRow();
|
|
|
|
MonitoredItem monitoredItem = new MonitoredItem(m_subscription.DefaultItem);
|
|
monitoredItem.StartNodeId = itemsToMonitor[ii];
|
|
monitoredItem.AttributeId = Attributes.EventNotifier;
|
|
monitoredItem.NodeClass = NodeClass.Object;
|
|
monitoredItem.IndexRange = null;
|
|
monitoredItem.Encoding = null;
|
|
monitoredItem.Handle = row;
|
|
m_subscription.AddItem(monitoredItem);
|
|
|
|
UpdateRow(row, monitoredItem);
|
|
m_dataset.Tables[0].Rows.Add(row);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Moves the sequence forward.
|
|
/// </summary>
|
|
public void Next()
|
|
{
|
|
if (m_state == DisplayState.ViewUpdates)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (m_state == DisplayState.SelectEventType)
|
|
{
|
|
UpdateFilter();
|
|
}
|
|
|
|
SetDisplayState(++m_state);
|
|
|
|
if (m_state == DisplayState.SelectEventType)
|
|
{
|
|
BrowseCTRL.Initialize(m_session, Opc.Ua.ObjectTypeIds.BaseEventType, Opc.Ua.ReferenceTypeIds.HasSubtype);
|
|
BrowseCTRL.SelectNode((m_filter == null || m_filter.EventTypeId == null) ? Opc.Ua.ObjectTypeIds.BaseEventType : m_filter.EventTypeId);
|
|
EventTypeCTRL.ShowType(Opc.Ua.ObjectTypeIds.BaseEventType);
|
|
return;
|
|
}
|
|
|
|
if (m_state == DisplayState.SelectEventFields)
|
|
{
|
|
EventFilterCTRL.SetFilter(m_filter);
|
|
return;
|
|
}
|
|
|
|
if (m_state == DisplayState.ApplyChanges)
|
|
{
|
|
UpdateItems();
|
|
return;
|
|
}
|
|
|
|
if (m_state == DisplayState.ViewUpdates)
|
|
{
|
|
EventsCTRL.SetFilter(m_filter);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Moves the sequence backward.
|
|
/// </summary>
|
|
public void Back()
|
|
{
|
|
if (m_state == DisplayState.EditItems)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SetDisplayState(--m_state);
|
|
|
|
if (m_state == DisplayState.SelectEventFields)
|
|
{
|
|
EventFilterCTRL.SetFilter(m_filter);
|
|
return;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Private Methods
|
|
/// <summary>
|
|
/// Sets the display state for the control.
|
|
/// </summary>
|
|
private void SetDisplayState(DisplayState state)
|
|
{
|
|
m_state = state;
|
|
|
|
switch (m_state)
|
|
{
|
|
case DisplayState.EditItems:
|
|
{
|
|
ItemsDV.Visible = true;
|
|
EventTypePN.Visible = false;
|
|
EventsCTRL.Visible = false;
|
|
EventFilterCTRL.Visible = false;
|
|
SamplingIntervalCH.Visible = true;
|
|
DiscardOldestCH.Visible = true;
|
|
DiscardOldestCH.AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
|
|
OperationStatusCH.Visible = false;
|
|
BackBTN.Visible = false;
|
|
NextBTN.Visible = true;
|
|
NextBTN.Enabled = true;
|
|
OkBTN.Visible = false;
|
|
break;
|
|
}
|
|
|
|
case DisplayState.SelectEventType:
|
|
{
|
|
ItemsDV.Visible = false;
|
|
EventTypePN.Visible = true;
|
|
EventsCTRL.Visible = false;
|
|
EventFilterCTRL.Visible = false;
|
|
BackBTN.Visible = true;
|
|
NextBTN.Visible = true;
|
|
NextBTN.Enabled = true;
|
|
OkBTN.Visible = false;
|
|
break;
|
|
}
|
|
|
|
case DisplayState.SelectEventFields:
|
|
{
|
|
ItemsDV.Visible = false;
|
|
EventTypePN.Visible = false;
|
|
EventsCTRL.Visible = false;
|
|
EventFilterCTRL.Visible = true;
|
|
BackBTN.Visible = true;
|
|
NextBTN.Visible = true;
|
|
NextBTN.Enabled = true;
|
|
OkBTN.Visible = false;
|
|
break;
|
|
}
|
|
|
|
case DisplayState.ApplyChanges:
|
|
{
|
|
ItemsDV.Visible = true;
|
|
EventTypePN.Visible = false;
|
|
EventsCTRL.Visible = false;
|
|
SamplingIntervalCH.Visible = true;
|
|
DiscardOldestCH.Visible = true;
|
|
DiscardOldestCH.AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells;
|
|
OperationStatusCH.Visible = true;
|
|
BackBTN.Visible = true;
|
|
NextBTN.Visible = true;
|
|
NextBTN.Enabled = true;
|
|
OkBTN.Visible = false;
|
|
break;
|
|
}
|
|
|
|
case DisplayState.ViewUpdates:
|
|
{
|
|
ItemsDV.Visible = false;
|
|
EventTypePN.Visible = false;
|
|
EventsCTRL.Visible = true;
|
|
BackBTN.Visible = true;
|
|
NextBTN.Enabled = false;
|
|
OkBTN.Visible = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates the row with the monitored item.
|
|
/// </summary>
|
|
private void UpdateRow(DataRow row, MonitoredItem monitoredItem)
|
|
{
|
|
row[0] = monitoredItem;
|
|
row[1] = ImageList.Images[ClientUtils.GetImageIndex(monitoredItem.AttributeId, null)];
|
|
row[2] = m_session.NodeCache.GetDisplayText(monitoredItem.StartNodeId) + "/" + Attributes.GetBrowseName(monitoredItem.AttributeId);
|
|
row[3] = monitoredItem.MonitoringMode;
|
|
row[4] = monitoredItem.SamplingInterval;
|
|
row[5] = monitoredItem.DiscardOldest;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates the row with the monitored item status.
|
|
/// </summary>
|
|
private void UpdateRow(DataRow row, MonitoredItemStatus status)
|
|
{
|
|
row[4] = status.SamplingInterval;
|
|
|
|
if (ServiceResult.IsBad(status.Error))
|
|
{
|
|
row[6] = status.Error.StatusCode;
|
|
}
|
|
else
|
|
{
|
|
row[6] = (StatusCode)StatusCodes.Good;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the display string for the subscription status.
|
|
/// </summary>
|
|
private string GetDisplayString(Subscription subscription)
|
|
{
|
|
StringBuilder buffer = new StringBuilder();
|
|
|
|
buffer.Append((subscription.CurrentPublishingEnabled) ? "Enabled" : "Disabled");
|
|
buffer.Append(" (");
|
|
buffer.Append(subscription.CurrentPublishingInterval);
|
|
buffer.Append("ms/");
|
|
buffer.Append(subscription.CurrentPublishingInterval*subscription.CurrentKeepAliveCount/1000);
|
|
buffer.Append("s/");
|
|
buffer.Append(subscription.CurrentPublishingInterval*subscription.CurrentLifetimeCount/1000);
|
|
buffer.Append("s}");
|
|
|
|
return buffer.ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates the items with the current filter.
|
|
/// </summary>
|
|
private void UpdateItems()
|
|
{
|
|
List<FilterDeclarationField> fields = new List<FilterDeclarationField>();
|
|
|
|
foreach (FilterDeclarationField field in m_filter.Fields)
|
|
{
|
|
// only keep fields that are used.
|
|
if (field.Selected || field.FilterEnabled)
|
|
{
|
|
fields.Add(field);
|
|
continue;
|
|
}
|
|
|
|
// add mandatory fields.
|
|
switch (field.InstanceDeclaration.BrowsePathDisplayText)
|
|
{
|
|
case Opc.Ua.BrowseNames.EventId:
|
|
case Opc.Ua.BrowseNames.EventType:
|
|
case Opc.Ua.BrowseNames.Time:
|
|
{
|
|
field.Selected = true;
|
|
fields.Add(field);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_filter.Fields = fields;
|
|
|
|
// construct filter.
|
|
EventFilter filter = m_filter.GetFilter();
|
|
|
|
// update items.
|
|
for (int ii = 0; ii < m_dataset.Tables[0].Rows.Count; ii++)
|
|
{
|
|
MonitoredItem monitoredItem = (MonitoredItem)m_dataset.Tables[0].Rows[ii][0];
|
|
monitoredItem.Filter = filter;
|
|
}
|
|
|
|
// apply changes.
|
|
m_subscription.ApplyChanges();
|
|
|
|
// show results.
|
|
for (int ii = 0; ii < m_dataset.Tables[0].Rows.Count; ii++)
|
|
{
|
|
DataRow row = m_dataset.Tables[0].Rows[ii];
|
|
MonitoredItem monitoredItem = (MonitoredItem)row[0];
|
|
UpdateRow(row, monitoredItem.Status);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates the filter from the controls.
|
|
/// </summary>
|
|
private void UpdateFilter()
|
|
{
|
|
// get selected declarations.
|
|
List<InstanceDeclaration> declarations = new List<InstanceDeclaration>();
|
|
NodeId eventTypeId = CollectInstanceDeclarations(declarations);
|
|
|
|
if (m_filter == null)
|
|
{
|
|
m_filter = new FilterDeclaration();
|
|
}
|
|
|
|
if (m_filter.Fields == null || m_filter.Fields.Count == 0)
|
|
{
|
|
m_filter.Fields = new List<FilterDeclarationField>();
|
|
|
|
// select some default values to display in the list.
|
|
AddDefaultFilter(m_filter.Fields, Opc.Ua.BrowseNames.EventType, true);
|
|
AddDefaultFilter(m_filter.Fields, Opc.Ua.BrowseNames.SourceName, true);
|
|
AddDefaultFilter(m_filter.Fields, Opc.Ua.BrowseNames.SourceNode, true);
|
|
AddDefaultFilter(m_filter.Fields, Opc.Ua.BrowseNames.Time, true);
|
|
AddDefaultFilter(m_filter.Fields, Opc.Ua.BrowseNames.Severity, true);
|
|
AddDefaultFilter(m_filter.Fields, Opc.Ua.BrowseNames.Message, true);
|
|
}
|
|
|
|
// copy settings from existing filter.
|
|
List<FilterDeclarationField> fields = new List<FilterDeclarationField>();
|
|
|
|
foreach (InstanceDeclaration declaration in declarations)
|
|
{
|
|
if (declaration.NodeClass != NodeClass.Variable)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
FilterDeclarationField field = new FilterDeclarationField(declaration);
|
|
|
|
foreach (FilterDeclarationField field2 in m_filter.Fields)
|
|
{
|
|
if (field2.InstanceDeclaration.BrowsePathDisplayText == field.InstanceDeclaration.BrowsePathDisplayText)
|
|
{
|
|
field.DisplayInList = field2.DisplayInList;
|
|
field.FilterEnabled = field2.FilterEnabled;
|
|
field.FilterOperator = field2.FilterOperator;
|
|
field.FilterValue = field2.FilterValue;
|
|
break;
|
|
}
|
|
}
|
|
|
|
fields.Add(field);
|
|
}
|
|
|
|
// update filter.
|
|
m_filter.EventTypeId = eventTypeId;
|
|
m_filter.Fields = fields;
|
|
}
|
|
|
|
private void AddDefaultFilter(List<FilterDeclarationField> fields, string browsePath, bool displayInList)
|
|
{
|
|
FilterDeclarationField field = new FilterDeclarationField();
|
|
field.InstanceDeclaration = new InstanceDeclaration();
|
|
field.InstanceDeclaration.BrowsePathDisplayText = browsePath;
|
|
field.DisplayInList = displayInList;
|
|
fields.Add(field);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Collects the instance declarations for the selected types.
|
|
/// </summary>
|
|
private NodeId CollectInstanceDeclarations(List<InstanceDeclaration> declarations)
|
|
{
|
|
List<NodeId> typeIds = new List<NodeId>();
|
|
|
|
// get list of selected types.
|
|
NodeId baseTypeId = CollectTypeIds(BrowseCTRL.BrowseTV.Nodes[0], typeIds);
|
|
|
|
// merge declarations from the selected types.
|
|
foreach (NodeId typeId in typeIds)
|
|
{
|
|
List<InstanceDeclaration> declarations2 = ClientUtils.CollectInstanceDeclarationsForType(m_session, typeId);
|
|
|
|
for (int ii = 0; ii < declarations2.Count; ii++)
|
|
{
|
|
bool found = false;
|
|
|
|
for (int jj = 0; jj < declarations.Count; jj++)
|
|
{
|
|
if (declarations[jj].BrowsePathDisplayText == declarations2[ii].BrowsePathDisplayText)
|
|
{
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found)
|
|
{
|
|
declarations.Add(declarations2[ii]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return baseTypeId;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Collects the types selected in the control.
|
|
/// </summary>
|
|
private NodeId CollectTypeIds(TreeNode node, List<NodeId> typeIds)
|
|
{
|
|
if (!node.Checked)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
ReferenceDescription reference = node.Tag as ReferenceDescription;
|
|
|
|
NodeId typeId = null;
|
|
int childCount = 0;
|
|
|
|
foreach (TreeNode child in node.Nodes)
|
|
{
|
|
NodeId childTypeId = CollectTypeIds(child, typeIds);
|
|
|
|
if (childTypeId != null)
|
|
{
|
|
typeId = childTypeId;
|
|
childCount++;
|
|
}
|
|
}
|
|
|
|
if (reference != null)
|
|
{
|
|
if (childCount != 1)
|
|
{
|
|
typeId = (NodeId)reference.NodeId;
|
|
}
|
|
|
|
if (childCount == 0)
|
|
{
|
|
typeIds.Add((NodeId)reference.NodeId);
|
|
}
|
|
}
|
|
|
|
return typeId;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the checks for the currently checked event type.
|
|
/// </summary>
|
|
private void SetEventTypeChecks(TreeNode node, bool isChecked)
|
|
{
|
|
if (!isChecked)
|
|
{
|
|
foreach (TreeNode child in node.Nodes)
|
|
{
|
|
child.Checked = false;
|
|
}
|
|
}
|
|
|
|
if (node.Parent == null || node.Parent.Checked == isChecked)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (isChecked)
|
|
{
|
|
node.Parent.Checked = true;
|
|
return;
|
|
}
|
|
|
|
bool found = false;
|
|
|
|
foreach (TreeNode child in node.Parent.Nodes)
|
|
{
|
|
if (child.Checked)
|
|
{
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (found)
|
|
{
|
|
return;
|
|
}
|
|
|
|
node.Parent.Checked = false;
|
|
}
|
|
#endregion
|
|
|
|
#region Event Handlers
|
|
private void OnPublishStatusChanged(object sender, EventArgs e)
|
|
{
|
|
if (!Object.ReferenceEquals(sender, m_subscription))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (this.InvokeRequired)
|
|
{
|
|
this.BeginInvoke(m_PublishStatusChanged, sender, e);
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
if (m_subscription.PublishingStopped)
|
|
{
|
|
SubscriptionStateTB.Text = "STOPPED";
|
|
SubscriptionStateTB.ForeColor = Color.Red;
|
|
}
|
|
else
|
|
{
|
|
SubscriptionStateTB.Text = GetDisplayString(m_subscription);
|
|
SubscriptionStateTB.ForeColor = Color.Empty;
|
|
}
|
|
|
|
SequenceNumberTB.Text = m_subscription.SequenceNumber.ToString();
|
|
LastNotificationTB.Text = m_subscription.LastNotificationTime.ToLocalTime().ToString("hh:mm:ss");
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void OnEvent(Subscription subscription, EventNotificationList notification, IList<string> stringTable)
|
|
{
|
|
if (!Object.ReferenceEquals(subscription, m_subscription))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (this.InvokeRequired)
|
|
{
|
|
this.BeginInvoke(new FastEventNotificationEventHandler(OnEvent), subscription, notification, stringTable);
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
foreach (EventFieldList e in notification.Events)
|
|
{
|
|
EventsCTRL.DisplayEvent(e);
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void BackBTN_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
Back();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void NextBTN_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
Next();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void OkBTN_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
DialogResult = DialogResult.OK;
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void SubscriptionStateTB_DropDownItemClicked(object sender, ToolStripItemClickedEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (!Object.ReferenceEquals(e.ClickedItem, Subscription_EditMI))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!new EditSubscriptionDlg().ShowDialog(m_subscription))
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_subscription.Modify();
|
|
|
|
if (m_subscription.PublishingEnabled != m_subscription.CurrentPublishingEnabled)
|
|
{
|
|
m_subscription.SetPublishingMode(m_subscription.PublishingEnabled);
|
|
}
|
|
|
|
SubscriptionStateTB.Text = GetDisplayString(m_subscription);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void BrowseCTRL_AfterSelect(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
ReferenceDescription reference = BrowseCTRL.SelectedNode;
|
|
|
|
if (reference == null || NodeId.IsNull(reference.NodeId) || reference.NodeId.IsAbsolute)
|
|
{
|
|
EventTypeCTRL.ShowType(null);
|
|
return;
|
|
}
|
|
|
|
EventTypeCTRL.ShowType((NodeId)reference.NodeId);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void BrowseTV_AfterCheck(object sender, TreeViewEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
SetEventTypeChecks(e.Node, e.Node.Checked);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void CancelBTN_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (this.Modal)
|
|
{
|
|
DialogResult = DialogResult.Cancel;
|
|
}
|
|
else
|
|
{
|
|
Close();
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void NewMI_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (m_state != DisplayState.EditItems)
|
|
{
|
|
return;
|
|
}
|
|
|
|
MonitoredItem monitoredItem = null;
|
|
|
|
foreach (DataGridViewRow row in ItemsDV.SelectedRows)
|
|
{
|
|
DataRowView source = row.DataBoundItem as DataRowView;
|
|
monitoredItem = (MonitoredItem)source.Row[0];
|
|
break;
|
|
}
|
|
|
|
if (monitoredItem == null)
|
|
{
|
|
monitoredItem = new MonitoredItem(m_subscription.DefaultItem);
|
|
}
|
|
else
|
|
{
|
|
monitoredItem = new MonitoredItem(monitoredItem);
|
|
}
|
|
|
|
if (new EditMonitoredItemDlg().ShowDialog(m_session, monitoredItem, true))
|
|
{
|
|
m_subscription.AddItem(monitoredItem);
|
|
DataRow row = m_dataset.Tables[0].NewRow();
|
|
monitoredItem.Handle = row;
|
|
UpdateRow(row, monitoredItem);
|
|
m_dataset.Tables[0].Rows.Add(row);
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void EditMI_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (m_state != DisplayState.EditItems)
|
|
{
|
|
return;
|
|
}
|
|
|
|
MonitoredItem monitoredItem = null;
|
|
|
|
foreach (DataGridViewRow row in ItemsDV.SelectedRows)
|
|
{
|
|
DataRowView source = row.DataBoundItem as DataRowView;
|
|
monitoredItem = (MonitoredItem)source.Row[0];
|
|
break;
|
|
}
|
|
|
|
if (monitoredItem == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (new EditMonitoredItemDlg().ShowDialog(m_session, monitoredItem, true))
|
|
{
|
|
DataRow row = (DataRow)monitoredItem.Handle;
|
|
UpdateRow(row, monitoredItem);
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void DeleteMI_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (m_state != DisplayState.EditItems)
|
|
{
|
|
return;
|
|
}
|
|
|
|
foreach (DataGridViewRow row in ItemsDV.SelectedRows)
|
|
{
|
|
DataRowView source = row.DataBoundItem as DataRowView;
|
|
MonitoredItem monitoredItem = (MonitoredItem)source.Row[0];
|
|
m_subscription.RemoveItem(monitoredItem);
|
|
source.Row.Delete();
|
|
}
|
|
|
|
m_dataset.AcceptChanges();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void ItemsDV_DoubleClick(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (m_state == DisplayState.EditItems)
|
|
{
|
|
EditMI_Click(sender, e);
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void SetMonitoringModeMI_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (m_state != DisplayState.EditItems && m_state != DisplayState.ApplyChanges)
|
|
{
|
|
return;
|
|
}
|
|
|
|
List<MonitoredItem> monitoredItems = new List<MonitoredItem>();
|
|
|
|
foreach (DataGridViewRow row in ItemsDV.SelectedRows)
|
|
{
|
|
DataRowView source = row.DataBoundItem as DataRowView;
|
|
monitoredItems.Add((MonitoredItem)source.Row[0]);
|
|
}
|
|
|
|
if (monitoredItems.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
MonitoringMode oldMonitoringMode = monitoredItems[0].MonitoringMode;
|
|
MonitoringMode newMonitoringMode = new EditMonitoredItemDlg().ShowDialog(oldMonitoringMode);
|
|
|
|
if (oldMonitoringMode != newMonitoringMode)
|
|
{
|
|
List<MonitoredItem> itemsToModify = new List<MonitoredItem>();
|
|
|
|
foreach (MonitoredItem monitoredItem in monitoredItems)
|
|
{
|
|
DataRow row = (DataRow)monitoredItem.Handle;
|
|
row[5] = newMonitoringMode;
|
|
|
|
if (monitoredItem.Created)
|
|
{
|
|
itemsToModify.Add(monitoredItem);
|
|
continue;
|
|
}
|
|
|
|
monitoredItem.MonitoringMode = newMonitoringMode;
|
|
}
|
|
|
|
if (itemsToModify.Count != 0)
|
|
{
|
|
m_subscription.SetMonitoringMode(newMonitoringMode, itemsToModify);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
}
|