/// <summary>
 ///   Raises the NickCollision event.
 /// </summary>
 protected internal void OnNickInUse(IrcMessageEventArgs<NickInUseMessage> e)
 {
     if (this.NickInUse != null)
     {
         this.NickInUse(this, e);
     }
 }

        private void ClientIsOnReply(object sender, IrcMessageEventArgs<IsOnReplyMessage> e)
        {
            foreach (string onlineNick in e.Message.Nicks)
            {
                if (this._waitingOnNicks.Contains(onlineNick))
                {
                    this._waitingOnNicks.Remove(onlineNick);
                }
                User knownUser;
                if (this.Contacts.Users.TryGetValue(onlineNick, out knownUser))
                {
                    knownUser.Online = true;
                }
                else if (this._trackedNicks.Contains(onlineNick))
                {
                    this._trackedNicks.Remove(onlineNick);
                }
            }

            foreach (var offlineUser in this._waitingOnNicks.Select(nick => this.Contacts.Users[nick]))
            {
                offlineUser.Online = false;
            }
            this._waitingOnNicks.Clear();
        }

 /// <summary>
 ///   Raises the NickCollision event.
 /// </summary>
 protected internal void OnNickCollision(IrcMessageEventArgs<NickCollisionMessage> e)
 {
     if (this.NickCollision != null)
     {
         this.NickCollision(this, e);
     }
 }

 /// <summary>
 ///   Raises the ErroneusNick event.
 /// </summary>
 protected internal void OnErroneusNick(IrcMessageEventArgs<ErroneusNickMessage> e)
 {
     if (this.ErroneusNick != null)
     {
         this.ErroneusNick(this, e);
     }
 }

 /// <summary>
 ///   Raises the GenericErrorMessage event.
 /// </summary>
 protected internal void OnGenericErrorMessage(IrcMessageEventArgs<GenericErrorMessage> e)
 {
     if (this.GenericErrorMessage != null)
     {
         this.GenericErrorMessage(this, e);
     }
 }

 void client_IsOnReply( object sender, IrcMessageEventArgs<IsOnReplyMessage> e )
 {
     foreach ( String onlineNick in e.Message.Nicks )
     {
         if ( waitingOnNicks.Contains( onlineNick ) )
         {
             waitingOnNicks.Remove( onlineNick );
         }
         User knownUser = Contacts.Users.Find( onlineNick );
         if ( knownUser != null && knownUser.OnlineStatus == UserOnlineStatus.Offline )
         {
             knownUser.OnlineStatus = UserOnlineStatus.Online;
         }
         if ( knownUser == null && trackedNicks.Contains( onlineNick ) )
         {
             trackedNicks.Remove( onlineNick );
         }
     }
     foreach ( String nick in waitingOnNicks )
     {
         User offlineUser = Contacts.Users.Find( nick );
         offlineUser.OnlineStatus = UserOnlineStatus.Offline;
         waitingOnNicks.Remove( nick );
     }
 }

 void client_WatchedUserOnline( object sender, IrcMessageEventArgs<WatchedUserOnlineMessage> e )
 {
     User knownUser = Contacts.Users.Find( e.Message.WatchedUser.Nick );
     if ( knownUser != null && knownUser.OnlineStatus == UserOnlineStatus.Offline )
     {
         knownUser.OnlineStatus = UserOnlineStatus.Online;
     }
 }

 void client_MonitoredUserOffline( object sender, IrcMessageEventArgs<MonitoredUserOfflineMessage> e )
 {
     foreach ( String offlineNick in e.Message.Nicks )
     {
         User knownUser = this.Contacts.Users.Find( offlineNick );
         if ( knownUser != null )
         {
             knownUser.OnlineStatus = UserOnlineStatus.Offline;
         }
     }
 }

 private void ClientMonitoredUserOffline(object sender, IrcMessageEventArgs<MonitoredUserOfflineMessage> e)
 {
     foreach (var offlineNick in e.Message.Nicks)
     {
         User knownUser;
         if (this.Contacts.Users.TryGetValue(offlineNick, out knownUser))
         {
             knownUser.Online = false;
         }
     }
 }

 private void ClientMonitoredUserOnline(object sender, IrcMessageEventArgs<MonitoredUserOnlineMessage> e)
 {
     foreach (var onlineUser in e.Message.Users.Values)
     {
         User knownUser;
         if (this.Contacts.Users.TryGetValue(onlineUser.Nickname, out knownUser))
         {
             knownUser.CopyFrom(onlineUser);
             knownUser.Online = true;
         }
     }
 }

 void client_MonitoredUserOnline( object sender, IrcMessageEventArgs<MonitoredUserOnlineMessage> e )
 {
     foreach ( User onlineUser in e.Message.Users )
     {
         User knownUser = this.Contacts.Users.Find( onlineUser.Nick );
         if ( knownUser != null )
         {
             knownUser.MergeWith( onlineUser );
             if ( knownUser.OnlineStatus == UserOnlineStatus.Offline )
             {
                 knownUser.OnlineStatus = UserOnlineStatus.Online;
             }
         }
     }
 }

        private void IrcClient_LocalUser_MessageReceived(object sender, IrcMessageEventArgs e)
        {
            var localUser = (IrcLocalUser)sender;

            if (e.Source is IrcUser)
            {
                // Read message and process if it is chat command.
                if (ReadChatCommand(localUser.Client, e))
                    return;
            }

            OnLocalUserMessageReceived(localUser, e);
        }

        private void IrcClient_Channel_NoticeReceived(object sender, IrcMessageEventArgs e)
        {
            var channel = (IrcChannel)sender;

            OnChannelNoticeReceived(channel, e);
        }

        private void IrcClient_Channel_MessageReceived(object sender, IrcMessageEventArgs e)
        {
            var channel = (IrcChannel)sender;

            if (e.Source is IrcUser)
            {
                // Read message and process if it is chat command.
                if (ReadChatCommand(channel.Client, e))
                    return;
            }

            OnChannelMessageReceived(channel, e);
        }

 protected abstract void OnLocalUserNoticeReceived(IrcLocalUser localUser, IrcMessageEventArgs e);

 protected abstract void OnChannelNoticeReceived(IrcChannel channel, IrcMessageEventArgs e);

        private void routeTopicSets( Object sender, IrcMessageEventArgs<TopicSetReplyMessage> e )
        {
            Client source = sender as Client;
            if ( source == null )
            {
                return;
            }

            Channel channel = this.Channels[source].FindChannel( e.Message.Channel );
            if ( channel != null )
            {
                User topicSetter = this.Users[source].EnsureUser( e.Message.User );
                channel.TopicSetter = topicSetter;
                channel.TopicSetTime = e.Message.TimeSet;
            }
        }

 private void welcomed( Object sender, IrcMessageEventArgs<WelcomeMessage> e )
 {
     General.client.SendJoin("#devatan");
     textBox1.Text += "Connecting to channel..." + Environment.NewLine;
     General.client.DefaultQuitMessage = "DevAtan IRC - DevAtan Official Chat Application";
 }

 private static void ircClient2_LocalUser_MessageSent(object sender, IrcMessageEventArgs e)
 {
     if (client2LocalUserMessageSentEvent != null)
         client2LocalUserMessageSentEvent.Set();
 }

        private void routeQuits( Object sender, IrcMessageEventArgs<QuitMessage> e )
        {
            Client source = sender as Client;
            if ( source == null )
            {
                return;
            }

            String nick = e.Message.Sender.Nick;
            if ( IsMe( nick, source ) )
            {
                foreach ( Channel c in this.Channels[source] )
                {
                    c.Open = false;
                }
            }
            else
            {
                foreach ( Channel channel in this.Channels[source] )
                {
                    channel.Users.RemoveFirst( nick );
                }
            }
        }