root/lang/csharp/Criw-0/MainForm.cs

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Threading;
using System.IO;
using System.Net;
using System.Net.Sockets;
using Circuit.Net.Irc;
using System.Diagnostics;
using System.Text.RegularExpressions;
using System.Runtime.InteropServices;

namespace Misuzilla.Applications.Mobile.Criw0
{
    public partial class MainForm : Form
    {
        private readonly String VersionString = String.Format("Criw-0/{0}; {1}; .NET CLR {2}", "2006-12-23", Environment.OSVersion, Environment.Version.ToString());
        private const String ConsoleName = "*Console*";
        //private Regex _uriRegex = new Regex("(?:(?<uri>(urn:[-_.!~*'()a-zA-Z0-9;/?:@&=+$,%#]+|https?://[-_.!~*'()a-zA-Z0-9;/?:@&=+$,%#]+))|(?<text>(?:(?!h?ttps?://[-_.!~*'()a-zA-Z0-9;/?:@&=+$,%#]+).)+))", RegexOptions.Compiled);
        private Regex _uriRegex = new Regex("h?ttp(s?://[-_.!~*'()a-zA-Z0-9;/?:@&=+$,%#]+)");

        private IRCConnection _ircConnection;
        private String _selfNickname = "";
        private String _connectionName = "";
        private String _connectionHost = "";
        private StringDictionary _channelLogs;
        private StringDictionary _channelTopics;
        private String _currentLogName = ConsoleName;
        private List<String> _autoJoinChannels = null;
        private Dictionary<String, List<String>> _nicknameList = null;
        private Dictionary<String, Boolean> _nicknameListUpdating = null;

        //
        // Messages
        //
        private readonly String PartMessageText = String.Format("Leaving");
        public String QuitMesssageText { get { return String.Format("Connection Closing; {1}", VersionString); } }
        public String QuitMesssageTextOnApplicationExit { get { return String.Format("Application Exit; {0}", VersionString); } }
        //

        public static void Main(String[] args)
        {
            //Thread.CurrentThread.SetApartmentState(ApartmentState.STA);
            Application.Run(new MainForm());
        }

        public MainForm()
        {
            InitializeComponent();
            SettingManager.Load();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            _ircConnection = new IRCConnection();
            _ircConnection.Connecting += new EventHandler(_ircConnection_Connecting);
            _ircConnection.Connected += new EventHandler(_ircConnection_Connected);
            _ircConnection.Disconnected += new EventHandler(_ircConnection_Disconnected);
            _ircConnection.MessageReceived += new EventHandler<IRCConnection.MessageReceivedEventArgs>(_ircConnection_MessageReceived);

            _channelLogs = new StringDictionary();
            _nicknameList = new Dictionary<string, List<String>>();
            _nicknameListUpdating = new Dictionary<string, Boolean>();
            _channelTopics = new StringDictionary();

            MessageProcessChain += new MessageReceivedDelegate(ProcessNick);
            MessageProcessChain += new MessageReceivedDelegate(ProcessJoin);
            MessageProcessChain += new MessageReceivedDelegate(ProcessPart);
            MessageProcessChain += new MessageReceivedDelegate(ProcessPrivMsg);
            MessageProcessChain += new MessageReceivedDelegate(ProcessPing);
            MessageProcessChain += new MessageReceivedDelegate(ProcessNotice);
            MessageProcessChain += new MessageReceivedDelegate(ProcessNumericReply);
            MessageProcessChain += new MessageReceivedDelegate(ProcessTopic);
            MessageProcessChain += new MessageReceivedDelegate(ProcessQuit);
            MessageProcessChain += new MessageReceivedDelegate(ProcessNumReply353);
            MessageProcessChain += new MessageReceivedDelegate(ProcessNumReply366);
           //MessageProcessChain += new MessageReceivedDelegate(ProcessOtherMessage);

            listChannels.Items.Add(new ListViewItem(ConsoleName));
            textLog.ContextMenu = new ContextMenu();
            MenuItem menuItemContextOpenUrl = new MenuItem();
            MenuItem menuItemContextCopy = new MenuItem();
            textLog.ContextMenu.MenuItems.Add(menuItemContextOpenUrl);
            textLog.ContextMenu.MenuItems.Add(menuItemContextCopy);
            menuItemContextOpenUrl.Text = "URL���(&O)...";
            menuItemContextOpenUrl.Click += delegate(Object _sender, EventArgs _e)
            {
                ProcessStartInfo startInfo = new ProcessStartInfo();
                Match m = _uriRegex.Match(textLog.SelectedText);
                if (!m.Success) return;
                startInfo.Verb = "open";
                //startInfo.UseShellExecute = true;
                startInfo.FileName = "http" + m.Groups[1].Captures[0].Value;
                Process.Start(startInfo);
            };
            menuItemContextCopy.Text = "�R�s�[(&C)";
            menuItemContextCopy.Click += delegate(Object _sender, EventArgs _e)
            {
                Clipboard.SetDataObject(textLog.SelectedText);
            };
            //SendMessage(textLog.Handle, 0x00CF, 1, 0);

            textAllLog.Font = new Font(textAllLog.Font.Name, SettingManager.Setting.ChannelLogTextFontSize, textAllLog.Font.Style);
            textLog.Font = new Font(textLog.Font.Name, SettingManager.Setting.ChannelLogTextFontSize, textLog.Font.Style);
        }

        void _ircConnection_Connecting(object sender, EventArgs e)
        {
            AddLogText(ConsoleName, String.Format("�T�[�o '{0}' �ɐڑ����Ă��܂�...", _connectionHost));
        }

        void _ircConnection_Connected(object sender, EventArgs e)
        {
            //throw new Exception("The method or operation is not implemented.");
            menuItemConnectDisconnect.Enabled = true;
            menuItemChannel.Enabled = true;
            menuItemNext.Enabled = true;
            timerPing.Enabled = true;

            // ����JOIN
            if (_autoJoinChannels != null)
            {
                foreach (String channel in _autoJoinChannels)
                {
                    _ircConnection.Send("JOIN :" + channel);
                }
            }
        }
        void _ircConnection_Disconnected(object sender, EventArgs e)
        {
            AddLogText(ConsoleName, String.Format("�T�[�o�����f���܂���", _connectionHost));

            // ����            // FIXME: ���O�̔���
            String consoleLog = _channelLogs[ConsoleName];
            _currentLogName = ConsoleName;
            _channelLogs = new StringDictionary();
            _channelLogs[ConsoleName] = consoleLog;
            
            _nicknameList.Clear();

            listChannels.Items.Clear();
            listChannels.Items.Add(new ListViewItem(ConsoleName)).SubItems.Add("");

            menuItemChannel.Enabled = false;
            menuItemConnectDisconnect.Enabled = false;
            menuItemNext.Enabled = false;
            timerPing.Enabled = false;

            this.Text = "Criw";
        }

        void _ircConnection_MessageReceived(object sender, IRCConnection.MessageReceivedEventArgs e)
        {
            this.Invoke(new MessageReceivedDelegate(MessageReceivedOnForm), new Object[] { e.Message });
        }

        private delegate void MessageReceivedDelegate(IRCMessage m);
        private event MessageReceivedDelegate MessageProcessChain;
        private void MessageReceivedOnForm(IRCMessage m)
        {
            MessageProcessChain(m);

            //_channelLogs[ConsoleName] += m.ToString() + "\r\n";
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="m"></param>
        private void ProcessNumReply366(IRCMessage m)
        {
            NumericReplyMessage numReply = m as NumericReplyMessage;
            if (numReply == null || numReply.ReplyNumber != (Int32)NumericReply.RPL_ENDOFNAMES) return;
            if (!_nicknameListUpdating.ContainsKey(numReply.CommandParams[1].ToLower())) return;
            _nicknameListUpdating[numReply.CommandParams[1].ToLower()] = false;
            UpdateUserList();
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="m"></param>
        private void ProcessNumReply353(IRCMessage m)
        {
            NumericReplyMessage numReply = m as NumericReplyMessage;
            if (numReply == null || numReply.ReplyNumber != (Int32)NumericReply.RPL_NAMREPLY) return;
            String channel = numReply.CommandParams[2].ToLower();

            // JOIN���ĂȂ��Ƃ�
            if (!_nicknameListUpdating.ContainsKey(channel)) return;

            if (!_nicknameListUpdating[channel])
            {
                _nicknameList[channel].Clear();
                _nicknameListUpdating[channel] = true;
            }

            foreach (String nick in numReply.CommandParams[3].Split(new Char[] { ' ' }))
            {
                // FIXME: �Ȃ�
                if (nick.StartsWith("@"))
                {
                    _nicknameList[channel].Add(nick.Substring(1));
                }
                else
                {
                    _nicknameList[channel].Add(nick);
                }
            }

            AddLogText(channel, String.Format("* Names: {0}",
               numReply.CommandParams[3]));

        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="m"></param>
        private void ProcessNick(IRCMessage m)
        {
            NickMessage nickMsg = m as NickMessage;
            if (nickMsg == null || nickMsg.Sender == null || nickMsg.Sender.Length == 0) return; // �����ő��M�̏ꍇ�Ƃ�

            if (nickMsg.SenderNick == _selfNickname)
            {
                _selfNickname = nickMsg.NewNick;
                this.Text = String.Format("{0} @ {1} - Criw", _selfNickname, _connectionName);
            }
            else
            {
                //�ق��̃��[�U
            }

            foreach (String channel in _nicknameList.Keys)
            {
                if (_nicknameList[channel].Contains(nickMsg.SenderNick))
                {
                    _nicknameList[channel].Remove(nickMsg.SenderNick);
                    _nicknameList[channel].Add(nickMsg.NewNick);
                }
            }
            UpdateUserList();

            AddLogText(ConsoleName, String.Format("* Nick {0} �� {1}",
                nickMsg.SenderNick
                , nickMsg.NewNick), true);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="m"></param>
        private void ProcessJoin(IRCMessage m)
        {
            JoinMessage joinMsg = m as JoinMessage;
            if (joinMsg == null) return;

            if (joinMsg.SenderNick == _selfNickname)
            {
                _nicknameList[joinMsg.Channel.ToLower()] = new List<string>();
                _nicknameListUpdating[joinMsg.Channel.ToLower()] = false;
                ListViewItem item = listChannels.Items.Add(new ListViewItem(joinMsg.Channel));
                item.SubItems.Add("");
            }
            else
            {
                //�ق��̃��[�U
            }

            String channel = joinMsg.Channel.ToLower();
            if (!_nicknameList[channel].Contains(joinMsg.SenderNick))
            {
                _nicknameList[channel].Add(joinMsg.SenderNick);
            }
            UpdateUserList();

            AddLogText(joinMsg.Channel, String.Format("* Join {0} ({1})",
               joinMsg.SenderNick
               , joinMsg.Sender));
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="m"></param>
        private void ProcessPart(IRCMessage m)
        {
            PartMessage partMsg = m as PartMessage;
            if (partMsg == null) return;

            if (partMsg.SenderNick == _selfNickname)
            {
                ListViewItem lvItem = null;
                foreach (ListViewItem item in listChannels.Items)
                {
                    if (String.Compare(item.Text, partMsg.Channel, true) == 0)
                    {
                        lvItem = item;
                    }
                }
                if (lvItem != null)
                {
                    listChannels.Items.Remove(lvItem);
                }
            }
            else
            {
                //�ق��̃��[�U
            }
            
            String channel = partMsg.Channel.ToLower();
            if (_nicknameList[channel].Contains(partMsg.SenderNick))
            {
                _nicknameList[channel].Remove(partMsg.SenderNick);
            }
            UpdateUserList();

            AddLogText(partMsg.Channel, String.Format("* Part {0} ({1})",
              partMsg.SenderNick
              , partMsg.Message));
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="m"></param>
        private void ProcessQuit(IRCMessage m)
        {
            QuitMessage quitMsg = m as QuitMessage;
            if (quitMsg == null) return;

            if (quitMsg.SenderNick == _selfNickname)
            {
            }
            else
            {
                //�ق��̃��[�U
            }

            foreach (String channel in _nicknameList.Keys)
            {
                if (_nicknameList[channel].Contains(quitMsg.SenderNick))
                {
                    _nicknameList[channel].Remove(quitMsg.SenderNick);
                }
            }
            UpdateUserList();

            AddLogText(ConsoleName, String.Format("* Quit {0} ({1})",
              quitMsg.SenderNick
              , quitMsg.Message), true);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="m"></param>
        private void ProcessPrivMsg(IRCMessage m)
        {
            PrivMsgMessage prvMsg = m as PrivMsgMessage;
            if (prvMsg == null) return;

            if (String.Compare(prvMsg.Receiver, _selfNickname, true) == 0)
            {
                // Priv
            }
            else
            {
                // channel
            }
            if (prvMsg.SenderNick.Length == 0 ||
                String.Compare(prvMsg.SenderNick, _selfNickname, true) == 0)
            {
                //�����Ŕ���
                AddLogText(prvMsg.Receiver, String.Format(">{0}< {1}",
                    _selfNickname
                    , prvMsg.Content));
            }
            else
            {
                UnreadCountIncrement(prvMsg.Receiver);
                AddLogText(prvMsg.Receiver, String.Format("<{0}> {1}",
                    prvMsg.SenderNick
                    , prvMsg.Content));
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="m"></param>
        private void ProcessNotice(IRCMessage m)
        {
            NoticeMessage noticeMsg = m as NoticeMessage;
            if (noticeMsg == null) return;

            if (String.Compare(noticeMsg.Receiver, _selfNickname, true) == 0)
            {
                // Priv
            }
            else
            {
                // channel
            }

            if (noticeMsg.IsServerMessage || noticeMsg.Receiver == _selfNickname)
            {
                AddLogText(ConsoleName, noticeMsg.ToString());
            }
            else
            {
                AddLogText(noticeMsg.Receiver, String.Format("({0}) {1}", noticeMsg.SenderNick, noticeMsg.Content));
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="m"></param>
        private void ProcessPing(IRCMessage m)
        {
            if (String.Compare(m.Command, "PING", true) != 0) return;

            // PONG
            _ircConnection.Send("PONG :" + m.CommandParam);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="m"></param>
        void ProcessNumericReply(IRCMessage m)
        {
            NumericReplyMessage numMsg = m as NumericReplyMessage;
            if (numMsg == null) return;

            switch (numMsg.ReplyNumber)
            {
                //case (Int32)NumericReply.RPL_TOPICWHOTIME:
                case (Int32)NumericReply.RPL_TOPIC:
                    AddLogText(numMsg.CommandParams[1], "* Topic: " + numMsg.CommandParams[2]);
                    ChangeChannelTopic(numMsg.CommandParams[1], numMsg.CommandParams[2]);
                    break;
                default:
                    AddLogText(ConsoleName, numMsg.ToString());
                    break;
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="m"></param>
        void ProcessTopic(IRCMessage m)
        {
            TopicMessage topicMsg = m as TopicMessage;
            if (topicMsg == null) return;
            if (topicMsg.IsServerMessage)
            {
                AddLogText(topicMsg.CommandParams[0], "Topic: " + topicMsg.CommandParams[1]);
                ChangeChannelTopic(topicMsg.CommandParams[0], topicMsg.CommandParams[1]);
            }
        }

        void ChangeChannelTopic(String channel, String text)
        {
            _channelTopics[channel.ToLower()] = text;
            //this.Text = String.Format("{0} @ {1} - Criw", _selfNickname, _connectionName);
        }

        private void textInput_KeyDown_Old(object sender, KeyEventArgs e)
        {
            if (!_ircConnection.IsConnected) return;

            if (e.KeyCode == Keys.Enter && textInput.Text.Length > 0)
            {
                //AllLogUpdateDelegate("Send: "+textBox1.Text);
                if (textInput.Text.StartsWith("/"))
                {
                    // ���ő��M
                    try
                    {
                        IRCMessage m = IRCMessage.CreateMessage(textInput.Text.Substring(1));
                        _ircConnection.Send(m.RawMessage);
                        MessageReceivedOnForm(m);
                    }
                    catch (IRCInvalidMessageException ex)
                    {
                        MessageBox.Show(ex.ToString());
                    }
                }
                else
                {
                    // �I���������PrivMsg
                    if (_currentLogName != ConsoleName)
                    {
                        // �R���\�[���ȊO
                        PrivMsgMessage privMsg = new PrivMsgMessage(_currentLogName, textInput.Text);
                        _ircConnection.Send(privMsg.RawMessage);
                        MessageReceivedOnForm(privMsg);
                    }
                    else
                    {
                        // �R���\�[���ł͑��M�ł��Ȃ�
                        return;
                    }
                }
                textInput.Text = "";
                e.Handled = true;
            }
        }

        private void button3_Click(object sender, EventArgs e)
        {
            _ircConnection.Close();
            this.Close();
        }

        private void listChannels_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (listChannels.SelectedIndices.Count > 0)
            {
                Int32 index = listChannels.SelectedIndices[0];
                System.Diagnostics.Debug.WriteLine(listChannels.Items[index].Text);
                SetLogView(listChannels.Items[index].Text);

                if (index != 0)
                {
                    listChannels.Items[index].SubItems[1].Text = "";
                }

                UpdateUserList();
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="channel"></param>
        private void UnreadCountClear(String channel)
        {
            foreach (ListViewItem item in listChannels.Items)
            {
                if (String.Compare(item.Text, channel, true) == 0)
                {
                    item.SubItems[1].Text = "";
                    break;
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="channel"></param>
        private void UnreadCountIncrement(String channel)
        {

            // ���ǂ�����E���g���Ȃ�
            if (channel == _currentLogName)
                return;

            // �I��܂���           foreach (ListViewItem item in listChannels.Items)
            {
                if (String.Compare(item.Text, channel, true) == 0)
                {
                    // ����
                    Int32 count = 0;
                    try
                    {
                        if (item.SubItems[1].Text != "")
                        {

                            count = Int32.Parse(item.SubItems[1].Text);
                        }
                    }
                    catch (FormatException) { }

                    item.SubItems[1].Text = (count + 1).ToString();
                    break;
                }
            }
        }

        private void UpdateUserList()
        {
            listUsers.Items.Clear();
            if (!_nicknameList.ContainsKey(_currentLogName.ToLower())) return;
            foreach (String name in _nicknameList[_currentLogName.ToLower()])
            {
                listUsers.Items.Add(name);
            }
        }

        private void SetLogView(String logName)
        {
            textLog.Text = _channelLogs[logName.ToLower()];
            _currentLogName = logName;
            textLog.SelectionStart = textLog.Text.Length;
            textLog.SelectionLength = 0;
            textLog.ScrollToCaret();
        }

        private void AddLogText(String logName, String line)
        {
            AddLogText(logName, line, false);
        }
        private void AddLogText(String logName, String line, Boolean broadcast)
        {
            String time = "[" + DateTime.Now.ToString("HH:mm:ss") + "]: ";
            if (String.Compare(_currentLogName, logName, true) == 0)
            {
                // ���I��܂�
                textLog.SelectionStart = textLog.Text.Length;
                textLog.SelectionLength = 0;
                textLog.SelectedText = time + line + "\r\n";
                textLog.ScrollToCaret();
            }
            else
            {
                // �I��܂���           }

            if (logName != ConsoleName || broadcast)
            {
                if (textAllLog.Text.Length > 2000)
                {
                    textAllLog.Text = textAllLog.Text.Substring(500);
                }
                textAllLog.SelectionStart = textAllLog.Text.Length;
                textAllLog.SelectionLength = 0;
                textAllLog.SelectedText = time + logName + ": " + line + "\r\n";
                textAllLog.ScrollToCaret();
            }

            _channelLogs[logName.ToLower()] += time + line + "\r\n";
            String channelLog = _channelLogs[logName.ToLower()];
            if (channelLog.Length > 30000)
            {
                _channelLogs[logName.ToLower()] = channelLog.Substring(channelLog.Length - 30000);
            }
        }

        private void menuItemConnect_Popup(object sender, EventArgs e)
        {
            menuItemConnectServers.MenuItems.Clear();
            menuItemConnectServers.MenuItems.Add(menuItemConnectForm);
            menuItemConnectServers.MenuItems.Add(menuItemConnectSep);
            foreach (Connection c in SettingManager.Setting.Connections)
            {
                MenuItem m = new MenuItem();
                m.Text = c.Name;
                m.Click += new EventHandler(menuItemConnectServerItem_Click);
                menuItemConnectServers.MenuItems.Add(m);
            }
        }

        void menuItemConnectServerItem_Click(object sender, EventArgs e)
        {
            MenuItem m = sender as MenuItem;

            if (_ircConnection.IsConnected)
            {
                _ircConnection.Disconnect(QuitMesssageText);
            }

            // �T��...
            Connection c = SettingManager.Setting.Connections.Find(
                delegate(Connection con) { return con.Name == m.Text; }
            );
            if (c != null)
            {
                _autoJoinChannels = c.AutoJoinChannels;
                _selfNickname = c.NickName;
                _connectionName = c.Name;
                _connectionHost = c.Host + ":" + c.Port.ToString();
                _ircConnection.Connect(c.Host, c.Port, c.UserName, c.Password, c.NickName, c.UserInfo);
                this.Text = String.Format("{0} @ {1} - Criw", _selfNickname, _connectionName);

                return;
            }
        }

        private void menuItemConnectForm_Click(object sender, EventArgs e)
        {
            (new ConnectionForm()).ShowDialog();
        }

        private void menuItemExit_Click(object sender, EventArgs e)
        {
            if (_ircConnection.IsConnected)
            {
                _ircConnection.Disconnect(QuitMesssageTextOnApplicationExit);
            }
            this.Close();
        }

        private void menuItemChannelJoin_Click(object sender, EventArgs e)
        {
            if (_ircConnection.IsConnected)
            {
                JoinForm joinForm = new JoinForm();
                if (joinForm.ShowDialog() == DialogResult.OK)
                {
                    _ircConnection.Send(new JoinMessage(joinForm.ChannelName, "").RawMessage);
                }
            }
        }

        private void menuItemChannelPart_Click(object sender, EventArgs e)
        {
            if (_ircConnection.IsConnected && _currentLogName != ConsoleName)
            {
                _ircConnection.Send(new PartMessage(_currentLogName, PartMessageText).RawMessage);
            }
        }

        private void menuItemChannelTopic_Click(object sender, EventArgs e)
        {

        }

        private void menuItemConnectDisconnect_Click(object sender, EventArgs e)
        {
            if (_ircConnection.IsConnected)
            {
                _ircConnection.Disconnect(QuitMesssageText);
            }
        }

        private void textInput_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (!_ircConnection.IsConnected) return;

            if (e.KeyChar == '\r')
            {
                if (textInput.Text.Length > 0)
                {
                    // ���b�Z�[�W���M
                    //AllLogUpdateDelegate("Send: "+textBox1.Text);
                    if (textInput.Text.StartsWith("/"))
                    {
                        if (textInput.Text.StartsWith("/font "))
                        {
                            // �t�H���g�T�C�Y�ݒ�                            try
                            {
                                Single fontSize = Single.Parse(textInput.Text.Substring(6));
                                textAllLog.Font = new Font(textAllLog.Font.Name, fontSize, textAllLog.Font.Style);
                                textLog.Font = new Font(textLog.Font.Name, fontSize, textLog.Font.Style);
                                SettingManager.Setting.ChannelLogTextFontSize = fontSize;
                                SettingManager.Save();
                            }
                            catch (FormatException)
                            {
                            }
                        }
                        else
                        {
                            // ���ő��M
                            try
                            {
                                IRCMessage m = IRCMessage.CreateMessage(textInput.Text.Substring(1));
                                _ircConnection.Send(m.RawMessage);
                                MessageReceivedOnForm(m);
                            }
                            catch (IRCInvalidMessageException ex)
                            {
                                MessageBox.Show(ex.ToString());
                            }
                        }
                    }
                    else
                    {
                        // �I���������PrivMsg
                        if (_currentLogName != ConsoleName)
                        {
                            // �R���\�[���ȊO
                            PrivMsgMessage privMsg = new PrivMsgMessage(_currentLogName, textInput.Text);
                            _ircConnection.Send(privMsg.RawMessage);
                            MessageReceivedOnForm(privMsg);
                        }
                        else
                        {
                            // �R���\�[���ł͑��M�ł��Ȃ�
                            return;
                        }
                    }
                    textInput.Text = "";
                    e.Handled = true;
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="reverse"></param>
        private void NextChannel(bool reverse)
        {
            // �`�����l���؂���
            Debug.Assert(listChannels.Items.Count != 0);
            Int32 selectedIndex =
                listChannels.SelectedIndices.Count == 0 ?
                    0 : listChannels.SelectedIndices[0];

            // �܂���
            listChannels.Items[selectedIndex].Selected = false;

            selectedIndex += (reverse ? -1 : 1);

            if (selectedIndex == -1)
            {
                listChannels.Items[listChannels.Items.Count - 1].Selected = true;
            }
            else if (selectedIndex == listChannels.Items.Count)
            {
                listChannels.Items[0].Selected = true;
            }
            else
            {
                listChannels.Items[selectedIndex].Selected = true;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void textInput_KeyUp(object sender, KeyEventArgs e)
        {
            if (e.Shift && (e.KeyCode == Keys.Up || e.KeyCode == Keys.Down))
            {
                NextChannel(e.KeyCode == Keys.Up);
            }
        }

        [DllImport("coredll.dll")]
        private extern static UInt32 SendMessage(IntPtr hWnd, UInt32 Msg, UInt32 wParam, UInt32 lParam);

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void menuItemNext_Click(object sender, EventArgs e)
        {
            NextChannel(false);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void menuItemChannelPrev_Click(object sender, EventArgs e)
        {
            NextChannel(true);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void timerPing_Tick(object sender, EventArgs e)
        {
            if (_ircConnection.IsConnected)
            {
                _ircConnection.Send("PONG :"+_selfNickname);
            }
        }
    }
}