Example #1
0
        /// <summary>
        /// Invokes callback for a read attributes request.
        /// </summary>
        private bool InvokeCallback(TsCHdaReadAttributesCompleteEventHandler callback, object results)
        {
            // check for valid result type.
            if (!typeof(TsCHdaItemAttributeCollection).IsInstanceOfType(results))
            {
                return(false);
            }

            TsCHdaItemAttributeCollection values = (TsCHdaItemAttributeCollection)results;

            // update item handles and actual times.
            UpdateResults(new TsCHdaItemAttributeCollection[] { values });

            try
            {
                callback(this, values);
            }
            catch
            {
                // ignore exceptions in the callbacks.
            }

            // request always completes
            return(true);
        }
Example #2
0
        /// <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);
            }
        }
Example #3
0
        /// <summary>
        /// Called when an asynchronous read attributes request completes.
        /// </summary>
        public void OnReadAttributeComplete(
            int dwTransactionID,
            int hrStatus,
            int hClient,
            int dwNumItems,
            OPCHDA_ATTRIBUTE[] pAttributeValues,
            int[]              phrErrors)
        {
            try
            {
                lock (this)
                {
                    // lookup request transaction.
                    Request request = (Request)m_requests[dwTransactionID];

                    if (request == null)
                    {
                        return;
                    }

                    // create item object to collect results.
                    TsCHdaItemAttributeCollection item = new TsCHdaItemAttributeCollection();
                    item.ServerHandle = hClient;

                    // unmarshal results.
                    Technosoftware.DaAeHdaClient.Hda.TsCHdaAttributeValueCollection[] results = new Technosoftware.DaAeHdaClient.Hda.TsCHdaAttributeValueCollection[pAttributeValues.Length];

                    for (int ii = 0; ii < pAttributeValues.Length; ii++)
                    {
                        results[ii] = Interop.GetAttributeValueCollection(pAttributeValues[ii], false);

                        results[ii].Result = Technosoftware.DaAeHdaClient.Utilities.Interop.GetResultID(phrErrors[ii]);

                        item.Add(results[ii]);
                    }

                    // invoke callback - remove request if all results arrived.
                    if (request.InvokeCallback(item))
                    {
                        m_requests.Remove(request.RequestID);
                    }
                }
            }
            catch (Exception exception)
            {
                HandleException(dwTransactionID, exception);
            }
        }
        /// <summary>
        /// Displays the results of a read attributes request.
        /// </summary>
        public void Initialize(TsCHdaServer server, TsCHdaItemAttributeCollection results)
        {
            mServer_ = server;

            attributesLv_.Items.Clear();

            if (results != null)
            {
                foreach (Technosoftware.DaAeHdaClient.Hda.TsCHdaAttributeValueCollection result in results)
                {
                    AddListItem(result);
                }

                AdjustColumns();
            }
        }
        /// <summary>
        /// Displays the results of a read attributes request.
        /// </summary>
        public void Initialize(TsCHdaServer server, TsCHdaItemAttributeCollection results)
        {
            m_server = server;

            AttributesLV.Items.Clear();

            if (results != null)
            {
                foreach (OpcClientSdk.Hda.TsCHdaAttributeValueCollection result in results)
                {
                    AddListItem(result);
                }

                AdjustColumns();
            }
        }
Example #6
0
        /// <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;
            }

            if (!m_fixedItem)
            {
                m_attributeIDs = null;
                m_item         = null;
            }
        }
        /// <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;
            }

            if (!mFixedItem_)
            {
                mAttributeIDs_ = null;
                mItem_         = null;
            }
        }
Example #8
0
        /// <summary>
        /// Creates a server handle for the selected item and reads the data.
        /// </summary>
        private void DoItemRead()
        {
            // get the attribute ids.
            if (m_attributeIDs == null)
            {
                m_attributeIDs = AttributesCTRL.GetAttributeIDs(true);
                return;
            }

            // create item (if necessary).
            TsCHdaItem item = m_trend.Items[m_item];

            if (item == null)
            {
                item = m_trend.AddItem(m_item);
            }

            // get the paramaters.
            TrendCTRL.Update(m_trend);

            // get the attributes.
            m_attributeIDs = AttributesCTRL.GetAttributeIDs(true);

            if (m_synchronous)
            {
                // read data.
                TsCHdaItemAttributeCollection results = m_trend.ReadAttributes(item, m_attributeIDs);

                if (results == null || results.Count != m_attributeIDs.Length)
                {
                    ////throw new InvalidResponseException();
                }

                // display results.
                ResultsCTRL.Initialize(m_server, results);

                // save results.
                m_results = results;
            }
            else
            {
                // check if already waiting for results.
                if (m_asyncSent)
                {
                    return;
                }

                // begin read data.
                TsCHdaResultCollection results = m_trend.ReadAttributes(
                    item,
                    m_attributeIDs,
                    null,
                    new TsCHdaReadAttributesCompleteEventHandler(OnReadComplete),
                    out m_request);

                if (results == null || results.Count != m_attributeIDs.Length)
                {
                    ////throw new InvalidResponseException();
                }

                // display initial results.
                AsyncResultsCTRL.Initialize(m_server, m_attributeIDs, results);
                m_asyncSent = true;
            }
        }
        /// <summary>
        /// Creates a server handle for the selected item and reads the data.
        /// </summary>
        private void DoItemRead()
        {
            // get the attribute ids.
            if (mAttributeIDs_ == null)
            {
                mAttributeIDs_ = attributesCtrl_.GetAttributeIDs(true);
                return;
            }

            // create item (if necessary).
            TsCHdaItem item = mTrend_.Items[mItem_];

            if (item == null)
            {
                item = mTrend_.AddItem(mItem_);
            }

            // get the paramaters.
            trendCtrl_.Update(mTrend_);

            // get the attributes.
            mAttributeIDs_ = attributesCtrl_.GetAttributeIDs(true);

            if (mSynchronous_)
            {
                // read data.
                TsCHdaItemAttributeCollection results = mTrend_.ReadAttributes(item, mAttributeIDs_);

                if (results == null || results.Count != mAttributeIDs_.Length)
                {
                    ////throw new InvalidResponseException();
                }

                // display results.
                resultsCtrl_.Initialize(mServer_, results);

                // save results.
                mResults_ = results;
            }
            else
            {
                // check if already waiting for results.
                if (mAsyncSent_)
                {
                    return;
                }

                // begin read data.
                TsCHdaResultCollection results = mTrend_.ReadAttributes(
                    item,
                    mAttributeIDs_,
                    null,
                    new TsCHdaReadAttributesCompleteEventHandler(OnReadComplete),
                    out mRequest_);

                if (results == null || results.Count != mAttributeIDs_.Length)
                {
                    ////throw new InvalidResponseException();
                }

                // display initial results.
                asyncResultsCtrl_.Initialize(mServer_, mAttributeIDs_, results);
                mAsyncSent_ = true;
            }
        }