private void ConnectionOnMessage(object sender, Message msg)
 {
     OnMessageReceived(new MessageReceivedArgs
     {
         Message = Create(msg)
     });
 }

        public void should_parse_room_message_into_proper_type()
        {
            var message = new agsXMPP.protocol.client.Message() {From = "[email protected]/Dharma Soft", Body = "Message Body"};

            var xmppMessage = MessageFactory.Create(message);
            Assert.That(xmppMessage.MessageType,Is.EqualTo(MessageType.RoomMessage));
        }

 public static bool IsContentMessage(Message msg)
 {
     //A "content message" -- that is, a message stanza whose primary meaning is contained in
     //standard messaging content such as the XMPP <body/> or any other properly-namespaced child
     //element(s) other than those defined for chat state notifications in this specification.
     return !string.IsNullOrEmpty(msg.Body) || msg.HasTag(XamlBody.TAG);
 }

        public Message Create(FlowDocument document)
        {
            var xdoc = new XmlDocument();
            xdoc.LoadXml(XamlWriter.Save(document));

            var newAttr = xdoc.CreateAttribute("xml:space");
            newAttr.Value = "preserve";

            xdoc.DocumentElement.Attributes.Append(newAttr);
            var sb = new StringBuilder(xdoc.OuterXml);
            //see: http://stackoverflow.com/questions/2624068/wpf-richtextbox-xamlwriter-behaviour
            var xamlPart = sb.Replace("{}{", "{").ToString();

            var txtPart = new TextRange(document.ContentStart, document.ContentEnd)
                    .Text
                    .TrimEnd();
            var xaml = new XamlBody();
            xaml.Content = xamlPart;
            var msg = new Message
            {
                    Body = txtPart,
            };
            msg.AddChild(xaml);
            return msg;
        }

        public bool CanProcess(Message message)
        {
            if (message == null)
                return false;

            return !string.IsNullOrEmpty(CommandProcessor.GetCommandFromMessage(message.Body));
        }

        public void ProcessMessage(Message message)
        {
            if (!CanProcess(message))
                return;

            ChatMember from = _directory.LookUp(message.From.Bare);

            if (from == null)
                return;

            if (from.ActiveInChat)
            {
                IEnumerable<ChatMember> recipients = _directory.GetToListForSubscriber(message.From.Bare);

                foreach (ChatMember member in recipients)
                {
                    if (member.ActiveInChat)
                    {
                        _communicator.SendMessage(member.Jid, string.Format("[\"{0}\"] {1}", from.Alias, message.Body));
                    }
                }
            }
            else
            {
                _communicator.SendMessage(from.Jid, NOT_ACTIVE_IN_CHAT_MESSAGE);
            }
        }

        protected virtual void ProcessMessage(Message message)
        {
            if (message.Body == null) return;

            try
            {
                var msgObj = MessageFactory.GetMessageFromXml(message.Body);
                if (msgObj == null) return;

                var msgType = msgObj.GetType();

                if (msgType == typeof(GameStartMessage))
                    ProcessGameStartMessage(message.From, (GameStartMessage)msgObj);
                if (msgType == typeof(GameOverMessage))
                    ProcessGameOverMessage(message.From, (GameOverMessage)msgObj);
                if (msgType == typeof(TurnResultMessage))
                    ProcessTurnResultMessage(message.From, (TurnResultMessage)msgObj);
                if (msgType == typeof(TurnStartMessage))
                    ProcessTurnStartMessage(message.From, (TurnStartMessage)msgObj);
                if (msgType == typeof(RegistrationCompleteMessage))
                    ProcessRegistrationCompleteMessage(message.From);
                if (msgType == typeof(TournamentStartedMessage))
                    ProcessTournamentStartedMessage(message.From, (TournamentStartedMessage)msgObj);
                if (msgType == typeof(PlayerMoveMessage))
                    ProcessPlayerMoveMessage(message.From, (PlayerMoveMessage)msgObj);
                if (msgType == typeof(RegisterMessage))
                    ProcessRegisterMessage(message.From);
            }
            catch (Exception) { }
        }

        private void Message1()
        {
            // transient message (will not be stored offline if the server support AMP)

            /*
            <message to='[email protected]'
                     from='[email protected]/elsinore'
                     type='chat'
                     id='chatty1'>
              <body>Who&apos;s there?</body>
              <amp xmlns='http://jabber.org/protocol/amp'>
                <rule action='drop' condition='deliver' value='stored'/>
              </amp>
            </message>
            */

            agsXMPP.protocol.client.Message msg = new agsXMPP.protocol.client.Message();
            msg.To = new Jid("[email protected]");
            msg.From = new Jid("[email protected]/elsinore");
            msg.Type = MessageType.chat;
            msg.Id = "chatty1";

            msg.Body = "Who&apos;s there?";

            Amp amp = new Amp();
            Rule rule = new Rule(Condition.Deliver, "stored", agsXMPP.protocol.extensions.amp.Action.drop);
            amp.AddRule(rule);

            msg.AddChild(amp);

            Program.Print(msg);
        }

 public void Execute(Message message)
 {
     if(_directory.RemoveSubscriber(message.From.Bare))
     {
         _communicator.SendMessage(message.From.Bare,REMOVED_CONFIRMATION_MESSAGE);
     }
 }

        void XmppConnection_OnMessage(object sender, Message msg)
        {
            if (!roomName.Contains(msg.From.User))
                return;

            if (msg.From.Resource == Client.LoginPacket.AllSummonerData.Summoner.Name)
                return;

            Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(() =>
            {
                if (msg.Body == "This room is not anonymous")
                    return;

                var tr = new TextRange(ChatText.Document.ContentEnd, ChatText.Document.ContentEnd)
                {
                    Text = msg.From.Resource + ": "
                };
                tr.ApplyPropertyValue(TextElement.ForegroundProperty, Brushes.Turquoise);

                tr = new TextRange(ChatText.Document.ContentEnd, ChatText.Document.ContentEnd)
                {
                    Text = msg.Body.Replace("<![CDATA[", "").Replace("]]>", string.Empty) + Environment.NewLine
                };
                tr.ApplyPropertyValue(TextElement.ForegroundProperty, Brushes.White);

                ChatText.ScrollToEnd();
            }));
        }

        private void MessageCallBack(object sender, Message msg, object data)
        {
            if (msg.Body != null)
            {
                var payload = new MessagePayload();
                payload.Attachments = new List<MessagePayloadAttachment>();
                if (!msg.Body.Contains("@everyone"))
                {
                    msg.Body = string.Concat("@everyone: ", msg.Body);
                }
                payload.Attachments.Add(new MessagePayloadAttachment()
                {
                    Text = msg.Body.Replace("@everyone", "@channel"),
                    Title = string.Format("{0}: Message from {1}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), "Marvin"),
                    Colour = "#ff0066"
                });
                Plugin.SendToRoom(payload, Properties.Settings.Default.FleetRoomName, Properties.Settings.Default.SlackWebhook, Properties.Settings.Default.FleetBotName);

                if (msg.Body.Contains("bog_all"))
                {
                    foreach (var hook in Properties.Settings.Default.DiscordLinkSlackWebhooks)
                    {
                        Plugin.SendToRoom(payload, Properties.Settings.Default.FleetRoomName, hook, Properties.Settings.Default.FleetBotName);
                    }
                }
            }
        }

        //������Ϣ
        private void button2_Click(object sender, EventArgs e)
        {
            agsXMPP.protocol.client.Message msg = new agsXMPP.protocol.client.Message();

            if (listBox1.SelectedIndex > 0)
            {
                msg.Type = MessageType.chat;
                msg.Body = richTextBox2.Text;
                msg.From = new Jid(con.Username, "localhost", "resource");
                msg.To = new Jid(name, "localhost", con.Username);

                con.Send(msg);

                richTextBox2.Text = "";
            }
            else
            {
                msg.Type = MessageType.groupchat;
                msg.Body = richTextBox2.Text;
                msg.From = new Jid(con.Username, "localhost", "resource");
                msg.To = new Jid(con.Server, "localhost", con.Username);

                con.Send(msg);

                richTextBox2.Text = "";
            }
        }

 private void cmdSend_Click()
 {
     // Send a message
     agsXMPP.protocol.client.Message msg = new agsXMPP.protocol.client.Message();
     msg.Type = agsXMPP.protocol.client.MessageType.chat;
     msg.To = new Jid("");
     msg.Body = "";
 }

 private IMessage Create(Message msg)
 {
     return new FeedMessage
     {
         XmppMessage = msg,
         Date = DateTime.Now,
         ClientId = _client.Id
     };
 }

 public FurikoMessage(Message _msg)
 {
     DateTime now = DateTime.Now;
     //time = now.ToString("yyyy-MM-dd HH:mm:ss");
     time = DateTime.Now;
     with = _msg.From.Bare;
     jid = _msg.From.Bare;
     body = _msg.Body;
 }

 public void OnMessage(object sender, Message msg)
 {
     if (msg.Type == MessageType.chat)
     {
         messages.Enqueue(msg);
         messageEvent.Set();
         //currentChat = msg.CreateNewThread();
     }
 }

 public Message Create(FlowDocument document)
 {
     var body = new TextRange(document.ContentStart, document.ContentEnd)
             .Text
             .TrimEnd(Environment.NewLine.ToCharArray());
     var msg = new Message();
     msg.Body = body;
     return msg;
 }

 private void button2_Click_1(object sender, EventArgs e)
 {
     agsXMPP.protocol.client.Message msg = new agsXMPP.protocol.client.Message();
     msg.Type = MessageType.groupchat;
     msg.To = Roomjid;
     msg.Body = textBox2.Text;
     dbcon.Send(msg);
     textBox2.Clear();
 }

        //Blink and add to notification list if messaged
        private void XmppConnection_OnMessage(object sender, Message msg)
        {
            //If is special message, don't show popup
            if (msg.Subject != null)
            {
                Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(() =>
                {
                    var subject = (ChatSubjects)Enum.Parse(typeof(ChatSubjects), msg.Subject, true);

                    if ((subject == ChatSubjects.PRACTICE_GAME_INVITE ||
                         subject == ChatSubjects.GAME_INVITE) &&
                        Client.NotificationContainer.Visibility != Visibility.Visible)
                    {
                        NotificationButton.Content = ".";
                    }
                }));
                return;
            }

            if (!Client.AllPlayers.ContainsKey(msg.From.User) || string.IsNullOrWhiteSpace(msg.Body))
                return;
            if (msg.Body.ToLower().Contains("elo") && msg.Body.ToLower().Contains("boost"))
                return;

            ChatPlayerItem chatItem = Client.AllPlayers[msg.From.User];
            Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(() =>
            {
                NotificationChatPlayer player =
                    ChatListView.Items.Cast<object>()
                        .Where(i => i.GetType() == typeof(NotificationChatPlayer))
                        .Cast<NotificationChatPlayer>()
                        .FirstOrDefault(x => x.PlayerName == chatItem.Username);

                if (player == null)
                {
                    player = new NotificationChatPlayer
                    {
                        Tag = chatItem,
                        PlayerName = chatItem.Username,
                        Margin = new Thickness(1, 0, 1, 0),
                        PlayerLabelName = { Content = chatItem.Username }
                    };
                    Client.ChatListView.Items.Add(player);
                }

                if (Client.ChatItem != null)
                {
                    if ((string)Client.ChatItem.PlayerLabelName.Content != chatItem.Username)
                    {
                        player.BlinkRectangle.Visibility = Visibility.Visible;
                    }
                }
                else
                    player.BlinkRectangle.Visibility = Visibility.Visible;
            }));
        }

        private void OnMessage(object sender, Message msg)
        {
            if (m_listener == null)
            return;

             if (msg.From.Bare != Jid)
            return;

             m_listener.OnMessage(new ChatMessage(msg.From.Resource, msg.Body));
        }