Example #1
0
            /// <summary>
            /// Load all configuration and override the current values
            /// </summary>
            /// <returns></returns>
            public static bool ConfigurationLoad()
            {
                // Check if config file is present
                Restore(ConfigFile);
                bool Protocols = false;
                if (File.Exists(ConfigFile))
                {
                    try
                    {
                        XmlDocument configuration = new XmlDocument();
                        configuration.Load(ConfigFile);
                        lock (Configuration.ShortcutKeylist)
                        {
                            Configuration.ShortcutKeylist = new List<Shortcut>();
                        }
                        lock (Ignoring.IgnoreList)
                        {
                            Ignoring.IgnoreList.Clear();
                        }
                        lock (Configuration.HighlighterList)
                        {
                            Configuration.HighlighterList = new List<Network.Highlighter>();
                        }
                        lock (NetworkData.Networks)
                        {
                            NetworkData.Networks.Clear();
                        }
                        lock (Configuration.UserData.History)
                        {
                            Configuration.UserData.History.Clear();
                        }
                        Commands.ClearAliases();
                        foreach (XmlNode node in configuration.ChildNodes)
                        {
                            if (node.Name == "configuration.pidgeon")
                            {
                                foreach (XmlNode curr in node.ChildNodes)
                                {
                                    if (curr.Name == "history")
                                    {
                                        lock (Configuration.UserData.History)
                                        {
                                            Configuration.UserData.History.Add(curr.InnerText);
                                        }
                                        continue;
                                    }
                                    if (curr.Attributes == null)
                                    {
                                        continue;
                                    }
                                    if (curr.Attributes.Count > 0)
                                    {
                                        if (curr.Name.StartsWith("extension.", StringComparison.Ordinal))
                                        {
                                            Configuration.SetConfig(curr.Name.Substring(10), curr.InnerText);
                                            continue;
                                        }
                                        if (curr.Name == "alias")
                                        {
                                            Commands.RegisterAlias(curr.Attributes[0].InnerText, curr.Attributes[1].InnerText, bool.Parse(curr.Attributes[2].InnerText));
                                            continue;
                                        }
                                        if (curr.Name == "network")
                                        {
                                            if (curr.Attributes.Count > 3)
                                            {
                                                NetworkData.NetworkInfo info = new NetworkData.NetworkInfo();
                                                foreach (XmlAttribute xx in curr.Attributes)
                                                {
                                                    switch (xx.Name.ToLower())
                                                    {
                                                        case "name":
                                                            info.Name = xx.Value;
                                                            break;
                                                        case "server":
                                                            info.Server = xx.Value;
                                                            break;
                                                        case "ssl":
                                                            info.SSL = bool.Parse(xx.Value);
                                                            break;
                                                    }
                                                }
                                                lock (NetworkData.Networks)
                                                {
                                                    NetworkData.Networks.Add(info);
                                                }
                                            }
                                            continue;
                                        }
                                        if (curr.Name == "window")
                                        {
                                            string name = curr.InnerText;
                                            PidgeonGtkToolkit.PidgeonForm.Info w = new PidgeonGtkToolkit.PidgeonForm.Info();
                                            if (curr.Attributes == null)
                                            {
                                                continue;
                                            }
                                            foreach (XmlAttribute option in curr.Attributes)
                                            {
                                                if (curr.Value == null)
                                                {
                                                    // invalid config
                                                    continue;
                                                }
                                                switch (option.Name)
                                                {
                                                    case "width":
                                                        w.Width = int.Parse(curr.Value);
                                                        break;
                                                    case "height":
                                                        w.Height = int.Parse(curr.Value);
                                                        break;
                                                    case "x":
                                                        w.X = int.Parse(curr.Value);
                                                        break;
                                                    case "y":
                                                        w.Y = int.Parse(curr.Value);
                                                        break;
                                                }
                                            }
                                            lock (PidgeonGtkToolkit.PidgeonForm.WindowInfo)
                                            {
                                                if (!PidgeonGtkToolkit.PidgeonForm.WindowInfo.ContainsKey(name))
                                                {
                                                    PidgeonGtkToolkit.PidgeonForm.WindowInfo.Add(name, w);
                                                }
                                            }
                                        }
                                        if (curr.Name == "ignore")
                                        {
                                            if (curr.Attributes.Count > 3)
                                            {
                                                Ignoring.Ignore.Type _t = Ignoring.Ignore.Type.Everything;
                                                if (curr.Attributes[3].Value == "User")
                                                {
                                                    _t = Ignoring.Ignore.Type.User;
                                                }
                                                Ignoring.Ignore ignore = new Ignoring.Ignore(bool.Parse(curr.Attributes[0].Value), bool.Parse(curr.Attributes[1].Value), curr.Attributes[2].Value, _t);
                                                lock (Ignoring.IgnoreList)
                                                {
                                                    Ignoring.IgnoreList.Add(ignore);
                                                }
                                            }
                                            continue;
                                        }

                                        if (curr.Name == "list")
                                        {
                                            if (curr.Attributes.Count > 2)
                                            {
                                                Network.Highlighter list = new Network.Highlighter();
                                                list.simple = bool.Parse(curr.Attributes[0].Value);
                                                list.text = curr.Attributes[1].Value;
                                                list.enabled = bool.Parse(curr.Attributes[2].Value);
                                                lock (Configuration.HighlighterList)
                                                {
                                                    Configuration.HighlighterList.Add(list);
                                                }
                                            }
                                            continue;
                                        }

                                        if (curr.Name == "protocol")
                                        {
                                            if (!Protocols)
                                            {
                                                Configuration.Parser.Protocols.Clear();
                                                Protocols = true;
                                            }
                                            Configuration.Parser.Protocols.Add(curr.InnerText);
                                            continue;
                                        }

                                        if (curr.Name == "shortcut")
                                        {
                                            if (curr.Attributes.Count > 2)
                                            {
                                                Shortcut list = new Shortcut(ParseKey(curr.Attributes[0].Value), bool.Parse(curr.Attributes[1].Value), bool.Parse(curr.Attributes[2].Value), bool.Parse(curr.Attributes[3].Value));
                                                list.data = curr.InnerText;
                                                Configuration.ShortcutKeylist.Add(list);
                                            }
                                            continue;
                                        }
                                        if (curr.Attributes.Count > 0)
                                        {
                                            if (curr.Attributes[0].Name == "confname")
                                            {
                                                switch (curr.Attributes[0].Value)
                                                {
                                                    case "Configuration.Window.x1":
                                                    case "location.x1":
                                                        Configuration.Window.TextboxLeft = int.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Window.window_size":
                                                    case "window.size":
                                                        Configuration.Window.WindowSize = int.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Window.x4":
                                                    case "location.x4":
                                                        Configuration.Window.SidebarLeft = int.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Window.Window_Maximized":
                                                    case "location.maxi":
                                                        Configuration.Window.Window_Maximized = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "timestamp.display":
                                                    case "Configuration.Scrollback.chat_timestamp":
                                                        Configuration.Scrollback.chat_timestamp = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.UserData.nick":
                                                    case "network.nick":
                                                        Configuration.UserData.nick = curr.InnerText;
                                                        break;
                                                    case "Configuration.UserData.Nick2":
                                                    case "network.n2":
                                                        Configuration.UserData.Nick2 = curr.InnerText;
                                                        break;
                                                    case "Configuration.UserData.ident":
                                                    case "network.ident":
                                                        Configuration.UserData.ident = curr.InnerText;
                                                        break;
                                                    case "Configuration.irc.DisplayCtcp":
                                                    case "scrollback.showctcp":
                                                        Configuration.irc.DisplayCtcp = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Scrollback.format_nick":
                                                    case "formats.user":
                                                        Configuration.Scrollback.format_nick = curr.InnerText;
                                                        break;
                                                    case "Configuration.Scrollback.format_date":
                                                    case "formats.date":
                                                        Configuration.Scrollback.format_date = curr.InnerText;
                                                        break;
                                                    case "Configuration.Scrollback.timestamp_mask":
                                                    case "formats.datetime":
                                                        Configuration.Scrollback.timestamp_mask = curr.InnerText;
                                                        break;
                                                    case "Configuration.ChannelModes.aggressive_whois":
                                                    case "irc.auto.whois":
                                                        Configuration.ChannelModes.aggressive_whois = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.ChannelModes.aggressive_bans":
                                                    case "irc.auto.bans":
                                                        Configuration.ChannelModes.aggressive_bans = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.ChannelModes.aggressive_exception":
                                                    case "irc.auto.exception":
                                                        Configuration.ChannelModes.aggressive_exception = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.ChannelModes.aggressive_channel":
                                                    case "irc.auto.channels":
                                                        Configuration.ChannelModes.aggressive_channel = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.ChannelModes.aggressive_invites":
                                                    case "irc.auto.invites":
                                                        Configuration.ChannelModes.aggressive_invites = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.ChannelModes.aggressive_mode":
                                                    case "irc.auto.mode":
                                                        Configuration.ChannelModes.aggressive_mode = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.irc.DefaultReason":
                                                    case "network.reason":
                                                        Configuration.irc.DefaultReason = curr.InnerText;
                                                        break;
                                                    case "Configuration.Logs.logs_name":
                                                    case "logs.type":
                                                        Configuration.Logs.logs_name = curr.InnerText;
                                                        break;
                                                    case "logs.html":
                                                    case "Configuration.Logs.logs_html":
                                                        Configuration.Logs.logs_html = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "logs.dir":
                                                    case "Configuration.Logs.logs_dir":
                                                        Configuration.Logs.logs_dir = curr.InnerText;
                                                        break;
                                                    case "logs.xml":
                                                    case "Configuration.Logs.logs_xml":
                                                        Configuration.Logs.logs_xml = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "logs.txt":
                                                    case "Configuration.Logs.logs_txt":
                                                        Configuration.Logs.logs_txt = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Scrollback.scrollback_plimit":
                                                    case "scrollback_plimit":
                                                        Configuration.Scrollback.scrollback_plimit = int.Parse(curr.InnerText);
                                                        break;
                                                    case "notification.tray":
                                                    case "Configuration.Kernel.Notice":
                                                        Configuration.Kernel.Notice = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "pidgeon.size":
                                                    case "Configuration.Services.Depth":
                                                        Configuration.Services.Depth = int.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.UserData.LastNick":
                                                    case "history.nick":
                                                        Configuration.UserData.LastNick = curr.InnerText;
                                                        break;
                                                    case "Configuration.Kernel.NetworkSniff":
                                                    case "sniffer":
                                                        Configuration.Kernel.NetworkSniff = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.UserData.LastHost":
                                                    case "history.host":
                                                        Configuration.UserData.LastHost = curr.InnerText;
                                                        break;
                                                    case "Configuration.Kernel.CheckUpdate":
                                                    case "updater.check":
                                                        Configuration.Kernel.CheckUpdate = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.UserData.LastPort":
                                                    case "history.port":
                                                        Configuration.UserData.LastPort = curr.InnerText;
                                                        break;
                                                    case "Configuration.Parser.Separators":
                                                    case "delimiters":
                                                        List<char> temp = new List<char>();
                                                        foreach (char part in curr.InnerText)
                                                        {
                                                            temp.Add(part);
                                                        }
                                                        Configuration.Parser.Separators = temp;
                                                        break;
                                                    case "colors.changelinks":
                                                    case "Configuration.Colors.ChangeLinks":
                                                        Configuration.Colors.ChangeLinks = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Kernel.Debugging":
                                                    case "debugger":
                                                        Configuration.Kernel.Debugging = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Services.UsingCache":
                                                    case "services.usingcache":
                                                        Configuration.Services.UsingCache = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.irc.mq":
                                                    case "message_mq":
                                                        Configuration.irc.mq = int.Parse(curr.InnerText);
                                                        break;
                                                    case "logs.services.log.type":
                                                    case "Configuration.Logs.ServicesLogs":
                                                        Configuration.Logs.ServiceLogs type = Configuration.Logs.ServiceLogs.none;
                                                        switch (curr.InnerText.ToLower())
                                                        {
                                                            case "incremental":
                                                                type = Configuration.Logs.ServiceLogs.incremental;
                                                                break;
                                                            case "full":
                                                                type = Configuration.Logs.ServiceLogs.full;
                                                                break;
                                                        }
                                                        Configuration.Logs.ServicesLogs = type;
                                                        break;
                                                    case "Configuration.Window.history":
                                                        Configuration.Window.History = int.Parse(curr.InnerText);
                                                        break;
                                                    case "userdata.openlinkinbrowser":
                                                    case "Configuration.UserData.OpenLinkInBrowser":
                                                        Configuration.UserData.OpenLinkInBrowser = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Parser.formatter":
                                                    case "formatter":
                                                        Configuration.Parser.formatter = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Memory.MaximumChannelBufferSize":
                                                    case "system.maximumchannelbuffersize":
                                                        Configuration.Memory.MaximumChannelBufferSize = int.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Memory.EnableSimpleViewCache":
                                                    case "system.enablesimpleviewcache":
                                                        Configuration.Memory.EnableSimpleViewCache = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Search.Y":
                                                    case "Configuration.Window.Search_Y":
                                                        Configuration.Window.Search_Y = int.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Search.X":
                                                    case "Configuration.Window.Search_X":
                                                        Configuration.Window.Search_X = int.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Kernel.Profiler":
                                                        Configuration.Kernel.Profiler = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.irc.FirewallCTCP":
                                                        Configuration.irc.FirewallCTCP = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Kernel.MaximalRingLogSize":
                                                    case "maximumlog":
                                                        Configuration.Kernel.MaximalRingLogSize = int.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Parser.ParserCache":
                                                        Configuration.Parser.ParserCache = int.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Kernel.Profiler_Minimal":
                                                        Configuration.Kernel.Profiler_Minimal = int.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.UserData.TrayIcon":
                                                        Configuration.UserData.TrayIcon = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.UserData.LastSSL":
                                                        Configuration.UserData.LastSSL = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Window.MiddleClick_Side":
                                                        Configuration.Window.MiddleClick_Side = from1(curr.InnerText);
                                                        break;
                                                    case "SelectedLanguage":
                                                        Core.SelectedLanguage = curr.InnerText;
                                                        break;
                                                    case "Configuration.Media.NotificationSound":
                                                        Configuration.Media.NotificationSound = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.CurrentSkin":
                                                        Skin.ReloadSkin(curr.InnerText);
                                                        break;
                                                    case "Configuration.Window.RememberPosition":
                #pragma warning disable
                                                        Configuration.Window.RememberPosition = bool.Parse(curr.InnerText);
                                                        break;
                #pragma warning restore
                                                    case "Configuration.irc.DefaultCTCPPort":
                                                        Configuration.irc.DefaultCTCPPort = uint.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.irc.CertificateDCC":
                                                        Configuration.irc.CertificateDCC = curr.InnerText;
                                                        break;
                                                    case "Configuration.UserData.SwitchWindowOnJoin":
                                                        Configuration.UserData.SwitchWindowOnJoin = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Window.DoubleClick":
                                                        if (!Enum.TryParse<Configuration.UserList_MouseClick>(curr.InnerText, out Configuration.Window.DoubleClick))
                                                        {
                                                            Configuration.Window.DoubleClick = Configuration.UserList_MouseClick.Nothing;
                                                        }
                                                        break;
                                                    case "Configuration.Window.MiddleClick":
                                                        if (!Enum.TryParse<Configuration.UserList_MouseClick>(curr.InnerText, out Configuration.Window.MiddleClick))
                                                        {
                                                            Configuration.Window.MiddleClick = Configuration.UserList_MouseClick.Nothing;
                                                        }
                                                        break;
                                                    case "Configuration.irc.ShowReplyForCTCP":
                                                        Configuration.irc.ShowReplyForCTCP = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.irc.FriendlyWhois":
                                                        Configuration.irc.FriendlyWhois = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.irc.DetailedVersion":
                                                        Configuration.irc.DetailedVersion = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.irc.NetworkEncoding":
                                                        switch (curr.InnerText)
                                                        {
                                                            case "System.Text.Encoding.ASCIIEncoding":
                                                                Configuration.irc.NetworkEncoding = System.Text.Encoding.ASCII;
                                                                break;
                                                            case "System.Text.Encoding.UTF32Encoding":
                                                                Configuration.irc.NetworkEncoding = System.Text.Encoding.UTF32;
                                                                break;
                                                            case "System.Text.Encoding.UnicodeEncoding":
                                                                Configuration.irc.NetworkEncoding = System.Text.Encoding.Unicode;
                                                                break;
                                                            case "System.Text.Encoding.UTF7Encoding":
                                                                Configuration.irc.NetworkEncoding = System.Text.Encoding.UTF7;
                                                                break;
                                                        }
                                                        break;
                                                    case "Configuration.Parser.InputTrim":
                                                        Configuration.Parser.InputTrim = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Kernel.KernelDump":
                                                        Configuration.Kernel.KernelDump = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Window.NotifyPrivate":
                                                        Configuration.Window.NotifyPrivate = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.irc.DisplayMode":
                                                        Configuration.irc.DisplayMode = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Scrollback.UnderlineBold":
                                                        Configuration.Scrollback.UnderlineBold = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.irc.IgnoreInvites":
                                                        Configuration.irc.IgnoreInvites = bool.Parse(curr.InnerText);
                                                        break;
                                                    case "Configuration.Scrollback.KeepSpecialCharsSimple":
                                                        Configuration.Scrollback.KeepSpecialCharsSimple = bool.Parse(curr.InnerText);
                                                        break;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    catch (Exception f)
                    {
                        handleException(f);
                        return false;
                    }
                }
                return true;
            }
Example #2
0
 /// <summary>
 /// This is a first function that should be called after application start
 /// </summary>
 /// <returns></returns>
 public static bool Load()
 {
     if (Status.Loading != _Status)
     {
         throw new Core.PidgeonException("You can't load core multiple times");
     }
     try
     {
         KernelThread = Thread.CurrentThread;
         LoadTime = DateTime.Now;
         // turn on debugging until we load the config
         Configuration.Kernel.Debugging = true;
         SystemRoot = Application.StartupPath + Path.DirectorySeparatorChar;
         if (Root == null && Application.LocalUserAppDataPath.EndsWith(Application.ProductVersion, StringComparison.Ordinal))
         {
             Root = Application.LocalUserAppDataPath.Substring(0, Application.LocalUserAppDataPath.Length - Application.ProductVersion.Length);
             ConfigFile = Root + "configuration.dat";
         }
         else if (Root == null)
         {
             Root = System.Windows.Forms.Application.LocalUserAppDataPath + Path.DirectorySeparatorChar;
             ConfigFile = Root + "configuration.dat";
         }
         Ringlog("Pidgeon " + Application.ProductVersion.ToString() + " loading core");
         KernelProc = Process.GetCurrentProcess();
         if (Configuration.Kernel.Safe)
         {
             Ringlog("Running in safe mode");
         }
         foreach (string data in Program.Parameters)
         {
             startupParams.Add(data);
         }
         Configuration.Logs.logs_dir = Root + "logs";
         Ringlog("Root path is " + Root);
         Ringlog("Config file: " + ConfigFile);
         Configuration.irc.CertificateDCC = Root + "certificate.p12";
         string is64 = " which is a 32 bit system";
         if (Environment.Is64BitOperatingSystem)
         {
             is64 = " which is a 64 bit system";
         }
         Ringlog("This pidgeon is compiled for " + Configuration.CurrentPlatform.ToString() + " and running on " + Environment.OSVersion.ToString() + is64);
         DebugLog("Loading messages");
         messages.Read(Configuration.Kernel.Safe);
         trafficscanner = new Forms.TrafficScanner();
         if (!System.IO.File.Exists(Application.StartupPath + System.IO.Path.DirectorySeparatorChar + "pidgeon.dat"))
         {
             LoadSkin();
             DebugLog("Loading configuration file");
             Configuration.Kernel.Debugging = false;
             Core._Configuration.ConfigurationLoad();
             if (!Directory.Exists(PermanentTemp))
             {
                 Directory.CreateDirectory(PermanentTemp);
             }
             if (Configuration.Kernel.Safe)
             {
                 DebugLog("Not running updater in safe mode");
             }
             else
             {
                 DebugLog("Running updater");
                 ThUp = new Thread(Updater.Run);
                 ThUp.Name = "pidgeon service";
                 ThUp.Start();
                 SystemThreads.Add(ThUp);
             }
             DebugLog("Loading log writer thread");
             Thread_logs = new Thread(IO.Load);
             Thread_logs.Name = "Logs";
             SystemThreads.Add(Thread_logs);
             Thread_logs.Start();
             DebugLog("Loading commands");
             Commands.Initialise();
             notification = new Forms.Notification();
             //DebugLog("Loading scripting core");
             //ScriptingCore.Load();
             if (Configuration.Kernel.Safe)
             {
                 DebugLog("Skipping load of extensions");
             }
             else
             {
                 DebugLog("Loading extensions");
                 Extension.Init();
                 if (Directory.Exists(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location) + Path.DirectorySeparatorChar + "modules"))
                 {
                     foreach (string dll in Directory.GetFiles(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location) + Path.DirectorySeparatorChar + "modules", "*.pmod"))
                     {
                         DebugLog("Registering plugin " + dll);
                         RegisterPlugin(dll);
                     }
                 }
             }
             DebugLog("Loading http");
             Hyperlink.Initialize();
             if (!File.Exists(ConfigFile))
             {
                 Commands.RegisterAlias("j", "join", false);
                 if (Configuration.CurrentPlatform == Platform.Linuxx86 || Configuration.CurrentPlatform == Platform.Linuxx64)
                 {
                     Commands.RegisterAlias("grep", "pidgeon.term grep", false);
                     Commands.RegisterAlias("shell", "pidgeon.term2in", false);
                 }
                 Network.Highlighter simple = new Network.Highlighter();
                 simple.enabled = true;
                 simple.text = "$nick";
                 Configuration.HighlighterList.Add(simple);
             }
             ResetMainActivityTimer();
             Hooks._Sys.AfterCore();
             _Status = Status.Running;
             return true;
         }
         Updater _finalisingupdater = new Updater();
         _finalisingupdater.update.Visible = false;
         _finalisingupdater.finalize = true;
         _finalisingupdater.lStatus.Text = messages.get("update2");
         _Status = Status.Killed;
         System.Windows.Forms.Application.Run(_finalisingupdater);
     }
     catch (Exception panic)
     {
         Core.DebugLog("Failed to Core.Load: " + panic.Message + panic.StackTrace);
         Core.handleException(panic, true);
     }
     return false;
 }