conversationmanagerimp.cs

破解的飞信源代码

namespace Imps.Client.Pc
{
    using Imps.Client;
    using Imps.Client.Core;
    using Imps.Client.Pc.BizControls.NotifyWindows;
    using Imps.Client.Pc.BizControls.NotifyWindows.Templates;
    using Imps.Client.Pc.ScheduleSmsUI;
    using Imps.Client.Resource;
    using Imps.Client.Utils;
    using Imps.Client.Utils.Win32;
    using Imps.Common;
    using Imps.Utils;
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Diagnostics;
    using System.IO;
    using System.Media;
    using System.Threading;
    using System.Windows.Forms;

    public class ConversationManagerImp : IConversationManager
    {
        private List<ConversationWindow> _allConversatonWindows;
        private CustomEmotionAddFromEntityForm _ceAddFromEntityForm;
        private CustomEmotionManagerForm _ceManagerForm;
        private bool _forceToCloseWindow;
        private IFrameworkWindow _frameworkWnd;
        private ManageForm _scheduleSmsform;
        private bool _showFileType;
        private GroupSMSForm _smsForm;

        public ConversationManagerImp(IFrameworkWindow framework)
        {
            try
            {
                this._frameworkWnd = framework;
                this.CurrentUser.ConversationManager.FindConversationForm += new EventHandler<FindConversationFormEventArgs>(this, (IntPtr) this.ConversationManager_FindConversationWindow);
                ((Form) framework).add_FormClosed(new FormClosedEventHandler(this, (IntPtr) this.mainFormclosed));
                framework.AccountManager.BeforeUserLogOut += new EventHandler<ImpsCancelEventArgs>(this, (IntPtr) this.AccountManager_BeforeUserLogOut);
                this.CurrentUser.StatusChanged += new EventHandler<UserSatusChangedEventArgs>(this, (IntPtr) this.CurrentUser_StatusChanged);
            }
            catch (Exception exception)
            {
                ClientLogger.WriteException(exception);
            }
        }

        private void AccountManager_BeforeUserLogOut(object sender, ImpsCancelEventArgs e)
        {
            ImpsCancelOperationDelegate delegate2 = null;
            bool flag = this.AllConversatonWindows.get_Count() > 0;
            bool flag2 = (this._smsForm != null) && !this._smsForm.IsDisposed;
            if (flag || flag2)
            {
                string text;
                e.Cancel = true;
                if (flag)
                {
                    text = "注销后所有的会话窗口都将被关闭，确认要注销吗？";
                    if (flag2)
                    {
                        text = "注销后群发短信窗口和所有的会话窗口都将被关闭，确认要注销吗？";
                    }
                }
                else
                {
                    text = "注销后群发短信窗口将会被关闭，确认要注销吗？";
                }
                e.CancelQuestions.Add(text);
                if (delegate2 == null)
                {
                    delegate2 = delegate (bool realCancelled) {
                        if (!realCancelled)
                        {
                            this._forceToCloseWindow = true;
                            this.CloseAllConversationWindow();
                            if ((this._smsForm != null) && !this._smsForm.IsDisposed)
                            {
                                this._smsForm.Close();
                            }
                        }
                    };
                }
                e.CancelOperations.Add(delegate2);
            }
        }

        public void AddToOwnerEmotion(IWin32Window owner, string shortCut, string name, string filePath)
        {
            if ((this._ceAddFromEntityForm != null) && !this._ceAddFromEntityForm.IsDisposed)
            {
                this._ceAddFromEntityForm.Close();
            }
            this._ceAddFromEntityForm = new CustomEmotionAddFromEntityForm(this._frameworkWnd, shortCut, name, filePath);
            ControlHelper.ShowFormCenterOnParent(this._ceAddFromEntityForm, owner);
        }

        public void CloseAllConversationWindow()
        {
            try
            {
                for (int i = this.AllConversatonWindows.get_Count() - 1; i >= 0; i--)
                {
                    this.AllConversatonWindows.get_Item(i).Close();
                }
            }
            catch (Exception exception)
            {
                ClientLogger.WriteGeneral(exception.ToString());
            }
        }

        private void ConversationManager_FindConversationWindow(object sender, FindConversationFormEventArgs e)
        {
            try
            {
                if (e.Conversation.Dialogs.Count > 0)
                {
                    IicUri uri = new IicUri(e.Conversation.Dialogs[0].To);
                    if (uri.Type == IicUriType.PersonalGroup)
                    {
                        return;
                    }
                }
            }
            catch (Exception exception)
            {
                ClientLogger.WriteException(exception);
            }
            try
            {
                lock (this.AllConversatonWindows)
                {
                    List<ConversationWindow>.Enumerator enumerator = this.AllConversatonWindows.GetEnumerator();
                    try
                    {
                        while (enumerator.MoveNext())
                        {
                            ConversationWindow form = enumerator.get_Current();
                            if ((form.CurrentConversation != null) && (form.CurrentConversation.CallId == e.Conversation.CallId))
                            {
                                this.DoFindForm(form, e.Conversation);
                                return;
                            }
                        }
                    }
                    finally
                    {
                        enumerator.Dispose();
                    }
                    List<ConversationWindow>.Enumerator enumerator2 = this.AllConversatonWindows.GetEnumerator();
                    try
                    {
                        while (enumerator2.MoveNext())
                        {
                            ConversationWindow window2 = enumerator2.get_Current();
                            if (window2.Uri == e.Conversation.CurrentDialog.To)
                            {
                                this.DoFindForm(window2, e.Conversation);
                                return;
                            }
                        }
                    }
                    finally
                    {
                        enumerator2.Dispose();
                    }
                    List<ConversationWindow>.Enumerator enumerator3 = this.AllConversatonWindows.GetEnumerator();
                    try
                    {
                        while (enumerator3.MoveNext())
                        {
                            ConversationWindow window3 = enumerator3.get_Current();
                            if (!string.IsNullOrEmpty(window3.MobileNo) && (e.Conversation.CurrentDialog.Participants.Count == 1))
                            {
                                Imps.Client.Core.Contact contact = e.Conversation.CurrentDialog.Participants[0].Contact;
                                if ((contact is NonFederationContact) && ((contact as NonFederationContact).MobileNo == window3.MobileNo))
                                {
                                    this.DoFindForm(window3, e.Conversation);
                                    return;
                                }
                            }
                        }
                    }
                    finally
                    {
                        enumerator3.Dispose();
                    }
                }
                ConversationWindow newForm = this.CreateConversationWindow(e.Conversation);
                if (BossKey.Hidden)
                {
                    newForm.ShowInTaskbar = false;
                    newForm.Show();
                    newForm.Visible = false;
                }
                else
                {
                    newForm.WindowState = FormWindowState.Minimized;
                    newForm.Show();
                }
                if (((this.CurrentUser.Configuration.UserSetting.NotifyWinodwSetting.NewMessageNotify != null) && (this.CurrentUser.Presence.MainPresence != MainPresence.Busy)) && ((this.CurrentUser.Presence.MainPresence != MainPresence.DoNotDisturb) && !BossKey.Hidden))
                {
                    ShowMessageReceiveNotifyWindow(newForm, e.Contact, e.Message);
                }
            }
            catch (Exception exception2)
            {
                ClientLogger.WriteException(exception2);
            }
            finally
            {
                e.AutoEvent.Set();
            }
        }

        private ConversationWindow CreateConversationWindow(Imps.Client.Core.Conversation conv)
        {
            ConversationWindow window = new ConversationWindow(this, conv);
            window.LoadWindowSetting();
            this.AllConversatonWindows.Add(window);
            window.add_FormClosed(new FormClosedEventHandler(this, (IntPtr) this.form_FormClosed));
            window.Activated += new EventHandler(this.form_Activated);
            window.Deactivate += new EventHandler(this.form_Deactivate);
            return window;
        }

        private void CurrentUser_StatusChanged(object sender, UserSatusChangedEventArgs e)
        {
            try
            {
                if (e.NewStatus != UserAccountStatus.Logon)
                {
                    if (this._ceManagerForm != null)
                    {
                        this._ceManagerForm.Close();
                    }
                    if (this._ceAddFromEntityForm != null)
                    {
                        this._ceAddFromEntityForm.Close();
                    }
                }
            }
            catch (Exception exception)
            {
                ClientLogger.WriteException(exception);
            }
        }

        private void DoFindForm(ConversationWindow form, Imps.Client.Core.Conversation conv)
        {
            if (form.CurrentConversation != conv)
            {
                form.CurrentConversation = conv;
            }
        }

        public static void ExecuteFile(IWin32Window owner, string filePath)
        {
            ThreadPool.QueueUserWorkItem(new WaitCallback(ConversationManagerImp.ExecuteFileInThread), filePath);
        }

        private static void ExecuteFileInThread(object obj)
        {
            string url = obj as string;
            try
            {
                if (url.ToLower().StartsWith("http://") || url.ToLower().StartsWith("www."))
                {
                    ShellHelper.StartUrl(url);
                }
                else
                {
                    Process.Start(url);
                }
            }
            catch (Win32Exception exception)
            {
                if (File.Exists(url))
                {
                    try
                    {
                        Imps.Client.Utils.Win32.NativeMethods.ShellExecute(IntPtr.Zero, null, "RUNDLL32.EXE", "shell32.dll,OpenAs_RunDLL " + url, null, 5);
                    }
                    catch (Exception exception2)
                    {
                        ClientLogger.WriteException(exception2);
                    }
                }
                else
                {
                    ClientLogger.WriteException(exception);
                }