第五次作业【mp3播放器--草莓播放器】

【草莓播放器】

代码实现:
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

using System.Runtime.InteropServices;
using DotNetSimple.MusicPlayer.Plus;
using System.IO;
using System.Xml;
//BASS解码器引用
using Un4seen.Bass;
using System.Diagnostics;
using System.Threading;
using System.Net;

namespace DotNetSimple.MusicPlayer
{
    public partial class mainFrm : TempleteFrm
    {
        //垃圾回收声明
        [DllImport("kernel32.dll", EntryPoint = "SetProcessWorkingSetSize")]
        public static extern int SetProcessWorkingSetSize(int hProcess, int dwMinimumWorkingSetSize, int dwMaximumWorkingSetSize);

        #region Enum 枚举类型

        /// <summary>
        /// 播放器状态
        /// </summary>
        private enum PlayerState
        {
            /// <summary>
            /// 停止模式
            /// </summary>
            Stop,
            /// <summary>
            /// 播放模式
            /// </summary>
            Play,
            /// <summary>
            /// 暂停模式
            /// </summary>
            Pause
        }

        /// <summary>
        /// 播放模式选择
        /// </summary>
        private enum PlayMode
        {
            /// <summary>
            /// 单曲播放
            /// </summary>
            SinglePlay,
            /// <summary>
            /// 单曲循环
            /// </summary>
            SingleCycle,
            /// <summary>
            /// 列表循环
            /// </summary>
            CyclePlay,
            /// <summary>
            /// 顺序播放
            /// </summary>
            OrderPlay,
            /// <summary>
            /// 随机播放
            /// </summary>
            RandomPlay
        }

        #endregion

        #region 当前曲目参数

        /// <summary>
        /// 当前播放曲目索引
        /// </summary>
        private int changeValue = 0;

        //记录当前播放器的状态。
        private PlayerState playerState = PlayerState.Stop;

        /// <summary>
        /// 播放模式
        /// </summary>
        private PlayMode playModel = PlayMode.SinglePlay;

        /// <summary>
        /// 播放器实例
        /// </summary>
        public BassEngine bassPlayer = null;

        /// <summary>
        /// Lrc文件时间组
        /// </summary>
        private string[] Ltime = new string[200];

        private string[] Ltext = new string[200];

        private string bigTime;

        private string smallTime;

        private bool nextLrc = false;

        #endregion

        #region 其他

        protected internal AnchorStyles StopAanhor = AnchorStyles.None;

        /// <summary>
        /// 音乐窗实例
        /// </summary>
        protected internal musicMiniFrm musicMiniFrm;

        /// <summary>
        /// 桌面歌词窗
        /// </summary>
        protected internal DiskLrcFrm diskLrcFrm;

        /// <summary>
        /// 歌词秀窗体实例
        /// </summary>
        protected internal LyricsFrm lyricsFrm;

        /// <summary>
        /// 歌词搜索下载类
        /// </summary>
        protected internal LyricsHelper lyricsHelper;

        /// <summary>
        /// 歌词匹配类
        /// </summary>
        protected internal LrcRegex lrcRegex = new LrcRegex();

        /// <summary>
        /// 当前音乐列表类型
        /// </summary>
        protected internal string tabMusicType = "默认列表";

        /// <summary>
        /// 搜索歌词线程
        /// </summary>
        protected internal Thread threadSearchLrc;

        #endregion

        public mainFrm()
        {
            InitializeComponent();

            #region 初始化配置信息

            LoadDiskLrcPanel();

            this.lyricsHelper = new LyricsHelper(false);
            
            this.lyricsHelper.InitializeProxy += new EventHandler(InitializeProxy);
            
            this.lyricsHelper.WebException += new EventHandler(WebException);
            
            this.lyricsHelper.SelectSong += new EventHandler(SelectSong);

            try
            {
               
                this.bassPlayer = BassEngine.Instance;
            }
            catch (Exception exp)
            {
                MessageBox.Show(exp.Message, "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Error);
                Application.Exit();
                return;
            }

            
            this.lvMusicListView.SmallImageList = new ImageList();
            this.lvMusicListView.SmallImageList.ImageSize = new Size(1, 22);

            
            IniFiles ini = new IniFiles(Application.StartupPath + "\\Ini\\config.ini");

            
            int valume = int.Parse(ini.ReadValue("Player", "Valume"));
            //初始化音量默认参数
            this.bassPlayer.Volume = this.tbValume.Value = valume;

            //获取配置文件 - 播放模式
            int playModel = int.Parse(ini.ReadValue("Player", "PlayModel"));
            switch (playModel)
            {
                case (int)PlayMode.CyclePlay:
                    this.tsmiCyclePlay.Checked = true;
                    this.playModel = PlayMode.CyclePlay;
                    this.tipTitle.SetToolTip(this.pbPlayerModel, this.tsmiCyclePlay.Text);
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\cycle.png");
                    break;
                case (int)PlayMode.OrderPlay:
                    this.tsmiOrderPlay.Checked = true;
                    this.playModel = PlayMode.OrderPlay;
                    this.tipTitle.SetToolTip(this.pbPlayerModel, this.tsmiOrderPlay.Text);
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\order.png");
                    break;
                case (int)PlayMode.RandomPlay:
                    this.tsmiRandomPlay.Checked = true;
                    this.playModel = PlayMode.RandomPlay;
                    this.tipTitle.SetToolTip(this.pbPlayerModel, this.tsmiRandomPlay.Text);
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\random.png");
                    break;
                case (int)PlayMode.SingleCycle:
                    this.tsmiSingleCycle.Checked = true;
                    this.playModel = PlayMode.SingleCycle;
                    this.tipTitle.SetToolTip(this.pbPlayerModel, this.tsmiSingleCycle.Text);
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\singlecycle.png");
                    break;
                case (int)PlayMode.SinglePlay:
                    this.tsmiSinglePlay.Checked = true;
                    this.playModel = PlayMode.SinglePlay;
                    this.tipTitle.SetToolTip(this.pbPlayerModel, this.tsmiSinglePlay.Text);
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\single.png");
                    break;
                default:
                    break;
            }

            
            int mainHeight = int.Parse(ini.ReadValue("Player", "MainHeight"));
            this.Height = mainHeight;

            //加载XML文件歌曲列表
            OpenPlayList();

            #endregion
        }

        #region 窗体按钮事件

        protected override void OnFormClosing(FormClosingEventArgs e)
        {
            if (MessageBox.Show(null, "要关闭窗口吗？", "自定义窗口按钮", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.Cancel)
            {
                e.Cancel = true;
            }
            base.OnFormClosing(e);
        }

        private void pbClose_Click(object sender, EventArgs e)
        {
            Application.Exit();
        }

        private void pbContextMenu_MouseDown(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
                this.contextMenuStrip1.Show(MousePosition);
        }

        private void pbMinimized_Click(object sender, EventArgs e)
        {
            this.WindowState = FormWindowState.Minimized;
        }

        private void pnlHearts_MouseDown(object sender, MouseEventArgs e)
        {
            if (this.pnlHearts.Tag.ToString() == "0")
            {
                this.pnlHearts.Tag = "1";
                this.pnlHearts.BackgroundImage = Image.FromFile(Application.StartupPath + "\\images\\hearts_m.png");
            }
            else
            {
                this.pnlHearts.Tag = "0";
                this.pnlHearts.BackgroundImage = Image.FromFile(Application.StartupPath + "\\images\\hearts.png");
            }
        }

        #endregion

        /// <summary>
        /// 关闭歌词面板
        /// </summary>
        protected void CloseLrcPanel()
        {
            this.diskLrcFrm.manualReset.Set();
            this.diskLrcFrm.thread.Abort();
            this.diskLrcFrm.Close();
            this.diskLrcFrm = null;
        }

        /// <summary>
        /// 加载歌词面板
        /// </summary>
        protected void LoadDiskLrcPanel()
        {
            this.diskLrcFrm = new DiskLrcFrm();
            //关闭歌词面板回调函数
            this.diskLrcFrm.CloseLrcPanel += new DiskLrcFrm.CloseLrcPanelHandler(CloseLrcPanel);
            //上一曲回调函数
            this.diskLrcFrm.PreMusicLrcPanel += new DiskLrcFrm.PreMusicLrcPanelHandler(PreMusicLrcPanel);
            //播放暂停回调函数
            this.diskLrcFrm.PlayOrPauseMusicLrcPanel += new DiskLrcFrm.PlayOrPauseMusicLrcPanelHandler(PlayOrPauseMusicLrcPanel);
            //下一曲回调函数
            this.diskLrcFrm.NextMusicLrcPanel += new DiskLrcFrm.NextMusicLrcPanelHandler(NextMusicLrcPanel);
            //搜索歌词回调函数
            this.diskLrcFrm.SearchLrcPanel += new DiskLrcFrm.SearchLrcPanelHandler(SearchLrcPanel);
            this.diskLrcFrm.Init("===草莓音乐===", 0);
            this.diskLrcFrm.Show();
        }

        #region 媒体列表管理

        /// <summary>
        /// 打开曲目列表
        /// </summary>
        private void OpenPlayList()
        {
            XmlDocument xmlDoc = new XmlDocument();

            //加载Xml文件
            xmlDoc.Load(string.Format("{0}\\PlayList\\{1}.xml", Application.StartupPath, this.tabMusicType));

            //匹配曲目列表
            XmlNode root = xmlDoc.SelectSingleNode("musiclist");//查找<musiclist>
            //清空歌曲列表
            this.lvMusicListView.Items.Clear();
            //获取所有曲目列表
            XmlNodeList xnl = root.ChildNodes;
            bool flag = false;      //设置当前列表是否有正在播放的曲目
            this.lvMusicListView.BeginUpdate();
            for (int i = 0; i < xnl.Count; i++)
            {
                ListViewItem item = new ListViewItem(root.ChildNodes[i].Attributes["genre"].Value);
                //依次顺序为：曲目名称|曲目长度
                item.SubItems.AddRange(new string[] { root.ChildNodes[i].Attributes["lenght"].Value });

                //设置背景色
                if (i % 2 == 0)
                    item.BackColor = Color.FromArgb(232, 243, 250);

                //设置曲目绝对路径
                item.Tag = root.ChildNodes[i].Attributes["filename"].Value;
                //判断当前加载曲目是否是当前播放曲目，如果是则高亮显示并保存播放信息
                if (this.bassPlayer.OpenningFile == root.ChildNodes[i].Attributes["filename"].Value)
                {
                    //设置当前选中项背景颜色
                    item.BackColor = Color.FromArgb(142, 185, 209);
                    item.ForeColor = Color.FromArgb(255, 255, 255);
                    //更新当前下标，以免造成可能的列表下标越界
                    this.changeValue = i;
                    flag = true;
                }
                this.lvMusicListView.Items.Add(item);
                //处理消息队列
                Application.DoEvents();
            }
            this.lvMusicListView.EndUpdate();

            //如果当前列表没有正在播放的曲目，则将序列号初始化为-1,以免造成可能的列表下标越界
            if (!flag)
            {
                //由于在进行计时器运行时，播放下一曲会进行+1，因此设置成-1后，计时器加1变成0，刚好从0下标开始重新播放
                this.changeValue = -1;
            }
        }

        /// <summary>
        /// 添加本地歌曲
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tsmiAddLocalMusic_Click(object sender, EventArgs e)
        {
            try
            {
                using (OpenFileDialog ofd = new OpenFileDialog())
                {
                    //允许多选
                    ofd.Multiselect = true;
                    //文件格式
                    ofd.Filter = "音乐文件|*.mp3;*.wma;*.flac;*.ogg*.wav;*.aiff;*.mp2;*.mp1";
                    //对话框标题
                    ofd.Title = "打开媒体文件";
                    if (ofd.ShowDialog() == DialogResult.OK)
                    {
                        XmlDocument xmlDoc = new XmlDocument();

                        //加载Xml文件
                        xmlDoc.Load(string.Format("{0}\\PlayList\\{1}.xml", Application.StartupPath, this.tabMusicType));
                        XmlNode root = xmlDoc.SelectSingleNode("musiclist");//查找<musiclist>
                        //列表更新准备
                        this.lvMusicListView.BeginUpdate();
                        //遍历加载当前选中文件
                        for (int i = 0; i < ofd.FileNames.Length; i++)
                        {
                            //打开音乐设备
                            this.bassPlayer.OpenFile(ofd.FileNames[i]);
                            //返回没有后缀的文件名
                            string musicName = Path.GetFileNameWithoutExtension(ofd.FileNames[i]);
                            //添加ListView项
                            ListViewItem item = new ListViewItem(musicName);
                            item.SubItems.AddRange(new string[] { GetStardandTimeString(this.bassPlayer.ChannelLength) });

                            //设置背景色
                            if (i % 2 == 0)
                                item.BackColor = Color.FromArgb(232, 243, 250);

                            item.Tag = ofd.FileNames[i];
                            this.lvMusicListView.Items.Add(item);

                            XmlElement xe1 = xmlDoc.CreateElement("name");//创建一个音乐节点 
                            xe1.SetAttribute("genre", musicName);//设置该节点文件路径属性 
                            xe1.SetAttribute("filename", ofd.FileNames[i]);//设置该节点文件名属性
                            xe1.SetAttribute("lenght", GetStardandTimeString(this.bassPlayer.ChannelLength));//设置该节点音乐时间属性
                            root.AppendChild(xe1);//添加到<musiclist>节点中                         
                            //处理消息队列
                            //Application.DoEvents();
                        }
                        //更新列表结束
                        this.lvMusicListView.EndUpdate();
                        xmlDoc.Save(string.Format("{0}\\PlayList\\{1}.xml", Application.StartupPath, this.tabMusicType));

                        //释放资源，减少内存占用
                        SetProcessWorkingSetSize(Process.GetCurrentProcess().Handle.ToInt32(), -1, -1);
                    }
                }
            }
            catch (Exception exp)
            {
                MessageBox.Show(exp.Message, "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// 添加文件夹
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tsmiAddLocalFolder_Click(object sender, EventArgs e)
        {
            try
            {
                //打开文件夹选择对话框
                using (FolderBrowserDialog fbd = new FolderBrowserDialog())
                {
                    if (fbd.ShowDialog() == DialogResult.OK)
                    {
                        DirectoryInfo dInfo = new DirectoryInfo(fbd.SelectedPath);
                        //遍历该文件夹
                        FileInfo[] files = dInfo.GetFiles("*.*", SearchOption.AllDirectories);

                        try
                        {
                            XmlDocument xmlDoc = new XmlDocument();
                            //加载Xml文件
                            xmlDoc.Load(string.Format("{0}\\PlayList\\{1}.xml", Application.StartupPath, this.tabMusicType));
                            XmlNode root = xmlDoc.SelectSingleNode("musiclist");//查找<musiclist>
                            this.lvMusicListView.BeginUpdate();
                            foreach (FileInfo fileName in files)
                            {
                                //获取文件扩展名
                                string extension = Path.GetExtension(fileName.FullName);
                                //判断是否为音乐文件
                                //if (extension.ToLower() == ".mp3" || extension.ToLower() == ".wma" || extension.ToLower() == ".wav")
                                //{
                                //打开音乐设备
                                this.bassPlayer.OpenFile(fileName.FullName);

                                XmlElement xe1 = xmlDoc.CreateElement("name");//创建一个音乐节点 
                                xe1.SetAttribute("genre", Path.GetFileNameWithoutExtension(fileName.FullName));//设置该节点文件路径属性 
                                xe1.SetAttribute("filename", fileName.FullName);//设置该节点文件名属性
                                xe1.SetAttribute("lenght", GetStardandTimeString(this.bassPlayer.ChannelLength));//设置该节点音乐时间属性
                                root.AppendChild(xe1);//添加到<musiclist>节点中   

                                ListViewItem item = new ListViewItem(Path.GetFileNameWithoutExtension(fileName.FullName));
                                //添加到播放列表
                                item.SubItems.AddRange(new string[] { xe1.GetAttribute("length") });
                                item.Tag = fileName.FullName;
                                this.lvMusicListView.Items.Add(item);
                                //}
                                //Application.DoEvents();
                            }
                            this.lvMusicListView.EndUpdate();
                            xmlDoc.Save(string.Format("{0}\\PlayList\\{1}.xml", Application.StartupPath, this.tabMusicType));
                        }
                        catch (Exception exp)
                        {
                            throw exp;
                        }

                        //垃圾回收，释放资源，减少内存占用
                        SetProcessWorkingSetSize(Process.GetCurrentProcess().Handle.ToInt32(), -1, -1);
                    }
                    //this.Mainfrm.btnPlayOrPause.Enabled = true;
                }
            }
            catch (Exception exp)
            {
                MessageBox.Show(exp.Message, "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// 删除选中歌曲
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tsmiDeleteChangeMusic_Click(object sender, EventArgs e)
        {
            try
            {
                //判断是否至少选中一项
                if (this.lvMusicListView.SelectedItems.Count == 0)
                {
                    MessageBox.Show("请选择您要删除的歌曲!", "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                else
                {
                    //获取选中歌曲数目
                    ListView.SelectedListViewItemCollection collection = this.lvMusicListView.SelectedItems;
                    //循环删除选中歌曲
                    foreach (ListViewItem item in collection)
                    {
                        this.lvMusicListView.Items.Remove(item);
                    }
                    SaveXmlFile();

                    this.lvMusicListView.BeginUpdate();
                    //重置列表背景颜色
                    for (int i = 0; i < this.lvMusicListView.Items.Count; i++)
                    {
                        if (i % 2 == 0)
                            this.lvMusicListView.Items[i].BackColor = Color.FromArgb(230, 243, 250);
                        else
                            this.lvMusicListView.Items[i].BackColor = Color.FromArgb(250, 250, 250);
                    }
                    this.lvMusicListView.EndUpdate();
                }
            }
            catch (Exception exp)
            {
                MessageBox.Show(exp.Message, "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// 清空当前列表
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tsmiClearList_Click(object sender, EventArgs e)
        {
            try
            {
                XmlDocument xmlDoc = new XmlDocument();
                //加载Xml文件
                xmlDoc.Load(string.Format("{0}\\PlayList\\{1}.xml", Application.StartupPath, this.tabMusicType));
                XmlNode root = xmlDoc.SelectSingleNode("musiclist");//查找<musiclist>
                //删除所有歌曲列表
                root.RemoveAll();
                //保存歌曲列表
                xmlDoc.Save(string.Format("{0}\\PlayList\\{1}.xml", Application.StartupPath, this.tabMusicType));
                //清空列表
                this.lvMusicListView.Items.Clear();

                //this.number = 1;
            }
            catch (Exception exp)
            {
                MessageBox.Show(exp.Message, "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }


        /// <summary>
        /// 触发删除键,删除选中歌曲
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void lvMusicListView_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Delete)       //如果触发Delete删除键则删除当前选中歌曲
                tsmiDeleteChangeMusic_Click(null, null);
        }

        /// <summary>
        /// 删除重复歌曲
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tsmDeleteRepeat_Click(object sender, EventArgs e)
        {
            //冒泡排序法——删除重复歌曲
            for (int i = 0; i < this.lvMusicListView.Items.Count; i++)            //控制比较多少轮
            {
                //将重复元素删除
                for (int j = 0; j < this.lvMusicListView.Items.Count; j++)
                {
                    //如果两个比较的元素相同并且不是同一元素,执行删除操作
                    if (this.lvMusicListView.Items[i].Tag.ToString() == this.lvMusicListView.Items[j].Tag.ToString() && i != j)
                    {
                        this.lvMusicListView.Items[j].Remove();
                        //判断当前播放歌曲是否存在于删除之列,如果存在设置当前播放曲目为第一首
                        if (this.changeValue == j)
                            this.changeValue = 0;
                    }
                }
            }

            this.lvMusicListView.BeginUpdate();
            //重置列表背景颜色
            for (int i = 0; i < this.lvMusicListView.Items.Count; i++)
            {
                if (i % 2 == 0)
                    this.lvMusicListView.Items[i].BackColor = Color.FromArgb(230, 243, 250);
                else
                    this.lvMusicListView.Items[i].BackColor = Color.FromArgb(250, 250, 250);
            }
            this.lvMusicListView.EndUpdate();

            SaveXmlFile();
        }

        /// <summary>
        /// 删除本地文件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tsmiDeleteLocalFile_Click(object sender, EventArgs e)
        {
            //循环删除选中歌曲本地文件
            foreach (ListViewItem item in this.lvMusicListView.SelectedItems)
            {
                File.Delete(item.Tag.ToString());
            }
            //删除列表文件
            tsmiDeleteChangeMusic_Click(sender, e);
        }

        /// <summary>
        /// 重新保存歌曲列表
        /// </summary>
        private void SaveXmlFile()
        {
            XmlDocument xmlDoc = new XmlDocument();
            //加载Xml文件
            xmlDoc.Load(string.Format("{0}\\PlayList\\{1}.xml", Application.StartupPath, this.tabMusicType));
            XmlNode root = xmlDoc.SelectSingleNode("musiclist");//查找<musiclist>
            //清空原来所有歌曲
            root.RemoveAll();
            for (int i = 0; i < this.lvMusicListView.Items.Count; i++)
            {
                XmlElement xe1 = xmlDoc.CreateElement("name");//创建一个音乐节点 
                xe1.SetAttribute("genre", this.lvMusicListView.Items[i].SubItems[0].Text);//设置该节点文件路径属性 
                xe1.SetAttribute("filename", this.lvMusicListView.Items[i].Tag.ToString());//设置该节点文件名属性
                xe1.SetAttribute("lenght", this.lvMusicListView.Items[i].SubItems[1].Text);//设置该节点音乐时间属性
                root.AppendChild(xe1);//添加到<musiclist>节点中    
            }
            //保存歌曲列表
            xmlDoc.Save(string.Format("{0}\\PlayList\\{1}.xml", Application.StartupPath, this.tabMusicType));
        }


        /// <summary>
        /// 初始化ListView列表控件背景颜色
        /// </summary>
        /// <param name="lv"></param>
        private void InitListView(ListView lv, int index)
        {
            if (this.changeValue != -1)
            {
                //将上次选中项背景还原为默认颜色
                lv.Items[index].BackColor = index % 2 == 0 ? Color.FromArgb(230, 243, 250) : Color.FromArgb(255, 255, 255);
                lv.Items[index].ForeColor = Color.FromArgb(105, 105, 105);
            }
        }

        #endregion

        #region 控件状态设置

        /// <summary>
        /// 播放状态下控件
        /// </summary>
        private void GetPlayButton()
        {
            //设置曲目标题
            this.lblMusicName.Text = this.lvMusicListView.Items[this.changeValue].SubItems[0].Text;
            //设置当前播放状态为正在播放
            this.playerState = PlayerState.Play;
            //开始播放
            this.bassPlayer.Play();
            //启动指针计时器
            this.timer1.Start();
            //修改当前播放按钮背景
            this.pbPlayOrPause.Image = Image.FromFile(Application.StartupPath + "\\images\\pause.png");
            this.pbTagImage.Image = this.bassPlayer.TagInfo.PictureGetImage(0);

            //启动新的线程，搜索歌词
            threadSearchLrc = new Thread(new ThreadStart(SerchLrc));
            threadSearchLrc.Start();

            if (this.diskLrcFrm != null)
            {
                this.diskLrcFrm.IsPlay = true;
                this.diskLrcFrm.IsAfreshDraw = true;
            }
        }

        /// <summary>
        /// 暂停状态下的控件
        /// </summary>
        private void GetPauseButton()
        {
            //停止计时器
            this.timer1.Stop();
            //将播放器设备设置为暂停
            this.bassPlayer.Pause();
            //将播放标识设置为暂停
            this.playerState = PlayerState.Pause;
            //修改播放按钮背景
            this.pbPlayOrPause.Image = Image.FromFile(Application.StartupPath + "\\images\\play.png");

            if (this.diskLrcFrm != null)
            {
                this.diskLrcFrm.IsPlay = false;
                this.diskLrcFrm.IsAfreshDraw = true;
            }
        }

        /// <summary>
        /// 停止状态下的控件
        /// </summary>
        private void GetStopButton()
        {
            //停止计时器
            this.timer1.Stop();
            //还原进度条归零
            this.tbSlider.Value = 0;
            //还原计时显示归零
            this.lblDuration.Text = "00:00";
            //还原当前播放歌曲标题显示提示
            this.lblMusicName.Text = "暂无音乐文件";
            //设置当前播放状态标识为停止播放
            this.playerState = PlayerState.Stop;
            //停止播放器设备
            this.bassPlayer.Stop();
            //修改播放按钮背景
            this.pbPlayOrPause.Image = Image.FromFile(Application.StartupPath + "\\images\\play.png");

            if (this.diskLrcFrm != null)
            {
                this.diskLrcFrm.IsPlay = false;
                this.diskLrcFrm.IsAfreshDraw = true;
            }
        }


        #endregion

        #region 歌词搜索处理

        protected void SelectSong(object sender, EventArgs e)
        {
            //返回Xml形式的搜索结果
            XmlNodeList list = sender as XmlNodeList;
            string musicName = Path.GetFileNameWithoutExtension(this.bassPlayer.OpenningFile);
            //判断是否搜索到歌词信息
            if (list != null)
            {
                //如果歌词集合为0，表示没有搜索结果
                if (list.Count == 0)
                {
                    this.tmrLrc.Stop();
                    //如果没有搜索结果，歌词面板显示手动下载链接
                    this.diskLrcFrm.LrcText = "未搜索到歌词！请尝试手动下载。";
                    this.diskLrcFrm.IsAfreshDraw = true;
                }
                else
                {
                    //默认选择第一条歌词信息作为下载对象
                    this.lyricsHelper.CurrentSong = list[0];
                    //下载歌词文件
                    bool flag = this.lyricsHelper.DownloadLrc(musicName + ".lrc");
                    //判断歌词文件是否下载成功
                    if (flag)
                    {
                        IList<Plus.Attribute> attributeList = new List<Plus.Attribute>();
                        attributeList.Add(new Plus.Attribute() { AttributeName = "name", AttributeValue = this.bassPlayer.OpenningFile });
                        attributeList.Add(new Plus.Attribute() { AttributeName = "lrc", AttributeValue = string.Format("{0}\\lrc\\{1}.lrc", Application.StartupPath, musicName) });

                        //将歌词文件与歌曲绑定存入XML
                        XmlHelper.Insert(Application.StartupPath + "\\xml\\lrclist.xml", "lrclist", "music", attributeList);

                        //加载歌词
                        ChangeLable(string.Format("{0}\\lrc\\{1}.lrc", Application.StartupPath, musicName));
                    }
                    else
                    {
                        //如果下载不成功，歌词面板显示手动下载链接
                        LoadLrcText("歌词下载失败！请尝试手动下载。");
                    }
                }
            }
            else
            {
                //如果下载不成功，歌词面板显示手动下载链接
                LoadLrcText("未搜索到歌词！请尝试手动下载。");
            }
        }

        /// <summary>
        /// 加载歌词
        /// </summary>
        /// <param name="lrcText">歌词信息</param>
        protected void LoadLrcText(string lrcText)
        {
            if (this.diskLrcFrm != null)
            {
                //如果下载不成功，歌词面板显示手动下载链接
                this.diskLrcFrm.LrcText = lrcText;
                this.diskLrcFrm.IsAfreshDraw = true;
            }
        }

       
        public void SearchLrcFrm_OnSearchLrc()
        {
            
            this.lyricsHelper.SearchLrc("", Path.GetFileNameWithoutExtension(this.bassPlayer.OpenningFile));
        }

        
        protected void WebException(object sender, EventArgs e)
        {
            WebException ex = sender as WebException;
            MessageBox.Show(ex.Message, "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }

       
        protected void InitializeProxy(object sender, EventArgs e)
        {
            MessageBox.Show("暂不支持代理", "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            //WebProxy proxy = null;
            //frmProxy f2 = new frmProxy();
            //f2.OkButton.Click += new EventHandler(delegate(object _sender, EventArgs _e)
            //{
            //    proxy = new WebProxy(f2.Host.Text, int.Parse(f2.Port.Text));
            //    proxy.Credentials = new NetworkCredential(f2.Username.Text, f2.PwdText.Text);
            //    f2.Close();
            //});
            //f2.ShowDialog();
            //q.Proxy = proxy;
        }

        /// <summary>
        /// 搜索歌词信息
        /// </summary>
        public void SerchLrc()
        {
            LoadLrcText("正在加载歌词，请稍候...");

            string attribute = XmlHelper.ReadElementAttributeValue(string.Format("{0}\\xml\\lrclist.xml", Application.StartupPath), "music", "name", this.bassPlayer.OpenningFile, "lrc");
            if (File.Exists(attribute))
            {
                ChangeLable(attribute);
            }
            else
            {
                this.lyricsHelper.SearchLrc("", Path.GetFileNameWithoutExtension(this.bassPlayer.OpenningFile));
            }
        }

        private void ChangeLable(string lrcPath)
        {
            this.Ltime = new string[200];
            this.Ltext = new string[200];

            this.lrcRegex.GetLrc(lrcPath);
            this.Ltext = lrcRegex.ReturnText();
            this.Ltime = lrcRegex.ReturnTime();
            //this.lyricsFrm.IsSearch = true;
            //this.lyricsFrm.LrcText = Ltext[0];
            //this.diskLrcFrm.TextLrc = Ltext[0];
            //Lyric l = new Lyric(string.Format("{0}\\Lrc\\{1}.Lrc", Application.StartupPath, lyricsHelper.ReturnPath()));
            //this.lyricShow1.SetLyric(l);
            //this.lyricsFrm.IsSearch = true;
            if (this.diskLrcFrm != null)
            {
                //设置当前歌曲时间
                this.diskLrcFrm.MusicTime = (int)this.bassPlayer.ChannelLength.TotalMilliseconds;
            }
            this.tmrLrc.Start();
        }

        /// <summary>
        /// 偏移量计算
        /// </summary>
        public void LeftRight()
        {
            string time = this.lblDuration.Text + ":00";
            try
            {
                int start = int.Parse(time.Substring(0, 2));
                string zj = time.Substring(3, 2);
                int zjnum = int.Parse(zj);
                this.bigTime = time.Substring(0, 3) + (zjnum + 2).ToString() + ":00";
                if (zjnum >= 2)
                {
                    this.smallTime = time.Substring(0, 3) + (zjnum - 2).ToString() + ":00";
                }
                else if (zjnum == 00 && start > 0)
                {
                    this.smallTime = "0" + (start - 1).ToString() + ":" + 58.ToString() + ":00";
                }
            }
            catch (Exception)
            {

            }
        }

        /// <summary>
        /// 歌词字幕切换计时器
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tmrLrc_Tick(object sender, EventArgs e)
        {
            string time = this.lblDuration.Text + ":00";

            if (this.nextLrc == true)
            {
                LeftRight();    //计算偏移量
                for (int i = 0; i < 100; i++)
                {
                    if (Ltime[i] == this.bigTime || Ltime[i] == this.smallTime)
                    {
                        //判断当前歌词窗是否被打开，如果被打开则更新歌词字幕
                        if (this.diskLrcFrm != null)
                        {
                            //this.lyricsFrm.IsSearch = true;
                            //更新设置当前歌词文字
                            //this.lyricsFrm.LrcText = Ltext[i];
                            DateTime startTime = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd HH:") + Ltime[i].Substring(0, 5));

                            this.diskLrcFrm.CurrentMusicStartTime = startTime.Minute * 60 * 1000 + startTime.Second * 1000 + startTime.Millisecond;
                            if (Ltime[i + 1] != null)
                            {
                                DateTime endTime = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd HH:") + Ltime[i + 1].Substring(0, 5));
                                this.diskLrcFrm.CurrentMusicEndTime = endTime.Minute * 60 * 1000 + endTime.Second * 1000 + endTime.Millisecond; ;
                            }
                            else
                            {
                                this.diskLrcFrm.CurrentMusicEndTime = (int)this.bassPlayer.ChannelLength.TotalMilliseconds;
                            }
                            LoadLrcText(Ltext[i]);
                            nextLrc = false;
                        }
                    }
                }
            }

            for (int i = 0; i < 100; i++)
            {
                //判断当前时间是否有匹配的歌词字幕
                if (time == Ltime[i])
                {
                    //判断当前歌词窗是否被打开，如果被打开则更新歌词
                    if (this.diskLrcFrm != null)
                    {
                        //this.lyricsFrm.IsSearch = true;
                        //更新设置当前歌词字幕
                        //this.lyricsFrm.LrcText = Ltext[i];     
                        DateTime startTime = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd HH:") + Ltime[i].Substring(0, 5));

                        this.diskLrcFrm.CurrentMusicStartTime = startTime.Minute * 60 * 1000 + startTime.Second * 1000 + startTime.Millisecond;
                        if (Ltime[i + 1] != null)
                        {
                            DateTime endTime = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd HH:") + Ltime[i + 1].Substring(0, 5));
                            this.diskLrcFrm.CurrentMusicEndTime = endTime.Minute * 60 * 1000 + endTime.Second * 1000 + endTime.Millisecond; ;
                        }
                        else
                        {
                            this.diskLrcFrm.CurrentMusicEndTime = (int)this.bassPlayer.ChannelLength.TotalMilliseconds;
                        }
                        LoadLrcText(Ltext[i]);
                    }
                }
            }

            //更新当前歌词指针
            if (this.diskLrcFrm != null)
            {
                this.diskLrcFrm.CurrentTime = (int)this.bassPlayer.ChannelPosition.TotalMilliseconds;
                //更新可调面板
                this.diskLrcFrm.IsAfreshDraw = true;
            }
        }

        /// <summary>
        /// 将时间表示成00:00的格式。
        /// </summary>
        /// <param name="timeSpan"></param>
        /// <returns></returns>
        private string GetStardandTimeString(TimeSpan timeSpan)
        {
            return string.Format("{0}:{1}", timeSpan.Minutes.ToString("00"), timeSpan.Seconds.ToString("00"));
        }

        #endregion

        #region 媒体信号控制

        /// <summary>
        /// 静音设置
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void pbAudioOnOff_Click(object sender, EventArgs e)
        {
            if (this.bassPlayer.IsMuted)
                this.pbAudioOnOff.Image = Image.FromFile(Application.StartupPath + "\\images\\sound.png");
            else
                this.pbAudioOnOff.Image = Image.FromFile(Application.StartupPath + "\\images\\sound_m.png");

            //设置静音模式为当前静音模式反向值
            this.bassPlayer.IsMuted = !this.bassPlayer.IsMuted;

            IniFiles ini = new IniFiles(Application.StartupPath + "\\Ini\\config.ini");
            ini.WriteValue("Player", "Muted", this.bassPlayer.IsMuted.ToString());
        }

        /// <summary>
        /// 音量设置
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tbValume_ScrollValueChange(object sender, EventArgs e)
        {
            this.bassPlayer.Volume = this.tbValume.Value;
            IniFiles ini = new IniFiles(Application.StartupPath + "\\ini\\config.ini");
            //将当前音量保存到ini文件
            ini.WriteValue("Player", "Valume", this.tbValume.Value);
        }

        /// <summary>
        /// 声道设置
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tsmiChannel_Click(object sender, EventArgs e)
        {
            ToolStripItemCollection collection = tsmiChannel.DropDownItems;
            //获取所有声道菜单，并更新为不选中状态
            foreach (ToolStripItem item in collection)
            {
                (item as ToolStripMenuItem).Checked = false;
            }
            ToolStripMenuItem menuItem = (sender as ToolStripMenuItem);
            //获取当前声道菜单，并更新为选中状态
            menuItem.Checked = true;

            switch (menuItem.Text)
            {
                case "立体声":
                    this.bassPlayer.ChannelSounrd(16);
                    break;
                case "左声道":
                    this.bassPlayer.ChannelSounrd(0);
                    break;
                case "右声道":
                    this.bassPlayer.ChannelSounrd(32);
                    break;
                default:
                    break;
            }

        }

        /// <summary>
        /// 进度设置
        /// </summary>
        /// <param name="sender"></param>
        private void tbSlider_ScrollValueChange(object sender, EventArgs e)
        {
            //设置当前播放曲目进度
            this.bassPlayer.ChannelPosition = TimeSpan.FromMilliseconds(this.tbSlider.Value);
        }

        /// <summary>
        /// 播放时间戳，记录播放进度和播放模式的执行
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void timer1_Tick(object sender, EventArgs e)
        {
            try
            {
                //判断是否已经播放结束
                if (!this.bassPlayer.IsPlaying)
                {
                    this.playerState = PlayerState.Stop;
                    this.bassPlayer.Stop();
                    //将结束播放的歌曲背景还原为默认颜色
                    this.lvMusicListView.Items[this.changeValue].BackColor = Color.FromArgb(255, 255, 255);
                    this.lvMusicListView.Items[this.changeValue].ForeColor = Color.FromArgb(105, 105, 105);
                }

                //判断是否已经播放完成
                if (this.playerState == PlayerState.Stop)
                {
                    if (this.lvMusicListView.Items.Count > 0)
                    {
                        switch (this.playModel)
                        {
                            case PlayMode.CyclePlay:
                                //判断当前播放曲目是否为最后一首,如果是返回第一曲,否则播放下一曲
                                if (this.changeValue >= this.lvMusicListView.Items.Count - 1)
                                    this.changeValue = 0;
                                else
                                    this.changeValue++;
                                GetDownOrUp(sender, e);
                                break;
                            case PlayMode.OrderPlay:
                                //判断当前播放曲目是否为最后一首,如果是停止播放,否则播放下一曲
                                if (this.changeValue >= this.lvMusicListView.Items.Count - 1)
                                {
                                    //停止播放
                                    pbPlayOrPause_Click(null, null);
                                    GetStopButton();
                                }
                                else
                                {
                                    this.changeValue++;
                                    GetDownOrUp(sender, e);
                                }
                                break;
                            case PlayMode.RandomPlay:
                                //生成播放列表数量以内的随机数作为播放曲目
                                this.changeValue = new Random().Next(this.lvMusicListView.Items.Count - 1);
                                GetDownOrUp(sender, e);
                                break;
                            case PlayMode.SingleCycle:
                                GetDownOrUp(sender, e);
                                break;
                            case PlayMode.SinglePlay:
                                //停止播放
                                tsmiStopMusic_Click(null, null);
                                GetStopButton();
                                break;
                            default:
                                break;
                        }
                    }
                    else
                    {
                        //停止播放
                        tsmiStopMusic_Click(null, null);
                        GetStopButton();
                    }
                }
                else
                {
                    //设置音乐当前时间
                    this.tbSlider.Value = (int)this.bassPlayer.ChannelPosition.TotalMilliseconds;
                    //设置音乐的当前进度
                    this.lblDuration.Text = GetStardandTimeString(this.bassPlayer.ChannelPosition);
                }
            }
            catch (Exception exp)
            {
                MessageBox.Show(exp.Message, "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        #region 播放模式

        /// <summary>
        /// 播放模式按钮鼠标进入事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void pbPlayerModel_MouseEnter(object sender, EventArgs e)
        {
            switch (this.playModel)
            {
                case PlayMode.CyclePlay:

                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\cycle_m.png");
                    break;
                case PlayMode.OrderPlay:

                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\order_m.png");
                    break;
                case PlayMode.RandomPlay:

                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\random_m.png");
                    break;
                case PlayMode.SingleCycle:
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\singlecycle_m.png");
                    break;
                case PlayMode.SinglePlay:
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\single_m.png");
                    break;
                default:
                    break;
            }
        }

        /// <summary>
        /// 播放模式按钮鼠标离开事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void pbPlayerModel_MouseLeave(object sender, EventArgs e)
        {
            switch (this.playModel)
            {
                case PlayMode.CyclePlay:
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\cycle.png");
                    break;
                case PlayMode.OrderPlay:
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\order.png");
                    break;
                case PlayMode.RandomPlay:
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\random.png");
                    break;
                case PlayMode.SingleCycle:
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\singlecycle.png");
                    break;
                case PlayMode.SinglePlay:
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\single.png");
                    break;
                default:
                    break;
            }
        }

        /// <summary>
        /// 播放模式按钮切换单击事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void pbPlayerModel_Click(object sender, EventArgs e)
        {
            ToolStripItemCollection collection = tsmiPlayModel.DropDownItems;
            //获取所有播放模式菜单，并更新为不选中状态
            foreach (ToolStripItem item in collection)
            {
                (item as ToolStripMenuItem).Checked = false;
            }

            //更新播放模式按钮状态
            switch (this.playModel)
            {
                case PlayMode.CyclePlay:
                    this.tsmiOrderPlay.Checked = true;
                    this.playModel = PlayMode.OrderPlay;
                    this.tipTitle.SetToolTip(this.pbPlayerModel, this.tsmiOrderPlay.Text);
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\order_m.png");
                    break;
                case PlayMode.OrderPlay:
                    this.tsmiRandomPlay.Checked = true;
                    this.playModel = PlayMode.RandomPlay;
                    this.tipTitle.SetToolTip(this.pbPlayerModel, this.tsmiRandomPlay.Text);
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\random_m.png");
                    break;
                case PlayMode.RandomPlay:
                    this.tsmiSingleCycle.Checked = true;
                    this.playModel = PlayMode.SingleCycle;
                    this.tipTitle.SetToolTip(this.pbPlayerModel, this.tsmiSingleCycle.Text);
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\singlecycle_m.png");
                    break;
                case PlayMode.SingleCycle:
                    this.tsmiSinglePlay.Checked = true;
                    this.playModel = PlayMode.SinglePlay;
                    this.tipTitle.SetToolTip(this.pbPlayerModel, this.tsmiSinglePlay.Text);
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\single_m.png");
                    break;
                case PlayMode.SinglePlay:
                    this.tsmiCyclePlay.Checked = true;
                    this.playModel = PlayMode.CyclePlay;
                    this.tipTitle.SetToolTip(this.pbPlayerModel, this.tsmiCyclePlay.Text);
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\cycle_m.png");
                    break;
                default:
                    break;
            }

            IniFiles ini = new IniFiles(Application.StartupPath + "\\ini\\config.ini");
            ini.WriteValue("Player", "PlayModel", (int)this.playModel);
        }

        
        private void tsmiPlayModel_Click(object sender, EventArgs e)
        {
            ToolStripItemCollection collection = tsmiPlayModel.DropDownItems;
            //获取所有播放模式菜单，并更新为不选中状态
            foreach (ToolStripItem item in collection)
            {
                (item as ToolStripMenuItem).Checked = false;
            }

            ToolStripMenuItem stripItem = (sender as ToolStripMenuItem);
            switch (stripItem.Text)
            {
                case "循环播放":
                    this.tsmiCyclePlay.Checked = true;
                    this.playModel = PlayMode.CyclePlay;
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\cycle.png");
                    break;
                case "顺序播放":
                    this.tsmiOrderPlay.Checked = true;
                    this.playModel = PlayMode.OrderPlay;
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\order.png");
                    break;
                case "随机播放":
                    this.tsmiRandomPlay.Checked = true;
                    this.playModel = PlayMode.RandomPlay;
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\random.png");
                    break;
                case "单曲循环":
                    this.tsmiSingleCycle.Checked = true;
                    this.playModel = PlayMode.SingleCycle;
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\singlecycle.png");
                    break;
                case "单曲播放":
                    this.tsmiSinglePlay.Checked = true;
                    this.playModel = PlayMode.SinglePlay;
                    this.pbPlayerModel.Image = Image.FromFile(Application.StartupPath + "\\images\\single.png");
                    break;
                default:
                    break;
            }

            this.tipTitle.SetToolTip(this.pbPlayerModel, stripItem.Text);
            IniFiles ini = new IniFiles(Application.StartupPath + "\\ini\\config.ini");
            ini.WriteValue("Player", "PlayModel", (int)this.playModel);
        }

        #endregion

        #endregion

        #region 播放控制事件

        
        private void lvMusicListView_DoubleClick(object sender, EventArgs e)
        {
            try
            {
                //判断是否正在播放，如果正在播放则停止播放器
                if (this.playerState == PlayerState.Play || this.playerState == PlayerState.Pause)
                {
                    //清除歌曲列表选中项
                    InitListView(this.lvMusicListView, this.changeValue);

                    //设置当前播放状态为停止
                    this.playerState = PlayerState.Stop;
                    //停止播放
                    bassPlayer.Stop();
                }

                //当播放器停止播放时，开始初始化并播放选中歌曲
                if (playerState == PlayerState.Stop)
                {
                    //判断当前选中歌曲文件是否存在磁盘中
                    if (File.Exists(this.lvMusicListView.SelectedItems[0].Tag.ToString()))
                    {
                        //保存当前播放歌曲下标
                        this.changeValue = this.lvMusicListView.SelectedItems[0].Index;

                        //设置当前选中项背景颜色
                        this.lvMusicListView.SelectedItems[0].BackColor = Color.FromArgb(142, 185, 209);
                        this.lvMusicListView.SelectedItems[0].ForeColor = Color.FromArgb(255, 255, 255);

                        //设置当前播放曲目地址
                        this.bassPlayer.OpenFile(this.lvMusicListView.SelectedItems[0].Tag.ToString());
                        //设置进度条长度
                        this.tbSlider.Maximum = (int)bassPlayer.ChannelLength.TotalMilliseconds;

                        this.bassPlayer.GetTag();

                        //播放状态下的按钮
                        GetPlayButton();
                    }
                    else
                    {
                        MessageBox.Show("媒体文件读取失败,请确定当前播放的文件是否存在.", "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                    }
                }
            }
            catch (Exception exp)
            {
                MessageBox.Show(exp.Message, "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
            }

            //垃圾回收，释放资源，减少内存占用
            SetProcessWorkingSetSize(Process.GetCurrentProcess().Handle.ToInt32(), -1, -1);
        }

        /// <summary>
        /// 初始化播放曲目并开始播放
        /// </summary>
        public void GetDownOrUp(object sender, EventArgs e)
        {
            try
            {
                if (File.Exists(this.lvMusicListView.Items[changeValue].Tag.ToString()))
                {
                    //设置当前选中项背景颜色
                    this.lvMusicListView.Items[changeValue].BackColor = Color.FromArgb(142, 185, 209);
                    this.lvMusicListView.Items[changeValue].ForeColor = Color.FromArgb(255, 255, 255);

                    //设置当前播放曲目地址
                    this.bassPlayer.OpenFile(this.lvMusicListView.Items[changeValue].Tag.ToString());
                    //设置进度条长度
                    this.tbSlider.Value = 0;
                    this.tbSlider.Maximum = (int)this.bassPlayer.ChannelLength.TotalMilliseconds;

                    //播放状态下的按钮
                    GetPlayButton();

                    //垃圾回收，释放资源，减少内存占用
                    SetProcessWorkingSetSize(Process.GetCurrentProcess().Handle.ToInt32(), -1, -1);
                }
                else
                {
                    MessageBox.Show("媒体文件读取失败,请确定当前播放的文件是否存在.", "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                }
            }
            catch (Exception exp)
            {
                MessageBox.Show(exp.Message, "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
            }
        }

        /// <summary>
        /// 播放或暂停歌曲
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void pbPlayOrPause_Click(object sender, EventArgs e)
        {
            try
            {
                //如果当前播放器正在播放则暂停
                if (this.playerState == PlayerState.Play)
                {
                    GetPauseButton();
                    this.pbPlayOrPause.Image = Image.FromFile(Application.StartupPath + "\\images\\play_m.png");
                }
                else if (this.playerState == PlayerState.Pause) //如果当前播放器暂停则播放
                {
                    GetPlayButton();
                    this.pbPlayOrPause.Image = Image.FromFile(Application.StartupPath + "\\images\\pause_m.png");
                }
                else
                {
                    //如果当前播放器已停止播放则判断是否有选中的播放曲目
                    if (this.lvMusicListView.SelectedItems.Count == 0)
                    {
                        this.diskLrcFrm.IsPlay = false;
                        this.diskLrcFrm.IsAfreshDraw = true;
                        MessageBox.Show("请选择要播放的曲目", "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                    else
                    {
                        //如果当前已经有选中歌曲则执行双击播放列表事件，执行播放
                        this.lvMusicListView_DoubleClick(null, null);
                    }
                }
            }
            catch (Exception exp)
            {
                MessageBox.Show(exp.Message, "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }


        /// <summary>
        /// 上一首歌曲
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void pbPre_Click(object sender, EventArgs e)
        {
            try
            {
                if (this.lvMusicListView.Items.Count > 0)
                {
                    //将上次选中项背景还原为默认颜色
                    InitListView(this.lvMusicListView, this.changeValue);

                    if (changeValue <= 0)
                        changeValue = this.lvMusicListView.Items.Count - 1;
                    else
                        changeValue--;
                    //初始化播放曲目
                    GetDownOrUp(sender, e);
                    //按钮状态
                    GetPlayButton();
                }
                else
                {
                    MessageBox.Show("播放列表中没有任何歌曲", "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
            }
            catch (Exception exp)
            {
                MessageBox.Show(exp.Message, "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// 下一首歌曲
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void pbNext_Click(object sender, EventArgs e)
        {
            try
            {
                if (this.lvMusicListView.Items.Count > 0)
                {
                    //初始化ListView控件背景颜色
                    InitListView(this.lvMusicListView, this.changeValue);

                    if (this.changeValue >= this.lvMusicListView.Items.Count - 1)
                        this.changeValue = 0;
                    else
                        this.changeValue++;
                    //初始化播放曲目
                    GetDownOrUp(sender, e);
                    //按钮状态
                    GetPlayButton();
                }
                else
                {
                    MessageBox.Show("播放列表中没有任何歌曲", "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
            }
            catch (Exception exp)
            {
                MessageBox.Show(exp.Message, "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }


        /// <summary>
        /// 播放歌曲
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tsmiPlayMusic_Click(object sender, EventArgs e)
        {
            try
            {
                //如果当前播放器已暂停或停止则播放
                if (this.playerState == PlayerState.Pause || this.playerState == PlayerState.Stop)
                {
                    GetPlayButton();
                    this.pbPlayOrPause.Image = Image.FromFile(Application.StartupPath + "\\images\\pause_m.png");
                }
            }
            catch (Exception exp)
            {
                MessageBox.Show(exp.Message, "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// 暂停播放
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tsmiPauseMusic_Click(object sender, EventArgs e)
        {
            try
            {
                //如果当前播放器正在播放则暂停
                if (this.playerState == PlayerState.Play)
                {
                    GetPauseButton();
                    this.pbPlayOrPause.Image = Image.FromFile(Application.StartupPath + "\\images\\play_m.png");
                }
            }
            catch (Exception exp)
            {
                MessageBox.Show(exp.Message, "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// 停止播放
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tsmiStopMusic_Click(object sender, EventArgs e)
        {
            try
            {
                //如果当前播放器正在播放则停止
                if (this.playerState == PlayerState.Play)
                {
                    GetStopButton();
                    this.pbPlayOrPause.Image = Image.FromFile(Application.StartupPath + "\\images\\play_m.png");
                }
            }
            catch (Exception exp)
            {
                MessageBox.Show(exp.Message, "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// 上一曲按钮鼠标进入事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void pbPre_MouseEnter(object sender, EventArgs e)
        {
            this.pbPre.Image = Image.FromFile(Application.StartupPath + "\\images\\pre_m.png");
        }

        /// <summary>
        /// 上一曲按钮鼠标离开事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void pbPre_MouseLeave(object sender, EventArgs e)
        {
            this.pbPre.Image = Image.FromFile(Application.StartupPath + "\\images\\pre.png");
        }

        /// <summary>
        /// 播放暂停按钮鼠标进入事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void pbPlayOrPause_MouseEnter(object sender, EventArgs e)
        {
            if (this.playerState == PlayerState.Pause || this.playerState == PlayerState.Stop)
                this.pbPlayOrPause.Image = Image.FromFile(Application.StartupPath + "\\images\\play_m.png");
            else
                this.pbPlayOrPause.Image = Image.FromFile(Application.StartupPath + "\\images\\pause_m.png");
        }

        /// <summary>
        /// 播放暂停按钮鼠标离开事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void pbPlayOrPause_MouseLeave(object sender, EventArgs e)
        {
            if (this.playerState == PlayerState.Pause || this.playerState == PlayerState.Stop)
                this.pbPlayOrPause.Image = Image.FromFile(Application.StartupPath + "\\images\\play.png");
            else
                this.pbPlayOrPause.Image = Image.FromFile(Application.StartupPath + "\\images\\pause.png");
        }

        /// <summary>
        /// 下一曲按钮鼠标进入事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void pbNext_MouseEnter(object sender, EventArgs e)
        {
            this.pbNext.Image = Image.FromFile(Application.StartupPath + "\\images\\next_m.png");
        }

        /// <summary>
        /// 下一曲按钮鼠标离开事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void pbNext_MouseLeave(object sender, EventArgs e)
        {
            this.pbNext.Image = Image.FromFile(Application.StartupPath + "\\images\\next.png");
        }

        #endregion

        #region 主窗体状态

        private void mainFrm_Resize(object sender, EventArgs e)
        {
            switch (this.WindowState)
            {
                case FormWindowState.Maximized:
                    this.notifyIcon1.Visible = false;
                    this.ShowInTaskbar = true;
                    break;
                case FormWindowState.Minimized:
                    this.notifyIcon1.Visible = true;
                    this.ShowInTaskbar = false;
                    this.Opacity = 0;
                    break;
                case FormWindowState.Normal:
                    this.notifyIcon1.Visible = false;
                    this.ShowInTaskbar = true;
                    break;
                default:
                    break;
            }
        }

        private void notifyIcon1_DoubleClick(object sender, EventArgs e)
        {
            this.WindowState = FormWindowState.Normal;
            this.notifyIcon1.Visible = false;
            this.ShowInTaskbar = true;
            this.Opacity = 1;
        }

        #endregion

        private void tsmiFeedBackHelp_Click(object sender, EventArgs e)
        {
            System.Diagnostics.Process.Start("http://hi.baidu.com/qinyun118/item/7ad23ce59ff4c3acc00d758b");
        }

        /// <summary>
        /// 搜索框获得焦点事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txtSerachMusic_Enter(object sender, EventArgs e)
        {
            if (this.txtSerachMusic.Text == "请输入搜索内容")
            {
                this.txtSerachMusic.Text = string.Empty;
                this.txtSerachMusic.BackColor = Color.FromArgb(255, 255, 255);
                this.pnlSerach.BackgroundImage = Image.FromFile(Application.StartupPath + "\\images\\search.png");
            }
        }

        /// <summary>
        /// 搜索框失去焦点事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txtSerachMusic_Leave(object sender, EventArgs e)
        {
            if (this.txtSerachMusic.Text == string.Empty)
            {
                this.txtSerachMusic.Text = "请输入搜索内容";
                this.txtSerachMusic.BackColor = Color.FromArgb(183, 209, 226);
                this.pnlSerach.BackgroundImage = null;
            }
            else
            {
                this.txtSerachMusic.BackColor = Color.FromArgb(255, 255, 255);
                this.pnlSerach.BackgroundImage = Image.FromFile(Application.StartupPath + "\\images\\search.png");
            }
        }

        /// <summary>
        /// 音乐窗/歌词按钮鼠标移入事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void lblLabelWin_MouseEnter(object sender, EventArgs e)
        {
            Label label = (sender as Label);
            if (label.Tag.Equals("关闭"))
                label.BackColor = Color.FromArgb(11, 88, 136);
        }

        /// <summary>
        /// 音乐窗/歌词按钮鼠标移出事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void lblLabelWin_MouseLeave(object sender, EventArgs e)
        {
            Label label = (sender as Label);
            if (label.Tag.Equals("关闭"))
                label.BackColor = Color.Transparent;
        }

        /// <summary>
        /// 打开/关闭音乐窗
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void lblMusicWin_Click(object sender, EventArgs e)
        {
            if (this.lblMusicWin.Tag.Equals("关闭"))
            {
                this.lblMusicWin.Tag = "打开";
                this.lblMusicWin.BackColor = Color.FromArgb(11, 88, 136);
                musicMiniFrm = new musicMiniFrm();
                //musicMiniFrm.MediaPlayerDoubleClick += new musicMiniFrm.MediaPlayerDoubleClickEventHandler(MediaPlayerDoubleClick);
                //musicMiniFrm.MusicListFrmClose += new musicMiniFrm.MusicListFrmCloseEventHandler(MusicListFrmClose);
              
                MagneticMagnager test2 = new MagneticMagnager(this, musicMiniFrm, MagneticPosition.Right);
                musicMiniFrm.Show();
            }
            else
            {
                this.lblMusicWin.Tag = "关闭";
                musicMiniFrm.Close();
            }
        }

        /// <summary>
        /// 打开/关闭歌词窗
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void lblLyrics_Click(object sender, EventArgs e)
        {
            if (this.diskLrcFrm == null)
            {
                this.lblLyrics.BackColor = Color.FromArgb(11, 88, 136);
                LoadDiskLrcPanel();
            }
            else
            {
                this.lblLyrics.BackColor = Color.Transparent;
                CloseLrcPanel();
            }
        }

        /// <summary>
        /// 歌曲搜索
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txtSerachMusic_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
            {
                if (musicMiniFrm == null)
                {
                    this.lblMusicWin_Click(null, null);
                }
                //打开音乐窗搜索页
                this.musicMiniFrm.webBrowser1.Url = new Uri("http://musicmini.baidu.com/app/search/searchList.php?qword=" + this.txtSerachMusic.Text);
            }
        }

        /// <summary>
        /// 歌曲面板切换
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void pnlList_Click(object sender, EventArgs e)
        {
            System.Windows.Forms.Control.ControlCollection collection = this.pnlMusicList.Controls;
            //获取所有歌曲面板菜单，并更新为不选中状态
            foreach (Control item in collection)
            {
                if (item is Panel)
                {
                    (item as Panel).BackColor = Color.Transparent;
                    System.Windows.Forms.Control.ControlCollection labelCollection = item.Controls;
                    foreach (Control label in labelCollection)
                    {
                        if (label is Label)
                            (label as Label).ForeColor = Color.FromArgb(58, 58, 59);
                    }
                }
            }

            if (sender is Panel)
            {
                Panel panel = (sender as Panel);
                panel.BackColor = Color.FromArgb(142, 185, 209);
                foreach (Control label in panel.Controls)
                {
                    if (label is Label)
                        (label as Label).ForeColor = Color.FromArgb(255, 255, 255);
                }
                this.tabMusicType = panel.Tag.ToString();
            }
            else
            {
                Label label = (sender as Label);
                (label.Parent as Panel).BackColor = Color.FromArgb(142, 185, 209);
                label.ForeColor = Color.FromArgb(255, 255, 255);
                this.tabMusicType = (label.Parent as Panel).Tag.ToString();
            }
            //初始化歌曲列表
            OpenPlayList();
        }

        /// <summary>
        /// 退出程序时，关闭播放器
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void mainFrm_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (!e.Cancel)
            {
                //关闭音频流
                if (bassPlayer != null)
                    bassPlayer.Stop();

                if (this.diskLrcFrm != null)
                {
                    this.diskLrcFrm.manualReset.Set();
                    this.diskLrcFrm.thread.Abort();
                }
            }
        }

        /// <summary>
        /// 上一曲桌面歌词回调函数
        /// </summary>
        private void PreMusicLrcPanel()
        {
            this.pbPre_Click(null, null);
        }

        /// <summary>
        /// 播放/暂停桌面歌词回调函数
        /// </summary>
        private void PlayOrPauseMusicLrcPanel()
        {
            this.pbPlayOrPause_Click(null, null);
        }

        /// <summary>
        /// 下一曲
        /// </summary>
        private void NextMusicLrcPanel()
        {
            this.pbNext_Click(null, null);
        }

        /// <summary>
        /// 搜索歌词
        /// </summary>
        private void SearchLrcPanel()
        {
            SearchLrcFrm searchLrcFrm = new SearchLrcFrm(this.bassPlayer.OpenningFile, Path.GetFileNameWithoutExtension(this.bassPlayer.OpenningFile));
            searchLrcFrm.LoadMusicLrc += new SearchLrcFrm.LoadMusicLrcHandler(SerchLrc);
            searchLrcFrm.Show();
        }



        /// <summary>
        /// 解锁歌词
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tsmiUnLockLrcPanel_Click(object sender, EventArgs e)
        {
            if (this.diskLrcFrm != null)
            {
                this.diskLrcFrm.IsLockPanel = false;
            }
        }

        private void lvMusicListView_SelectedIndexChanged(object sender, EventArgs e)
        {

        }
    }
}

测试截图：

     

<1> 设计思路:

      由于是团队编程，并且我们对制作mp3播放文件不太了解。所以我们先选择网上查阅资料，在CSDN这个论坛中，我们初步了解了一下。

知道了用window mediaplayer控件来实现mp3的播放。有了这个思路之后我们各自思考，大家相互讨论，如何能做到播放并且达到理想效果

为了这个目标，我们大家开始下面的编写代码过程，由于C#学的不够好，中途我们出现了困难，团队里发生了争执。还好大家能够克服自己。

作为这个团队的负责人，感到队员们还是比较配合的，按照各自分工，做好自己的事。这点我很开心。我们在实现歌词搜索这方面，没有克服困难，

考虑到的利用百度联网搜索歌词没有实现。但我们显现了一些基本的常用功能。

<2>团队分工：

负责人：洪亮，负责项目规范和代码实现(2分)

队员：刘远航，负责代码错误和代码规范(2分)

队员：卞玉新，负责项目测试和完善(2分)

队员：李田田，负责设计思路和总结(2分)

队员：李彬，负责PSP耗时分析团队编程总结(2分)

<3>PSP 耗时分析:

<4>团队编程总结：

  这次的编程对于我们大家来说，比较有新意。以前都没想过编做一个mp3播放器。刚开始时很有难度，但我们的负责人说，我们不会别人

肯定也会吃力的，他鼓励我们大家。我们分工合作，各自做好自己的事。这次的编程同样也是有挑战的。所以程序里有不少Bug,影响部分功能的实现

这次我们虽然分工不同，各自的贡献也是有所不同的，即使如此 为了鼓励我们大家的积极思考和参与，我们负责人决定我们的贡献分一致。

他认为这是一个好的开始。所以我们大家也就欣然接受了。我们通过论坛了解到了VS如何打包c#项目生成安装、卸载文件。并做了测试，通过在我们

电脑上的测试有些电脑是可以打开的，并播放了本地的音乐。所以我们这次完成了一小步挑战！