/// <summary>
/// Called when a update request completes.
/// </summary>
public void OnUpdateComplete(IOpcRequest request, TsCHdaResultCollection[] results)
{
// check if dialog has closed.
if (IsDisposed)
{
return;
}
// check if invoke is required.
if (InvokeRequired)
{
BeginInvoke(new TsCHdaUpdateCompleteEventHandler(OnUpdateComplete), new object[] { request, results });
return;
}
try
{
// display results.
resultsCtrl_.Initialize(mServer_, mValues_, results);
mResults_ = results;
nextBtn_.Enabled = true;
}
catch (Exception exception)
{
MessageBox.Show(exception.Message);
}
}
/// <summary>
/// Begins the asynchronous request.
/// </summary>
private void BeginRequest()
{
try
{
m_request = null;
// begin the asynchronous read request.
if (m_items != null)
{
m_subscription.Read(m_items, ++m_handle, new TsCDaReadCompleteEventHandler(OnReadComplete), out m_request);
}
// begin the asynchronous write request.
else if (m_values != null)
{
m_subscription.Write(m_values, ++m_handle, new TsCDaWriteCompleteEventHandler(OnWriteComplete), out m_request);
}
// update controls if request successful.
if (m_request != null)
{
OkBTN.Enabled = false;
CancelBTN.Enabled = false;
GoBTN.Visible = false;
StopBTN.Visible = true;
}
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
}
/// <summary>
/// Sends an asynchronous request to read item values that have been deleted or replaced.
/// </summary>
/// <param name="startTime">The beginning of the history period to read.</param>
/// <param name="endTime">The end of the history period to be read.</param>
/// <param name="maxValues">The number of values to be read for each item.</param>
/// <param name="items">The set of items to read (must include the item name).</param>
/// <param name="requestHandle">An identifier for the request assigned by the caller.</param>
/// <param name="callback">A delegate used to receive notifications when the request completes.</param>
/// <param name="request">An object that contains the state of the request (used to cancel the request).</param>
/// <returns>A set of results containing any errors encountered when the server validated the items.</returns>
internal OpcItemResult[] ReadModified(
TsCHdaTime startTime,
TsCHdaTime endTime,
int maxValues,
OpcItem[] items,
object requestHandle,
TsCHdaReadValuesCompleteEventHandler callback,
out IOpcRequest request)
{
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.HistoricalAccess);
if (Server == null)
{
throw new NotConnectedException();
}
OpcItemResult[] results = ((ITsCHdaServer)Server).ReadModified(
startTime,
endTime,
maxValues,
items,
requestHandle,
callback,
out request);
return(results);
}
/// <summary>
/// Requests that the server periodically send notifications when new data becomes available for a set of items.
/// </summary>
/// <param name="startTime">The beginning of the history period to read.</param>
/// <param name="resampleInterval">The interval between returned values.</param>
/// <param name="numberOfIntervals">The number of resample intervals that the server should return in each callback.</param>
/// <param name="items">The set of items to read (must include the item name).</param>
/// <param name="requestHandle">An identifier for the request assigned by the caller.</param>
/// <param name="callback">A delegate used to receive notifications when the request completes.</param>
/// <param name="request">An object that contains the state of the request (used to cancel the request).</param>
/// <returns>A set of results containing any errors encountered when the server validated the items.</returns>
internal OpcItemResult[] AdviseProcessed(
TsCHdaTime startTime,
decimal resampleInterval,
int numberOfIntervals,
TsCHdaItem[] items,
object requestHandle,
TsCHdaDataUpdateEventHandler callback,
out IOpcRequest request)
{
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.HistoricalAccess);
if (Server == null)
{
throw new NotConnectedException();
}
OpcItemResult[] results = ((ITsCHdaServer)Server).AdviseProcessed(
startTime,
resampleInterval,
numberOfIntervals,
items,
requestHandle,
callback,
out request);
return(results);
}
/// <summary>
/// Called when an asynchronous read request completes.
/// </summary>
private void OnReadComplete(object clientHandle, TsCDaItemValueResult[] results)
{
try
{
if (InvokeRequired)
{
BeginInvoke(new TsCDaReadCompleteEventHandler(OnReadComplete), new object[] { clientHandle, results });
return;
}
if (!mHandle_.Equals(clientHandle))
{
return;
}
resultsCtrl_.Initialize(mSubscription_.Server, null, results);
mRequest_ = null;
mResults_ = results;
okBtn_.Enabled = true;
cancelBtn_.Enabled = true;
goBtn_.Visible = true;
stopBtn_.Visible = false;
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
}
/// <summary>
/// Called when a read request completes.
/// </summary>
public void OnReadComplete(IOpcRequest request, TsCHdaItemAttributeCollection results)
{
// check if dialog has closed.
if (IsDisposed)
{
return;
}
// check if invoke is required.
if (InvokeRequired)
{
BeginInvoke(new TsCHdaReadAttributesCompleteEventHandler(OnReadComplete), new object[] { request, results });
return;
}
try
{
// enable next button since first batch of results have arrived.
ResultsCTRL.Initialize(m_server, results);
m_results = results;
NextBTN.Enabled = true;
}
catch (Exception exception)
{
MessageBox.Show(exception.Message);
}
}
/// <summary>
/// Sends an asynchronous request to read the attributes of an item.
/// </summary>
/// <param name="startTime">The beginning of the history period to read.</param>
/// <param name="endTime">The end of the history period to be read.</param>
/// <param name="item">The item to read (must include the item name).</param>
/// <param name="attributeIDs">The attributes to read.</param>
/// <param name="requestHandle">An identifier for the request assigned by the caller.</param>
/// <param name="callback">A delegate used to receive notifications when the request completes.</param>
/// <param name="request">An object that contains the state of the request (used to cancel the request).</param>
/// <returns>A set of results containing any errors encountered when the server validated the attribute ids.</returns>
internal TsCHdaResultCollection ReadAttributes(
TsCHdaTime startTime,
TsCHdaTime endTime,
OpcItem item,
int[] attributeIDs,
object requestHandle,
TsCHdaReadAttributesCompleteEventHandler callback,
out IOpcRequest request)
{
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.HistoricalAccess);
if (Server == null)
{
throw new NotConnectedException();
}
TsCHdaResultCollection results = ((ITsCHdaServer)Server).ReadAttributes(
startTime,
endTime,
item,
attributeIDs,
requestHandle,
callback,
out request);
return(results);
}
/// <summary>
/// Begins the asynchronous request.
/// </summary>
private void BeginRequest()
{
try
{
mRequest_ = null;
// begin the asynchronous read request.
if (mItems_ != null)
{
mSubscription_.Read(mItems_, ++mHandle_, new TsCDaReadCompleteEventHandler(OnReadComplete), out mRequest_);
}
// begin the asynchronous write request.
else if (mValues_ != null)
{
mSubscription_.Write(mValues_, ++mHandle_, new TsCDaWriteCompleteEventHandler(OnWriteComplete), out mRequest_);
}
// update controls if request successful.
if (mRequest_ != null)
{
okBtn_.Enabled = false;
cancelBtn_.Enabled = false;
goBtn_.Visible = false;
stopBtn_.Visible = true;
}
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
}
/// <summary>
/// Causes the server to send a data changed notification for all active items.
/// </summary>
/// <param name="requestHandle">An identifier for the request assigned by the caller.</param>
/// <param name="request">An object that contains the state of the request (used to cancel the request).</param>
/// <returns>A set of results containing any errors encountered when the server validated the items.</returns>
public void Refresh(
object requestHandle,
out IOpcRequest request)
{
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.DataAccess);
Subscription.Refresh(requestHandle, out request);
}
/// <summary>
/// Starts an asynchronous read annotations request for all items in the trend.
/// </summary>
public OpcItemResult[] ReadAnnotations(
object requestHandle,
TsCHdaReadAnnotationsCompleteEventHandler callback,
out IOpcRequest request)
{
return(ReadAnnotations(GetItems(), requestHandle, callback, out request));
}
/// <summary>
/// Starts an asynchronous read values at specific times request for all items in the trend.
/// </summary>
public OpcItemResult[] ReadAtTime(
object requestHandle,
TsCHdaReadValuesCompleteEventHandler callback,
out IOpcRequest request)
{
return(ReadAtTime(GetItems(), requestHandle, callback, out request));
}
/// <summary>
/// Sends an asynchronous request to read item values that have been deleted or replaced.
/// </summary>
/// <param name="startTime">The beginning of the history period to read.</param>
/// <param name="endTime">The end of the history period to be read.</param>
/// <param name="maxValues">The number of values to be read for each item.</param>
/// <param name="items">The set of items to read (must include the item name).</param>
/// <param name="requestHandle">An identifier for the request assigned by the caller.</param>
/// <param name="callback">A delegate used to receive notifications when the request completes.</param>
/// <param name="request">An object that contains the state of the request (used to cancel the request).</param>
/// <returns>A set of results containing any errors encountered when the server validated the items.</returns>
internal OpcItemResult[] ReadModified(
TsCHdaTime startTime,
TsCHdaTime endTime,
int maxValues,
OpcItem[] items,
object requestHandle,
TsCHdaReadValuesCompleteEventHandler callback,
out IOpcRequest request)
{
if (_server == null)
{
throw new NotConnectedException();
}
OpcItemResult[] results = ((ITsCHdaServer)_server).ReadModified(
startTime,
endTime,
maxValues,
items,
requestHandle,
callback,
out request);
return(results);
}
/// <summary>
/// Called when a delete request completes.
/// </summary>
public void OnDeleteComplete(IOpcRequest request, TsCHdaResultCollection[] results)
{
// check if dialog has closed.
if (IsDisposed)
{
return;
}
// check if invoke is required.
if (InvokeRequired)
{
BeginInvoke(new TsCHdaUpdateCompleteEventHandler(OnDeleteComplete), new object[] { request, results });
return;
}
try
{
// enable next button since first batch of results have arrived.
itemsCtrl_.Initialize(results);
mResults_ = results;
nextBtn_.Enabled = true;
}
catch (Exception exception)
{
MessageBox.Show(exception.Message);
}
}
/// <summary>
/// Called when an asynchronous read request completes.
/// </summary>
private void OnReadComplete(object clientHandle, TsCDaItemValueResult[] results)
{
try
{
if (InvokeRequired)
{
BeginInvoke(new TsCDaReadCompleteEventHandler(OnReadComplete), new object[] { clientHandle, results });
return;
}
if (!m_handle.Equals(clientHandle))
{
return;
}
ResultsCTRL.Initialize(m_subscription.Server, null, results);
m_request = null;
m_results = results;
OkBTN.Enabled = true;
CancelBTN.Enabled = true;
GoBTN.Visible = true;
StopBTN.Visible = false;
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
}
/// <summary>
/// Begins the playback of processed data from the historian database for a set of items.
/// </summary>
/// <param name="startTime">The beginning of the history period to read.</param>
/// <param name="endTime">The end of the history period to be read.</param>
/// <param name="resampleInterval">The interval between returned values.</param>
/// <param name="numberOfIntervals">The number of resample intervals that the server should return in each callback.</param>
/// <param name="updateInterval">The frequency, in seconds, that the server send data.</param>
/// <param name="items">The set of items to read (must include the item name).</param>
/// <param name="requestHandle">An identifier for the request assigned by the caller.</param>
/// <param name="callback">A delegate used to receive notifications when the request completes.</param>
/// <param name="request">An object that contains the state of the request (used to cancel the request).</param>
/// <returns>A set of results containing any errors encountered when the server validated the items.</returns>
internal OpcItemResult[] PlaybackProcessed(
TsCHdaTime startTime,
TsCHdaTime endTime,
decimal resampleInterval,
int numberOfIntervals,
decimal updateInterval,
TsCHdaItem[] items,
object requestHandle,
TsCHdaDataUpdateEventHandler callback,
out IOpcRequest request)
{
if (_server == null)
{
throw new NotConnectedException();
}
OpcItemResult[] results = ((ITsCHdaServer)_server).PlaybackProcessed(
startTime,
endTime,
resampleInterval,
numberOfIntervals,
updateInterval,
items,
requestHandle,
callback,
out request);
return(results);
}
/// <summary>
/// Starts an asynchronous delete values at specific times request for all items in the trend.
/// </summary>
public OpcItemResult[] DeleteAtTime(
object requestHandle,
TsCHdaUpdateCompleteEventHandler callback,
out IOpcRequest request)
{
return(DeleteAtTime(GetItems(), requestHandle, callback, out request));
}
/// <summary>
/// Begins an asynchronous write operation for a set of items.
/// </summary>
/// <param name="items">The set of item values to write (must include the item name).</param>
/// <param name="requestHandle">An identifier for the request assigned by the caller.</param>
/// <param name="callback">A delegate used to receive notifications when the request completes.</param>
/// <param name="request">An object that contains the state of the request (used to cancel the request).</param>
/// <returns>A set of results containing any errors encountered when the server validated the items.</returns>
public OpcItemResult[] Write(
TsCDaItemValue[] items,
object requestHandle,
TsCDaWriteCompleteEventHandler callback,
out IOpcRequest request)
{
return(_subscription.Write(items, requestHandle, callback, out request));
}
/// <summary>
/// Cancels an existing subscription.
/// </summary>
public void SubscribeCancel()
{
if (_subscription != null)
{
_server.CancelRequest(_subscription);
_subscription = null;
}
}
/// <summary>
/// Cancels an asynchronous request.
/// </summary>
/// <param name="request">The state object for the request to cancel.</param>
/// <param name="callback">A delegate used to receive notifications when the request completes.</param>
public void CancelRequest(IOpcRequest request, TsCHdaCancelCompleteEventHandler callback)
{
if (_server == null)
{
throw new NotConnectedException();
}
((ITsCHdaServer)_server).CancelRequest(request, callback);
}
///////////////////////////////////////////////////////////////////////
#region CancelRequest
/// <summary>
/// Cancels an asynchronous request.
/// </summary>
/// <param name="request">The state object for the request to cancel.</param>
public void CancelRequest(IOpcRequest request)
{
if (_server == null)
{
throw new NotConnectedException();
}
((ITsCHdaServer)_server).CancelRequest(request);
}
/// <summary>
/// Cancels an existing playback operation.
/// </summary>
public void PlaybackCancel()
{
if (_playback != null)
{
_server.CancelRequest(_playback);
_playback = null;
}
}
/// <summary>
/// Begins an asynchronous read operation for a set of items.
/// </summary>
/// <param name="items">The set of items to read (must include the item name).</param>
/// <param name="requestHandle">An identifier for the request assigned by the caller.</param>
/// <param name="callback">A delegate used to receive notifications when the request completes.</param>
/// <param name="request">An object that contains the state of the request (used to cancel the request).</param>
/// <returns>A set of results containing any errors encountered when the server validated the items.</returns>
public OpcItemResult[] Read(
TsCDaItem[] items,
object requestHandle,
TsCDaReadCompleteEventHandler callback,
out IOpcRequest request)
{
return(_subscription.Read(items, requestHandle, callback, out request));
}
/// <summary>
/// Cancels an asynchronous request.
/// </summary>
/// <param name="request">The state object for the request to cancel.</param>
public void CancelRequest(IOpcRequest request)
{
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.HistoricalAccess);
if (Server == null)
{
throw new NotConnectedException();
}
((ITsCHdaServer)Server).CancelRequest(request);
}
/// <summary>
/// Begins an asynchronous write operation for a set of items.
/// </summary>
/// <param name="items">The set of item values to write (must include the item name).</param>
/// <param name="requestHandle">An identifier for the request assigned by the caller.</param>
/// <param name="callback">A delegate used to receive notifications when the request completes.</param>
/// <param name="request">An object that contains the state of the request (used to cancel the request).</param>
/// <returns>A set of results containing any errors encountered when the server validated the items.</returns>
public OpcItemResult[] Write(
TsCDaItemValue[] items,
object requestHandle,
TsCDaWriteCompleteEventHandler callback,
out IOpcRequest request)
{
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.DataAccess);
return(Subscription.Write(items, requestHandle, callback, out request));
}
/// <summary>
/// Remove server handles for new items.
/// </summary>
private void UndoRead()
{
mResults_ = null;
mAsyncSent_ = false;
if (mRequest_ != null)
{
mServer_.CancelRequest(mRequest_, new TsCHdaCancelCompleteEventHandler(OnCancelComplete));
mRequest_ = null;
}
}
/// <summary>
/// Remove server handles for new items.
/// </summary>
private void UndoRead()
{
m_results = null;
m_asyncSent = false;
if (m_request != null)
{
m_server.CancelRequest(m_request, new TsCHdaCancelCompleteEventHandler(OnCancelComplete));
m_request = null;
}
}
/// <summary>
/// Requests that the server periodically send notifications when new data becomes available for a set of items.
/// </summary>
/// <param name="startTime">The beginning of the history period to read.</param>
/// <param name="updateInterval">The frequency, in seconds, that the server should check for new data.</param>
/// <param name="items">The set of items to read (must include the item name).</param>
/// <param name="requestHandle">An identifier for the request assigned by the caller.</param>
/// <param name="callback">A delegate used to receive notifications when the request completes.</param>
/// <param name="request">An object that contains the state of the request (used to cancel the request).</param>
/// <returns>A set of results containing any errors encountered when the server validated the items.</returns>
internal OpcItemResult[] AdviseRaw(
TsCHdaTime startTime,
decimal updateInterval,
OpcItem[] items,
object requestHandle,
TsCHdaDataUpdateEventHandler callback,
out IOpcRequest request)
{
if (_server == null)
{
throw new NotConnectedException();
}
return(((ITsCHdaServer)_server).AdviseRaw(startTime, updateInterval, items, requestHandle, callback, out request));
}
/// <summary>
/// Requests that the server periodically send notifications when new data becomes available for a set of items.
/// </summary>
/// <param name="startTime">The beginning of the history period to read.</param>
/// <param name="updateInterval">The frequency, in seconds, that the server should check for new data.</param>
/// <param name="items">The set of items to read (must include the item name).</param>
/// <param name="requestHandle">An identifier for the request assigned by the caller.</param>
/// <param name="callback">A delegate used to receive notifications when the request completes.</param>
/// <param name="request">An object that contains the state of the request (used to cancel the request).</param>
/// <returns>A set of results containing any errors encountered when the server validated the items.</returns>
internal OpcItemResult[] AdviseRaw(
TsCHdaTime startTime,
decimal updateInterval,
OpcItem[] items,
object requestHandle,
TsCHdaDataUpdateEventHandler callback,
out IOpcRequest request)
{
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.HistoricalAccess);
if (Server == null)
{
throw new NotConnectedException();
}
return(((ITsCHdaServer)Server).AdviseRaw(startTime, updateInterval, items, requestHandle, callback, out request));
}
/// <summary>
/// Starts an asynchronous read values at specific times request for a set of items.
/// </summary>
public OpcItemResult[] ReadAtTime(
TsCHdaItem[] items,
object requestHandle,
TsCHdaReadValuesCompleteEventHandler callback,
out IOpcRequest request)
{
DateTime[] timestamps = new DateTime[Timestamps.Count];
for (int ii = 0; ii < Timestamps.Count; ii++)
{
timestamps[ii] = Timestamps[ii];
}
return(_server.ReadAtTime(timestamps, items, requestHandle, callback, out request));
}
/// <summary>
/// Starts an asynchronous delete raw request for a set of items.
/// </summary>
public OpcItemResult[] Delete(
OpcItem[] items,
object requestHandle,
TsCHdaUpdateCompleteEventHandler callback,
out IOpcRequest request)
{
OpcItemResult[] results = _server.Delete(
StartTime,
EndTime,
items,
requestHandle,
callback,
out request);
return(results);
}
