/// <summary>
        /// Parses a "probenode" configuration node.
        /// </summary>
        /// <param name="nodes">The TreeNodeCollection to which config items are to be added.</param>
        /// <param name="probeXEl">The XElement containing the probenode</param>
        /// <returns>The number of netflow sensors in this probenode</returns>
        private int ParseProbeNode(TreeNodeCollection nodes, XElement probeXEl)
        {
            ProbeTreeNode probeNode = new ProbeTreeNode((string)probeXEl.Attribute("id"), ((string)probeXEl.Element("data").Element("name")).Trim());

            int numChildren = 0;

            foreach (XElement deviceXEl in probeXEl.Element("nodes").Elements("device"))
            {
                numChildren += this.ParseDeviceNode(probeNode, deviceXEl);
            }

            foreach (XElement groupXEl in probeXEl.Element("nodes").Elements("group"))
            {
                numChildren += this.ParseGroupNode(probeNode, groupXEl);
            }

            if (numChildren > 0)
            {
                nodes.Add(probeNode);
                probes.Add(probeNode);
            }

            return(numChildren);
        }
        private void AddDeviceTreeForChannel(int channelID, TreeNode parentNode)
        {
            if (!flowChannels.ContainsKey(channelID))
            {
                flowChannels[channelID] = new ChannelDefTreeNode(channelID, "ChannelDef_" + channelID);
            }

            TreeNode currentNode = flowChannels[channelID];

            PRTGTreeNode parNode = parentNode as PRTGTreeNode;
            PRTGTreeNode curNode = currentNode as PRTGTreeNode;

            if (parNode == null || curNode == null)
            {
                return;
            }

            Stack <PRTGTreeNode> nodeList = new Stack <PRTGTreeNode>();

            while (parNode != null)
            {
                PRTGTreeNode newNode = null;
                if (parNode is DeviceTreeNode)
                {
                    newNode = new DeviceTreeNode(parNode.Id, parNode.Text);
                }
                else if (parNode is GroupTreeNode)
                {
                    newNode = new GroupTreeNode(parNode.Id, parNode.Text);
                }
                else if (parNode is ProbeTreeNode)
                {
                    newNode = new ProbeTreeNode(parNode.Id, parNode.Text);
                }
                nodeList.Push(newNode);
                parNode = parNode.Parent as PRTGTreeNode;
            }

            while (nodeList.Count > 0)
            {
                PRTGTreeNode n     = nodeList.Pop();
                bool         found = false;
                PRTGTreeNode t     = null;

                foreach (PRTGTreeNode p in curNode.Nodes)
                {
                    if ((n is DeviceTreeNode && p is DeviceTreeNode && n.Id == p.Id) ||
                        (n is GroupTreeNode && p is GroupTreeNode && n.Id == p.Id) ||
                        (n is ProbeTreeNode && p is ProbeTreeNode && n.Id == p.Id))
                    {
                        found = true;
                        t     = p;
                        break;
                    }
                }

                if (found == true)
                {
                    curNode = t;
                    continue;
                }

                curNode.Nodes.Add(n);
                curNode = n;
            }
        }