#endregion

        #region "重新設置數據結構，清除原有數據"
        /// <summary>
        /// 重新設置數據結構，清除原有數據
        /// </summary>
        /// <param name="timepoints">時間點</param>
        /// <param name="channels">道數</param>
        public void ResetNew(int timePoints, int channels)
        {
            _data = new int[timePoints][];
            for (int i = 0; i < timePoints; i++)
            {
                _data[i] = new int[channels];
            }
            _overflowtable = new int[timePoints];
            _tmpdata = new byte[channels * 4];
            _tmpvalue = new int[channels];
            _receivedbyte = 0;
            _dataindex = TimePoints;
        }
        #endregion

        #region "清除數據"
        /// <summary>
        /// 清除數據
        /// </summary>
        public void Clean()
		{
            for (int i = 0; i < _data.GetLength(0); i++)
            {
                Array.Clear(_data[i], 0, _data[i].Length);
            }
            Array.Clear(_overflowtable, 0, _overflowtable.Length);
            _receivedbyte = 0;
            _dataindex = TimePoints;
        }
        #endregion

        #region "返回指定時間點的數據"
        /// <summary>
		/// 返回指定時間點的數據
		/// </summary>
		/// <param name="time">時間點</param>
		/// <returns>一維數組，下標表示道址，數組元素是計數數據</returns>
		public void GetData(out int[] data, int timePoint)
		{
			if(timePoint < 1 || timePoint > TimePoints)
			{
                throw new Exception("timepoint overflow!"); 
			}
			if(_overflow != null)//檢查事件是否有預定
			{
				double max = _islinecoordinate? _overflowtable[timePoint - 1] : Math.Log10(_overflowtable[timePoint - 1]);
				if(max > _maxcount)//如果全譜區的數據溢出則產生全譜區溢出事件
				{
					CountOverFlowEventArgs e = new CountOverFlowEventArgs(OverFlowType.Normal, max);
					_overflow(this, e);
				}
				if(max > _zmaxcount)//如果放大區的數據溢出則產生放大區溢出事件
				{
					CountOverFlowEventArgs e = new CountOverFlowEventArgs(OverFlowType.Zoom, max);
					_overflow(this, e);
				}
			}
            data = _data[timePoint - 1];
        }
        #endregion

        #region "返回最后使用的時間點的數據"
        /// <summary>
		/// 返回最后使用的時間點的數據
		/// </summary>
		/// <returns>一維數組，下標表示道址，數組元素是計數數據</returns>
		public void GetData(out int[] data)
		{
            if (_dataindex == TimePoints)
            {
                throw new Exception("No data.");
            }
            if(_overflow != null)//檢查事件是否有預定
			{
                double max = _islinecoordinate ? _overflowtable[_dataindex] : Math.Log10(_overflowtable[_dataindex]);
				if(max > _maxcount)//如果全譜區的數據溢出則產生全譜區溢出事件
				{
					CountOverFlowEventArgs e = new CountOverFlowEventArgs(OverFlowType.Normal, max);
					_overflow(this, e);
				}
				if(max > _zmaxcount)//如果放大區的數據溢出則產生放大區溢出事件
				{
					CountOverFlowEventArgs e = new CountOverFlowEventArgs(OverFlowType.Zoom, max);
					_overflow(this, e);
				}
			}
            data = _data[_dataindex];
            if (_dataindex < TimePoints - 1)
            {
                _dataindex++;
            }
        }
        #endregion

        #region "開始或停止串口接收數據"
        /// <summary>
        /// 開始或停止串口接收數據
        /// </summary>
        /// <param name="start">開始或停止</param>
        public void ReceiveData(bool start)
        {
            if (start)
            {
                if (_stop)
                {
                    _serialport.Write("1");
                    _stop = false;
                }
            }
            else
            {
                _stop = true;
            }
        }
        #endregion

        #region "從文件讀入數據"
        /// <summary>
		/// 從文件讀入數據
		/// </summary>
		/// <param name="filename">要讀入的文件名</param>
        /// <param name="filename">讀入的屬性</param>
		public void BuildData(string fileName, out Hashtable attributes)
		{
			int timepoints = 0;
			int channels = 0;
			int timepoint = 0;
			int channel = 0;
			int count = 0;
            Hashtable tmpattributes = new Hashtable();
			StreamReader filereader = new StreamReader(fileName);
            XmlTextReader datareader = new XmlTextReader(filereader);
			datareader.WhitespaceHandling = WhitespaceHandling.None;
			while(datareader.Read())
			{
				if(datareader.NodeType == XmlNodeType.Element)
				{
                    if(datareader.Name == "ddata")
					{
                        datareader.MoveToAttribute("timepoints");//讀入時間點數
                        if (datareader.Name == "timepoints")
                        {
                            timepoints = Convert.ToInt32(datareader.Value);
                            _data = new int[timepoints][];
                            _overflowtable = new int[timepoints];
                        }
                        else
                        {
                            throw (new XmlException());
                        }
                        datareader.MoveToAttribute("channels");//讀入道數
                        if (datareader.Name == "channels")
                        {
                            for (int i = 0; i < timepoints; i++)
                            {
                                channels = Convert.ToInt32(datareader.Value);
                                _data[i] = new int[channels];
                            }
                            _tmpdata = new byte[channels * 4];
                            _tmpvalue = new int[channels];
                            _receivedbyte = 0;
                        }
                        else
                        {
                            throw (new XmlException());
                        }
                        while (datareader.MoveToNextAttribute())
                        {
                            tmpattributes[datareader.Name] = datareader.Value;
                        }
					}else
					if(datareader.Name == "timepoint")//時間點
					{
                        datareader.MoveToAttribute("index");//讀入時間點
                        if (datareader.Name == "index")
                        {
                            timepoint = Convert.ToInt32(datareader.Value);
                        }
                        else
                        {
                            throw (new XmlException());
                        }
					}
					else
					if(datareader.Name == "data")//時間點//道址和計數
					{
                        datareader.Read();//讀入計數
						string[] data = datareader.Value.Split(',');
						for(channel = 1; channel < data.Length; channel++)
						{
							count = Convert.ToInt32(data[channel - 1]);
							SetData(timepoint, channel, count);
						}
					}
				}
			}
            _dataindex = 0;
			datareader.Close();
			filereader.Close();
            attributes = tmpattributes;
        }

        /// <summary>
        /// 從文件讀入數據
        /// </summary>
        /// <param name="filename">要讀入的文件名</param>
        public void BuildData(string fileName)
        {
            StreamReader datareader = new StreamReader(fileName);
            ArrayList tmpdata = new ArrayList();
            while (!datareader.EndOfStream)
            {
                tmpdata.Add(datareader.ReadLine());
            }
            _data = new int[1][];
            _data[0] = new int[tmpdata.Count];
            _overflowtable = new int[1];
            for (int i = 0; i < _data[0].Length; i++)
			{
                SetData(1, i + 1, Convert.ToInt32(tmpdata[i]));
			}
            datareader.Close();
        }
        #endregion

        #region "保存譜數據"
        /// <summary>
		/// 保存譜數據
		/// </summary>
		/// <param name="filename">要保存的文件名</param>
        /// <param name="attributes">要保存的屬性</param>
		public void SaveData(string fileName, Hashtable attributes)
		{
			//保存數據
            XmlTextWriter datawriter = new XmlTextWriter(fileName, System.Text.Encoding.Default);
            datawriter.Formatting = Formatting.Indented;
			datawriter.WriteStartDocument();
			datawriter.WriteStartElement("ddata");
            datawriter.WriteAttributeString("timepoints", _data.GetLength(0).ToString());
            datawriter.WriteAttributeString("channels", _data[0].GetLength(0).ToString());
            foreach (string s in attributes.Keys)
            {
                datawriter.WriteAttributeString(s, attributes[s].ToString());
            }
			//寫入每個時間點下的數據
			for(int i = 1; i <= _data.Length; i++)
			{
                datawriter.WriteStartElement("timepoint");
                datawriter.WriteAttributeString("index", i.ToString());
				StringBuilder data = new StringBuilder();
				for(int j = 0; j < _data[0].GetLength(0); j++)
				{
					//寫入每道的道址及其計數
					data.Append(_data[i - 1][j]);
					data.Append(',');
				}
				datawriter.WriteElementString("data", data.ToString());
                datawriter.WriteEndElement();//timepoint
			}
			datawriter.WriteEndElement();//ddata
			datawriter.WriteEndDocument();
			datawriter.Flush();
			datawriter.Close();
        }

        /// <summary>
        /// 保存譜數據
        /// </summary>
        /// <param name="fileName">要保存的文件名</param>
        public void SaveData(string fileName)
        {
            StreamWriter datawriter = new StreamWriter(fileName);
            foreach (int n in _data[_data.Length - 1])
            {
                datawriter.WriteLine(n);
            }
            datawriter.Close();
        }
        #endregion

        #region "返回指定時間點指定道的數據"
        /// <summary>
		/// 返回指定時間點指定道的數據
		/// </summary>
		/// <param name="time">時間點</param>
		/// <param name="channel">道址</param>
		/// <returns>計數</returns>
		public int GetValue(int timePoint, int channel)
		{
			if(timePoint < 1 || timePoint > TimePoints)
			{
                throw new Exception("timepoint overflow!"); 
			}
            if (channel < 0 || channel > _data[0].Length)
            {
                throw new Exception("channel overflow!"); 
            }
			return _data[timePoint - 1][channel - 1];
        }
        #endregion

        #region "返回最后使用的時間點指定道的數據"
        /// <summary>
		/// 返回最后時間點指定道的數據
		/// </summary>
		/// <param name="channel">道址</param>
		/// <returns>計數</returns>
		public int GetValue(int channel)
		{
            if (channel < 0 || channel > _data[0].Length)
            {
                throw new Exception("channel overflow!");
            }
            return _data[_dataindex][channel - 1];
        }
        #endregion

        #endregion

        #endregion

        #region "事件"
       
        /// <summary>
        /// 計數溢出事件
        /// </summary>
        private event CountOverFlowEventHandler _overflow;
        
        /// <summary>
        /// 數據到達事件
        /// </summary>
        private event EventHandler _datareceived;

        /// <summary>
        /// 增加或刪除計數溢出事件
        /// </summary>
        public event CountOverFlowEventHandler OverFlow
        {
            add
            {
                _overflow += value;
            }
            remove
            {
                _overflow -= value;
            }
        }

        /// <summary>
        /// 增加或刪除數據到達事件
        /// </summary>
        public event EventHandler DataReceived
        {
            add
            {
                _datareceived += value;
            }
            remove
            {
                _datareceived -= value;
            }
        }

        #endregion
    }
    #endregion

    #region "計數溢出事件的委托"
    /// <summary>
    /// 計數溢出事件的委托
    /// </summary>
    public delegate void CountOverFlowEventHandler(object sender, CountOverFlowEventArgs e);
    #endregion

    #region "計數溢出事件類"
    /// <summary>
	/// 計數溢出事件類
	/// </summary>
	public class CountOverFlowEventArgs : EventArgs
	{
		/// <summary>
		/// 計數溢出類型
		/// </summary>
		private OverFlowType _oftype;
		private double _maxcount;
		
		public CountOverFlowEventArgs(OverFlowType oftype, double maxcount)
		{
			_oftype = oftype;
			_maxcount = maxcount;
		}

		/// <summary>
		/// 獲取計數溢出類型
		/// </summary>
		public OverFlowType Oftype
		{
			get
			{
				return _oftype;
			}
		}

        /// <summary>
        /// 獲取最大計數
        /// </summary>
		public double MaxCount
		{
			get
			{
				return _maxcount;
			}
		}
    }
    #endregion

    #region "計數溢出枚舉"
    /// <summary>
	/// 表示是哪個區的計數溢出
	/// </summary>
	public enum OverFlowType
	{
		/// <summary>
		/// Normal表示全譜區，Zoom表示放大曲
		/// </summary>
		Normal, Zoom
    }
    #endregion
}