WIP?

Closes #256

.gitattributes

@@ -0,0 +1,5 @@
+# Auto detect text files and perform LF normalization
+* text=auto
+
+*.txt text eof=lf
+*.cs  diff=csharp

Configuration/Arguments.cs

@@ -1,17 +1,19 @@
 using System;
-using TweetDck.Core.Utils;
+using TweetDuck.Data;
 
-namespace TweetDck.Configuration{
+namespace TweetDuck.Configuration{
     static class Arguments{
         // public args
         public const string ArgDataFolder = "-datafolder";
-        public const string ArgLocale = "-locale";
         public const string ArgLogging = "-log";
-        public const string ArgDebugUpdates = "-debugupdates";
+        public const string ArgIgnoreGDPR = "-nogdpr";
+        public const string ArgFreeze = "-freeze";
 
         // internal args
         public const string ArgRestart = "-restart";
         public const string ArgImportCookies = "-importcookies";
+        public const string ArgDeleteCookies = "-deletecookies";
+        public const string ArgUpdated = "-updated";
 
         // class data and methods
         private static readonly CommandLineArgs Current = CommandLineArgs.FromStringArray('-', Environment.GetCommandLineArgs());
@@ -28,7 +30,19 @@ namespace TweetDck.Configuration{
             CommandLineArgs args = Current.Clone();
             args.RemoveFlag(ArgRestart);
             args.RemoveFlag(ArgImportCookies);
+            args.RemoveFlag(ArgDeleteCookies);
+            args.RemoveFlag(ArgUpdated);
             return args;
         }
+
+        public static CommandLineArgs GetCurrentForInstaller(){
+            CommandLineArgs args = GetCurrentClean();
+            args.AddFlag(ArgUpdated);
+            return args;
+        }
+
+        public static string GetCurrentForInstallerCmd(){
+            return GetCurrentForInstaller().ToString().Replace("\"", "::");
+        }
     }
 }

Configuration/ConfigManager.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using TweetDuck.Configuration.Instance;
+using TweetDuck.Core.Utils;
+using TweetDuck.Data;
+using TweetDuck.Data.Serialization;
+
+namespace TweetDuck.Configuration{
+    sealed class ConfigManager{
+        public UserConfig User { get; }
+        public SystemConfig System { get; }
+        public PluginConfig Plugins { get; }
+        
+        public event EventHandler ProgramRestartRequested;
+
+        private readonly FileConfigInstance<UserConfig> infoUser;
+        private readonly FileConfigInstance<SystemConfig> infoSystem;
+        private readonly PluginConfigInstance infoPlugins;
+
+        private readonly IConfigInstance<BaseConfig>[] infoList;
+
+        public ConfigManager(){
+            User = new UserConfig(this);
+            System = new SystemConfig(this);
+            Plugins = new PluginConfig(this);
+            
+            infoList = new IConfigInstance<BaseConfig>[]{
+                infoUser = new FileConfigInstance<UserConfig>(Program.UserConfigFilePath, User, "program options"),
+                infoSystem = new FileConfigInstance<SystemConfig>(Program.SystemConfigFilePath, System, "system options"),
+                infoPlugins = new PluginConfigInstance(Program.PluginConfigFilePath, Plugins)
+            };
+
+            // TODO refactor further
+
+            infoUser.Serializer.RegisterTypeConverter(typeof(WindowState), WindowState.Converter);
+
+            infoUser.Serializer.RegisterTypeConverter(typeof(Point), new SingleTypeConverter<Point>{
+                ConvertToString = value => $"{value.X} {value.Y}",
+                ConvertToObject = value => {
+                    int[] elements = StringUtils.ParseInts(value, ' ');
+                    return new Point(elements[0], elements[1]);
+                }
+            });
+            
+            infoUser.Serializer.RegisterTypeConverter(typeof(Size), new SingleTypeConverter<Size>{
+                ConvertToString = value => $"{value.Width} {value.Height}",
+                ConvertToObject = value => {
+                    int[] elements = StringUtils.ParseInts(value, ' ');
+                    return new Size(elements[0], elements[1]);
+                }
+            });
+        }
+
+        public void LoadAll(){
+            infoUser.Load();
+            infoSystem.Load();
+            infoPlugins.Load();
+        }
+
+        public void SaveAll(){
+            infoUser.Save();
+            infoSystem.Save();
+            infoPlugins.Save();
+        }
+
+        public void ReloadAll(){
+            infoUser.Reload();
+            infoSystem.Reload();
+            infoPlugins.Reload();
+        }
+
+        private void TriggerProgramRestartRequested(){
+            ProgramRestartRequested?.Invoke(this, EventArgs.Empty);
+        }
+
+        private IConfigInstance<BaseConfig> GetInstanceInfo(BaseConfig instance){
+            Type instanceType = instance.GetType();
+            return Array.Find(infoList, info => info.Instance.GetType() == instanceType); // TODO handle null
+        }
+
+        public abstract class BaseConfig{
+            private readonly ConfigManager configManager;
+
+            protected BaseConfig(ConfigManager configManager){
+                this.configManager = configManager;
+            }
+
+            // Management
+
+            public void Save(){
+                configManager.GetInstanceInfo(this).Save();
+            }
+
+            public void Reload(){
+                configManager.GetInstanceInfo(this).Reload();
+            }
+
+            public void Reset(){
+                configManager.GetInstanceInfo(this).Reset();
+            }
+
+            // Construction methods
+
+            public T ConstructWithDefaults<T>() where T : BaseConfig{
+                return ConstructWithDefaults(configManager) as T;
+            }
+
+            protected abstract BaseConfig ConstructWithDefaults(ConfigManager configManager);
+
+            // Utility methods
+
+            protected void UpdatePropertyWithEvent<T>(ref T field, T value, EventHandler eventHandler){
+                if (!EqualityComparer<T>.Default.Equals(field, value)){
+                    field = value;
+                    eventHandler?.Invoke(this, EventArgs.Empty);
+                }
+            }
+
+            protected void UpdatePropertyWithRestartRequest<T>(ref T field, T value){
+                if (!EqualityComparer<T>.Default.Equals(field, value)){
+                    field = value;
+                    configManager.TriggerProgramRestartRequested();
+                }
+            }
+        }
+    }
+}

Configuration/Instance/FileConfigInstance.cs

@@ -0,0 +1,104 @@
+using System;
+using System.IO;
+using TweetDuck.Data.Serialization;
+
+namespace TweetDuck.Configuration.Instance{
+    sealed class FileConfigInstance<T> : IConfigInstance<T> where T : ConfigManager.BaseConfig{
+        private const string ErrorTitle = "Configuration Error";
+
+        public T Instance { get; }
+        public FileSerializer<T> Serializer { get; }
+
+        private readonly string filenameMain;
+        private readonly string filenameBackup;
+        private readonly string errorIdentifier;
+
+        public FileConfigInstance(string filename, T instance, string errorIdentifier){
+            this.filenameMain = filename;
+            this.filenameBackup = filename+".bak";
+            this.errorIdentifier = errorIdentifier;
+
+            this.Instance = instance;
+            this.Serializer = new FileSerializer<T>();
+        }
+
+        private void LoadInternal(bool backup){
+            Serializer.Read(backup ? filenameBackup : filenameMain, Instance);
+        }
+
+        public void Load(){
+            Exception firstException = null;
+            
+            for(int attempt = 0; attempt < 2; attempt++){
+                try{
+                    LoadInternal(attempt > 0);
+
+                    if (firstException != null){ // silently log exception that caused a backup restore
+                        Program.Reporter.LogImportant(firstException.ToString());
+                    }
+
+                    return;
+                }catch(FileNotFoundException){
+                }catch(DirectoryNotFoundException){
+                    break;
+                }catch(Exception e){
+                    if (firstException == null){
+                        firstException = e;
+                    }
+                }
+            }
+            
+            if (firstException is FormatException){
+                Program.Reporter.HandleException(ErrorTitle, "The configuration file for "+errorIdentifier+" is outdated or corrupted. If you continue, your "+errorIdentifier+" will be reset.", true, firstException);
+            }
+            else if (firstException is SerializationSoftException sse){
+                Program.Reporter.HandleException(ErrorTitle, $"{sse.Errors.Count} error{(sse.Errors.Count == 1 ? " was" : "s were")} encountered while loading the configuration file for "+errorIdentifier+". If you continue, some of your "+errorIdentifier+" will be reset.", true, firstException);
+            }
+            else if (firstException != null){
+                Program.Reporter.HandleException(ErrorTitle, "Could not open the configuration file for "+errorIdentifier+". If you continue, your "+errorIdentifier+" will be reset.", true, firstException);
+            }
+        }
+
+        public void Save(){
+            try{
+                if (File.Exists(filenameMain)){
+                    File.Delete(filenameBackup);
+                    File.Move(filenameMain, filenameBackup);
+                }
+
+                Serializer.Write(filenameMain, Instance);
+            }catch(SerializationSoftException e){
+                Program.Reporter.HandleException(ErrorTitle, $"{e.Errors.Count} error{(e.Errors.Count == 1 ? " was" : "s were")} encountered while saving the configuration file for "+errorIdentifier+".", true, e);
+            }catch(Exception e){
+                Program.Reporter.HandleException(ErrorTitle, "Could not save the configuration file for "+errorIdentifier+".", true, e);
+            }
+        }
+
+        public void Reload(){
+            try{
+                LoadInternal(false);
+            }catch(FileNotFoundException){
+                try{
+                    Serializer.Write(filenameMain, Instance.ConstructWithDefaults<T>());
+                    LoadInternal(false);
+                }catch(Exception e){
+                    Program.Reporter.HandleException(ErrorTitle, "Could not regenerate the configuration file for "+errorIdentifier+".", true, e);
+                }
+            }catch(Exception e){
+                Program.Reporter.HandleException(ErrorTitle, "Could not reload the configuration file for "+errorIdentifier+".", true, e);
+            }
+        }
+
+        public void Reset(){
+            try{
+                File.Delete(filenameMain);
+                File.Delete(filenameBackup);
+            }catch(Exception e){
+                Program.Reporter.HandleException(ErrorTitle, "Could not delete configuration files to reset "+errorIdentifier+".", true, e);
+                return;
+            }
+            
+            Reload();
+        }
+    }
+}

Configuration/Instance/IConfigInstance.cs

@@ -0,0 +1,9 @@
+namespace TweetDuck.Configuration.Instance{
+    interface IConfigInstance<out T>{
+        T Instance { get; }
+
+        void Save();
+        void Reload();
+        void Reset();
+    }
+}

Configuration/Instance/PluginConfigInstance.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace TweetDuck.Configuration.Instance{
+    class PluginConfigInstance : IConfigInstance<PluginConfig>{
+        public PluginConfig Instance { get; }
+
+        private readonly string filename;
+
+        public PluginConfigInstance(string filename, PluginConfig instance){
+            this.filename = filename;
+            this.Instance = instance;
+        }
+
+        public void Load(){
+            try{
+                using(StreamReader reader = new StreamReader(new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read), Encoding.UTF8)){
+                    string line = reader.ReadLine();
+
+                    if (line == "#Disabled"){
+                        HashSet<string> newDisabled = new HashSet<string>();
+
+                        while((line = reader.ReadLine()) != null){
+                            newDisabled.Add(line);
+                        }
+
+                        Instance.ReloadSilently(newDisabled);
+                    }
+                }
+            }catch(FileNotFoundException){
+            }catch(DirectoryNotFoundException){
+            }catch(Exception e){
+                Program.Reporter.HandleException("Plugin Configuration Error", "Could not read the plugin configuration file. If you continue, the list of disabled plugins will be reset to default.", true, e);
+            }
+        }
+
+        public void Save(){
+            try{
+                using(StreamWriter writer = new StreamWriter(new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.None), Encoding.UTF8)){
+                    writer.WriteLine("#Disabled");
+
+                    foreach(string identifier in Instance.DisabledPlugins){
+                        writer.WriteLine(identifier);
+                    }
+                }
+            }catch(Exception e){
+                Program.Reporter.HandleException("Plugin Configuration Error", "Could not save the plugin configuration file.", true, e);
+            }
+        }
+
+        public void Reload(){
+            Load();
+        }
+
+        public void Reset(){
+            try{
+                File.Delete(filename);
+                Instance.ReloadSilently(Instance.ConstructWithDefaults<PluginConfig>().DisabledPlugins);
+            }catch(Exception e){
+                Program.Reporter.HandleException("Plugin Configuration Error", "Could not delete the plugin configuration file.", true, e);
+                return;
+            }
+            
+            Reload();
+        }
+    }
+}

Configuration/LockManager.cs

@@ -1,29 +1,27 @@
-using System;
+using System;
 using System.ComponentModel;
 using System.Diagnostics;
 using System.IO;
-using TweetDck.Core.Utils;
+using System.Threading;
+using TweetDuck.Core.Utils;
 
-namespace TweetDck.Configuration{
+namespace TweetDuck.Configuration{
     sealed class LockManager{
+        private const int RetryDelay = 250;
+
         public enum Result{
             Success, HasProcess, Fail
         }
 
-        public Process LockingProcess { get; private set; }
-
         private readonly string file;
         private FileStream lockStream;
+        private Process lockingProcess;
 
         public LockManager(string file){
             this.file = file;
         }
 
-        private void CreateLockFileStream(){
-            lockStream = new FileStream(file, FileMode.Create, FileAccess.Write, FileShare.Read);
-            WriteIntToStream(lockStream, GetCurrentProcessId());
-            lockStream.Flush(true);
-        }
+        // Lock file
 
         private bool ReleaseLockFileStream(){
             if (lockStream != null){
@@ -37,8 +35,10 @@ namespace TweetDck.Configuration{
         }
 
         private Result TryCreateLockFile(){
-            if (lockStream != null){
-                throw new InvalidOperationException("Lock file already exists.");
+            void CreateLockFileStream(){
+                lockStream = new FileStream(file, FileMode.Create, FileAccess.Write, FileShare.Read);
+                lockStream.Write(BitConverter.GetBytes(WindowsUtils.CurrentProcessID), 0, sizeof(int));
+                lockStream.Flush(true);
             }
 
             try{
@@ -60,6 +60,8 @@ namespace TweetDck.Configuration{
             }
         }
 
+        // Lock management
+
         public Result Lock(){
             if (lockStream != null){
                 return Result.Success;
@@ -72,7 +74,9 @@ namespace TweetDck.Configuration{
                     int pid;
 
                     using(FileStream fileStream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)){
-                        pid = ReadIntFromStream(fileStream);
+                        byte[] bytes = new byte[sizeof(int)];
+                        fileStream.Read(bytes, 0, bytes.Length);
+                        pid = BitConverter.ToInt32(bytes, 0);
                     }
 
                     try{
@@ -80,7 +84,7 @@ namespace TweetDck.Configuration{
 
                         using(Process currentProcess = Process.GetCurrentProcess()){
                             if (foundProcess.MainModule.FileVersionInfo.InternalName == currentProcess.MainModule.FileVersionInfo.InternalName){
-                                LockingProcess = foundProcess;
+                                lockingProcess = foundProcess;
                             }
                             else{
                                 foundProcess.Close();
@@ -91,7 +95,7 @@ namespace TweetDck.Configuration{
                         // Process.MainModule can throw exceptions in some cases
                     }
 
-                    return LockingProcess == null ? Result.Fail : Result.HasProcess;
+                    return lockingProcess == null ? Result.Fail : Result.HasProcess;
                 }catch{
                     return Result.Fail;
                 }
@@ -100,49 +104,71 @@ namespace TweetDck.Configuration{
             return initialResult;
         }
 
-        public bool Unlock(){
-            bool result = true;
+        public Result LockWait(int timeout){
+            for(int elapsed = 0; elapsed < timeout; elapsed += RetryDelay){
+                Result result = Lock();
 
+                if (result == Result.HasProcess){
+                    Thread.Sleep(RetryDelay);
+                }
+                else{
+                    return result;
+                }
+            }
+
+            return Lock();
+        }
+
+        public bool Unlock(){
             if (ReleaseLockFileStream()){
                 try{
                     File.Delete(file);
                 }catch(Exception e){
-                    Program.Reporter.Log(e.ToString());
-                    result = false;
+                    Program.Reporter.LogImportant(e.ToString());
+                    return false;
                 }
             }
 
-            return result;
+            return true;
+        }
+
+        // Locking process
+
+        public bool RestoreLockingProcess(int failTimeout){
+            if (lockingProcess != null && lockingProcess.MainWindowHandle == IntPtr.Zero){ // restore if the original process is in tray
+                NativeMethods.BroadcastMessage(Program.WindowRestoreMessage, (uint)lockingProcess.Id, 0);
+
+                if (WindowsUtils.TrySleepUntil(() => CheckLockingProcessExited() || (lockingProcess.MainWindowHandle != IntPtr.Zero && lockingProcess.Responding), failTimeout, RetryDelay)){
+                    return true;
+                }
+            }
+
+            return false;
         }
 
         public bool CloseLockingProcess(int closeTimeout, int killTimeout){
-            if (LockingProcess != null){
+            if (lockingProcess != null){
                 try{
-                    if (LockingProcess.CloseMainWindow()){
-                        WindowsUtils.TrySleepUntil(CheckLockingProcessExited, closeTimeout, 250);
+                    if (lockingProcess.CloseMainWindow()){
+                        WindowsUtils.TrySleepUntil(CheckLockingProcessExited, closeTimeout, RetryDelay);
                     }
 
-                    if (!LockingProcess.HasExited){
-                        LockingProcess.Kill();
-                        WindowsUtils.TrySleepUntil(CheckLockingProcessExited, killTimeout, 250);
+                    if (!lockingProcess.HasExited){
+                        lockingProcess.Kill();
+                        WindowsUtils.TrySleepUntil(CheckLockingProcessExited, killTimeout, RetryDelay);
                     }
 
-                    if (LockingProcess.HasExited){
-                        LockingProcess.Dispose();
-                        LockingProcess = null;
+                    if (lockingProcess.HasExited){
+                        lockingProcess.Dispose();
+                        lockingProcess = null;
                         return true;
                     }
-                }catch(Exception ex){
-                    if (ex is InvalidOperationException || ex is Win32Exception){
-                        if (LockingProcess != null){
-                            LockingProcess.Refresh();
-
-                            bool hasExited = LockingProcess.HasExited;
-                            LockingProcess.Dispose();
-                            return hasExited;
-                        }
+                }catch(Exception ex) when (ex is InvalidOperationException || ex is Win32Exception){
+                    if (lockingProcess != null){
+                        bool hasExited = CheckLockingProcessExited();
+                        lockingProcess.Dispose();
+                        return hasExited;
                     }
-                    else throw;
                 }
             }
 
@@ -150,27 +176,8 @@ namespace TweetDck.Configuration{
         }
 
         private bool CheckLockingProcessExited(){
-            LockingProcess.Refresh();
-            return LockingProcess.HasExited;
-        }
-
-        // Utility functions
-
-        private static void WriteIntToStream(Stream stream, int value){
-            byte[] id = BitConverter.GetBytes(value);
-            stream.Write(id, 0, id.Length);
-        }
-
-        private static int ReadIntFromStream(Stream stream){
-            byte[] bytes = new byte[4];
-            stream.Read(bytes, 0, 4);
-            return BitConverter.ToInt32(bytes, 0);
-        }
-
-        private static int GetCurrentProcessId(){
-            using(Process process = Process.GetCurrentProcess()){
-                return process.Id;
-            }
+            lockingProcess.Refresh();
+            return lockingProcess.HasExited;
         }
     }
 }

Configuration/PluginConfig.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using TweetDuck.Plugins;
+using TweetDuck.Plugins.Events;
+
+namespace TweetDuck.Configuration{
+    sealed class PluginConfig : ConfigManager.BaseConfig, IPluginConfig{
+        private static readonly string[] DefaultDisabled = {
+            "official/clear-columns",
+            "official/reply-account"
+        };
+
+        // CONFIGURATION
+
+        public IEnumerable<string> DisabledPlugins => disabled;
+        
+        public event EventHandler<PluginChangedStateEventArgs> PluginChangedState;
+
+        public void SetEnabled(Plugin plugin, bool enabled){
+            if ((enabled && disabled.Remove(plugin.Identifier)) || (!enabled && disabled.Add(plugin.Identifier))){
+                PluginChangedState?.Invoke(this, new PluginChangedStateEventArgs(plugin, enabled));
+                Save();
+            }
+        }
+
+        public bool IsEnabled(Plugin plugin){
+            return !disabled.Contains(plugin.Identifier);
+        }
+
+        public void ReloadSilently(IEnumerable<string> newDisabled){
+            disabled.Clear();
+            disabled.UnionWith(newDisabled);
+        }
+
+        private readonly HashSet<string> disabled = new HashSet<string>(DefaultDisabled);
+        
+        // END OF CONFIG
+
+        public PluginConfig(ConfigManager configManager) : base(configManager){}
+
+        protected override ConfigManager.BaseConfig ConstructWithDefaults(ConfigManager configManager){
+            return new PluginConfig(configManager);
+        }
+    }
+}

Configuration/SystemConfig.cs

@@ -0,0 +1,26 @@
+namespace TweetDuck.Configuration{
+    sealed class SystemConfig : ConfigManager.BaseConfig{
+
+        // CONFIGURATION DATA
+        
+        public bool _hardwareAcceleration = true;
+        
+        public bool ClearCacheAutomatically { get; set; } = true;
+        public int ClearCacheThreshold      { get; set; } = 250;
+
+        // SPECIAL PROPERTIES
+        
+        public bool HardwareAcceleration{
+            get => _hardwareAcceleration;
+            set => UpdatePropertyWithRestartRequest(ref _hardwareAcceleration, value);
+        }
+        
+        // END OF CONFIG
+
+        public SystemConfig(ConfigManager configManager) : base(configManager){}
+
+        protected override ConfigManager.BaseConfig ConstructWithDefaults(ConfigManager configManager){
+            return new SystemConfig(configManager);
+        }
+    }
+}

Configuration/UserConfig.cs

@@ -1,250 +1,144 @@
 using System;
 using System.Drawing;
-using System.IO;
-using System.Runtime.Serialization;
-using System.Runtime.Serialization.Formatters.Binary;
-using TweetDck.Core;
-using TweetDck.Core.Controls;
-using TweetDck.Core.Notification;
-using TweetDck.Core.Utils;
-using TweetDck.Plugins;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Notification;
+using TweetDuck.Core.Other;
+using TweetDuck.Core.Utils;
+using TweetDuck.Data;
 
-namespace TweetDck.Configuration{
-    [Serializable]
-    sealed class UserConfig{
-        private static readonly IFormatter Formatter = new BinaryFormatter();
+namespace TweetDuck.Configuration{
+    sealed class UserConfig : ConfigManager.BaseConfig{
+        
+        // CONFIGURATION DATA
 
-        private const int CurrentFileVersion = 9;
+        public bool FirstRun            { get; set; } = true;
+        public bool AllowDataCollection { get; set; } = false;
 
-        // START OF CONFIGURATION
+        public WindowState BrowserWindow { get; set; } = new WindowState();
+        public Size PluginsWindowSize    { get; set; } = Size.Empty;
 
-        public WindowState BrowserWindow { get; set; }
-        public bool DisplayNotificationColumn { get; set; }
-        public bool DisplayNotificationTimer { get; set; }
-        public bool NotificationTimerCountDown { get; set; }
-        public bool NotificationSkipOnLinkClick { get; set; }
-        public bool NotificationNonIntrusiveMode { get; set; }
+        public bool ExpandLinksOnHover        { get; set; } = true;
+        public bool FocusDmInput              { get; set; } = true;
+        public bool OpenSearchInFirstColumn   { get; set; } = true;
+        public bool KeepLikeFollowDialogsOpen { get; set; } = true;
+        public bool BestImageQuality          { get; set; } = true;
+        public bool EnableAnimatedImages      { get; set; } = true;
 
-        public TweetNotification.Position NotificationPosition { get; set; }
-        public Point CustomNotificationPosition { get; set; }
-        public int NotificationEdgeDistance { get; set; }
-        public int NotificationDisplay { get; set; }
-        public int NotificationIdlePauseSeconds { get; set; }
-        public int NotificationDurationValue { get; set; }
+        private bool _enableSmoothScrolling = true;
+        private bool _enableTouchAdjustment = false;
+        private string _customCefArgs       = null;
 
-        public bool EnableSpellCheck { get; set; }
-        public bool ExpandLinksOnHover { get; set; }
-        public bool SwitchAccountSelectors { get; set; }
-        public bool EnableTrayHighlight { get; set; }
+        public string BrowserPath            { get; set; } = null;
+        public bool IgnoreTrackingUrlWarning { get; set; } = false;
+        public string SearchEngineUrl        { get; set; } = null;
+        private int _zoomLevel                             = 100;
 
-        public bool EnableUpdateCheck { get; set; }
-        public string DismissedUpdate { get; set; }
+        public int VideoPlayerVolume { get; set; } = 50;
+        
+        public bool EnableSpellCheck { get; set; } = false;
+        private string _spellCheckLanguage         = "en-US";
 
-        [Obsolete] public PluginConfig Plugins { get; set; } // TODO remove eventually
-        public WindowState PluginsWindow { get; set; }
+        public string TranslationTarget { get; set; } = "en";
+        
+        private TrayIcon.Behavior _trayBehavior       = TrayIcon.Behavior.Disabled;
+        public bool EnableTrayHighlight { get; set; } = true;
 
-        public string CustomCefArgs { get; set; }
-        public string CustomBrowserCSS { get; set; }
-        public string CustomNotificationCSS { get; set; }
+        public bool EnableUpdateCheck { get; set; } = true;
+        public string DismissedUpdate { get; set; } = null;
+
+        public bool DisplayNotificationColumn    { get; set; } = false;
+        public bool NotificationMediaPreviews    { get; set; } = true;
+        public bool NotificationSkipOnLinkClick  { get; set; } = false;
+        public bool NotificationNonIntrusiveMode { get; set; } = true;
+        public int NotificationIdlePauseSeconds  { get; set; } = 0;
+
+        public bool DisplayNotificationTimer   { get; set; } = true;
+        public bool NotificationTimerCountDown { get; set; } = false;
+        public int NotificationDurationValue   { get; set; } = 25;
+
+        public TweetNotification.Position NotificationPosition { get; set; } = TweetNotification.Position.TopRight;
+        public Point CustomNotificationPosition                { get; set; } = ControlExtensions.InvisibleLocation;
+        public int NotificationDisplay                         { get; set; } = 0;
+        public int NotificationEdgeDistance                    { get; set; } = 8;
+
+        public TweetNotification.Size NotificationSize { get; set; } = TweetNotification.Size.Auto;
+        public Size CustomNotificationSize             { get; set; } = Size.Empty;
+        public int NotificationScrollSpeed             { get; set; } = 100;
+        
+        private string _notificationSoundPath;
+        private int _notificationSoundVolume = 100;
+
+        private bool _muteNotifications;
+
+        public string CustomBrowserCSS      { get; set; } = null;
+        public string CustomNotificationCSS { get; set; } = null;
+        
+        // SPECIAL PROPERTIES
 
         public bool IsCustomNotificationPositionSet => CustomNotificationPosition != ControlExtensions.InvisibleLocation;
+        public bool IsCustomNotificationSizeSet => CustomNotificationSize != Size.Empty;
+        public bool IsCustomSoundNotificationSet => NotificationSoundPath != string.Empty;
 
+        public TwitterUtils.ImageQuality TwitterImageQuality => BestImageQuality ? TwitterUtils.ImageQuality.Orig : TwitterUtils.ImageQuality.Default;
+        
         public string NotificationSoundPath{
-            get => string.IsNullOrEmpty(notificationSoundPath) ? string.Empty : notificationSoundPath;
-            set => notificationSoundPath = value;
+            get => _notificationSoundPath ?? string.Empty;
+            set => UpdatePropertyWithEvent(ref _notificationSoundPath, value, SoundNotificationChanged);
+        }
+        
+        public int NotificationSoundVolume{
+            get => _notificationSoundVolume;
+            set => UpdatePropertyWithEvent(ref _notificationSoundVolume, value, SoundNotificationChanged);
         }
 
         public bool MuteNotifications{
-            get => muteNotifications;
-
-            set{
-                if (muteNotifications != value){
-                    muteNotifications = value;
-                    MuteToggled?.Invoke(this, new EventArgs());
-                }
-            }
+            get => _muteNotifications;
+            set => UpdatePropertyWithEvent(ref _muteNotifications, value, MuteToggled);
         }
 
         public int ZoomLevel{
-            get => zoomLevel;
-
-            set{
-                if (zoomLevel != value){
-                    zoomLevel = value;
-                    ZoomLevelChanged?.Invoke(this, new EventArgs());
-                }
-            }
+            get => _zoomLevel;
+            set => UpdatePropertyWithEvent(ref _zoomLevel, value, ZoomLevelChanged);
         }
-
-        public double ZoomMultiplier => zoomLevel/100.0;
-
+        
         public TrayIcon.Behavior TrayBehavior{
-            get => trayBehavior;
-
-            set{
-                if (trayBehavior != value){
-                    trayBehavior = value;
-                    TrayBehaviorChanged?.Invoke(this, new EventArgs());
-                }
-            }
+            get => _trayBehavior;
+            set => UpdatePropertyWithEvent(ref _trayBehavior, value, TrayBehaviorChanged);
+        }
+        
+        public bool EnableSmoothScrolling{
+            get => _enableSmoothScrolling;
+            set => UpdatePropertyWithRestartRequest(ref _enableSmoothScrolling, value);
         }
 
-        // END OF CONFIGURATION
+        public bool EnableTouchAdjustment{
+            get => _enableTouchAdjustment;
+            set => UpdatePropertyWithRestartRequest(ref _enableTouchAdjustment, value);
+        }
+
+        public string CustomCefArgs{
+            get => _customCefArgs;
+            set => UpdatePropertyWithRestartRequest(ref _customCefArgs, value);
+        }
+
+        public string SpellCheckLanguage{
+            get => _spellCheckLanguage;
+            set => UpdatePropertyWithRestartRequest(ref _spellCheckLanguage, value);
+        }
+
+        // EVENTS
         
-        [field:NonSerialized]
         public event EventHandler MuteToggled;
-        
-        [field:NonSerialized]
         public event EventHandler ZoomLevelChanged;
-        
-        [field:NonSerialized]
         public event EventHandler TrayBehaviorChanged;
+        public event EventHandler SoundNotificationChanged;
 
-        [NonSerialized]
-        private string file;
-
-        private int fileVersion;
-        private bool muteNotifications;
-        private int zoomLevel;
-        private string notificationSoundPath;
-        private TrayIcon.Behavior trayBehavior;
-
-        private UserConfig(string file){
-            this.file = file;
-
-            BrowserWindow = new WindowState();
-            ZoomLevel = 100;
-            DisplayNotificationTimer = true;
-            NotificationNonIntrusiveMode = true;
-            NotificationPosition = TweetNotification.Position.TopRight;
-            CustomNotificationPosition = ControlExtensions.InvisibleLocation;
-            NotificationEdgeDistance = 8;
-            NotificationDurationValue = 25;
-            EnableUpdateCheck = true;
-            ExpandLinksOnHover = true;
-            SwitchAccountSelectors = true;
-            EnableTrayHighlight = true;
-            PluginsWindow = new WindowState();
-        }
-
-        private void UpgradeFile(){
-            if (fileVersion == CurrentFileVersion){
-                return;
-            }
-
-            // if outdated, cycle through all versions
-            if (fileVersion == 0){
-                DisplayNotificationTimer = true;
-                EnableUpdateCheck = true;
-                ++fileVersion;
-            }
-
-            if (fileVersion == 1){
-                ExpandLinksOnHover = true;
-                ++fileVersion;
-            }
-
-            if (fileVersion == 2){
-                BrowserWindow = new WindowState();
-                PluginsWindow = new WindowState();
-                ++fileVersion;
-            }
-
-            if (fileVersion == 3){
-                EnableTrayHighlight = true;
-                NotificationDurationValue = 25;
-                ++fileVersion;
-            }
-
-            if (fileVersion == 4){
-                ++fileVersion;
-            }
-
-            if (fileVersion == 5){
-                ++fileVersion;
-            }
-
-            if (fileVersion == 6){
-                NotificationNonIntrusiveMode = true;
-                ++fileVersion;
-            }
-
-            if (fileVersion == 7){
-                ZoomLevel = 100;
-                ++fileVersion;
-            }
-
-            if (fileVersion == 8){
-                SwitchAccountSelectors = true;
-                ++fileVersion;
-            }
-
-            // update the version
-            fileVersion = CurrentFileVersion;
-            Save();
-        }
-
-        public bool Save(){
-            try{
-                string directory = Path.GetDirectoryName(file);
-                if (directory == null)return false;
-
-                Directory.CreateDirectory(directory);
-
-                if (File.Exists(file)){
-                    string backupFile = GetBackupFile(file);
-                    File.Delete(backupFile);
-                    File.Move(file, backupFile);
-                }
-
-                using(Stream stream = new FileStream(file, FileMode.Create, FileAccess.Write, FileShare.None)){
-                    Formatter.Serialize(stream, this);
-                }
-
-                return true;
-            }catch(Exception e){
-                Program.Reporter.HandleException("Configuration Error", "Could not save the configuration file.", true, e);
-                return false;
-            }
-        }
+        // END OF CONFIG
         
-        public static UserConfig Load(string file){
-            UserConfig config = null;
-            Exception firstException = null;
+        public UserConfig(ConfigManager configManager) : base(configManager){}
 
-            for(int attempt = 0; attempt < 2; attempt++){
-                try{
-                    using(Stream stream = new FileStream(attempt == 0 ? file : GetBackupFile(file), FileMode.Open, FileAccess.Read, FileShare.Read)){
-                        if ((config = Formatter.Deserialize(stream) as UserConfig) != null){
-                            config.file = file;
-                        }
-                    }
-
-                    config?.UpgradeFile();
-                    break;
-                }catch(FileNotFoundException){
-                }catch(DirectoryNotFoundException){
-                    break;
-                }catch(Exception e){
-                    if (attempt == 0){
-                        firstException = e;
-                        Program.Reporter.Log(e.ToString());
-                    }
-                    else if (firstException != null){
-                        Program.Reporter.HandleException("Configuration Error", "Could not open the backup configuration file. If you continue, you may lose your settings and list of enabled plugins.", true, e);
-                    }
-                }
-            }
-
-            if (firstException != null && config == null){
-                Program.Reporter.HandleException("Configuration Error", "Could not open the configuration file.", true, firstException);
-            }
-
-            return config ?? new UserConfig(file);
-        }
-
-        public static string GetBackupFile(string file){
-            return file+".bak";
+        protected override ConfigManager.BaseConfig ConstructWithDefaults(ConfigManager configManager){
+            return new UserConfig(configManager);
         }
     }
 }

Core/Bridge/CallbackBridge.cs

@@ -1,19 +0,0 @@
-using System;
-using System.Windows.Forms;
-using TweetDck.Core.Controls;
-
-namespace TweetDck.Core.Bridge{
-    sealed class CallbackBridge{
-        private readonly Control owner;
-        private readonly Action safeCallback;
-
-        public CallbackBridge(Control owner, Action safeCallback){
-            this.owner = owner;
-            this.safeCallback = safeCallback;
-        }
-
-        public void Trigger(){
-            owner.InvokeSafe(safeCallback);
-        }
-    }
-}

Core/Bridge/PropertyBridge.cs

@@ -1,45 +1,35 @@
-using System;
-using System.Text;
+using System.Text;
+using TweetDuck.Configuration;
 
-namespace TweetDck.Core.Bridge{
+namespace TweetDuck.Core.Bridge{
     static class PropertyBridge{
-        [Flags]
-        public enum Properties{
-            ExpandLinksOnHover = 1,
-            MuteNotifications = 2,
-            HasCustomNotificationSound = 4,
-            SkipOnLinkClick = 8,
-            SwitchAccountSelectors = 16,
-            AllBrowser = ExpandLinksOnHover | SwitchAccountSelectors | MuteNotifications | HasCustomNotificationSound,
-            AllNotification = ExpandLinksOnHover | SkipOnLinkClick
+        public enum Environment{
+            Browser, Notification
         }
 
-        public static string GenerateScript(Properties properties){
-            StringBuilder build = new StringBuilder();
-            build.Append("(function(c){");
+        public static string GenerateScript(Environment environment){
+            string Bool(bool value) => value ? "true;" : "false;";
+            string Str(string value) => '"'+value+"\";";
 
-            if (properties.HasFlag(Properties.ExpandLinksOnHover)){
-                build.Append("c.expandLinksOnHover=").Append(Program.UserConfig.ExpandLinksOnHover ? "true;" : "false;");
+            UserConfig config = Program.Config.User;
+            StringBuilder build = new StringBuilder(128).Append("(function(x){");
+
+            build.Append("x.expandLinksOnHover=").Append(Bool(config.ExpandLinksOnHover));
+            
+            if (environment == Environment.Browser){
+                build.Append("x.focusDmInput=").Append(Bool(config.FocusDmInput));
+                build.Append("x.openSearchInFirstColumn=").Append(Bool(config.OpenSearchInFirstColumn));
+                build.Append("x.keepLikeFollowDialogsOpen=").Append(Bool(config.KeepLikeFollowDialogsOpen));
+                build.Append("x.muteNotifications=").Append(Bool(config.MuteNotifications));
+                build.Append("x.notificationMediaPreviews=").Append(Bool(config.NotificationMediaPreviews));
+                build.Append("x.translationTarget=").Append(Str(config.TranslationTarget));
             }
 
-            if (properties.HasFlag(Properties.SwitchAccountSelectors)){
-                build.Append("c.switchAccountSelectors=").Append(Program.UserConfig.SwitchAccountSelectors ? "true;" : "false;");
+            if (environment == Environment.Notification){
+                build.Append("x.skipOnLinkClick=").Append(Bool(config.NotificationSkipOnLinkClick));
             }
-
-            if (properties.HasFlag(Properties.MuteNotifications)){
-                build.Append("c.muteNotifications=").Append(Program.UserConfig.MuteNotifications ? "true;" : "false;");
-            }
-
-            if (properties.HasFlag(Properties.HasCustomNotificationSound)){
-                build.Append("c.hasCustomNotificationSound=").Append(Program.UserConfig.NotificationSoundPath.Length > 0 ? "true;" : "false;");
-            }
-
-            if (properties.HasFlag(Properties.SkipOnLinkClick)){
-                build.Append("c.skipOnLinkClick=").Append(Program.UserConfig.NotificationSkipOnLinkClick ? "true;" : "false;");
-            }
-
-            build.Append("})(window.$TDX=window.$TDX||{})");
-            return build.ToString();
+            
+            return build.Append("})(window.$TDX=window.$TDX||{})").ToString();
         }
     }
 }

Core/Bridge/TweetDeckBridge.cs

@@ -1,82 +1,107 @@
 using System.Windows.Forms;
-using TweetDck.Core.Controls;
-using TweetDck.Core.Notification;
-using TweetDck.Core.Utils;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Management;
+using TweetDuck.Core.Notification;
+using TweetDuck.Core.Other;
+using TweetDuck.Core.Utils;
 
-namespace TweetDck.Core.Bridge{
-    sealed class TweetDeckBridge{
-        public static string LastRightClickedLink = string.Empty;
-        public static string LastHighlightedTweet = string.Empty;
-        public static string LastHighlightedQuotedTweet = string.Empty;
+namespace TweetDuck.Core.Bridge{
+    class TweetDeckBridge{
+        public static string FontSize { get; private set; }
+        public static string NotificationHeadLayout { get; private set; }
+        public static readonly ContextInfo ContextInfo = new ContextInfo();
 
         public static void ResetStaticProperties(){
-            LastRightClickedLink = LastHighlightedTweet = LastHighlightedQuotedTweet = string.Empty;
+            FontSize = NotificationHeadLayout = null;
         }
 
         private readonly FormBrowser form;
         private readonly FormNotificationMain notification;
 
-        public TweetDeckBridge(FormBrowser form, FormNotificationMain notification){
+        protected TweetDeckBridge(FormBrowser form, FormNotificationMain notification){
             this.form = form;
             this.notification = notification;
         }
 
-        public void LoadFontSizeClass(string fsClass){
-            form.InvokeAsyncSafe(() => {
-               TweetNotification.SetFontSizeClass(fsClass);
-            });
+        // Browser only
+
+        public sealed class Browser : TweetDeckBridge{
+            public Browser(FormBrowser form, FormNotificationMain notification) : base(form, notification){}
+
+            public void OpenContextMenu(){
+                form.InvokeAsyncSafe(form.OpenContextMenu);
+            }
+
+            public void OpenProfileImport(){
+                form.InvokeAsyncSafe(form.OpenProfileImport);
+            }
+            
+            public void OnIntroductionClosed(bool showGuide, bool allowDataCollection){
+                form.InvokeAsyncSafe(() => {
+                    form.OnIntroductionClosed(showGuide, allowDataCollection);
+                });
+            }
+
+            public void LoadNotificationLayout(string fontSize, string headLayout){
+                form.InvokeAsyncSafe(() => {
+                    FontSize = fontSize;
+                    NotificationHeadLayout = headLayout;
+                });
+            }
+
+            public void SetRightClickedLink(string type, string url){
+                ContextInfo.SetLink(type, url);
+            }
+
+            public void SetRightClickedChirp(string tweetUrl, string quoteUrl, string chirpAuthors, string chirpImages){
+                ContextInfo.SetChirp(tweetUrl, quoteUrl, chirpAuthors, chirpImages);
+            }
+
+            public void DisplayTooltip(string text){
+                form.InvokeAsyncSafe(() => form.DisplayTooltip(text));
+            }
         }
 
-        public void LoadNotificationHeadContents(string headContents){
-            form.InvokeAsyncSafe(() => {
-               TweetNotification.SetHeadTag(headContents); 
-            });
+        // Notification only
+
+        public sealed class Notification : TweetDeckBridge{
+            public Notification(FormBrowser form, FormNotificationMain notification) : base(form, notification){}
+
+            public void DisplayTooltip(string text){
+                notification.InvokeAsyncSafe(() => notification.DisplayTooltip(text));
+            }
+
+            public void LoadNextNotification(){
+                notification.InvokeAsyncSafe(notification.FinishCurrentNotification);
+            }
+
+            public void ShowTweetDetail(){
+                notification.InvokeAsyncSafe(notification.ShowTweetDetail);
+            }
         }
 
-        public void SetLastRightClickedLink(string link){
-            form.InvokeAsyncSafe(() => LastRightClickedLink = link);
-        }
+        // Global
 
-        public void SetLastHighlightedTweet(string link, string quotedLink){
-            form.InvokeAsyncSafe(() => {
-                LastHighlightedTweet = link;
-                LastHighlightedQuotedTweet = quotedLink;
-            });
-        }
-
-        public void OpenContextMenu(){
-            form.InvokeAsyncSafe(form.OpenContextMenu);
-        }
-
-        public void OnTweetPopup(string columnName, string tweetHtml, int tweetCharacters, string tweetUrl, string quoteUrl){
+        public void OnTweetPopup(string columnId, string chirpId, string columnName, string tweetHtml, int tweetCharacters, string tweetUrl, string quoteUrl){
             notification.InvokeAsyncSafe(() => {
                 form.OnTweetNotification();
-                notification.ShowNotification(new TweetNotification(columnName, tweetHtml, tweetCharacters, tweetUrl, quoteUrl));
+                notification.ShowNotification(new TweetNotification(columnId, chirpId, columnName, tweetHtml, tweetCharacters, tweetUrl, quoteUrl));
             });
         }
 
         public void OnTweetSound(){
             form.InvokeAsyncSafe(() => {
                 form.OnTweetNotification();
-                form.PlayNotificationSound();
+                form.OnTweetSound();
             });
         }
 
-        public void DisplayTooltip(string text, bool showInNotification){
-            if (showInNotification){
-                notification.InvokeAsyncSafe(() => notification.DisplayTooltip(text));
-            }
-            else{
-                form.InvokeAsyncSafe(() => form.DisplayTooltip(text));
-            }
+        public void ScreenshotTweet(string html, int width){
+            form.InvokeAsyncSafe(() => form.OnTweetScreenshotReady(html, width));
         }
 
-        public void LoadNextNotification(){
-            notification.InvokeAsyncSafe(notification.FinishCurrentNotification);
-        }
-
-        public void ScreenshotTweet(string html, int width, int height){
-            form.InvokeAsyncSafe(() => form.OnTweetScreenshotReady(html, width, height));
+        public void PlayVideo(string url, string username){
+            form.InvokeAsyncSafe(() => form.PlayVideo(url, username));
         }
 
         public void FixClipboard(){
@@ -84,7 +109,11 @@ namespace TweetDck.Core.Bridge{
         }
 
         public void OpenBrowser(string url){
-            BrowserUtils.OpenExternalBrowser(url);
+            form.InvokeAsyncSafe(() => BrowserUtils.OpenExternalBrowser(url));
+        }
+
+        public int GetIdleSeconds(){
+            return NativeMethods.GetIdleSeconds();
         }
 
         public void Alert(string type, string contents){
@@ -97,11 +126,14 @@ namespace TweetDck.Core.Bridge{
                 default: icon = MessageBoxIcon.None; break;
             }
 
-            MessageBox.Show(contents, Program.BrandName+" Browser Message", MessageBoxButtons.OK, icon);
+            FormMessage.Show("TweetDuck Browser Message", contents, icon, FormMessage.OK);
         }
 
-        public void Log(string data){
-            System.Diagnostics.Debug.WriteLine(data);
+        public void CrashDebug(string message){
+            #if DEBUG
+            System.Diagnostics.Debug.WriteLine(message);
+            System.Diagnostics.Debugger.Break();
+            #endif
         }
     }
 }

Core/Bridge/UpdateBridge.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Windows.Forms;
+using TweetDuck.Core.Controls;
+using TweetDuck.Updates;
+
+namespace TweetDuck.Core.Bridge{
+    class UpdateBridge{
+        private readonly UpdateHandler updates;
+        private readonly Control sync;
+
+        private UpdateInfo nextUpdate = null;
+
+        public event EventHandler<UpdateInfo> UpdateAccepted;
+        public event EventHandler<UpdateInfo> UpdateDelayed;
+        public event EventHandler<UpdateInfo> UpdateDismissed;
+
+        public UpdateBridge(UpdateHandler updates, Control sync){
+            this.sync = sync;
+
+            this.updates = updates;
+            this.updates.CheckFinished += updates_CheckFinished;
+        }
+
+        internal void Cleanup(){
+            updates.CheckFinished -= updates_CheckFinished;
+            nextUpdate?.DeleteInstaller();
+        }
+
+        private void updates_CheckFinished(object sender, UpdateCheckEventArgs e){
+            UpdateInfo foundUpdate = e.Result.HasValue ? e.Result.Value : null;
+
+            if (nextUpdate != null && !nextUpdate.Equals(foundUpdate)){
+                nextUpdate.DeleteInstaller();
+            }
+
+            nextUpdate = foundUpdate;
+        }
+
+        private void HandleInteractionEvent(EventHandler<UpdateInfo> eventHandler){
+            UpdateInfo tmpInfo = nextUpdate;
+
+            if (tmpInfo != null){
+                sync.InvokeAsyncSafe(() => eventHandler?.Invoke(this, tmpInfo));
+            }
+        }
+
+        // Bridge methods
+
+        public void TriggerUpdateCheck(){
+            updates.Check(false);
+        }
+
+        public void OnUpdateAccepted(){
+            HandleInteractionEvent(UpdateAccepted);
+        }
+
+        public void OnUpdateDelayed(){
+            HandleInteractionEvent(UpdateDelayed);
+        }
+
+        public void OnUpdateDismissed(){
+            HandleInteractionEvent(UpdateDismissed);
+
+            nextUpdate?.DeleteInstaller();
+            nextUpdate = null;
+        }
+    }
+}

Core/Controls/ControlExtensions.cs

@@ -1,10 +1,9 @@
-using System;
+using System;
 using System.Drawing;
 using System.Linq;
 using System.Windows.Forms;
-using TweetDck.Core.Utils;
 
-namespace TweetDck.Core.Controls{
+namespace TweetDuck.Core.Controls{
     static class ControlExtensions{
         public static readonly Point InvisibleLocation = new Point(-32000, -32000);
 
@@ -21,6 +20,12 @@ namespace TweetDck.Core.Controls{
             control.BeginInvoke(func);
         }
 
+        public static float GetDPIScale(this Control control){
+            using(Graphics graphics = control.CreateGraphics()){
+                return graphics.DpiY/96F;
+            }
+        }
+
         public static bool IsFullyOutsideView(this Form form){
             return !Screen.AllScreens.Any(screen => screen.WorkingArea.IntersectsWith(form.Bounds));
         }
@@ -41,16 +46,24 @@ namespace TweetDck.Core.Controls{
             }
         }
 
+        public static void SetValueSafe(this NumericUpDown numUpDown, int value){
+            if (value >= numUpDown.Minimum && value <= numUpDown.Maximum){
+                numUpDown.Value = value;
+            }
+        }
+
         public static void SetValueSafe(this TrackBar trackBar, int value){
             if (value >= trackBar.Minimum && value <= trackBar.Maximum){
                 trackBar.Value = value;
             }
         }
 
-        public static void SetElevated(this Button button){
-            button.Text = " "+button.Text;
-            button.FlatStyle = FlatStyle.System;
-            NativeMethods.SendMessage(button.Handle, NativeMethods.BCM_SETSHIELD, 0, new IntPtr(1));
+        public static bool AlignValueToTick(this TrackBar trackBar){
+            if (trackBar.Value % trackBar.SmallChange != 0){
+                trackBar.Value = trackBar.SmallChange*(int)Math.Floor(((double)trackBar.Value/trackBar.SmallChange)+0.5);
+                return false;
+            }
+            else return true;
         }
 
         public static void EnableMultilineShortcuts(this TextBox textBox){

Core/Controls/FlatButton.cs

@@ -1,8 +1,8 @@
 using System;
 using System.Windows.Forms;
 
-namespace TweetDck.Core.Controls{
-    class FlatButton : Button{
+namespace TweetDuck.Core.Controls{
+    sealed class FlatButton : Button{
         protected override bool ShowFocusCues => false;
 
         public FlatButton(){

Core/Controls/FlatProgressBar.cs

@@ -1,7 +1,8 @@
-using System.Drawing;
+using System;
+using System.Drawing;
 using System.Windows.Forms;
 
-namespace TweetDck.Core.Controls{
+namespace TweetDuck.Core.Controls{
     sealed class FlatProgressBar : ProgressBar{
         private readonly SolidBrush brush;
 
@@ -13,7 +14,7 @@ namespace TweetDck.Core.Controls{
         }
 
         public void SetValueInstant(int value){
-            ControlExtensions.SetValueInstant(this, value);
+            ControlExtensions.SetValueInstant(this, Math.Max(Minimum, Math.Min(Maximum, value)));
         }
 
         protected override void OnPaint(PaintEventArgs e){
@@ -23,7 +24,7 @@ namespace TweetDck.Core.Controls{
 
             Rectangle rect = e.ClipRectangle;
             rect.Width = (int)(rect.Width*((double)Value/Maximum));
-            e.Graphics.FillRectangle(brush,rect);
+            e.Graphics.FillRectangle(brush, rect);
         }
 
         protected override void Dispose(bool disposing){

Core/Controls/LabelVertical.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace TweetDuck.Core.Controls{
+    sealed class LabelVertical : Label{
+        public int LineHeight { get; set; }
+
+        protected override void OnPaint(PaintEventArgs e){
+            int y = (int)Math.Floor((ClientRectangle.Height-Text.Length*LineHeight)/2F)-1;
+
+            using(Brush brush = new SolidBrush(ForeColor)){
+                foreach(char chr in Text){
+                    string str = chr.ToString();
+                    float x = (ClientRectangle.Width-e.Graphics.MeasureString(str, Font).Width)/2F;
+
+                    e.Graphics.DrawString(str, Font, brush, x, y);
+                    y += LineHeight;
+                }
+            }
+        }
+    }
+}

Core/Controls/NumericUpDownEx.cs

@@ -0,0 +1,18 @@
+using System.ComponentModel;
+using System.Windows.Forms;
+
+namespace TweetDuck.Core.Controls{
+    sealed class NumericUpDownEx : NumericUpDown{
+        public string TextSuffix { get; set ; }
+
+        protected override void UpdateEditText(){
+            base.UpdateEditText();
+
+            if (LicenseManager.UsageMode != LicenseUsageMode.Designtime){
+                ChangingText = true;
+                Text += TextSuffix;
+                ChangingText = false;
+            }
+        }
+    }
+}

Core/Controls/TabButton.cs

@@ -1,25 +0,0 @@
-using System;
-using System.Drawing;
-using System.Windows.Forms;
-
-namespace TweetDck.Core.Controls{
-    sealed class TabButton : FlatButton{
-        public Action Callback { get; private set; }
-
-        public void SetupButton(int locationX, int sizeWidth, string title, Action callback){
-            Callback = callback;
-
-            SuspendLayout();
-            FlatAppearance.BorderColor = Color.DimGray;
-            FlatAppearance.MouseDownBackColor = Color.White;
-            FlatAppearance.MouseOverBackColor = Color.White;
-            FlatStyle = FlatStyle.Flat;
-            Location = new Point(locationX, 0);
-            Margin = new Padding(0);
-            Size = new Size(sizeWidth, 30);
-            Text = title;
-            UseVisualStyleBackColor = true;
-            ResumeLayout(true);
-        }
-    }
-}

Core/Controls/TabPanel.Designer.cs

@@ -1,68 +0,0 @@
-namespace TweetDck.Core.Controls {
-    partial class TabPanel {
-        /// <summary> 
-        /// Required designer variable.
-        /// </summary>
-        private System.ComponentModel.IContainer components = null;
-
-        /// <summary> 
-        /// Clean up any resources being used.
-        /// </summary>
-        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-        protected override void Dispose(bool disposing) {
-            if (disposing && (components != null)) {
-                components.Dispose();
-            }
-            base.Dispose(disposing);
-        }
-
-        #region Component Designer generated code
-
-        /// <summary> 
-        /// Required method for Designer support - do not modify 
-        /// the contents of this method with the code editor.
-        /// </summary>
-        private void InitializeComponent() {
-            this.panelButtons = new System.Windows.Forms.Panel();
-            this.panelContent = new System.Windows.Forms.Panel();
-            this.SuspendLayout();
-            // 
-            // panelButtons
-            // 
-            this.panelButtons.Dock = System.Windows.Forms.DockStyle.Top;
-            this.panelButtons.Location = new System.Drawing.Point(0, 0);
-            this.panelButtons.Margin = new System.Windows.Forms.Padding(0);
-            this.panelButtons.Name = "panelButtons";
-            this.panelButtons.Size = new System.Drawing.Size(640, 30);
-            this.panelButtons.TabIndex = 0;
-            // 
-            // panelContent
-            // 
-            this.panelContent.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
-            | System.Windows.Forms.AnchorStyles.Left) 
-            | System.Windows.Forms.AnchorStyles.Right)));
-            this.panelContent.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
-            this.panelContent.Location = new System.Drawing.Point(0, 29);
-            this.panelContent.Margin = new System.Windows.Forms.Padding(0);
-            this.panelContent.Name = "panelContent";
-            this.panelContent.Size = new System.Drawing.Size(640, 451);
-            this.panelContent.TabIndex = 1;
-            // 
-            // TabPanel
-            // 
-            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-            this.Controls.Add(this.panelContent);
-            this.Controls.Add(this.panelButtons);
-            this.Name = "TabPanel";
-            this.Size = new System.Drawing.Size(640, 480);
-            this.ResumeLayout(false);
-
-        }
-
-        #endregion
-
-        private System.Windows.Forms.Panel panelButtons;
-        private System.Windows.Forms.Panel panelContent;
-    }
-}

Core/Controls/TabPanel.cs

@@ -1,52 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Drawing;
-using System.Linq;
-using System.Windows.Forms;
-
-namespace TweetDck.Core.Controls{
-    sealed partial class TabPanel : UserControl{
-        public Panel Content => panelContent;
-        public IEnumerable<TabButton> Buttons => panelButtons.Controls.Cast<TabButton>();
-
-        public TabButton ActiveButton { get; private set; }
-
-        private int btnWidth;
-
-        public TabPanel(){
-            InitializeComponent();
-        }
-
-        public void SetupTabPanel(int buttonWidth){
-            this.btnWidth = buttonWidth;
-        }
-
-        public TabButton AddButton(string title, Action callback){
-            TabButton button = new TabButton();
-            button.SetupButton((btnWidth-1)*panelButtons.Controls.Count, btnWidth, title, callback);
-            button.Click += (sender, args) => SelectTab((TabButton)sender);
-
-            panelButtons.Controls.Add(button);
-            return button;
-        }
-
-        public void SelectTab(TabButton button){
-            if (ActiveButton != null){
-                ActiveButton.BackColor = SystemColors.Control;
-            }
-
-            button.BackColor = Color.White;
-            button.Callback();
-
-            ActiveButton = button;
-        }
-
-        public void ReplaceContent(Control newControl){
-            newControl.Dock = DockStyle.Fill;
-            Content.SuspendLayout();
-            Content.Controls.Clear();
-            Content.Controls.Add(newControl);
-            Content.ResumeLayout(true);
-        }
-    }
-}

Core/FormBrowser.Designer.cs

@@ -1,4 +1,4 @@
-namespace TweetDck.Core {
+namespace TweetDuck.Core {
     sealed partial class FormBrowser {
         /// <summary>
         /// Required designer variable.
@@ -24,24 +24,32 @@
         /// </summary>
         private void InitializeComponent() {
             this.components = new System.ComponentModel.Container();
-            this.trayIcon = new TweetDck.Core.TrayIcon(this.components);
+            this.trayIcon = new TweetDuck.Core.Other.TrayIcon(this.components);
             this.toolTip = new System.Windows.Forms.ToolTip(this.components);
+            this.timerResize = new System.Windows.Forms.Timer(this.components);
             this.SuspendLayout();
             // 
+            // timerResize
+            // 
+            this.timerResize.Interval = 500;
+            this.timerResize.Tick += new System.EventHandler(this.timerResize_Tick);
+            // 
             // FormBrowser
             // 
             this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
             this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-            this.BackColor = TweetDck.Core.Utils.BrowserUtils.BackgroundColor;
-            this.ClientSize = new System.Drawing.Size(324, 386);
+            this.BackColor = TweetDuck.Core.Utils.TwitterUtils.BackgroundColor;
+            this.ClientSize = new System.Drawing.Size(1008, 730);
             this.Icon = Properties.Resources.icon;
-            this.Location = TweetDck.Core.Controls.ControlExtensions.InvisibleLocation;
-            this.MinimumSize = new System.Drawing.Size(340, 424);
+            this.Location = TweetDuck.Core.Controls.ControlExtensions.InvisibleLocation;
+            this.MinimumSize = new System.Drawing.Size(348, 424);
             this.Name = "FormBrowser";
             this.StartPosition = System.Windows.Forms.FormStartPosition.Manual;
             this.Activated += new System.EventHandler(this.FormBrowser_Activated);
             this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.FormBrowser_FormClosing);
+            this.FormClosed += new System.Windows.Forms.FormClosedEventHandler(this.FormBrowser_FormClosed);
             this.ResizeEnd += new System.EventHandler(this.FormBrowser_ResizeEnd);
+            this.LocationChanged += new System.EventHandler(this.FormBrowser_LocationChanged);
             this.Resize += new System.EventHandler(this.FormBrowser_Resize);
             this.ResumeLayout(false);
 
@@ -49,8 +57,9 @@
 
         #endregion
 
-        private TrayIcon trayIcon;
+        private TweetDuck.Core.Other.TrayIcon trayIcon;
         private System.Windows.Forms.ToolTip toolTip;
+        private System.Windows.Forms.Timer timerResize;
     }
 }
 

Core/FormBrowser.cs

@@ -1,124 +1,123 @@
-using CefSharp;
-using CefSharp.WinForms;
-using System;
-using System.Diagnostics;
+using System;
 using System.Drawing;
-using System.Linq;
 using System.Windows.Forms;
-using TweetDck.Configuration;
-using TweetDck.Core.Bridge;
-using TweetDck.Core.Controls;
-using TweetDck.Core.Handling;
-using TweetDck.Core.Notification;
-using TweetDck.Core.Notification.Screenshot;
-using TweetDck.Core.Notification.Sound;
-using TweetDck.Core.Other;
-using TweetDck.Core.Utils;
-using TweetDck.Plugins;
-using TweetDck.Plugins.Enums;
-using TweetDck.Plugins.Events;
-using TweetDck.Resources;
-using TweetDck.Updates;
-using TweetDck.Updates.Events;
+using Microsoft.WindowsAPICodePack.Taskbar;
+using TweetDuck.Configuration;
+using TweetDuck.Core.Bridge;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Handling;
+using TweetDuck.Core.Handling.General;
+using TweetDuck.Core.Management;
+using TweetDuck.Core.Notification;
+using TweetDuck.Core.Notification.Screenshot;
+using TweetDuck.Core.Other;
+using TweetDuck.Core.Other.Analytics;
+using TweetDuck.Core.Other.Settings.Dialogs;
+using TweetDuck.Core.Utils;
+using TweetDuck.Plugins;
+using TweetDuck.Plugins.Events;
+using TweetDuck.Resources;
+using TweetDuck.Updates;
 
-namespace TweetDck.Core{
-    sealed partial class FormBrowser : Form{
-        private static UserConfig Config => Program.UserConfig;
+namespace TweetDuck.Core{
+    sealed partial class FormBrowser : Form, AnalyticsFile.IProvider{
+        private static UserConfig Config => Program.Config.User;
+
+        public bool IsWaiting{
+            set{
+                if (value){
+                    browser.Enabled = false;
+                    Cursor = Cursors.WaitCursor;
+                }
+                else{
+                    browser.Enabled = true;
+                    Cursor = Cursors.Default;
+
+                    if (Focused){ // re-focus browser only if the window or a child is activated
+                        browser.Focus();
+                    }
+                }
+            }
+        }
 
         public string UpdateInstallerPath { get; private set; }
+        private bool ignoreUpdateCheckError;
+        
+        public AnalyticsFile AnalyticsFile => analytics?.File ?? AnalyticsFile.Dummy;
 
-        private readonly ChromiumWebBrowser browser;
+        private readonly TweetDeckBrowser browser;
         private readonly PluginManager plugins;
         private readonly UpdateHandler updates;
         private readonly FormNotificationTweet notification;
         private readonly ContextMenu contextMenu;
+        private readonly UpdateBridge updateBridge;
+        private readonly TaskbarIcon taskbarIcon;
 
         private bool isLoaded;
-        private bool isBrowserReady;
         private FormWindowState prevState;
-
+        
         private TweetScreenshotManager notificationScreenshotManager;
-        private ISoundNotificationPlayer soundNotification;
+        private VideoPlayer videoPlayer;
+        private AnalyticsManager analytics;
 
-        public FormBrowser(PluginManager pluginManager, UpdaterSettings updaterSettings){
+        public FormBrowser(){
             InitializeComponent();
 
             Text = Program.BrandName;
-
-            this.plugins = pluginManager;
-            this.plugins.Reloaded += plugins_Reloaded;
-            this.plugins.PluginChangedState += plugins_PluginChangedState;
-
-            this.contextMenu = ContextMenuBrowser.CreateMenu(this);
-
-            this.notification = new FormNotificationTweet(this, plugins){
-                #if DEBUG
-                CanMoveWindow = () => (ModifierKeys & Keys.Alt) == Keys.Alt
-                #else
-                CanMoveWindow = () => false
-                #endif
-            };
-
-            this.notification.Show();
-
-            this.browser = new ChromiumWebBrowser("https://tweetdeck.twitter.com/"){
-                MenuHandler = new ContextMenuBrowser(this),
-                JsDialogHandler = new JavaScriptDialogHandler(),
-                LifeSpanHandler = new LifeSpanHandler()
-            };
-
-            #if DEBUG
-            this.browser.ConsoleMessage += BrowserUtils.HandleConsoleMessage;
-            #endif
-
-            this.browser.LoadingStateChanged += browser_LoadingStateChanged;
-            this.browser.FrameLoadStart += browser_FrameLoadStart;
-            this.browser.FrameLoadEnd += browser_FrameLoadEnd;
-            this.browser.LoadError += browser_LoadError;
-            this.browser.RegisterAsyncJsObject("$TD", new TweetDeckBridge(this, notification));
-            this.browser.RegisterAsyncJsObject("$TDP", plugins.Bridge);
             
-            browser.BrowserSettings.BackgroundColor = (uint)BrowserUtils.BackgroundColor.ToArgb();
-            browser.Dock = DockStyle.None;
-            browser.Location = ControlExtensions.InvisibleLocation;
-            Controls.Add(browser);
+            this.plugins = new PluginManager(Program.Config.Plugins, Program.PluginPath);
+            this.plugins.Reloaded += plugins_Reloaded;
+            this.plugins.Executed += plugins_Executed;
+            this.plugins.Reload();
+
+            this.notification = new FormNotificationTweet(this, plugins);
+            this.notification.Show();
+            
+            this.updates = new UpdateHandler(Program.InstallerPath);
+            this.updates.CheckFinished += updates_CheckFinished;
+
+            this.updateBridge = new UpdateBridge(updates, this);
+            this.updateBridge.UpdateAccepted += updateBridge_UpdateAccepted;
+            this.updateBridge.UpdateDelayed += updateBridge_UpdateDelayed;
+            this.updateBridge.UpdateDismissed += updateBridge_UpdateDismissed;
+
+            this.browser = new TweetDeckBrowser(this, plugins, new TweetDeckBridge.Browser(this, notification), updateBridge);
+            this.contextMenu = ContextMenuBrowser.CreateMenu(this);
 
             Controls.Add(new MenuStrip{ Visible = false }); // fixes Alt freezing the program in Win 10 Anniversary Update
 
+            this.taskbarIcon = new TaskbarIcon();
+            Shown += (sender, args) => taskbarIcon.UpdateIcon();
+
             Disposed += (sender, args) => {
+                Config.MuteToggled -= Config_MuteToggled;
+                Config.TrayBehaviorChanged -= Config_TrayBehaviorChanged;
+                
                 browser.Dispose();
+                updates.Dispose();
                 contextMenu.Dispose();
+                taskbarIcon.Dispose();
 
                 notificationScreenshotManager?.Dispose();
-                soundNotification?.Dispose();
+                videoPlayer?.Dispose();
+                analytics?.Dispose();
             };
 
+            Config.MuteToggled += Config_MuteToggled;
+
             this.trayIcon.ClickRestore += trayIcon_ClickRestore;
             this.trayIcon.ClickClose += trayIcon_ClickClose;
             Config.TrayBehaviorChanged += Config_TrayBehaviorChanged;
 
-            UpdateTrayIcon();
+            UpdateTray();
 
-            Config.MuteToggled += Config_MuteToggled;
-            Config.ZoomLevelChanged += Config_ZoomLevelChanged;
-
-            this.updates = new UpdateHandler(browser, this, updaterSettings);
-            this.updates.UpdateAccepted += updates_UpdateAccepted;
-            this.updates.UpdateDismissed += updates_UpdateDismissed;
+            if (Config.AllowDataCollection){
+                analytics = new AnalyticsManager(this, plugins, Program.AnalyticsFilePath);
+            }
 
             RestoreWindow();
         }
 
-        private bool TryBringToFront<T>() where T : Form{
-            T form = Application.OpenForms.OfType<T>().FirstOrDefault();
-
-            if (form != null){
-                form.BringToFront();
-                return true;
-            }
-            else return false;
-        }
-
         private void ShowChildForm(Form form){
             form.VisibleChanged += (sender, args) => form.MoveToCenter(this);
             form.Show(this);
@@ -137,79 +136,32 @@ namespace TweetDck.Core{
             isLoaded = true;
         }
 
-        private void OnBrowserReady(){
-            if (!isBrowserReady){
-                browser.Location = Point.Empty;
-                browser.Dock = DockStyle.Fill;
-                isBrowserReady = true;
-            }
-        }
-
-        private void UpdateTrayIcon(){
+        private void UpdateTray(){
             trayIcon.Visible = Config.TrayBehavior.ShouldDisplayIcon();
         }
 
-        // active event handlers
+        // event handlers
 
-        private void browser_LoadingStateChanged(object sender, LoadingStateChangedEventArgs e){
-            if (!e.IsLoading){
-                foreach(string word in BrowserUtils.DictionaryWords){
-                    browser.AddWordToDictionary(word);
-                }
-
-                BeginInvoke(new Action(OnBrowserReady));
-                browser.LoadingStateChanged -= browser_LoadingStateChanged;
-            }
-        }
-
-        private void browser_FrameLoadStart(object sender, FrameLoadStartEventArgs e){
-            if (e.Frame.IsMain){
-                if (Config.ZoomLevel != 100){
-                    BrowserUtils.SetZoomLevel(browser.GetBrowser(), Config.ZoomLevel);
-                }
-
-                if (BrowserUtils.IsTwitterWebsite(e.Frame)){
-                    ScriptLoader.ExecuteFile(e.Frame, "twitter.js");
-                }
-            }
-        }
-
-        private void browser_FrameLoadEnd(object sender, FrameLoadEndEventArgs e){
-            if (e.Frame.IsMain && BrowserUtils.IsTweetDeckWebsite(e.Frame)){
-                e.Frame.ExecuteJavaScriptAsync(BrowserUtils.BackgroundColorFix);
-
-                UpdateProperties(PropertyBridge.Properties.AllBrowser);
-                ScriptLoader.ExecuteFile(e.Frame, "code.js");
-                ReinjectCustomCSS(Config.CustomBrowserCSS);
-
-                if (plugins.HasAnyPlugin(PluginEnvironment.Browser)){
-                    ScriptLoader.ExecuteFile(e.Frame, PluginManager.PluginBrowserScriptFile);
-                    ScriptLoader.ExecuteFile(e.Frame, PluginManager.PluginGlobalScriptFile);
-                    plugins.ExecutePlugins(e.Frame, PluginEnvironment.Browser, true);
-                }
-
-                TweetDeckBridge.ResetStaticProperties();
-            }
-        }
-
-        private void browser_LoadError(object sender, LoadErrorEventArgs e){
-            if (e.ErrorCode == CefErrorCode.Aborted){
-                return;
-            }
-
-            if (!e.FailedUrl.StartsWith("http://td/")){
-                string errorPage = ScriptLoader.LoadResource("pages/error.html", true);
-
-                if (errorPage != null){
-                    browser.LoadHtml(errorPage.Replace("{err}", BrowserUtils.GetErrorName(e.ErrorCode)), "http://td/error");
-                }
-            }
+        private void timerResize_Tick(object sender, EventArgs e){
+            FormBrowser_ResizeEnd(this, e); // also stops timer
         }
 
         private void FormBrowser_Activated(object sender, EventArgs e){
             if (!isLoaded)return;
 
             trayIcon.HasNotifications = false;
+            taskbarIcon.HasNotifications = false;
+
+            if (!browser.Enabled){      // when taking a screenshot, the window is unfocused and
+                browser.Enabled = true; // the browser is disabled; if the user clicks back into
+            }                           // the window, enable the browser again
+        }
+
+        private void FormBrowser_LocationChanged(object sender, EventArgs e){
+            if (!isLoaded)return;
+            
+            timerResize.Stop();
+            timerResize.Start();
         }
 
         private void FormBrowser_Resize(object sender, EventArgs e){
@@ -227,11 +179,17 @@ namespace TweetDck.Core{
                     FormBrowser_ResizeEnd(sender, e);
                 }
             }
+            else{
+                timerResize.Stop();
+                timerResize.Start();
+            }
         }
 
         private void FormBrowser_ResizeEnd(object sender, EventArgs e){ // also triggers when the window moves
             if (!isLoaded)return;
 
+            timerResize.Stop();
+            
             if (Location != ControlExtensions.InvisibleLocation){
                 Config.BrowserWindow.Save(this);
                 Config.Save();
@@ -247,23 +205,25 @@ namespace TweetDck.Core{
             }
         }
 
-        private void Config_MuteToggled(object sender, EventArgs e){
-            UpdateProperties(PropertyBridge.Properties.MuteNotifications);
+        private void FormBrowser_FormClosed(object sender, FormClosedEventArgs e){
+            if (isLoaded && UpdateInstallerPath == null){
+                updateBridge.Cleanup();
+            }
         }
 
-        private void Config_ZoomLevelChanged(object sender, EventArgs e){
-            BrowserUtils.SetZoomLevel(browser.GetBrowser(), Config.ZoomLevel);
+        private void Config_MuteToggled(object sender, EventArgs e){
+            AnalyticsFile.NotificationMutes.Trigger();
         }
 
         private void Config_TrayBehaviorChanged(object sender, EventArgs e){
-            UpdateTrayIcon();
+            UpdateTray();
         }
 
         private void trayIcon_ClickRestore(object sender, EventArgs e){
             Show();
             RestoreWindow();
             Activate();
-            UpdateTrayIcon();
+            UpdateTray();
         }
 
         private void trayIcon_ClickClose(object sender, EventArgs e){
@@ -271,78 +231,124 @@ namespace TweetDck.Core{
         }
         
         private void plugins_Reloaded(object sender, PluginErrorEventArgs e){
-            browser.GetBrowser().Reload();
-        }
-
-        private void plugins_PluginChangedState(object sender, PluginChangedStateEventArgs e){
-            browser.ExecuteScriptAsync("window.TDPF_setPluginState", e.Plugin, e.IsEnabled);
-        }
-
-        private void updates_UpdateAccepted(object sender, UpdateAcceptedEventArgs e){
-            Hide();
-
-            FormUpdateDownload downloadForm = new FormUpdateDownload(e.UpdateInfo);
-            downloadForm.MoveToCenter(this);
-            downloadForm.ShowDialog();
-            downloadForm.Dispose();
-
-            if (downloadForm.UpdateStatus == FormUpdateDownload.Status.Succeeded){
-                UpdateInstallerPath = downloadForm.InstallerPath;
-                ForceClose();
+            if (e.HasErrors){
+                FormMessage.Error("Error Loading Plugins", "The following plugins will not be available until the issues are resolved:\n\n"+string.Join("\n\n", e.Errors), FormMessage.OK);
             }
-            else if (downloadForm.UpdateStatus == FormUpdateDownload.Status.Manual){
-                ForceClose();
+
+            if (isLoaded){
+                browser.ReloadToTweetDeck();
             }
-            else{
-                Show();
+        }
+        
+        private static void plugins_Executed(object sender, PluginErrorEventArgs e){
+            if (e.HasErrors){
+                FormMessage.Error("Error Executing Plugins", "Failed to execute the following plugins:\n\n"+string.Join("\n\n", e.Errors), FormMessage.OK);
             }
         }
 
-        private void updates_UpdateDismissed(object sender, UpdateDismissedEventArgs e){
-            Config.DismissedUpdate = e.VersionTag;
-            Config.Save();
+        private void updates_CheckFinished(object sender, UpdateCheckEventArgs e){
+            e.Result.Handle(update => {
+                string tag = update.VersionTag;
+
+                if (tag != Program.VersionTag && tag != Config.DismissedUpdate){
+                    update.BeginSilentDownload();
+                    browser.ShowUpdateNotification(tag, update.ReleaseNotes);
+                }
+                else{
+                    updates.StartTimer();
+                }
+            }, ex => {
+                if (!ignoreUpdateCheckError){
+                    Program.Reporter.HandleException("Update Check Error", "An error occurred while checking for updates.", true, ex);
+                    updates.StartTimer();
+                }
+            });
+
+            ignoreUpdateCheckError = true;
         }
 
-        private void soundNotification_PlaybackError(object sender, PlaybackErrorEventArgs e){
-            e.Ignore = true;
+        private void updateBridge_UpdateAccepted(object sender, UpdateInfo update){
+            FormManager.CloseAllDialogs();
 
-            using(FormMessage form = new FormMessage("Notification Sound Error", "Could not play custom notification sound."+Environment.NewLine+e.Message, MessageBoxIcon.Error)){
-                form.CancelButton = form.AddButton("Ignore");
+            if (!string.IsNullOrEmpty(Config.DismissedUpdate)){
+                Config.DismissedUpdate = null;
+                Config.Save();
+            }
 
-                Button btnOpenSettings = form.AddButton("Open Settings");
-                btnOpenSettings.Width += 16;
-                btnOpenSettings.Location = new Point(btnOpenSettings.Location.X-16, btnOpenSettings.Location.Y);
+            void OnFinished(){
+                UpdateDownloadStatus status = update.DownloadStatus;
 
-                if (form.ShowDialog() == DialogResult.OK && form.ClickedButton == btnOpenSettings){
-                    OpenSettings(FormSettings.TabIndexNotification);
+                if (status == UpdateDownloadStatus.Done){
+                    UpdateInstallerPath = update.InstallerPath;
+                    ForceClose();
+                }
+                else if (status != UpdateDownloadStatus.Canceled && FormMessage.Error("Update Has Failed", "Could not automatically download the update: "+(update.DownloadError?.Message ?? "unknown error")+"\n\nWould you like to open the website and try downloading the update manually?", FormMessage.Yes, FormMessage.No)){
+                    BrowserUtils.OpenExternalBrowser(Program.Website);
+                    ForceClose();
+                }
+                else{
+                    Show();
                 }
             }
+            
+            if (update.DownloadStatus.IsFinished(true)){
+                OnFinished();
+            }
+            else{
+                FormUpdateDownload downloadForm = new FormUpdateDownload(update);
+
+                downloadForm.VisibleChanged += (sender2, args2) => {
+                    downloadForm.MoveToCenter(this);
+                    Hide();
+                };
+
+                downloadForm.FormClosed += (sender2, args2) => {
+                    if (downloadForm.DialogResult != DialogResult.OK){
+                        update.CancelDownload();
+                    }
+
+                    downloadForm.Dispose();
+                    OnFinished();
+                };
+
+                downloadForm.Show();
+            }
+        }
+
+        private void updateBridge_UpdateDelayed(object sender, UpdateInfo update){
+            // stops the timer
+        }
+
+        private void updateBridge_UpdateDismissed(object sender, UpdateInfo update){
+            Config.DismissedUpdate = update.VersionTag;
+            Config.Save();
         }
 
         protected override void WndProc(ref Message m){
             if (isLoaded && m.Msg == Program.WindowRestoreMessage){
-                using(Process process = Process.GetCurrentProcess()){
-                    if (process.Id == m.WParam.ToInt32()){
-                        trayIcon_ClickRestore(trayIcon, new EventArgs());
-                    }
+                if (WindowsUtils.CurrentProcessID == m.WParam.ToInt32()){
+                    trayIcon_ClickRestore(trayIcon, EventArgs.Empty);
                 }
 
                 return;
             }
+            
+            if (browser.Ready && m.Msg == NativeMethods.WM_PARENTNOTIFY && (m.WParam.ToInt32() & 0xFFFF) == NativeMethods.WM_XBUTTONDOWN){
+                if (videoPlayer != null && videoPlayer.Running){
+                    videoPlayer.Close();
+                }
+                else{
+                    browser.OnMouseClickExtra(m.WParam);
+                    AnalyticsFile.BrowserExtraMouseButtons.Trigger();
+                }
 
-            if (isBrowserReady && m.Msg == NativeMethods.WM_PARENTNOTIFY && (m.WParam.ToInt32() & 0xFFFF) == NativeMethods.WM_XBUTTONDOWN){
-                browser.ExecuteScriptAsync("TDGF_onMouseClickExtra", (m.WParam.ToInt32() >> 16) & 0xFFFF);
                 return;
             }
 
             base.WndProc(ref m);
         }
 
-        // notification helpers
-
-        public FormNotificationMain CreateNotificationForm(bool enableContextMenu){
-            return new FormNotificationMain(this, plugins, enableContextMenu);
-        }
+        // bridge methods
 
         public void PauseNotification(){
             notification.PauseNotification();
@@ -351,92 +357,210 @@ namespace TweetDck.Core{
         public void ResumeNotification(){
             notification.ResumeNotification();
         }
-
-        // javascript calls
-
+        
         public void ReinjectCustomCSS(string css){
-            browser.ExecuteScriptAsync("TDGF_reinjectCustomCSS", css?.Replace(Environment.NewLine, " ") ?? string.Empty);
-        }
-
-        public void UpdateProperties(PropertyBridge.Properties properties){
-            browser.ExecuteScriptAsync(PropertyBridge.GenerateScript(properties));
+            browser.ReinjectCustomCSS(css);
         }
 
         public void ReloadToTweetDeck(){
-            browser.ExecuteScriptAsync("window.location.href = 'https://tweetdeck.twitter.com'");
+            #if DEBUG
+            ScriptLoader.HotSwap();
+            #else
+            if (ModifierKeys.HasFlag(Keys.Shift)){
+                ScriptLoader.ClearCache();
+            }
+            #endif
+
+            ignoreUpdateCheckError = false;
+            browser.ReloadToTweetDeck();
+            AnalyticsFile.BrowserReloads.Trigger();
+        }
+
+        public void AddSearchColumn(string query){
+            browser.AddSearchColumn(query);
+        }
+
+        public void TriggerTweetScreenshot(){
+            browser.TriggerTweetScreenshot();
+        }
+
+        public void ReloadColumns(){
+            browser.ReloadColumns();
+        }
+
+        public void PlaySoundNotification(){
+            browser.PlaySoundNotification();
+        }
+
+        public void ApplyROT13(){
+            browser.ApplyROT13();
+            AnalyticsFile.UsedROT13.Trigger();
+        }
+
+        public void OpenDevTools(){
+            browser.OpenDevTools();
         }
 
         // callback handlers
+        
+        public void OnIntroductionClosed(bool showGuide, bool allowDataCollection){
+            if (Config.FirstRun){
+                Config.FirstRun = false;
+                Config.AllowDataCollection = allowDataCollection;
+                Config.Save();
+
+                if (allowDataCollection && analytics == null){
+                    analytics = new AnalyticsManager(this, plugins, Program.AnalyticsFilePath);
+                }
+            }
+
+            if (showGuide){
+                FormGuide.Show();
+            }
+        }
 
         public void OpenContextMenu(){
             contextMenu.Show(this, PointToClient(Cursor.Position));
         }
 
         public void OpenSettings(){
-            OpenSettings(0);
+            OpenSettings(null);
         }
-
-        public void OpenSettings(int tabIndex){
-            if (!TryBringToFront<FormSettings>()){
+        
+        public void OpenSettings(Type startTab){
+            if (!FormManager.TryBringToFront<FormSettings>()){
                 bool prevEnableUpdateCheck = Config.EnableUpdateCheck;
 
-                FormSettings form = new FormSettings(this, plugins, updates, tabIndex);
-
+                FormSettings form = new FormSettings(this, plugins, updates, analytics, startTab);
+                
                 form.FormClosed += (sender, args) => {
                     if (!prevEnableUpdateCheck && Config.EnableUpdateCheck){
-                        updates.DismissUpdate(string.Empty);
-                        updates.Check(false);
+                        Config.DismissedUpdate = null;
+                        Config.Save();
+                        
+                        updates.Check(true);
                     }
 
                     if (!Config.EnableTrayHighlight){
                         trayIcon.HasNotifications = false;
                     }
 
-                    UpdateProperties(PropertyBridge.Properties.ExpandLinksOnHover | PropertyBridge.Properties.SwitchAccountSelectors | PropertyBridge.Properties.HasCustomNotificationSound);
+                    if (Config.AllowDataCollection){
+                        if (analytics == null){
+                            analytics = new AnalyticsManager(this, plugins, Program.AnalyticsFilePath);
+                        }
+                    }
+                    else if (analytics != null){
+                        analytics.Dispose();
+                        analytics = null;
+                    }
+
+                    BrowserCache.RefreshTimer();
+                    
+                    if (form.ShouldReloadBrowser){
+                        FormManager.TryFind<FormPlugins>()?.Close();
+                        plugins.Reload(); // also reloads the browser
+                    }
+                    else{
+                        browser.UpdateProperties();
+                    }
+
+                    notification.RequiresResize = true;
                     form.Dispose();
                 };
-
+                
+                AnalyticsFile.OpenOptions.Trigger();
                 ShowChildForm(form);
             }
         }
 
         public void OpenAbout(){
-            if (!TryBringToFront<FormAbout>()){
+            if (!FormManager.TryBringToFront<FormAbout>()){
+                AnalyticsFile.OpenAbout.Trigger();
                 ShowChildForm(new FormAbout());
             }
         }
 
         public void OpenPlugins(){
-            if (!TryBringToFront<FormPlugins>()){
+            if (!FormManager.TryBringToFront<FormPlugins>()){
+                AnalyticsFile.OpenPlugins.Trigger();
                 ShowChildForm(new FormPlugins(plugins));
             }
         }
 
-        public void OnTweetNotification(){ // may be called multiple times, once for each type of notification
-            if (Config.EnableTrayHighlight && !ContainsFocus){
-                trayIcon.HasNotifications = true;
+        public void OpenProfileImport(){
+            FormManager.TryFind<FormSettings>()?.Close();
+
+            using(DialogSettingsManage dialog = new DialogSettingsManage(plugins, true)){
+                if (!dialog.IsDisposed && dialog.ShowDialog() == DialogResult.OK && !dialog.IsRestarting){ // needs disposal check because the dialog may be closed in constructor
+                    BrowserProcessHandler.UpdatePrefs();
+                    FormManager.TryFind<FormPlugins>()?.Close();
+                    plugins.Reload(); // also reloads the browser
+                }
             }
         }
 
-        public void PlayNotificationSound(){
-            if (Config.NotificationSoundPath.Length == 0){
+        public void OnTweetNotification(){ // may be called multiple times, once for each type of notification
+            if (!ContainsFocus){
+                if (Config.EnableTrayHighlight){
+                    trayIcon.HasNotifications = true;
+                }
+
+                taskbarIcon.HasNotifications = false;
+            }
+        }
+
+        public void OnTweetSound(){
+            AnalyticsFile.SoundNotifications.Trigger();
+        }
+
+        public void PlayVideo(string url, string username){
+            if (string.IsNullOrEmpty(url)){
+                videoPlayer?.Close();
                 return;
             }
 
-            if (soundNotification == null){
-                soundNotification = SoundNotification.New();
-                soundNotification.PlaybackError += soundNotification_PlaybackError;
-            }
+            if (videoPlayer == null){
+                videoPlayer = new VideoPlayer(this);
 
-            soundNotification.Play(Config.NotificationSoundPath);
+                videoPlayer.ProcessExited += (sender, args) => {
+                    browser.HideVideoOverlay(true);
+                };
+            }
+            
+            videoPlayer.Launch(url, username);
+            AnalyticsFile.VideoPlays.Trigger();
         }
 
-        public void OnTweetScreenshotReady(string html, int width, int height){
-            if (notificationScreenshotManager == null){
-                notificationScreenshotManager = new TweetScreenshotManager(this);
+        public bool ProcessBrowserKey(Keys key){
+            if (videoPlayer != null && videoPlayer.Running){
+                videoPlayer.SendKeyEvent(key);
+                return true;
             }
 
-            notificationScreenshotManager.Trigger(html, width, height);
+            return false;
+        }
+
+        public void ShowTweetDetail(string columnId, string chirpId, string fallbackUrl){
+            Activate();
+
+            if (!browser.IsTweetDeckWebsite){
+                FormMessage.Error("View Tweet Detail", "TweetDeck is not currently loaded.", FormMessage.OK);
+                return;
+            }
+
+            notification.FinishCurrentNotification();
+            browser.ShowTweetDetail(columnId, chirpId, fallbackUrl);
+            AnalyticsFile.TweetDetails.Trigger();
+        }
+
+        public void OnTweetScreenshotReady(string html, int width){
+            if (notificationScreenshotManager == null){
+                notificationScreenshotManager = new TweetScreenshotManager(this, plugins);
+            }
+
+            notificationScreenshotManager.Trigger(html, width);
+            AnalyticsFile.TweetScreenshots.Trigger();
         }
 
         public void DisplayTooltip(string text){
@@ -449,9 +573,5 @@ namespace TweetDck.Core{
                 toolTip.Show(text, this, position);
             }
         }
-
-        public void TriggerTweetScreenshot(){
-            browser.ExecuteScriptAsync("TDGF_triggerScreenshot()");
-        }
     }
 }

Core/FormBrowser.resx

@@ -117,11 +117,13 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
-  <assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
-  <data name="trayIcon.TrayLocation" type="System.Drawing.Point, System.Drawing">
+  <metadata name="trayIcon.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
     <value>17, 17</value>
-  </data>
-  <data name="toolTip.TrayLocation" type="System.Drawing.Point, System.Drawing">
+  </metadata>
+  <metadata name="toolTip.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
     <value>112, 17</value>
-  </data>
+  </metadata>
+  <metadata name="timerResize.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>202, 17</value>
+  </metadata>
 </root>

Core/FormManager.cs

@@ -0,0 +1,30 @@
+using System.Linq;
+using System.Windows.Forms;
+
+namespace TweetDuck.Core{
+    static class FormManager{
+        public static T TryFind<T>() where T : Form{
+            return Application.OpenForms.OfType<T>().FirstOrDefault();
+        }
+
+        public static bool TryBringToFront<T>() where T : Form{
+            T form = TryFind<T>();
+
+            if (form != null){
+                form.BringToFront();
+                return true;
+            }
+            else return false;
+        }
+
+        public static bool HasAnyDialogs => Application.OpenForms.OfType<IAppDialog>().Any();
+        
+        public static void CloseAllDialogs(){
+            foreach(IAppDialog dialog in Application.OpenForms.OfType<IAppDialog>().Reverse()){
+                ((Form)dialog).Close();
+            }
+        }
+
+        public interface IAppDialog{}
+    }
+}

Core/Handling/BrowserProcessHandler.cs

@@ -1,15 +0,0 @@
-using CefSharp;
-using System;
-
-namespace TweetDck.Core.Handling{
-    class BrowserProcessHandler : IBrowserProcessHandler{
-        void IBrowserProcessHandler.OnContextInitialized(){
-            using(IRequestContext ctx = Cef.GetGlobalRequestContext()){
-                ctx.SetPreference("browser.enable_spellchecking", Program.UserConfig.EnableSpellCheck, out string _);
-            }
-        }
-
-        void IBrowserProcessHandler.OnScheduleMessagePumpWork(long delay){}
-        void IDisposable.Dispose(){}
-    }
-}

Core/Handling/ContextMenuBase.cs

@@ -1,124 +1,217 @@
-using CefSharp;
-using System;
-using System.IO;
+using System;
 using System.Text.RegularExpressions;
 using System.Windows.Forms;
-using TweetDck.Core.Bridge;
-using TweetDck.Core.Controls;
-using TweetDck.Core.Utils;
+using CefSharp;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Utils;
+using System.Linq;
+using TweetDuck.Configuration;
+using TweetDuck.Core.Bridge;
+using TweetDuck.Core.Management;
+using TweetDuck.Core.Notification;
+using TweetDuck.Core.Other;
+using TweetDuck.Core.Other.Analytics;
+using TweetDuck.Resources;
 
-namespace TweetDck.Core.Handling{
+namespace TweetDuck.Core.Handling{
     abstract class ContextMenuBase : IContextMenuHandler{
-        private static readonly Regex RegexTwitterAccount = new Regex(@"^https?://twitter\.com/([^/]+)/?$", RegexOptions.Compiled);
+        protected static UserConfig Config => Program.Config.User;
 
-        private const int MenuOpenLinkUrl = 26500;
-        private const int MenuCopyLinkUrl = 26501;
-        private const int MenuCopyUsername = 26502;
-        private const int MenuOpenImage = 26503;
-        private const int MenuSaveImage = 26504;
-        private const int MenuCopyImageUrl = 26505;
+        private static TwitterUtils.ImageQuality ImageQuality => Config.TwitterImageQuality;
+        
+        private const CefMenuCommand MenuOpenLinkUrl     = (CefMenuCommand)26500;
+        private const CefMenuCommand MenuCopyLinkUrl     = (CefMenuCommand)26501;
+        private const CefMenuCommand MenuCopyUsername    = (CefMenuCommand)26502;
+        private const CefMenuCommand MenuViewImage       = (CefMenuCommand)26503;
+        private const CefMenuCommand MenuOpenMediaUrl    = (CefMenuCommand)26504;
+        private const CefMenuCommand MenuCopyMediaUrl    = (CefMenuCommand)26505;
+        private const CefMenuCommand MenuSaveMedia       = (CefMenuCommand)26506;
+        private const CefMenuCommand MenuSaveTweetImages = (CefMenuCommand)26507;
+        private const CefMenuCommand MenuSearchInBrowser = (CefMenuCommand)26508;
+        private const CefMenuCommand MenuReadApplyROT13  = (CefMenuCommand)26509;
+        private const CefMenuCommand MenuOpenDevTools    = (CefMenuCommand)26599;
+        
+        protected ContextInfo.ContextData Context { get; private set; }
 
-        #if DEBUG
-        private const int MenuOpenDevTools = 26599;
+        private readonly AnalyticsFile.IProvider analytics;
 
-        protected void AddDebugMenuItems(IMenuModel model){
-            model.AddItem((CefMenuCommand)MenuOpenDevTools, "Open dev tools");
-        }
-        #endif
-
-        private readonly Form form;
-
-        protected ContextMenuBase(Form form){
-            this.form = form;
+        protected ContextMenuBase(AnalyticsFile.IProvider analytics){
+            this.analytics = analytics;
         }
 
         public virtual void OnBeforeContextMenu(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, IMenuModel model){
-            if (parameters.TypeFlags.HasFlag(ContextMenuType.Link) && !parameters.UnfilteredLinkUrl.EndsWith("tweetdeck.twitter.com/#", StringComparison.Ordinal)){
-                if (RegexTwitterAccount.IsMatch(parameters.UnfilteredLinkUrl)){
-                    model.AddItem((CefMenuCommand)MenuOpenLinkUrl, "Open account in browser");
-                    model.AddItem((CefMenuCommand)MenuCopyLinkUrl, "Copy account address");
-                    model.AddItem((CefMenuCommand)MenuCopyUsername, "Copy account username");
+            if (!TwitterUtils.IsTweetDeckWebsite(frame) || browser.IsLoading){
+                Context = TweetDeckBridge.ContextInfo.Reset();
+            }
+            else{
+                Context = TweetDeckBridge.ContextInfo.Create(parameters);
+            }
+            
+            if (parameters.TypeFlags.HasFlag(ContextMenuType.Selection) && !parameters.TypeFlags.HasFlag(ContextMenuType.Editable)){
+                model.AddItem(MenuSearchInBrowser, "Search in browser");
+                model.AddSeparator();
+                model.AddItem(MenuReadApplyROT13, "Apply ROT13");
+                model.AddSeparator();
+            }
+            
+            string TextOpen(string name) => "Open "+name+" in browser";
+            string TextCopy(string name) => "Copy "+name+" address";
+            string TextSave(string name) => "Save "+name+" as...";
+            
+            if (Context.Types.HasFlag(ContextInfo.ContextType.Link) && !Context.UnsafeLinkUrl.EndsWith("tweetdeck.twitter.com/#", StringComparison.Ordinal)){
+                if (TwitterUtils.RegexAccount.IsMatch(Context.UnsafeLinkUrl)){
+                    model.AddItem(MenuOpenLinkUrl, TextOpen("account"));
+                    model.AddItem(MenuCopyLinkUrl, TextCopy("account"));
+                    model.AddItem(MenuCopyUsername, "Copy account username");
                 }
                 else{
-                    model.AddItem((CefMenuCommand)MenuOpenLinkUrl, "Open link in browser");
-                    model.AddItem((CefMenuCommand)MenuCopyLinkUrl, "Copy link address");
+                    model.AddItem(MenuOpenLinkUrl, TextOpen("link"));
+                    model.AddItem(MenuCopyLinkUrl, TextCopy("link"));
                 }
 
                 model.AddSeparator();
             }
 
-            if (parameters.TypeFlags.HasFlag(ContextMenuType.Media) && parameters.HasImageContents){
-                model.AddItem((CefMenuCommand)MenuOpenImage, "Open image in browser");
-                model.AddItem((CefMenuCommand)MenuSaveImage, "Save image as...");
-                model.AddItem((CefMenuCommand)MenuCopyImageUrl, "Copy image address");
+            if (Context.Types.HasFlag(ContextInfo.ContextType.Video)){
+                model.AddItem(MenuOpenMediaUrl, TextOpen("video"));
+                model.AddItem(MenuCopyMediaUrl, TextCopy("video"));
+                model.AddItem(MenuSaveMedia, TextSave("video"));
+                model.AddSeparator();
+            }
+            else if (Context.Types.HasFlag(ContextInfo.ContextType.Image) && Context.MediaUrl != TweetNotification.AppLogo.Url){
+                model.AddItem(MenuViewImage, "View image in photo viewer");
+                model.AddItem(MenuOpenMediaUrl, TextOpen("image"));
+                model.AddItem(MenuCopyMediaUrl, TextCopy("image"));
+                model.AddItem(MenuSaveMedia, TextSave("image"));
+
+                if (Context.Chirp.Images.Length > 1){
+                    model.AddItem(MenuSaveTweetImages, TextSave("all images"));
+                }
+
                 model.AddSeparator();
             }
         }
 
         public virtual bool OnContextMenuCommand(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, CefMenuCommand commandId, CefEventFlags eventFlags){
-            switch((int)commandId){
+            Control control = browserControl.AsControl();
+
+            switch(commandId){
                 case MenuOpenLinkUrl:
-                    BrowserUtils.OpenExternalBrowser(parameters.LinkUrl);
+                    OpenBrowser(control, Context.LinkUrl);
                     break;
 
                 case MenuCopyLinkUrl:
-                    SetClipboardText(string.IsNullOrEmpty(TweetDeckBridge.LastRightClickedLink) ? parameters.UnfilteredLinkUrl : TweetDeckBridge.LastRightClickedLink);
+                    SetClipboardText(control, Context.UnsafeLinkUrl);
                     break;
 
-                case MenuOpenImage:
-                    BrowserUtils.OpenExternalBrowser(parameters.SourceUrl);
+                case MenuCopyUsername: {
+                    string url = Context.UnsafeLinkUrl;
+                    Match match = TwitterUtils.RegexAccount.Match(url);
+
+                    SetClipboardText(control, match.Success ? match.Groups[1].Value : url);
+                    control.InvokeAsyncSafe(analytics.AnalyticsFile.CopiedUsernames.Trigger);
+                    break;
+                }
+
+                case MenuOpenMediaUrl:
+                    OpenBrowser(control, TwitterUtils.GetMediaLink(Context.MediaUrl, ImageQuality));
                     break;
 
-                case MenuSaveImage:
-                    string fileName = GetImageFileName(parameters.SourceUrl);
-                    string extension = Path.GetExtension(fileName);
-                    string saveTarget;
-
-                    using(SaveFileDialog dialog = new SaveFileDialog{
-                        AutoUpgradeEnabled = true,
-                        OverwritePrompt = true,
-                        Title = "Save image",
-                        FileName = fileName,
-                        Filter = "Image ("+(string.IsNullOrEmpty(extension) ? "unknown" : extension)+")|*.*"
-                    }){
-                        saveTarget = dialog.ShowDialog() == DialogResult.OK ? dialog.FileName : null;
-                    }
-
-                    if (saveTarget != null){
-                        BrowserUtils.DownloadFileAsync(parameters.SourceUrl, saveTarget, ex => {
-                            MessageBox.Show("An error occurred while downloading the image: "+ex.Message, Program.BrandName+" Has Failed :(", MessageBoxButtons.OK, MessageBoxIcon.Error);
-                        });
-                    }
-
+                case MenuCopyMediaUrl:
+                    SetClipboardText(control, TwitterUtils.GetMediaLink(Context.MediaUrl, ImageQuality));
                     break;
 
-                case MenuCopyImageUrl:
-                    SetClipboardText(parameters.SourceUrl);
-                    break;
+                case MenuViewImage: {
+                    string url = Context.MediaUrl;
 
-                case MenuCopyUsername:
-                    Match match = RegexTwitterAccount.Match(parameters.UnfilteredLinkUrl);
-                    SetClipboardText(match.Success ? match.Groups[1].Value : parameters.UnfilteredLinkUrl);
+                    control.InvokeAsyncSafe(() => {
+                        TwitterUtils.ViewImage(url, ImageQuality);
+                        analytics.AnalyticsFile.ViewedImages.Trigger();
+                    });
+                    
                     break;
+                }
 
-                #if DEBUG
+                case MenuSaveMedia: {
+                    bool isVideo = Context.Types.HasFlag(ContextInfo.ContextType.Video);
+                    string url = Context.MediaUrl;
+                    string username = Context.Chirp.Authors.LastOrDefault();
+                    
+                    control.InvokeAsyncSafe(() => {
+                        if (isVideo){
+                            TwitterUtils.DownloadVideo(url, username);
+                            analytics.AnalyticsFile.DownloadedVideos.Trigger();
+                        }
+                        else{
+                            TwitterUtils.DownloadImage(url, username, ImageQuality);
+                            analytics.AnalyticsFile.DownloadedImages.Trigger();
+                        }
+                    });
+
+                    break;
+                }
+
+                case MenuSaveTweetImages: {
+                    string[] urls = Context.Chirp.Images;
+                    string username = Context.Chirp.Authors.LastOrDefault();
+                    
+                    control.InvokeAsyncSafe(() => {
+                        TwitterUtils.DownloadImages(urls, username, ImageQuality);
+                        analytics.AnalyticsFile.DownloadedImages.Trigger();
+                    });
+
+                    break;
+                }
+
+                case MenuReadApplyROT13:
+                    string selection = parameters.SelectionText;
+                    control.InvokeAsyncSafe(() => FormMessage.Information("ROT13", StringUtils.ConvertRot13(selection), FormMessage.OK));
+                    control.InvokeAsyncSafe(analytics.AnalyticsFile.UsedROT13.Trigger);
+                    return true;
+
+                case MenuSearchInBrowser:
+                    string query = parameters.SelectionText;
+                    control.InvokeAsyncSafe(() => BrowserUtils.OpenExternalSearch(query));
+                    DeselectAll(frame);
+                    break;
+                    
                 case MenuOpenDevTools:
                     browserControl.ShowDevTools();
                     break;
-                #endif
             }
 
             return false;
         }
 
-        public virtual void OnContextMenuDismissed(IWebBrowser browserControl, IBrowser browser, IFrame frame){}
+        public virtual void OnContextMenuDismissed(IWebBrowser browserControl, IBrowser browser, IFrame frame){
+            Context = TweetDeckBridge.ContextInfo.Reset();
+        }
 
         public virtual bool RunContextMenu(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, IMenuModel model, IRunContextMenuCallback callback){
             return false;
         }
 
-        protected void SetClipboardText(string text){
-            form.InvokeAsyncSafe(() => WindowsUtils.SetClipboard(text, TextDataFormat.UnicodeText));
+        protected static void DeselectAll(IFrame frame){
+            ScriptLoader.ExecuteScript(frame, "window.getSelection().removeAllRanges()", "gen:deselect");
+        }
+
+        protected static void OpenBrowser(Control control, string url){
+            control.InvokeAsyncSafe(() => BrowserUtils.OpenExternalBrowser(url));
+        }
+
+        protected static void SetClipboardText(Control control, string text){
+            control.InvokeAsyncSafe(() => WindowsUtils.SetClipboard(text, TextDataFormat.UnicodeText));
+        }
+
+        protected static void InsertSelectionSearchItem(IMenuModel model, CefMenuCommand insertCommand, string insertLabel){
+            model.InsertItemAt(model.GetIndexOf(MenuSearchInBrowser)+1, insertCommand, insertLabel);
+        }
+        
+        protected static void AddDebugMenuItems(IMenuModel model){
+            if (BrowserUtils.HasDevTools){
+                AddSeparator(model);
+                model.AddItem(MenuOpenDevTools, "Open dev tools");
+            }
         }
 
         protected static void RemoveSeparatorIfLast(IMenuModel model){
@@ -132,21 +225,5 @@ namespace TweetDck.Core.Handling{
                 model.AddSeparator();
             }
         }
-
-        private static string GetImageFileName(string url){
-            // twimg adds a colon after file extension
-            int dot = url.LastIndexOf('.');
-
-            if (dot != -1){
-                int colon = url.IndexOf(':', dot);
-            
-                if (colon != -1){
-                    url = url.Substring(0, colon);
-                }
-            }
-
-            // return file name
-            return BrowserUtils.GetFileNameFromUrl(url) ?? "unknown";
-        }
     }
 }

Core/Handling/ContextMenuBrowser.cs

@@ -1,94 +1,96 @@
 using CefSharp;
 using System.Windows.Forms;
-using TweetDck.Core.Bridge;
-using TweetDck.Core.Controls;
-using TweetDck.Core.Utils;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Management;
+using TweetDuck.Core.Utils;
 
-namespace TweetDck.Core.Handling{
-    class ContextMenuBrowser : ContextMenuBase{
-        private const int MenuGlobal = 26600;
-        private const int MenuMute = 26601;
-        private const int MenuSettings = 26602;
-        private const int MenuPlugins = 26003;
-        private const int MenuAbout = 26604;
+namespace TweetDuck.Core.Handling{
+    sealed class ContextMenuBrowser : ContextMenuBase{
+        private const CefMenuCommand MenuGlobal   = (CefMenuCommand)26600;
+        private const CefMenuCommand MenuMute     = (CefMenuCommand)26601;
+        private const CefMenuCommand MenuSettings = (CefMenuCommand)26602;
+        private const CefMenuCommand MenuPlugins  = (CefMenuCommand)26003;
+        private const CefMenuCommand MenuAbout    = (CefMenuCommand)26604;
         
-        private const int MenuOpenTweetUrl = 26610;
-        private const int MenuCopyTweetUrl = 26611;
-        private const int MenuOpenQuotedTweetUrl = 26612;
-        private const int MenuCopyQuotedTweetUrl = 26613;
-        private const int MenuScreenshotTweet = 26614;
+        private const CefMenuCommand MenuOpenTweetUrl       = (CefMenuCommand)26610;
+        private const CefMenuCommand MenuCopyTweetUrl       = (CefMenuCommand)26611;
+        private const CefMenuCommand MenuOpenQuotedTweetUrl = (CefMenuCommand)26612;
+        private const CefMenuCommand MenuCopyQuotedTweetUrl = (CefMenuCommand)26613;
+        private const CefMenuCommand MenuScreenshotTweet    = (CefMenuCommand)26614;
+        private const CefMenuCommand MenuWriteApplyROT13    = (CefMenuCommand)26615;
+        private const CefMenuCommand MenuSearchInColumn     = (CefMenuCommand)26616;
 
         private const string TitleReloadBrowser = "Reload browser";
         private const string TitleMuteNotifications = "Mute notifications";
-        private const string TitleSettings = "Settings";
+        private const string TitleSettings = "Options";
         private const string TitlePlugins = "Plugins";
         private const string TitleAboutProgram = "About "+Program.BrandName;
 
         private readonly FormBrowser form;
-
-        private string lastHighlightedTweet;
-        private string lastHighlightedQuotedTweet;
-
+        
         public ContextMenuBrowser(FormBrowser form) : base(form){
             this.form = form;
         }
 
         public override void OnBeforeContextMenu(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, IMenuModel model){
+            bool isSelecting = parameters.TypeFlags.HasFlag(ContextMenuType.Selection);
+            bool isEditing = parameters.TypeFlags.HasFlag(ContextMenuType.Editable);
+
             model.Remove(CefMenuCommand.Back);
             model.Remove(CefMenuCommand.Forward);
             model.Remove(CefMenuCommand.Print);
             model.Remove(CefMenuCommand.ViewSource);
             RemoveSeparatorIfLast(model);
 
-            if (parameters.TypeFlags.HasFlag(ContextMenuType.Selection)){
-                model.AddSeparator();
-            }
-
-            base.OnBeforeContextMenu(browserControl, browser, frame, parameters, model);
-
-            lastHighlightedTweet = TweetDeckBridge.LastHighlightedTweet;
-            lastHighlightedQuotedTweet = TweetDeckBridge.LastHighlightedQuotedTweet;
-
-            if (!BrowserUtils.IsTweetDeckWebsite(frame) || browser.IsLoading){
-                lastHighlightedTweet = string.Empty;
-                lastHighlightedQuotedTweet = string.Empty;
-            }
-
-            if (!string.IsNullOrEmpty(lastHighlightedTweet) && (parameters.TypeFlags & (ContextMenuType.Editable | ContextMenuType.Selection)) == 0){
-                model.AddItem((CefMenuCommand)MenuOpenTweetUrl, "Open tweet in browser");
-                model.AddItem((CefMenuCommand)MenuCopyTweetUrl, "Copy tweet address");
-                model.AddItem((CefMenuCommand)MenuScreenshotTweet, "Screenshot tweet to clipboard");
-
-                if (!string.IsNullOrEmpty(lastHighlightedQuotedTweet)){
+            if (isSelecting){
+                if (isEditing){
                     model.AddSeparator();
-                    model.AddItem((CefMenuCommand)MenuOpenQuotedTweetUrl, "Open quoted tweet in browser");
-                    model.AddItem((CefMenuCommand)MenuCopyQuotedTweetUrl, "Copy quoted tweet address");
+                    model.AddItem(MenuWriteApplyROT13, "Apply ROT13");
                 }
 
                 model.AddSeparator();
             }
 
-            if ((parameters.TypeFlags & (ContextMenuType.Editable | ContextMenuType.Selection)) == 0){
+            base.OnBeforeContextMenu(browserControl, browser, frame, parameters, model);
+
+            if (isSelecting && !isEditing && TwitterUtils.IsTweetDeckWebsite(frame)){
+                InsertSelectionSearchItem(model, MenuSearchInColumn, "Search in a column");
+            }
+
+            if (Context.Types.HasFlag(ContextInfo.ContextType.Chirp) && !isSelecting && !isEditing){
+                model.AddItem(MenuOpenTweetUrl, "Open tweet in browser");
+                model.AddItem(MenuCopyTweetUrl, "Copy tweet address");
+                model.AddItem(MenuScreenshotTweet, "Screenshot tweet to clipboard");
+
+                if (!string.IsNullOrEmpty(Context.Chirp.QuoteUrl)){
+                    model.AddSeparator();
+                    model.AddItem(MenuOpenQuotedTweetUrl, "Open quoted tweet in browser");
+                    model.AddItem(MenuCopyQuotedTweetUrl, "Copy quoted tweet address");
+                }
+
+                model.AddSeparator();
+            }
+
+            if (!isSelecting && !isEditing){
                 AddSeparator(model);
 
-                IMenuModel globalMenu = model.Count == 0 ? model : model.AddSubMenu((CefMenuCommand)MenuGlobal, Program.BrandName);
+                IMenuModel globalMenu = model.Count == 0 ? model : model.AddSubMenu(MenuGlobal, Program.BrandName);
             
                 globalMenu.AddItem(CefMenuCommand.Reload, TitleReloadBrowser);
-                globalMenu.AddCheckItem((CefMenuCommand)MenuMute, TitleMuteNotifications);
-                globalMenu.SetChecked((CefMenuCommand)MenuMute, Program.UserConfig.MuteNotifications);
+                globalMenu.AddCheckItem(MenuMute, TitleMuteNotifications);
+                globalMenu.SetChecked(MenuMute, Config.MuteNotifications);
                 globalMenu.AddSeparator();
 
-                globalMenu.AddItem((CefMenuCommand)MenuSettings, TitleSettings);
-                globalMenu.AddItem((CefMenuCommand)MenuPlugins, TitlePlugins);
-                globalMenu.AddItem((CefMenuCommand)MenuAbout, TitleAboutProgram);
-
-                #if DEBUG
-                globalMenu.AddSeparator();
+                globalMenu.AddItem(MenuSettings, TitleSettings);
+                globalMenu.AddItem(MenuPlugins, TitlePlugins);
+                globalMenu.AddItem(MenuAbout, TitleAboutProgram);
+                
                 AddDebugMenuItems(globalMenu);
-                #endif
             }
 
             RemoveSeparatorIfLast(model);
+            
+            form.InvokeAsyncSafe(form.AnalyticsFile.BrowserContextMenus.Trigger);
         }
 
         public override bool OnContextMenuCommand(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, CefMenuCommand commandId, CefEventFlags eventFlags){
@@ -96,8 +98,8 @@ namespace TweetDck.Core.Handling{
                 return true;
             }
 
-            switch((int)commandId){
-                case (int)CefMenuCommand.Reload:
+            switch(commandId){
+                case CefMenuCommand.Reload:
                     form.InvokeAsyncSafe(form.ReloadToTweetDeck);
                     return true;
 
@@ -118,11 +120,11 @@ namespace TweetDck.Core.Handling{
                     return true;
 
                 case MenuOpenTweetUrl:
-                    BrowserUtils.OpenExternalBrowser(lastHighlightedTweet);
+                    OpenBrowser(form, Context.Chirp.TweetUrl);
                     return true;
 
                 case MenuCopyTweetUrl:
-                    SetClipboardText(lastHighlightedTweet);
+                    SetClipboardText(form, Context.Chirp.TweetUrl);
                     return true;
 
                 case MenuScreenshotTweet:
@@ -130,12 +132,22 @@ namespace TweetDck.Core.Handling{
                     return true;
 
                 case MenuOpenQuotedTweetUrl:
-                    BrowserUtils.OpenExternalBrowser(lastHighlightedQuotedTweet);
+                    OpenBrowser(form, Context.Chirp.QuoteUrl);
                     return true;
 
                 case MenuCopyQuotedTweetUrl:
-                    SetClipboardText(lastHighlightedQuotedTweet);
+                    SetClipboardText(form, Context.Chirp.QuoteUrl);
                     return true;
+
+                case MenuWriteApplyROT13:
+                    form.InvokeAsyncSafe(form.ApplyROT13);
+                    return true;
+
+                case MenuSearchInColumn:
+                    string query = parameters.SelectionText;
+                    form.InvokeAsyncSafe(() => form.AddSearchColumn(query));
+                    DeselectAll(frame);
+                    break;
             }
 
             return false;
@@ -152,15 +164,16 @@ namespace TweetDck.Core.Handling{
             menu.MenuItems.Add(TitleAboutProgram,  (sender, args) => form.OpenAbout());
 
             menu.Popup += (sender, args) => {
-                menu.MenuItems[1].Checked = Program.UserConfig.MuteNotifications;
+                menu.MenuItems[1].Checked = Config.MuteNotifications;
+                form.AnalyticsFile.BrowserContextMenus.Trigger();
             };
 
             return menu;
         }
 
         private static void ToggleMuteNotifications(){
-            Program.UserConfig.MuteNotifications = !Program.UserConfig.MuteNotifications;
-            Program.UserConfig.Save();
+            Config.MuteNotifications = !Config.MuteNotifications;
+            Config.Save();
         }
     }
 }

Core/Handling/ContextMenuGuide.cs

@@ -0,0 +1,14 @@
+using CefSharp;
+using TweetDuck.Core.Other.Analytics;
+
+namespace TweetDuck.Core.Handling{
+    sealed class ContextMenuGuide : ContextMenuBase{
+        public ContextMenuGuide(AnalyticsFile.IProvider analytics) : base(analytics){}
+
+        public override void OnBeforeContextMenu(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, IMenuModel model){
+            model.Clear();
+            base.OnBeforeContextMenu(browserControl, browser, frame, parameters, model);
+            AddDebugMenuItems(model);
+        }
+    }
+}

Core/Handling/ContextMenuNotification.cs

@@ -1,13 +1,14 @@
 using CefSharp;
-using TweetDck.Core.Controls;
-using TweetDck.Core.Notification;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Notification;
 
-namespace TweetDck.Core.Handling{
-    class ContextMenuNotification : ContextMenuBase{
-        private const int MenuSkipTweet = 26600;
-        private const int MenuFreeze = 26601;
-        private const int MenuCopyTweetUrl = 26602;
-        private const int MenuCopyQuotedTweetUrl = 26603;
+namespace TweetDuck.Core.Handling{
+    sealed class ContextMenuNotification : ContextMenuBase{
+        private const CefMenuCommand MenuViewDetail         = (CefMenuCommand)26600;
+        private const CefMenuCommand MenuSkipTweet          = (CefMenuCommand)26601;
+        private const CefMenuCommand MenuFreeze             = (CefMenuCommand)26602;
+        private const CefMenuCommand MenuCopyTweetUrl       = (CefMenuCommand)26603;
+        private const CefMenuCommand MenuCopyQuotedTweetUrl = (CefMenuCommand)26604;
 
         private readonly FormNotificationBase form;
         private readonly bool enableCustomMenu;
@@ -28,29 +29,31 @@ namespace TweetDck.Core.Handling{
             base.OnBeforeContextMenu(browserControl, browser, frame, parameters, model);
 
             if (enableCustomMenu){
-                model.AddItem((CefMenuCommand)MenuSkipTweet, "Skip tweet");
-                model.AddCheckItem((CefMenuCommand)MenuFreeze, "Freeze");
-                model.SetChecked((CefMenuCommand)MenuFreeze, form.FreezeTimer);
-                model.AddSeparator();
+                if (form.CanViewDetail){
+                    model.AddItem(MenuViewDetail, "View detail");
+                }
+
+                model.AddItem(MenuSkipTweet, "Skip tweet");
+                model.AddCheckItem(MenuFreeze, "Freeze");
+                model.SetChecked(MenuFreeze, form.FreezeTimer);
 
                 if (!string.IsNullOrEmpty(form.CurrentTweetUrl)){
-                    model.AddItem((CefMenuCommand)MenuCopyTweetUrl, "Copy tweet address");
+                    model.AddSeparator();
+                    model.AddItem(MenuCopyTweetUrl, "Copy tweet address");
 
                     if (!string.IsNullOrEmpty(form.CurrentQuoteUrl)){
-                        model.AddItem((CefMenuCommand)MenuCopyQuotedTweetUrl, "Copy quoted tweet address");
+                        model.AddItem(MenuCopyQuotedTweetUrl, "Copy quoted tweet address");
                     }
-
-                    model.AddSeparator();
                 }
             }
-
-            #if DEBUG
+            
             AddDebugMenuItems(model);
-            #endif
-
             RemoveSeparatorIfLast(model);
 
-            form.InvokeAsyncSafe(() => form.ContextMenuOpen = true);
+            form.InvokeAsyncSafe(() => {
+                form.ContextMenuOpen = true;
+                form.AnalyticsFile.NotificationContextMenus.Trigger();
+            });
         }
 
         public override bool OnContextMenuCommand(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, CefMenuCommand commandId, CefEventFlags eventFlags){
@@ -58,7 +61,7 @@ namespace TweetDck.Core.Handling{
                 return true;
             }
 
-            switch((int)commandId){
+            switch(commandId){
                 case MenuSkipTweet:
                     form.InvokeAsyncSafe(form.FinishCurrentNotification);
                     return true;
@@ -67,12 +70,16 @@ namespace TweetDck.Core.Handling{
                     form.InvokeAsyncSafe(() => form.FreezeTimer = !form.FreezeTimer);
                     return true;
 
+                case MenuViewDetail:
+                    form.InvokeSafe(form.ShowTweetDetail);
+                    return true;
+
                 case MenuCopyTweetUrl:
-                    SetClipboardText(form.CurrentTweetUrl);
+                    SetClipboardText(form, form.CurrentTweetUrl);
                     return true;
 
                 case MenuCopyQuotedTweetUrl:
-                    SetClipboardText(form.CurrentQuoteUrl);
+                    SetClipboardText(form, form.CurrentQuoteUrl);
                     return true;
             }
 

Core/Handling/DragHandlerBrowser.cs

@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using CefSharp;
+using CefSharp.Enums;
+
+namespace TweetDuck.Core.Handling{
+    sealed class DragHandlerBrowser : IDragHandler{
+        private readonly RequestHandlerBrowser requestHandler;
+
+        public DragHandlerBrowser(RequestHandlerBrowser requestHandler){
+            this.requestHandler = requestHandler;
+        }
+        
+        public bool OnDragEnter(IWebBrowser browserControl, IBrowser browser, IDragData dragData, DragOperationsMask mask){
+            void TriggerDragStart(string type, string data = null){
+                browserControl.ExecuteScriptAsync("window.TDGF_onGlobalDragStart", type, data);
+            }
+            
+            requestHandler.BlockNextUserNavUrl = dragData.LinkUrl; // empty if not a link
+
+            if (dragData.IsLink){
+                TriggerDragStart("link", dragData.LinkUrl);
+            }
+            else if (dragData.IsFragment){
+                TriggerDragStart("text", dragData.FragmentText.Trim());
+            }
+            else{
+                TriggerDragStart("unknown");
+            }
+
+            return false;
+        }
+
+        public void OnDraggableRegionsChanged(IWebBrowser browserControl, IBrowser browser, IList<DraggableRegion> regions){}
+    }
+}

Core/Handling/Filters/ResponseFilterBase.cs

@@ -0,0 +1,72 @@
+using System;
+using System.IO;
+using System.Text;
+using CefSharp;
+
+namespace TweetDuck.Core.Handling.Filters{
+    abstract class ResponseFilterBase : IResponseFilter{
+        private enum State{
+            Reading, Writing, Done
+        }
+
+        private readonly Encoding encoding;
+        private byte[] responseData;
+
+        private State state;
+        private int offset;
+
+        protected ResponseFilterBase(int totalBytes, Encoding encoding){
+            this.responseData = new byte[totalBytes];
+            this.encoding = encoding;
+            this.state = State.Reading;
+        }
+        
+        FilterStatus IResponseFilter.Filter(Stream dataIn, out long dataInRead, Stream dataOut, out long dataOutWritten){
+            int responseLength = responseData.Length;
+
+            if (state == State.Reading){
+                int bytesToRead = Math.Min(responseLength-offset, (int)Math.Min(dataIn?.Length ?? 0, int.MaxValue));
+                
+                dataIn?.Read(responseData, offset, bytesToRead);
+                offset += bytesToRead;
+                
+                dataInRead = bytesToRead;
+                dataOutWritten = 0;
+                
+                if (offset >= responseLength){
+                    responseData = encoding.GetBytes(ProcessResponse(encoding.GetString(responseData)));
+                    state = State.Writing;
+                    offset = 0;
+                }
+
+                return FilterStatus.NeedMoreData;
+            }
+            else if (state == State.Writing){
+                int bytesToWrite = Math.Min(responseLength-offset, (int)Math.Min(dataOut.Length, int.MaxValue));
+
+                if (bytesToWrite > 0){
+                    dataOut.Write(responseData, offset, bytesToWrite);
+                    offset += bytesToWrite;
+                }
+
+                dataOutWritten = bytesToWrite;
+                dataInRead = 0;
+
+                if (offset < responseLength){
+                    return FilterStatus.NeedMoreData;
+                }
+                else{
+                    state = State.Done;
+                    return FilterStatus.Done;
+                }
+            }
+            else{
+                throw new InvalidOperationException("This resource filter cannot be reused.");
+            }
+        }
+        
+        public abstract bool InitFilter();
+        protected abstract string ProcessResponse(string text);
+        public abstract void Dispose();
+    }
+}

Core/Handling/Filters/ResponseFilterVendor.cs

@@ -0,0 +1,20 @@
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace TweetDuck.Core.Handling.Filters{
+    sealed class ResponseFilterVendor : ResponseFilterBase{
+        private static readonly Regex RegexRestoreJQuery = new Regex(@"(\w+)\.fn=\1\.prototype", RegexOptions.Compiled);
+
+        public ResponseFilterVendor(int totalBytes) : base(totalBytes, Encoding.UTF8){}
+
+        public override bool InitFilter(){
+            return true;
+        }
+        
+        protected override string ProcessResponse(string text){
+            return RegexRestoreJQuery.Replace(text, "window.$$=$1;$&", 1);
+        }
+
+        public override void Dispose(){}
+    }
+}

Core/Handling/General/BrowserProcessHandler.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Threading.Tasks;
+using CefSharp;
+using TweetDuck.Configuration;
+
+namespace TweetDuck.Core.Handling.General{
+    sealed class BrowserProcessHandler : IBrowserProcessHandler{
+        public static Task UpdatePrefs(){
+            return Cef.UIThreadTaskFactory.StartNew(UpdatePrefsInternal);
+        }
+
+        private static void UpdatePrefsInternal(){
+            UserConfig config = Program.Config.User;
+
+            using(IRequestContext ctx = Cef.GetGlobalRequestContext()){
+                ctx.SetPreference("browser.enable_spellchecking", config.EnableSpellCheck, out string _);
+                ctx.SetPreference("spellcheck.dictionary", config.SpellCheckLanguage, out string _);
+                ctx.SetPreference("settings.a11y.animation_policy", config.EnableAnimatedImages ? "allowed" : "none", out string _);
+            }
+        }
+
+        void IBrowserProcessHandler.OnContextInitialized(){
+            UpdatePrefsInternal();
+        }
+
+        void IBrowserProcessHandler.OnScheduleMessagePumpWork(long delay){}
+        void IDisposable.Dispose(){}
+    }
+}

Core/Handling/General/FileDialogHandler.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Windows.Forms;
+using CefSharp;
+
+namespace TweetDuck.Core.Handling.General{
+    sealed class FileDialogHandler : IDialogHandler{
+        public bool OnFileDialog(IWebBrowser browserControl, IBrowser browser, CefFileDialogMode mode, CefFileDialogFlags flags, string title, string defaultFilePath, List<string> acceptFilters, int selectedAcceptFilter, IFileDialogCallback callback){
+            if (mode == CefFileDialogMode.Open || mode == CefFileDialogMode.OpenMultiple){
+                string allFilters = string.Join(";", acceptFilters.Select(filter => "*"+filter));
+
+                using(OpenFileDialog dialog = new OpenFileDialog{
+                    AutoUpgradeEnabled = true,
+                    DereferenceLinks = true,
+                    Multiselect = mode == CefFileDialogMode.OpenMultiple,
+                    Title = "Open Files",
+                    Filter = $"All Supported Formats ({allFilters})|{allFilters}|All Files (*.*)|*.*"
+                }){
+                    if (dialog.ShowDialog() == DialogResult.OK){
+                        string ext = Path.GetExtension(dialog.FileName);
+                        callback.Continue(acceptFilters.FindIndex(filter => filter.Equals(ext, StringComparison.OrdinalIgnoreCase)), dialog.FileNames.ToList());
+                    }
+                    else{
+                        callback.Cancel();
+                    }
+
+                    callback.Dispose();
+                }
+
+                return true;
+            }
+            else{
+                callback.Dispose();
+                return false;
+            }
+        }
+    }
+}

Core/Handling/General/JavaScriptDialogHandler.cs

@@ -0,0 +1,90 @@
+using System.Drawing;
+using System.Windows.Forms;
+using CefSharp;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Other;
+using TweetDuck.Core.Utils;
+
+namespace TweetDuck.Core.Handling.General{
+    sealed class JavaScriptDialogHandler : IJsDialogHandler{
+        private static FormMessage CreateMessageForm(string caption, string text){
+            MessageBoxIcon icon = MessageBoxIcon.None;
+            int pipe = text.IndexOf('|');
+
+            if (pipe != -1){
+                switch(text.Substring(0, pipe)){
+                    case "error": icon = MessageBoxIcon.Error; break;
+                    case "warning": icon = MessageBoxIcon.Warning; break;
+                    case "info": icon = MessageBoxIcon.Information; break;
+                    case "question": icon = MessageBoxIcon.Question; break;
+                    default: return new FormMessage(caption, text, icon);
+                }
+
+                text = text.Substring(pipe+1);
+            }
+
+            return new FormMessage(caption, text, icon);
+        }
+
+        bool IJsDialogHandler.OnJSDialog(IWebBrowser browserControl, IBrowser browser, string originUrl, CefJsDialogType dialogType, string messageText, string defaultPromptText, IJsDialogCallback callback, ref bool suppressMessage){
+            browserControl.AsControl().InvokeSafe(() => {
+                FormMessage form;
+                TextBox input = null;
+
+                if (dialogType == CefJsDialogType.Alert){
+                    form = CreateMessageForm("Browser Message", messageText);
+                    form.AddButton(FormMessage.OK, ControlType.Accept | ControlType.Focused);
+                }
+                else if (dialogType == CefJsDialogType.Confirm){
+                    form = CreateMessageForm("Browser Confirmation", messageText);
+                    form.AddButton(FormMessage.No, DialogResult.No, ControlType.Cancel);
+                    form.AddButton(FormMessage.Yes, ControlType.Focused);
+                }
+                else if (dialogType == CefJsDialogType.Prompt){
+                    form = CreateMessageForm("Browser Prompt", messageText);
+                    form.AddButton(FormMessage.Cancel, DialogResult.Cancel, ControlType.Cancel);
+                    form.AddButton(FormMessage.OK, ControlType.Accept | ControlType.Focused);
+
+                    float dpiScale = form.GetDPIScale();
+                    int inputPad = form.HasIcon ? 43 : 0;
+
+                    input = new TextBox{
+                        Anchor = AnchorStyles.Left | AnchorStyles.Right | AnchorStyles.Bottom,
+                        Font = SystemFonts.MessageBoxFont,
+                        Location = new Point(BrowserUtils.Scale(22+inputPad, dpiScale), form.ActionPanelY-BrowserUtils.Scale(46, dpiScale)),
+                        Size = new Size(form.ClientSize.Width-BrowserUtils.Scale(44+inputPad, dpiScale), BrowserUtils.Scale(23, dpiScale))
+                    };
+
+                    form.Controls.Add(input);
+                    form.ActiveControl = input;
+                    form.Height += input.Size.Height+input.Margin.Vertical;
+                }
+                else{
+                    callback.Continue(false);
+                    return;
+                }
+
+                bool success = form.ShowDialog() == DialogResult.OK;
+
+                if (input == null){
+                    callback.Continue(success);
+                }
+                else{
+                    callback.Continue(success, input.Text);
+                    input.Dispose();
+                }
+
+                form.Dispose();
+            });
+
+            return true;
+        }
+
+        bool IJsDialogHandler.OnJSBeforeUnload(IWebBrowser browserControl, IBrowser browser, string message, bool isReload, IJsDialogCallback callback){
+            return false;
+        }
+
+        void IJsDialogHandler.OnResetDialogState(IWebBrowser browserControl, IBrowser browser){}
+        void IJsDialogHandler.OnDialogClosed(IWebBrowser browserControl, IBrowser browser){}
+    }
+}

Core/Handling/General/LifeSpanHandler.cs

@@ -1,17 +1,16 @@
 using CefSharp;
-using TweetDck.Core.Utils;
-
-namespace TweetDck.Core.Handling{
-    class LifeSpanHandler : ILifeSpanHandler{
-        public bool OnBeforePopup(IWebBrowser browserControl, IBrowser browser, IFrame frame, string targetUrl, string targetFrameName, WindowOpenDisposition targetDisposition, bool userGesture, IPopupFeatures popupFeatures, IWindowInfo windowInfo, IBrowserSettings browserSettings, ref bool noJavascriptAccess, out IWebBrowser newBrowser){
-            newBrowser = null;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Utils;
 
+namespace TweetDuck.Core.Handling.General{
+    sealed class LifeSpanHandler : ILifeSpanHandler{
+        public static bool HandleLinkClick(IWebBrowser browserControl, WindowOpenDisposition targetDisposition, string targetUrl){
             switch(targetDisposition){
                 case WindowOpenDisposition.NewBackgroundTab:
                 case WindowOpenDisposition.NewForegroundTab:
                 case WindowOpenDisposition.NewPopup:
                 case WindowOpenDisposition.NewWindow:
-                    BrowserUtils.OpenExternalBrowser(targetUrl);
+                    browserControl.AsControl().InvokeAsyncSafe(() => BrowserUtils.OpenExternalBrowser(targetUrl));
                     return true;
 
                 default:
@@ -19,6 +18,11 @@ namespace TweetDck.Core.Handling{
             }
         }
 
+        public bool OnBeforePopup(IWebBrowser browserControl, IBrowser browser, IFrame frame, string targetUrl, string targetFrameName, WindowOpenDisposition targetDisposition, bool userGesture, IPopupFeatures popupFeatures, IWindowInfo windowInfo, IBrowserSettings browserSettings, ref bool noJavascriptAccess, out IWebBrowser newBrowser){
+            newBrowser = null;
+            return HandleLinkClick(browserControl, targetDisposition, targetUrl);
+        }
+
         public void OnAfterCreated(IWebBrowser browserControl, IBrowser browser){}
 
         public bool DoClose(IWebBrowser browserControl, IBrowser browser){

Core/Handling/JavaScriptDialogHandler.cs

@@ -1,60 +0,0 @@
-using CefSharp;
-using CefSharp.WinForms;
-using System.Drawing;
-using System.Windows.Forms;
-using TweetDck.Core.Controls;
-using TweetDck.Core.Other;
-
-namespace TweetDck.Core.Handling {
-    class JavaScriptDialogHandler : IJsDialogHandler{
-        bool IJsDialogHandler.OnJSDialog(IWebBrowser browserControl, IBrowser browser, string originUrl, CefJsDialogType dialogType, string messageText, string defaultPromptText, IJsDialogCallback callback, ref bool suppressMessage){
-            ((ChromiumWebBrowser)browserControl).InvokeSafe(() => {
-                FormMessage form = new FormMessage(Program.BrandName, messageText, MessageBoxIcon.None);
-                TextBox input = null;
-
-                if (dialogType == CefJsDialogType.Alert){
-                    form.AcceptButton = form.AddButton("OK");
-                }
-                else if (dialogType == CefJsDialogType.Confirm){
-                    form.CancelButton = form.AddButton("No", DialogResult.No);
-                    form.AcceptButton = form.AddButton("Yes");
-                }
-                else if (dialogType == CefJsDialogType.Prompt){
-                    form.CancelButton = form.AddButton("Cancel", DialogResult.Cancel);
-                    form.AcceptButton = form.AddButton("OK");
-
-                    input = new TextBox{
-                        Anchor = AnchorStyles.Left | AnchorStyles.Right | AnchorStyles.Bottom,
-                        Location = new Point(27, form.ActionPanelY-46),
-                        Size = new Size(form.ClientSize.Width-54, 20)
-                    };
-
-                    form.Controls.Add(input);
-                    form.ActiveControl = input;
-                    form.Height += input.Size.Height+input.Margin.Vertical;
-                }
-
-                bool success = form.ShowDialog() == DialogResult.OK;
-
-                if (input == null){
-                    callback.Continue(success);
-                }
-                else{
-                    callback.Continue(success, input.Text);
-                    input.Dispose();
-                }
-
-                form.Dispose();
-            });
-
-            return true;
-        }
-
-        bool IJsDialogHandler.OnJSBeforeUnload(IWebBrowser browserControl, IBrowser browser, string message, bool isReload, IJsDialogCallback callback){
-            return false;
-        }
-
-        void IJsDialogHandler.OnResetDialogState(IWebBrowser browserControl, IBrowser browser){}
-        void IJsDialogHandler.OnDialogClosed(IWebBrowser browserControl, IBrowser browser){}
-    }
-}

Core/Handling/KeyboardHandlerBase.cs

@@ -0,0 +1,47 @@
+using System.Windows.Forms;
+using CefSharp;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Other;
+using TweetDuck.Core.Utils;
+
+namespace TweetDuck.Core.Handling{
+    class KeyboardHandlerBase : IKeyboardHandler{
+        protected virtual bool HandleRawKey(IWebBrowser browserControl, IBrowser browser, Keys key, CefEventFlags modifiers){
+            if (modifiers == (CefEventFlags.ControlDown | CefEventFlags.ShiftDown) && key == Keys.I){
+                if (BrowserUtils.HasDevTools){
+                    browser.ShowDevTools();
+                }
+                else{
+                    browserControl.AsControl().InvokeSafe(() => {
+                        string extraMessage;
+                        
+                        if (Program.IsPortable){
+                            extraMessage = "Please download the portable installer, select the folder with your current installation of TweetDuck Portable, and tick 'Install dev tools' during the installation process.";
+                        }
+                        else{
+                            extraMessage = "Please download the installer, and tick 'Install dev tools' during the installation process. The installer will automatically find and update your current installation of TweetDuck.";
+                        }
+
+                        FormMessage.Information("Dev Tools", "You do not have dev tools installed. "+extraMessage, FormMessage.OK);
+                    });
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
+        bool IKeyboardHandler.OnPreKeyEvent(IWebBrowser browserControl, IBrowser browser, KeyType type, int windowsKeyCode, int nativeKeyCode, CefEventFlags modifiers, bool isSystemKey, ref bool isKeyboardShortcut){
+            if (type == KeyType.RawKeyDown && !browser.FocusedFrame.Url.StartsWith("chrome-devtools://")){
+                return HandleRawKey(browserControl, browser, (Keys)windowsKeyCode, modifiers);
+            }
+
+            return false;
+        }
+
+        bool IKeyboardHandler.OnKeyEvent(IWebBrowser browserControl, IBrowser browser, KeyType type, int windowsKeyCode, int nativeKeyCode, CefEventFlags modifiers, bool isSystemKey){
+            return false;
+        }
+    }
+}

Core/Handling/KeyboardHandlerBrowser.cs

@@ -0,0 +1,20 @@
+using System.Windows.Forms;
+using CefSharp;
+
+namespace TweetDuck.Core.Handling{
+    sealed class KeyboardHandlerBrowser : KeyboardHandlerBase{
+        private readonly FormBrowser form;
+
+        public KeyboardHandlerBrowser(FormBrowser form){
+            this.form = form;
+        }
+
+        protected override bool HandleRawKey(IWebBrowser browserControl, IBrowser browser, Keys key, CefEventFlags modifiers){
+            if (base.HandleRawKey(browserControl, browser, key, modifiers)){
+                return true;
+            }
+
+            return form.ProcessBrowserKey(key);
+        }
+    }
+}

Core/Handling/KeyboardHandlerNotification.cs

@@ -0,0 +1,44 @@
+using CefSharp;
+using System.Windows.Forms;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Notification;
+
+namespace TweetDuck.Core.Handling {
+    sealed class KeyboardHandlerNotification : KeyboardHandlerBase{
+        private readonly FormNotificationBase notification;
+
+        public KeyboardHandlerNotification(FormNotificationBase notification){
+            this.notification = notification;
+        }
+
+        private void TriggerKeyboardShortcutAnalytics(){
+            notification.InvokeAsyncSafe(notification.AnalyticsFile.NotificationKeyboardShortcuts.Trigger);
+        }
+
+        protected override bool HandleRawKey(IWebBrowser browserControl, IBrowser browser, Keys key, CefEventFlags modifiers){
+            if (base.HandleRawKey(browserControl, browser, key, modifiers)){
+                return true;
+            }
+
+            switch(key){
+                case Keys.Enter:
+                    notification.InvokeAsyncSafe(notification.FinishCurrentNotification);
+                    TriggerKeyboardShortcutAnalytics();
+                    return true;
+
+                case Keys.Escape:
+                    notification.InvokeAsyncSafe(notification.HideNotification);
+                    TriggerKeyboardShortcutAnalytics();
+                    return true;
+
+                case Keys.Space:
+                    notification.InvokeAsyncSafe(() => notification.FreezeTimer = !notification.FreezeTimer);
+                    TriggerKeyboardShortcutAnalytics();
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+    }
+}

Core/Handling/RequestHandlerBase.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Linq;
+using System.Text.RegularExpressions;
+using CefSharp;
+using CefSharp.Handler;
+using TweetDuck.Core.Handling.General;
+using TweetDuck.Core.Utils;
+
+namespace TweetDuck.Core.Handling{
+    class RequestHandlerBase : DefaultRequestHandler{
+        private static readonly Regex TweetDeckResourceUrl = new Regex(@"/dist/(.*?)\.(.*?)\.(css|js)$", RegexOptions.Compiled);
+        private static readonly SortedList<string, string> TweetDeckHashes = new SortedList<string, string>(4);
+
+        public static void LoadResourceRewriteRules(string rules){
+            if (string.IsNullOrEmpty(rules)){
+                return;
+            }
+
+            TweetDeckHashes.Clear();
+
+            foreach(string rule in rules.Replace(" ", "").ToLower().Split(',')){
+                string[] split = rule.Split('=');
+
+                if (split.Length == 2){
+                    string key = split[0];
+                    string hash = split[1];
+
+                    if (hash.All(chr => char.IsDigit(chr) || (chr >= 'a' && chr <= 'f'))){
+                        TweetDeckHashes.Add(key, hash);
+                    }
+                    else{
+                        throw new ArgumentException("Invalid hash characters: "+rule);
+                    }
+                }
+                else{
+                    throw new ArgumentException("A rule must have exactly one '=' character: "+rule);
+                }
+            }
+        }
+
+        private readonly bool autoReload;
+
+        public RequestHandlerBase(bool autoReload){
+            this.autoReload = autoReload;
+        }
+
+        public override bool OnOpenUrlFromTab(IWebBrowser browserControl, IBrowser browser, IFrame frame, string targetUrl, WindowOpenDisposition targetDisposition, bool userGesture){
+            return LifeSpanHandler.HandleLinkClick(browserControl, targetDisposition, targetUrl);
+        }
+
+        public override CefReturnValue OnBeforeResourceLoad(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request, IRequestCallback callback){
+            if (BrowserUtils.HasDevTools){
+                NameValueCollection headers = request.Headers;
+                headers.Remove("x-devtools-emulate-network-conditions-client-id");
+                request.Headers = headers;
+            }
+
+            return base.OnBeforeResourceLoad(browserControl, browser, frame, request, callback);
+        }
+
+        public override bool OnResourceResponse(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request, IResponse response){
+            if ((request.ResourceType == ResourceType.Script || request.ResourceType == ResourceType.Stylesheet) && TweetDeckHashes.Count > 0){
+                string url = request.Url;
+                Match match = TweetDeckResourceUrl.Match(url);
+
+                if (match.Success && TweetDeckHashes.TryGetValue($"{match.Groups[1]}.{match.Groups[3]}", out string hash)){
+                    if (match.Groups[2].Value == hash){
+                        Program.Reporter.LogVerbose("[RequestHandlerBase] Accepting " + url);
+                    }
+                    else{
+                        Program.Reporter.LogVerbose("[RequestHandlerBase] Replacing " + url + " hash with " + hash);
+                        request.Url = TweetDeckResourceUrl.Replace(url, $"/dist/$1.{hash}.$3");
+                        return true;
+                    }
+                }
+            }
+
+            return base.OnResourceResponse(browserControl, browser, frame, request, response);
+        }
+        
+        public override void OnRenderProcessTerminated(IWebBrowser browserControl, IBrowser browser, CefTerminationStatus status){
+            if (autoReload){
+                browser.Reload();
+            }
+        }
+    }
+}

Core/Handling/RequestHandlerBrowser.cs

@@ -0,0 +1,65 @@
+using System.Collections.Specialized;
+using CefSharp;
+using TweetDuck.Core.Handling.Filters;
+using TweetDuck.Core.Utils;
+
+namespace TweetDuck.Core.Handling{
+    sealed class RequestHandlerBrowser : RequestHandlerBase{
+        private const string UrlVendorResource = "/dist/vendor";
+        private const string UrlLoadingSpinner = "/backgrounds/spinner_blue";
+
+        public string BlockNextUserNavUrl { get; set; }
+
+        public RequestHandlerBrowser() : base(true){}
+
+        public override CefReturnValue OnBeforeResourceLoad(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request, IRequestCallback callback){
+            if (request.ResourceType == ResourceType.MainFrame){
+                if (request.Url.EndsWith("//twitter.com/")){
+                    request.Url = TwitterUtils.TweetDeckURL; // redirect plain twitter.com requests, fixes bugs with login 2FA
+                }
+            }
+            else if (request.ResourceType == ResourceType.Script){
+                string url = request.Url;
+
+                if (url.Contains("analytics.")){
+                    callback.Dispose();
+                    return CefReturnValue.Cancel;
+                }
+                else if (url.Contains(UrlVendorResource)){
+                    NameValueCollection headers = request.Headers;
+                    headers["Accept-Encoding"] = "identity";
+                    request.Headers = headers;
+                }
+            }
+
+            return base.OnBeforeResourceLoad(browserControl, browser, frame, request, callback);
+        }
+
+        public override bool OnBeforeBrowse(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request, bool userGesture, bool isRedirect){
+            if (userGesture && request.TransitionType == TransitionType.LinkClicked){
+                bool block = request.Url == BlockNextUserNavUrl;
+                BlockNextUserNavUrl = string.Empty;
+                return block;
+            }
+
+            return base.OnBeforeBrowse(browserControl, browser, frame, request, userGesture, isRedirect);
+        }
+
+        public override bool OnResourceResponse(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request, IResponse response){
+            if (request.ResourceType == ResourceType.Image && request.Url.Contains(UrlLoadingSpinner)){
+                request.Url = TwitterUtils.LoadingSpinner.Url;
+                return true;
+            }
+
+            return base.OnResourceResponse(browserControl, browser, frame, request, response);
+        }
+
+        public override IResponseFilter GetResourceResponseFilter(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request, IResponse response){
+            if (request.ResourceType == ResourceType.Script && request.Url.Contains(UrlVendorResource) && int.TryParse(response.ResponseHeaders["Content-Length"], out int totalBytes)){
+                return new ResponseFilterVendor(totalBytes);
+            }
+
+            return base.GetResourceResponseFilter(browserControl, browser, frame, request, response);
+        }
+    }
+}

Core/Handling/ResourceHandlerFactory.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Concurrent;
+using CefSharp;
+using TweetDuck.Data;
+
+namespace TweetDuck.Core.Handling{
+    sealed class ResourceHandlerFactory : IResourceHandlerFactory{
+        public bool HasHandlers => !handlers.IsEmpty;
+
+        private readonly ConcurrentDictionary<string, IResourceHandler> handlers = new ConcurrentDictionary<string, IResourceHandler>(StringComparer.OrdinalIgnoreCase);
+
+        public IResourceHandler GetResourceHandler(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request){
+            try{
+                return handlers.TryGetValue(request.Url, out IResourceHandler handler) ? handler : null;
+            }finally{
+                request.Dispose();
+            }
+        }
+
+        // registration
+
+        public bool RegisterHandler(string url, IResourceHandler handler){
+            if (Uri.TryCreate(url, UriKind.Absolute, out Uri uri)){
+                handlers.AddOrUpdate(uri.AbsoluteUri, handler, (key, prev) => handler);
+                return true;
+            }
+
+            return false;
+        }
+
+        public bool RegisterHandler(ResourceLink link){
+            return RegisterHandler(link.Url, link.Handler);
+        }
+
+        public bool UnregisterHandler(string url){
+            return handlers.TryRemove(url, out IResourceHandler _);
+        }
+
+        public bool UnregisterHandler(ResourceLink link){
+            return UnregisterHandler(link.Url);
+        }
+    }
+}

Core/Handling/ResourceHandlerNotification.cs

@@ -3,8 +3,8 @@ using System.Collections.Specialized;
 using System.IO;
 using System.Text;
 
-namespace TweetDck.Core.Handling{
-    class ResourceHandlerNotification : IResourceHandler{
+namespace TweetDuck.Core.Handling{
+    sealed class ResourceHandlerNotification : IResourceHandler{
         private readonly NameValueCollection headers = new NameValueCollection(0);
         private MemoryStream dataIn;
 

Core/Management/BrowserCache.cs

@@ -0,0 +1,76 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace TweetDuck.Core.Management{
+    static class BrowserCache{
+        public static string CacheFolder => Path.Combine(Program.StoragePath, "Cache");
+        
+        private static bool ClearOnExit;
+        private static Timer AutoClearTimer;
+
+        private static long CalculateCacheSize(){
+            return new DirectoryInfo(CacheFolder).EnumerateFiles().Select(file => {
+                try{
+                    return file.Length;
+                }catch{
+                    return 0L;
+                }
+            }).Sum();
+        }
+
+        public static void GetCacheSize(Action<Task<long>> callbackBytes){
+            Task<long> task = new Task<long>(CalculateCacheSize);
+            task.ContinueWith(callbackBytes);
+            task.Start();
+        }
+        
+        public static void RefreshTimer(){
+            bool shouldRun = Program.Config.System.ClearCacheAutomatically && !ClearOnExit;
+
+            if (!shouldRun && AutoClearTimer != null){
+                AutoClearTimer.Dispose();
+                AutoClearTimer = null;
+            }
+            else if (shouldRun && AutoClearTimer == null){
+                AutoClearTimer = new Timer(state => {
+                    if (AutoClearTimer != null){
+                        try{
+                            if (CalculateCacheSize() >= Program.Config.System.ClearCacheThreshold*1024L*1024L){
+                                SetClearOnExit();
+                            }
+                        }catch(Exception){
+                            // TODO should probably log errors and report them at some point
+                        }
+                    }
+                }, null, TimeSpan.FromSeconds(30), TimeSpan.FromHours(4));
+            }
+        }
+
+        public static void SetClearOnExit(){
+            ClearOnExit = true;
+            RefreshTimer();
+        }
+
+        public static void TryClearNow(){
+            try{
+                Directory.Delete(CacheFolder, true);
+            }catch{
+                // welp, too bad
+            }
+        }
+
+        public static void Exit(){
+            if (AutoClearTimer != null){
+                AutoClearTimer.Dispose();
+                AutoClearTimer = null;
+            }
+
+            if (ClearOnExit){
+                TryClearNow();
+            }
+        }
+    }
+}

Core/Management/ContextInfo.cs

@@ -0,0 +1,161 @@
+using System;
+using CefSharp;
+using TweetDuck.Core.Utils;
+
+namespace TweetDuck.Core.Management{
+    sealed class ContextInfo{
+        private LinkInfo link;
+        private ChirpInfo? chirp;
+        
+        public ContextInfo(){
+            Reset();
+        }
+        
+        public void SetLink(string type, string url){
+            link = string.IsNullOrEmpty(url) ? null : new LinkInfo(type, url);
+        }
+
+        public void SetChirp(string tweetUrl, string quoteUrl, string chirpAuthors, string chirpImages){
+            chirp = string.IsNullOrEmpty(tweetUrl) ? (ChirpInfo?)null : new ChirpInfo(tweetUrl, quoteUrl, chirpAuthors, chirpImages);
+        }
+
+        public ContextData Reset(){
+            link = null;
+            chirp = null;
+            return ContextData.Empty;
+        }
+
+        public ContextData Create(IContextMenuParams parameters){
+            ContextData.Builder builder = new ContextData.Builder();
+            builder.AddContext(parameters);
+
+            if (link != null){
+                builder.AddOverride(link.Type, link.Url);
+            }
+            
+            if (chirp.HasValue){
+                builder.AddChirp(chirp.Value);
+            }
+
+            return builder.Build();
+        }
+
+        // Data structures
+
+        private sealed class LinkInfo{
+            public string Type { get; }
+            public string Url { get; }
+
+            public LinkInfo(string type, string url){
+                this.Type = type;
+                this.Url = url;
+            }
+        }
+
+        public struct ChirpInfo{
+            public string TweetUrl { get; }
+            public string QuoteUrl { get; }
+
+            public string[] Authors => chirpAuthors?.Split(';') ?? StringUtils.EmptyArray;
+            public string[] Images => chirpImages?.Split(';') ?? StringUtils.EmptyArray;
+            
+            private readonly string chirpAuthors;
+            private readonly string chirpImages;
+
+            public ChirpInfo(string tweetUrl, string quoteUrl, string chirpAuthors, string chirpImages){
+                this.TweetUrl = tweetUrl;
+                this.QuoteUrl = quoteUrl;
+                this.chirpAuthors = chirpAuthors;
+                this.chirpImages = chirpImages;
+            }
+        }
+
+        // Constructed context
+
+        [Flags]
+        public enum ContextType{
+            Unknown = 0,
+            Link    = 0b0001,
+            Image   = 0b0010,
+            Video   = 0b0100,
+            Chirp   = 0b1000
+        }
+
+        public sealed class ContextData{
+            public static readonly ContextData Empty = new Builder().Build();
+
+            public ContextType Types { get; }
+
+            public string LinkUrl { get; }
+            public string UnsafeLinkUrl { get; }
+            public string MediaUrl { get; }
+
+            public ChirpInfo Chirp { get; }
+
+            public ContextData(ContextType types, string linkUrl, string unsafeLinkUrl, string mediaUrl, ChirpInfo chirp){
+                Types = types;
+                LinkUrl = linkUrl;
+                UnsafeLinkUrl = unsafeLinkUrl;
+                MediaUrl = mediaUrl;
+                Chirp = chirp;
+            }
+
+            public sealed class Builder{
+                private ContextType types = ContextType.Unknown;
+
+                private string linkUrl = string.Empty;
+                private string unsafeLinkUrl = string.Empty;
+                private string mediaUrl = string.Empty;
+
+                private ChirpInfo chirp = default(ChirpInfo);
+
+                public void AddContext(IContextMenuParams parameters){
+                    ContextMenuType flags = parameters.TypeFlags;
+
+                    if (flags.HasFlag(ContextMenuType.Media) && parameters.HasImageContents){
+                        types |= ContextType.Image;
+                        types &= ~ContextType.Video;
+                        mediaUrl = parameters.SourceUrl;
+                    }
+
+                    if (flags.HasFlag(ContextMenuType.Link)){
+                        types |= ContextType.Link;
+                        linkUrl = parameters.LinkUrl;
+                        unsafeLinkUrl = parameters.UnfilteredLinkUrl;
+                    }
+                }
+
+                public void AddOverride(string type, string url){
+                    switch(type){
+                        case "link":
+                            types |= ContextType.Link;
+                            linkUrl = url;
+                            unsafeLinkUrl = url;
+                            break;
+
+                        case "image":
+                            types |= ContextType.Image;
+                            types &= ~(ContextType.Video | ContextType.Link);
+                            mediaUrl = url;
+                            break;
+
+                        case "video":
+                            types |= ContextType.Video;
+                            types &= ~(ContextType.Image | ContextType.Link);
+                            mediaUrl = url;
+                            break;
+                    }
+                }
+
+                public void AddChirp(ChirpInfo chirp){
+                    this.types |= ContextType.Chirp;
+                    this.chirp = chirp;
+                }
+
+                public ContextData Build(){
+                    return new ContextData(types, linkUrl, unsafeLinkUrl, mediaUrl, chirp);
+                }
+            }
+        }
+    }
+}

Core/Management/ProfileManager.cs

@@ -2,35 +2,46 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Windows.Forms;
-using TweetDck.Configuration;
-using TweetDck.Plugins;
-using TweetDck.Plugins.Enums;
+using TweetDuck.Core.Other;
+using TweetDuck.Data;
+using TweetDuck.Plugins;
+using TweetDuck.Plugins.Enums;
 
-namespace TweetDck.Core.Other.Settings.Export{
-    sealed class ExportManager{
+namespace TweetDuck.Core.Management{
+    sealed class ProfileManager{
         private static readonly string CookiesPath = Path.Combine(Program.StoragePath, "Cookies");
         private static readonly string TempCookiesPath = Path.Combine(Program.StoragePath, "CookiesTmp");
 
-        public bool IsRestarting { get; private set; }
-        public Exception LastException { get; private set; }
-
+        [Flags]
+        public enum Items{
+            None = 0,
+            UserConfig = 1,
+            SystemConfig = 2,
+            Session = 4,
+            PluginData = 8,
+            All = UserConfig|SystemConfig|Session|PluginData
+        }
+        
         private readonly string file;
         private readonly PluginManager plugins;
 
-        public ExportManager(string file, PluginManager plugins){
+        public ProfileManager(string file, PluginManager plugins){
             this.file = file;
             this.plugins = plugins;
         }
 
-        public bool Export(ExportFileFlags flags){
+        public bool Export(Items items){
             try{
                 using(CombinedFileStream stream = new CombinedFileStream(new FileStream(file, FileMode.Create, FileAccess.Write, FileShare.None))){
-                    if (flags.HasFlag(ExportFileFlags.Config)){
-                        stream.WriteFile("config", Program.ConfigFilePath);
+                    if (items.HasFlag(Items.UserConfig)){
+                        stream.WriteFile("config", Program.UserConfigFilePath);
                     }
 
-                    if (flags.HasFlag(ExportFileFlags.PluginData)){
+                    if (items.HasFlag(Items.SystemConfig)){
+                        stream.WriteFile("system", Program.SystemConfigFilePath);
+                    }
+
+                    if (items.HasFlag(Items.PluginData)){
                         stream.WriteFile("plugin.config", Program.PluginConfigFilePath);
 
                         foreach(Plugin plugin in plugins.Plugins){
@@ -38,13 +49,13 @@ namespace TweetDck.Core.Other.Settings.Export{
                                 try{
                                     stream.WriteFile(new string[]{ "plugin.data", plugin.Identifier, path.Relative }, path.Full);
                                 }catch(ArgumentOutOfRangeException e){
-                                    MessageBox.Show("Could not include a plugin file in the export. "+e.Message, "Export Profile", MessageBoxButtons.OK, MessageBoxIcon.Warning);
+                                    FormMessage.Warning("Export Profile", "Could not include a plugin file in the export. "+e.Message, FormMessage.OK);
                                 }
                             }
                         }
                     }
 
-                    if (flags.HasFlag(ExportFileFlags.Session)){
+                    if (items.HasFlag(Items.Session)){
                         stream.WriteFile("cookies", CookiesPath);
                     }
 
@@ -53,13 +64,13 @@ namespace TweetDck.Core.Other.Settings.Export{
 
                 return true;
             }catch(Exception e){
-                LastException = e;
+                Program.Reporter.HandleException("Profile Export Error", "An exception happened while exporting TweetDuck profile.", true, e);
                 return false;
             }
         }
 
-        public ExportFileFlags GetImportFlags(){
-            ExportFileFlags flags = ExportFileFlags.None;
+        public Items FindImportItems(){
+            Items items = Items.None;
 
             try{
                 using(CombinedFileStream stream = new CombinedFileStream(new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.None))){
@@ -68,29 +79,32 @@ namespace TweetDck.Core.Other.Settings.Export{
                     while((key = stream.SkipFile()) != null){
                         switch(key){
                             case "config":
-                                flags |= ExportFileFlags.Config;
+                                items |= Items.UserConfig;
+                                break;
+
+                            case "system":
+                                items |= Items.SystemConfig;
                                 break;
 
                             case "plugin.config":
                             case "plugin.data":
-                                flags |= ExportFileFlags.PluginData;
+                                items |= Items.PluginData;
                                 break;
 
                             case "cookies":
-                                flags |= ExportFileFlags.Session;
+                                items |= Items.Session;
                                 break;
                         }
                     }
                 }
-            }catch(Exception e){
-                LastException = e;
-                flags = ExportFileFlags.None;
+            }catch(Exception){
+                items = Items.None;
             }
 
-            return flags;
+            return items;
         }
 
-        public bool Import(ExportFileFlags flags){
+        public bool Import(Items items){
             try{
                 HashSet<string> missingPlugins = new HashSet<string>();
 
@@ -100,21 +114,28 @@ namespace TweetDck.Core.Other.Settings.Export{
                     while((entry = stream.ReadFile()) != null){
                         switch(entry.KeyName){
                             case "config":
-                                if (flags.HasFlag(ExportFileFlags.Config)){
-                                    entry.WriteToFile(Program.ConfigFilePath);
+                                if (items.HasFlag(Items.UserConfig)){
+                                    entry.WriteToFile(Program.UserConfigFilePath);
+                                }
+
+                                break;
+
+                            case "system":
+                                if (items.HasFlag(Items.SystemConfig)){
+                                    entry.WriteToFile(Program.SystemConfigFilePath);
                                 }
 
                                 break;
 
                             case "plugin.config":
-                                if (flags.HasFlag(ExportFileFlags.PluginData)){
+                                if (items.HasFlag(Items.PluginData)){
                                     entry.WriteToFile(Program.PluginConfigFilePath);
                                 }
 
                                 break;
 
                             case "plugin.data":
-                                if (flags.HasFlag(ExportFileFlags.PluginData)){
+                                if (items.HasFlag(Items.PluginData)){
                                     string[] value = entry.KeyValue;
 
                                     entry.WriteToFile(Path.Combine(Program.PluginDataPath, value[0], value[1]), true);
@@ -127,9 +148,8 @@ namespace TweetDck.Core.Other.Settings.Export{
                                 break;
 
                             case "cookies":
-                                if (flags.HasFlag(ExportFileFlags.Session)){
+                                if (items.HasFlag(Items.Session)){
                                     entry.WriteToFile(Path.Combine(Program.StoragePath, TempCookiesPath));
-                                    IsRestarting = true;
                                 }
 
                                 break;
@@ -138,19 +158,12 @@ namespace TweetDck.Core.Other.Settings.Export{
                 }
 
                 if (missingPlugins.Count > 0){
-                    MessageBox.Show("Detected missing plugins when importing plugin data:"+Environment.NewLine+string.Join(Environment.NewLine, missingPlugins), "Importing "+Program.BrandName+" Profile", MessageBoxButtons.OK, MessageBoxIcon.Information);
-                }
-
-                if (IsRestarting){
-                    Program.Restart(new string[]{ Arguments.ArgImportCookies });
-                }
-                else{
-                    Program.ReloadConfig();
+                    FormMessage.Information("Profile Import", "Detected missing plugins when importing plugin data:\n"+string.Join("\n", missingPlugins), FormMessage.OK);
                 }
 
                 return true;
             }catch(Exception e){
-                LastException = e;
+                Program.Reporter.HandleException("Profile Import", "An exception happened while importing TweetDuck profile.", true, e);
                 return false;
             }
         }
@@ -169,16 +182,34 @@ namespace TweetDck.Core.Other.Settings.Export{
             }
         }
 
-        private static IEnumerable<PathInfo> EnumerateFilesRelative(string root){
-            return Directory.Exists(root) ? Directory.EnumerateFiles(root, "*.*", SearchOption.AllDirectories).Select(fullPath => new PathInfo{
-                Full = fullPath,
-                Relative = fullPath.Substring(root.Length).TrimStart(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar) // strip leading separator character
-            }) : Enumerable.Empty<PathInfo>();
+        public static void DeleteCookies(){
+            try{
+                if (File.Exists(CookiesPath)){
+                    File.Delete(CookiesPath);
+                }
+            }catch(Exception e){
+                Program.Reporter.HandleException("Session Reset Error", "Could not remove the cookie file to reset the login session.", true, e);
+            }
         }
 
-        private class PathInfo{
-            public string Full { get; set; }
-            public string Relative { get; set; }
+        private static IEnumerable<PathInfo> EnumerateFilesRelative(string root){
+            if (Directory.Exists(root)){
+                int rootLength = root.Length;
+                return Directory.EnumerateFiles(root, "*.*", SearchOption.AllDirectories).Select(fullPath => new PathInfo(fullPath, rootLength));
+            }
+            else{
+                return Enumerable.Empty<PathInfo>();
+            }
+        }
+
+        private sealed class PathInfo{
+            public string Full { get; }
+            public string Relative { get; }
+
+            public PathInfo(string fullPath, int rootLength){
+                this.Full = fullPath;
+                this.Relative = fullPath.Substring(rootLength).TrimStart(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar); // strip leading separator character
+            }
         }
     }
 }

Core/Management/VideoPlayer.cs

@@ -0,0 +1,213 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Windows.Forms;
+using TweetDuck.Configuration;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Other;
+using TweetDuck.Core.Utils;
+using TweetLib.Communication;
+
+namespace TweetDuck.Core.Management{
+    sealed class VideoPlayer : IDisposable{
+        private static UserConfig Config => Program.Config.User;
+
+        public bool Running => currentInstance != null && currentInstance.Running;
+
+        public event EventHandler ProcessExited;
+
+        private readonly FormBrowser owner;
+
+        private Instance currentInstance;
+        private bool isClosing;
+
+        public VideoPlayer(FormBrowser owner){
+            this.owner = owner;
+            this.owner.FormClosing += owner_FormClosing;
+        }
+
+        public void Launch(string url, string username){
+            if (Running){
+                Destroy();
+                isClosing = false;
+            }
+            
+            try{
+                DuplexPipe.Server pipe = DuplexPipe.CreateServer();
+                pipe.DataIn += pipe_DataIn;
+
+                Process process;
+
+                if ((process = Process.Start(new ProcessStartInfo{
+                    FileName = Path.Combine(Program.ProgramPath, "TweetDuck.Video.exe"),
+                    Arguments = $"{owner.Handle} {(int)Math.Floor(100F*owner.GetDPIScale())} {Config.VideoPlayerVolume} \"{url}\" \"{pipe.GenerateToken()}\"",
+                    UseShellExecute = false,
+                    RedirectStandardOutput = true
+                })) != null){
+                    currentInstance = new Instance(process, pipe, url, username);
+
+                    process.EnableRaisingEvents = true;
+                    process.Exited += process_Exited;
+                    
+                    process.BeginOutputReadLine();
+                    process.OutputDataReceived += process_OutputDataReceived;
+
+                    pipe.DisposeToken();
+                }
+                else{
+                    pipe.DataIn -= pipe_DataIn;
+                    pipe.Dispose();
+                }
+            }catch(Exception e){
+                Program.Reporter.HandleException("Video Playback Error", "Error launching video player.", true, e);
+            }
+        }
+
+        public void SendKeyEvent(Keys key){
+            currentInstance?.Pipe.Write("key", ((int)key).ToString());
+        }
+
+        private void pipe_DataIn(object sender, DuplexPipe.PipeReadEventArgs e){
+            owner.InvokeSafe(() => {
+                switch(e.Key){
+                    case "vol":
+                        if (int.TryParse(e.Data, out int volume) && volume != Config.VideoPlayerVolume){
+                            Config.VideoPlayerVolume = volume;
+                            Config.Save();
+                        }
+
+                        break;
+
+                    case "download":
+                        if (currentInstance != null){
+                            owner.AnalyticsFile.DownloadedVideos.Trigger();
+                            TwitterUtils.DownloadVideo(currentInstance.Url, currentInstance.Username);
+                        }
+
+                        break;
+
+                    case "rip":
+                        currentInstance?.Dispose();
+                        currentInstance = null;
+
+                        isClosing = false;
+                        TriggerProcessExitEventUnsafe();
+                        break;
+                }
+            });
+        }
+
+        public void Close(){
+            if (currentInstance != null){
+                if (isClosing){
+                    Destroy();
+                    isClosing = false;
+                }
+                else{
+                    isClosing = true;
+                    currentInstance.Process.Exited -= process_Exited;
+                    currentInstance.Pipe.Write("die");
+                }
+            }
+        }
+
+        public void Dispose(){
+            ProcessExited = null;
+
+            isClosing = true;
+            Destroy();
+        }
+
+        private void Destroy(){
+            if (currentInstance != null){
+                currentInstance.KillAndDispose();
+                currentInstance = null;
+
+                TriggerProcessExitEventUnsafe();
+            }
+        }
+
+        private void owner_FormClosing(object sender, FormClosingEventArgs e){
+            if (currentInstance != null){
+                currentInstance.Process.Exited -= process_Exited;
+            }
+        }
+
+        private void process_OutputDataReceived(object sender, DataReceivedEventArgs e){
+            if (!string.IsNullOrEmpty(e.Data)){
+                Program.Reporter.LogVerbose("[VideoPlayer] "+e.Data);
+            }
+        }
+
+        private void process_Exited(object sender, EventArgs e){
+            if (currentInstance == null){
+                return;
+            }
+
+            int exitCode = currentInstance.Process.ExitCode;
+            string url = currentInstance.Url;
+
+            currentInstance.Dispose();
+            currentInstance = null;
+
+            switch(exitCode){
+                case 3: // CODE_LAUNCH_FAIL
+                    if (FormMessage.Error("Video Playback Error", "Error launching video player, this may be caused by missing Windows Media Player. Do you want to open the video in your browser?", FormMessage.Yes, FormMessage.No)){
+                        BrowserUtils.OpenExternalBrowser(url);
+                    }
+
+                    break;
+
+                case 4: // CODE_MEDIA_ERROR
+                    if (FormMessage.Error("Video Playback Error", "The video could not be loaded, most likely due to unknown format. Do you want to open the video in your browser?", FormMessage.Yes, FormMessage.No)){
+                        BrowserUtils.OpenExternalBrowser(url);
+                    }
+
+                    break;
+            }
+            
+            owner.InvokeAsyncSafe(TriggerProcessExitEventUnsafe);
+        }
+
+        private void TriggerProcessExitEventUnsafe(){
+            ProcessExited?.Invoke(this, EventArgs.Empty);
+        }
+
+        private sealed class Instance : IDisposable{
+            public bool Running{
+                get{
+                    Process.Refresh();
+                    return !Process.HasExited;
+                }
+            }
+
+            public Process Process { get; }
+            public DuplexPipe.Server Pipe { get; }
+
+            public string Url { get; }
+            public string Username { get; }
+
+            public Instance(Process process, DuplexPipe.Server pipe, string url, string username){
+                this.Process = process;
+                this.Pipe = pipe;
+                this.Url = url;
+                this.Username = username;
+            }
+
+            public void KillAndDispose(){
+                try{
+                    Process.Kill();
+                }catch{
+                    // kill me instead then
+                }
+
+                Dispose();
+            }
+
+            public void Dispose(){
+                Process.Dispose();
+                Pipe.Dispose();
+            }
+        }
+    }
+}

Core/Notification/Example/FormNotificationExample.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Windows.Forms;
+using CefSharp;
+using TweetDuck.Core.Controls;
+using TweetDuck.Plugins;
+using TweetDuck.Resources;
+
+namespace TweetDuck.Core.Notification.Example{
+    sealed class FormNotificationExample : FormNotificationMain{
+        public override bool RequiresResize => true;
+        protected override bool CanDragWindow => Config.NotificationPosition == TweetNotification.Position.Custom;
+
+        protected override FormBorderStyle NotificationBorderStyle{
+            get{
+                if (Config.NotificationSize == TweetNotification.Size.Custom){
+                    switch(base.NotificationBorderStyle){
+                        case FormBorderStyle.FixedSingle: return FormBorderStyle.Sizable;
+                        case FormBorderStyle.FixedToolWindow: return FormBorderStyle.SizableToolWindow;
+                    }
+                }
+
+                return base.NotificationBorderStyle;
+            }
+        }
+
+        protected override string BodyClasses => base.BodyClasses+" td-example";
+
+        public event EventHandler Ready;
+
+        private readonly TweetNotification exampleNotification;
+
+        public FormNotificationExample(FormBrowser owner, PluginManager pluginManager) : base(owner, pluginManager, false){
+            browser.LoadingStateChanged += browser_LoadingStateChanged;
+
+            string exampleTweetHTML = ScriptLoader.LoadResourceSilent("pages/example.html")?.Replace("{avatar}", TweetNotification.AppLogo.Url) ?? string.Empty;
+
+            #if DEBUG
+            exampleTweetHTML = exampleTweetHTML.Replace("</p>", @"</p><div style='margin-top:256px'>Scrollbar test padding...</div>");
+            #endif
+
+            exampleNotification = new TweetNotification(string.Empty, string.Empty, "Home", exampleTweetHTML, 176, string.Empty, string.Empty);
+        }
+
+        private void browser_LoadingStateChanged(object sender, LoadingStateChangedEventArgs e){
+            if (!e.IsLoading){
+                Ready?.Invoke(this, EventArgs.Empty);
+                browser.LoadingStateChanged -= browser_LoadingStateChanged;
+            }
+        }
+
+        public override void HideNotification(){
+            Location = ControlExtensions.InvisibleLocation;
+        }
+
+        public override void FinishCurrentNotification(){}
+
+        public void ShowExampleNotification(bool reset){
+            if (reset){
+                LoadTweet(exampleNotification);
+            }
+            else{
+                PrepareAndDisplayWindow();
+            }
+
+            UpdateTitle();
+        }
+    }
+}

Core/Notification/FormNotificationBase.Designer.cs

@@ -1,4 +1,4 @@
-namespace TweetDck.Core.Notification {
+namespace TweetDuck.Core.Notification {
     partial class FormNotificationBase {
         /// <summary>
         /// Required designer variable.
@@ -34,7 +34,7 @@
             this.BackColor = System.Drawing.SystemColors.Control;
             this.ClientSize = new System.Drawing.Size(284, 122);
             this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow;
-            this.Location = TweetDck.Core.Controls.ControlExtensions.InvisibleLocation;
+            this.Location = TweetDuck.Core.Controls.ControlExtensions.InvisibleLocation;
             this.MaximizeBox = false;
             this.MinimizeBox = false;
             this.Name = "FormNotification";

Core/Notification/FormNotificationBase.cs

@@ -1,30 +1,44 @@
-using CefSharp;
-using CefSharp.WinForms;
-using System;
+using CefSharp.WinForms;
 using System.Drawing;
 using System.Windows.Forms;
-using TweetDck.Configuration;
-using TweetDck.Core.Controls;
-using TweetDck.Core.Handling;
-using TweetDck.Core.Utils;
+using TweetDuck.Configuration;
+using TweetDuck.Core.Bridge;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Handling;
+using TweetDuck.Core.Handling.General;
+using TweetDuck.Core.Other.Analytics;
+using TweetDuck.Core.Utils;
 
-namespace TweetDck.Core.Notification{
-    partial class FormNotificationBase : Form{
-        protected Point PrimaryLocation{
+namespace TweetDuck.Core.Notification{
+    abstract partial class FormNotificationBase : Form, AnalyticsFile.IProvider{
+        protected static UserConfig Config => Program.Config.User;
+
+        protected static int FontSizeLevel{
+            get{
+                switch(TweetDeckBridge.FontSize){
+                    case "largest": return 4;
+                    case "large": return 3;
+                    case "small": return 1;
+                    case "smallest": return 0;
+                    default: return 2;
+                }
+            }
+        }
+
+        protected virtual Point PrimaryLocation{
             get{
-                UserConfig config = Program.UserConfig;
                 Screen screen;
 
-                if (config.NotificationDisplay > 0 && config.NotificationDisplay <= Screen.AllScreens.Length){
-                    screen = Screen.AllScreens[config.NotificationDisplay-1];
+                if (Config.NotificationDisplay > 0 && Config.NotificationDisplay <= Screen.AllScreens.Length){
+                    screen = Screen.AllScreens[Config.NotificationDisplay-1];
                 }
                 else{
                     screen = Screen.FromControl(owner);
                 }
             
-                int edgeDist = config.NotificationEdgeDistance;
+                int edgeDist = Config.NotificationEdgeDistance;
 
-                switch(config.NotificationPosition){
+                switch(Config.NotificationPosition){
                     case TweetNotification.Position.TopLeft:
                         return new Point(screen.WorkingArea.X+edgeDist, screen.WorkingArea.Y+edgeDist);
 
@@ -38,66 +52,90 @@ namespace TweetDck.Core.Notification{
                         return new Point(screen.WorkingArea.X+screen.WorkingArea.Width-edgeDist-Width, screen.WorkingArea.Y+screen.WorkingArea.Height-edgeDist-Height);
 
                     case TweetNotification.Position.Custom:
-                        if (!config.IsCustomNotificationPositionSet){
-                            config.CustomNotificationPosition = new Point(screen.WorkingArea.X+screen.WorkingArea.Width-edgeDist-Width, screen.WorkingArea.Y+edgeDist);
-                            config.Save();
+                        if (!Config.IsCustomNotificationPositionSet){
+                            Config.CustomNotificationPosition = new Point(screen.WorkingArea.X+screen.WorkingArea.Width-edgeDist-Width, screen.WorkingArea.Y+edgeDist);
+                            Config.Save();
                         }
 
-                        return config.CustomNotificationPosition;
+                        return Config.CustomNotificationPosition;
                 }
 
                 return Location;
             }
         }
 
-        public bool IsNotificationVisible => Location != ControlExtensions.InvisibleLocation;
+        protected bool IsNotificationVisible => Location != ControlExtensions.InvisibleLocation;
+        protected virtual bool CanDragWindow => true;
 
         public new Point Location{
-            get => base.Location;
-            set => Visible = (base.Location = value) != ControlExtensions.InvisibleLocation;
+            get{
+                return base.Location;
+            }
+
+            set{
+                Visible = (base.Location = value) != ControlExtensions.InvisibleLocation;
+                FormBorderStyle = NotificationBorderStyle;
+            }
         }
+
+        protected virtual FormBorderStyle NotificationBorderStyle{
+            get{
+                if (WindowsUtils.ShouldAvoidToolWindow && Visible){ // Visible = workaround for alt+tab
+                    return FormBorderStyle.FixedSingle;
+                }
+                else{
+                    return FormBorderStyle.FixedToolWindow;
+                }
+            }
+        }
+
+        public AnalyticsFile AnalyticsFile => owner.AnalyticsFile;
         
-        public Func<bool> CanMoveWindow = () => true;
         protected override bool ShowWithoutActivation => true;
+        
+        protected float DpiScale { get; }
+        protected double SizeScale => DpiScale*Config.ZoomLevel/100.0;
 
-        protected readonly Form owner;
+        protected readonly FormBrowser owner;
         protected readonly ChromiumWebBrowser browser;
-
+        
         private readonly ResourceHandlerNotification resourceHandler = new ResourceHandlerNotification();
 
-        private string currentColumn;
+        private TweetNotification currentNotification;
         private int pauseCounter;
+        
+        public string CurrentTweetUrl => currentNotification?.TweetUrl;
+        public string CurrentQuoteUrl => currentNotification?.QuoteUrl;
 
-        public bool IsPaused => pauseCounter > 0;
+        public bool CanViewDetail => currentNotification != null && !string.IsNullOrEmpty(currentNotification.ColumnId) && !string.IsNullOrEmpty(currentNotification.ChirpId);
 
+        protected bool IsPaused => pauseCounter > 0;
+        protected bool IsCursorOverBrowser => browser.Bounds.Contains(PointToClient(Cursor.Position));
+        
         public bool FreezeTimer { get; set; }
         public bool ContextMenuOpen { get; set; }
-        public string CurrentTweetUrl { get; private set; }
-        public string CurrentQuoteUrl { get; private set; }
 
-        public event EventHandler Initialized;
-
-        public FormNotificationBase(Form owner, bool enableContextMenu){
+        protected FormNotificationBase(FormBrowser owner, bool enableContextMenu){
             InitializeComponent();
 
             this.owner = owner;
             this.owner.FormClosed += owner_FormClosed;
 
+            ResourceHandlerFactory resourceHandlerFactory = new ResourceHandlerFactory();
+            resourceHandlerFactory.RegisterHandler(TwitterUtils.TweetDeckURL, this.resourceHandler);
+            resourceHandlerFactory.RegisterHandler(TweetNotification.AppLogo);
+
             this.browser = new ChromiumWebBrowser("about:blank"){
                 MenuHandler = new ContextMenuNotification(this, enableContextMenu),
-                LifeSpanHandler = new LifeSpanHandler()
+                JsDialogHandler = new JavaScriptDialogHandler(),
+                LifeSpanHandler = new LifeSpanHandler(),
+                RequestHandler = new RequestHandlerBase(false),
+                ResourceHandlerFactory = resourceHandlerFactory
             };
 
             this.browser.Dock = DockStyle.None;
             this.browser.ClientSize = ClientSize;
-            this.browser.IsBrowserInitializedChanged += Browser_IsBrowserInitializedChanged;
-
-            #if DEBUG
-            this.browser.ConsoleMessage += BrowserUtils.HandleConsoleMessage;
-            #endif
-
-            DefaultResourceHandlerFactory handlerFactory = (DefaultResourceHandlerFactory)browser.ResourceHandlerFactory;
-            handlerFactory.RegisterHandler("https://tweetdeck.twitter.com", this.resourceHandler);
+            this.browser.SetupZoomEvents();
 
             Controls.Add(browser);
 
@@ -105,17 +143,15 @@ namespace TweetDck.Core.Notification{
                 this.browser.Dispose();
                 this.owner.FormClosed -= owner_FormClosed;
             };
-            
-            if (WindowsUtils.ShouldAvoidToolWindow){
-                FormBorderStyle = FormBorderStyle.FixedSingle;
-            }
+
+            DpiScale = this.GetDPIScale();
 
             // ReSharper disable once VirtualMemberCallInContructor
             UpdateTitle();
         }
 
         protected override void WndProc(ref Message m){
-            if (m.Msg == 0x0112 && (m.WParam.ToInt32() & 0xFFF0) == 0xF010 && !CanMoveWindow()){ // WM_SYSCOMMAND, SC_MOVE
+            if (m.Msg == 0x0112 && (m.WParam.ToInt32() & 0xFFF0) == 0xF010 && !CanDragWindow){ // WM_SYSCOMMAND, SC_MOVE
                 return;
             }
 
@@ -128,21 +164,14 @@ namespace TweetDck.Core.Notification{
             Close();
         }
 
-        private void Browser_IsBrowserInitializedChanged(object sender, IsBrowserInitializedChangedEventArgs e){
-            if (e.IsBrowserInitialized){
-                Initialized?.Invoke(this, new EventArgs());
-            }
-        }
-
         // notification methods
 
-        public virtual void HideNotification(bool loadBlank){
-            if (loadBlank){
-                browser.Load("about:blank");
-            }
+        public virtual void HideNotification(){
+            browser.Load("about:blank");
+            DisplayTooltip(null);
 
             Location = ControlExtensions.InvisibleLocation;
-            currentColumn = null;
+            currentNotification = null;
         }
 
         public virtual void FinishCurrentNotification(){}
@@ -159,30 +188,29 @@ namespace TweetDck.Core.Notification{
             }
         }
 
-        protected virtual string GetTweetHTML(TweetNotification tweet){
-            string bodyClasses = browser.Bounds.Contains(PointToClient(Cursor.Position)) ? "td-hover" : string.Empty;
-            return tweet.GenerateHtml(bodyClasses);
-        }
+        protected abstract string GetTweetHTML(TweetNotification tweet);
 
         protected virtual void LoadTweet(TweetNotification tweet){
-            CurrentTweetUrl = tweet.TweetUrl;
-            CurrentQuoteUrl = tweet.QuoteUrl;
-            currentColumn = tweet.Column;
-
+            currentNotification = tweet;
             resourceHandler.SetHTML(GetTweetHTML(tweet));
-            browser.Load("https://tweetdeck.twitter.com");
+
+            browser.Load(TwitterUtils.TweetDeckURL);
+            DisplayTooltip(null);
         }
 
         protected virtual void SetNotificationSize(int width, int height){
-            browser.ClientSize = ClientSize = new Size((int)Math.Round(width*Program.UserConfig.ZoomMultiplier), (int)Math.Round(height*Program.UserConfig.ZoomMultiplier));
-        }
-
-        protected virtual void OnNotificationReady(){
-            MoveToVisibleLocation();
+            browser.ClientSize = ClientSize = new Size(BrowserUtils.Scale(width, SizeScale), BrowserUtils.Scale(height, SizeScale));
         }
 
         protected virtual void UpdateTitle(){
-            Text = string.IsNullOrEmpty(currentColumn) || !Program.UserConfig.DisplayNotificationColumn ? Program.BrandName : Program.BrandName+" - "+currentColumn;
+            string title = currentNotification?.ColumnTitle;
+            Text = string.IsNullOrEmpty(title) || !Config.DisplayNotificationColumn ? Program.BrandName : $"{Program.BrandName} - {title}";
+        }
+
+        public void ShowTweetDetail(){
+            if (currentNotification != null){
+                owner.ShowTweetDetail(currentNotification.ColumnId, currentNotification.ChirpId, currentNotification.TweetUrl);
+            }
         }
 
         public void MoveToVisibleLocation(){

Core/Notification/FormNotificationMain.Designer.cs

@@ -1,4 +1,4 @@
-namespace TweetDck.Core.Notification {
+namespace TweetDuck.Core.Notification {
     partial class FormNotificationMain {
         /// <summary>
         /// Required designer variable.
@@ -26,7 +26,7 @@
             this.components = new System.ComponentModel.Container();
             this.timerDisplayDelay = new System.Windows.Forms.Timer(this.components);
             this.timerProgress = new System.Windows.Forms.Timer(this.components);
-            this.progressBarTimer = new TweetDck.Core.Controls.FlatProgressBar();
+            this.progressBarTimer = new TweetDuck.Core.Controls.FlatProgressBar();
             this.SuspendLayout();
             // 
             // timerDisplayDelay

Core/Notification/FormNotificationMain.cs

@@ -2,44 +2,19 @@
 using System;
 using System.Drawing;
 using System.Windows.Forms;
-using TweetDck.Core.Bridge;
-using TweetDck.Core.Controls;
-using TweetDck.Core.Utils;
-using TweetDck.Plugins;
-using TweetDck.Plugins.Enums;
-using TweetDck.Resources;
+using TweetDuck.Core.Bridge;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Handling;
+using TweetDuck.Core.Utils;
+using TweetDuck.Data;
+using TweetDuck.Plugins;
+using TweetDuck.Plugins.Enums;
+using TweetDuck.Resources;
 
-namespace TweetDck.Core.Notification{
-    partial class FormNotificationMain : FormNotificationBase{
-        private const string NotificationScriptFile = "notification.js";
-
-        private static readonly string NotificationScriptIdentifier = ScriptLoader.GetRootIdentifier(NotificationScriptFile);
-        private static readonly string PluginScriptIdentifier = ScriptLoader.GetRootIdentifier(PluginManager.PluginNotificationScriptFile);
-
-        private static readonly string NotificationJS, PluginJS;
-
-        static FormNotificationMain(){
-            NotificationJS = ScriptLoader.LoadResource(NotificationScriptFile);
-            PluginJS = ScriptLoader.LoadResource(PluginManager.PluginNotificationScriptFile);
-        }
-
-        private static int BaseClientWidth{
-            get{
-                int level = TweetNotification.FontSizeLevel;
-                int width = level == 0 ? 284 : (int)Math.Round(284.0*(1.0+0.05*level));
-                return (int)Math.Round(width*Program.UserConfig.ZoomMultiplier);
-            }
-        }
-
-        private static int BaseClientHeight{
-            get{
-                int level = TweetNotification.FontSizeLevel;
-                int height = level == 0 ? 118 : (int)Math.Round(118.0*(1.0+0.075*level));
-                return (int)Math.Round(height*Program.UserConfig.ZoomMultiplier);
-            }
-        }
-        
+namespace TweetDuck.Core.Notification{
+    abstract partial class FormNotificationMain : FormNotificationBase{
         private readonly PluginManager plugins;
+        private readonly int timerBarHeight;
 
         protected int timeLeft, totalTime;
         protected bool pausedDuringNotification;
@@ -51,9 +26,9 @@ namespace TweetDck.Core.Notification{
         private bool? prevDisplayTimer;
         private int? prevFontSize;
 
-        private bool RequiresResize{
+        public virtual bool RequiresResize{
             get{
-                return !prevDisplayTimer.HasValue || !prevFontSize.HasValue || prevDisplayTimer != Program.UserConfig.DisplayNotificationTimer || prevFontSize != TweetNotification.FontSizeLevel;
+                return !prevDisplayTimer.HasValue || !prevFontSize.HasValue || prevDisplayTimer != Config.DisplayNotificationTimer || prevFontSize != FontSizeLevel;
             }
 
             set{
@@ -62,23 +37,54 @@ namespace TweetDck.Core.Notification{
                     prevFontSize = null;
                 }
                 else{
-                    prevDisplayTimer = Program.UserConfig.DisplayNotificationTimer;
-                    prevFontSize = TweetNotification.FontSizeLevel;
+                    prevDisplayTimer = Config.DisplayNotificationTimer;
+                    prevFontSize = FontSizeLevel;
                 }
             }
         }
 
-        public FormNotificationMain(FormBrowser owner, PluginManager pluginManager, bool enableContextMenu) : base(owner, enableContextMenu){
+        private int BaseClientWidth{
+            get{
+                switch(Config.NotificationSize){
+                    default:
+                        return BrowserUtils.Scale(284, SizeScale*(1.0+0.05*FontSizeLevel));
+
+                    case TweetNotification.Size.Custom:
+                        return Config.CustomNotificationSize.Width;
+                }
+            }
+        }
+
+        private int BaseClientHeight{
+            get{
+                switch(Config.NotificationSize){
+                    default:
+                        return BrowserUtils.Scale(122, SizeScale*(1.0+0.08*FontSizeLevel));
+
+                    case TweetNotification.Size.Custom:
+                        return Config.CustomNotificationSize.Height;
+                }
+            }
+        }
+
+        protected virtual string BodyClasses => IsCursorOverBrowser ? "td-notification td-hover" : "td-notification";
+        
+        public Size BrowserSize => Config.DisplayNotificationTimer ? new Size(ClientSize.Width, ClientSize.Height-timerBarHeight) : ClientSize;
+
+        protected FormNotificationMain(FormBrowser owner, PluginManager pluginManager, bool enableContextMenu) : base(owner, enableContextMenu){
             InitializeComponent();
 
             this.plugins = pluginManager;
-
-            browser.RegisterAsyncJsObject("$TD", new TweetDeckBridge(owner, this));
-            browser.RegisterAsyncJsObject("$TDP", plugins.Bridge);
+            this.timerBarHeight = BrowserUtils.Scale(4, DpiScale);
+            
+            browser.KeyboardHandler = new KeyboardHandlerNotification(this);
+            browser.RegisterAsyncJsObject("$TD", new TweetDeckBridge.Notification(owner, this));
 
             browser.LoadingStateChanged += Browser_LoadingStateChanged;
             browser.FrameLoadEnd += Browser_FrameLoadEnd;
 
+            plugins.Register(browser, PluginEnvironment.Notification, this);
+
             mouseHookDelegate = MouseHookProc;
             Disposed += (sender, args) => StopMouseHook(true);
         }
@@ -103,8 +109,8 @@ namespace TweetDck.Core.Notification{
             if (nCode == 0){
                 int eventType = wParam.ToInt32();
 
-                if (eventType == NativeMethods.WM_MOUSEWHEEL && browser.Bounds.Contains(PointToClient(Cursor.Position)) && !ContainsFocus && !owner.ContainsFocus){
-                    browser.SendMouseWheelEvent(0, 0, 0, NativeMethods.GetMouseHookData(lParam), CefEventFlags.None);
+                if (eventType == NativeMethods.WM_MOUSEWHEEL && IsCursorOverBrowser){
+                    browser.SendMouseWheelEvent(0, 0, 0, BrowserUtils.Scale(NativeMethods.GetMouseHookData(lParam), Config.NotificationScrollSpeed*0.01), CefEventFlags.None);
                     return NativeMethods.HOOK_HANDLED;
                 }
                 else if (eventType == NativeMethods.WM_XBUTTONDOWN && DesktopBounds.Contains(Cursor.Position)){
@@ -118,6 +124,7 @@ namespace TweetDck.Core.Notification{
                     }
                     
                     blockXButtonUp = true;
+                    this.InvokeAsyncSafe(AnalyticsFile.NotificationExtraMouseButtons.Trigger);
                     return NativeMethods.HOOK_HANDLED;
                 }
                 else if (eventType == NativeMethods.WM_XBUTTONUP && blockXButtonUp){
@@ -138,7 +145,7 @@ namespace TweetDck.Core.Notification{
 
         private void FormNotification_FormClosing(object sender, FormClosingEventArgs e){
             if (e.CloseReason == CloseReason.UserClosing){
-                HideNotification(true);
+                HideNotification();
                 e.Cancel = true;
             }
         }
@@ -153,15 +160,11 @@ namespace TweetDck.Core.Notification{
         }
 
         private void Browser_FrameLoadEnd(object sender, FrameLoadEndEventArgs e){
-            if (e.Frame.IsMain && NotificationJS != null && browser.Address != "about:blank"){
-                e.Frame.ExecuteJavaScriptAsync(PropertyBridge.GenerateScript(PropertyBridge.Properties.AllNotification));
-                ScriptLoader.ExecuteScript(e.Frame, NotificationJS, NotificationScriptIdentifier);
+            IFrame frame = e.Frame;
 
-                if (plugins.HasAnyPlugin(PluginEnvironment.Notification)){
-                    ScriptLoader.ExecuteScript(e.Frame, PluginJS, PluginScriptIdentifier);
-                    ScriptLoader.ExecuteFile(e.Frame, PluginManager.PluginGlobalScriptFile);
-                    plugins.ExecutePlugins(e.Frame, PluginEnvironment.Notification, false);
-                }
+            if (frame.IsMain && browser.Address != "about:blank"){
+                frame.ExecuteJavaScriptAsync(PropertyBridge.GenerateScript(PropertyBridge.Environment.Notification));
+                ScriptLoader.ExecuteFile(frame, "notification.js", this);
             }
         }
 
@@ -171,12 +174,14 @@ namespace TweetDck.Core.Notification{
         }
 
         private void timerHideProgress_Tick(object sender, EventArgs e){
-            if (Bounds.Contains(Cursor.Position) || FreezeTimer || ContextMenuOpen)return;
+            if (Bounds.Contains(Cursor.Position) || FreezeTimer || ContextMenuOpen){
+                return;
+            }
 
             timeLeft -= timerProgress.Interval;
 
-            int value = (int)Math.Round(1025.0*(totalTime-timeLeft)/totalTime);
-            progressBarTimer.SetValueInstant(Math.Min(1000, Math.Max(0, Program.UserConfig.NotificationTimerCountDown ? 1000-value : value)));
+            int value = BrowserUtils.Scale(progressBarTimer.Maximum+25, (totalTime-timeLeft)/(double)totalTime);
+            progressBarTimer.SetValueInstant(Config.NotificationTimerCountDown ? progressBarTimer.Maximum-value : value);
 
             if (timeLeft <= 0){
                 FinishCurrentNotification();
@@ -189,21 +194,10 @@ namespace TweetDck.Core.Notification{
             LoadTweet(notification);
         }
 
-        public void ShowNotificationForSettings(bool reset){
-            if (reset){
-                LoadTweet(TweetNotification.ExampleTweet);
-            }
-            else{
-                PrepareAndDisplayWindow();
-            }
-
-            UpdateTitle();
-        }
-
-        public override void HideNotification(bool loadBlank){
-            base.HideNotification(loadBlank);
+        public override void HideNotification(){
+            base.HideNotification();
             
-            progressBarTimer.Value = Program.UserConfig.NotificationTimerCountDown ? 1000 : 0;
+            progressBarTimer.Value = Config.NotificationTimerCountDown ? progressBarTimer.Maximum : progressBarTimer.Minimum;
             timerProgress.Stop();
             totalTime = 0;
 
@@ -234,10 +228,10 @@ namespace TweetDck.Core.Notification{
         }
 
         protected override string GetTweetHTML(TweetNotification tweet){
-            string html = base.GetTweetHTML(tweet);
+            string html = tweet.GenerateHtml(BodyClasses, this);
 
-            foreach(InjectedHTML injection in plugins.Bridge.NotificationInjections){
-                html = injection.Inject(html);
+            foreach(InjectedHTML injection in plugins.NotificationInjections){
+                html = injection.InjectInto(html);
             }
 
             return html;
@@ -245,15 +239,15 @@ namespace TweetDck.Core.Notification{
 
         protected override void LoadTweet(TweetNotification tweet){
             timerProgress.Stop();
-            totalTime = timeLeft = tweet.GetDisplayDuration(Program.UserConfig.NotificationDurationValue);
-            progressBarTimer.Value = Program.UserConfig.NotificationTimerCountDown ? 1000 : 0;
+            totalTime = timeLeft = tweet.GetDisplayDuration(Config.NotificationDurationValue);
+            progressBarTimer.Value = Config.NotificationTimerCountDown ? progressBarTimer.Maximum : progressBarTimer.Minimum;
 
             base.LoadTweet(tweet);
         }
 
         protected override void SetNotificationSize(int width, int height){
-            if (Program.UserConfig.DisplayNotificationTimer){
-                ClientSize = new Size(width, height+4);
+            if (Config.DisplayNotificationTimer){
+                ClientSize = new Size(width, height+timerBarHeight);
                 progressBarTimer.Visible = true;
             }
             else{
@@ -264,7 +258,7 @@ namespace TweetDck.Core.Notification{
             browser.ClientSize = new Size(width, height);
         }
         
-        private void PrepareAndDisplayWindow(){
+        protected void PrepareAndDisplayWindow(){
             if (RequiresResize){
                 RequiresResize = false;
                 SetNotificationSize(BaseClientWidth, BaseClientHeight);
@@ -274,7 +268,7 @@ namespace TweetDck.Core.Notification{
             StartMouseHook();
         }
 
-        protected override void OnNotificationReady(){
+        protected virtual void OnNotificationReady(){
             PrepareAndDisplayWindow();
             timerProgress.Start();
         }

Core/Notification/FormNotificationTweet.Designer.cs

@@ -1,4 +1,4 @@
-namespace TweetDck.Core.Notification {
+namespace TweetDuck.Core.Notification {
     partial class FormNotificationTweet {
         /// <summary>
         /// Required designer variable.
@@ -40,7 +40,6 @@ namespace TweetDck.Core.Notification {
             // 
             // FormNotificationTweet
             // 
-            this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.FormNotificationTweet_FormClosing);
             this.ResumeLayout(true);
 
         }

Core/Notification/FormNotificationTweet.cs

@@ -1,49 +1,63 @@
 using System;
 using System.Collections.Generic;
 using System.Drawing;
-using TweetDck.Plugins;
+using TweetDuck.Plugins;
 using System.Windows.Forms;
-using TweetDck.Core.Utils;
+using TweetDuck.Core.Utils;
 
-namespace TweetDck.Core.Notification{
+namespace TweetDuck.Core.Notification{
     sealed partial class FormNotificationTweet : FormNotificationMain{
         private const int NonIntrusiveIdleLimit = 30;
         private const int TrimMinimum = 32;
 
+        protected override Point PrimaryLocation => hasTemporarilyMoved && IsNotificationVisible ? Location : base.PrimaryLocation;
         private bool IsCursorOverNotificationArea => new Rectangle(PrimaryLocation, Size).Contains(Cursor.Position);
 
+        protected override bool CanDragWindow{
+            get{
+                if (ModifierKeys.HasFlag(Keys.Alt)){
+                    hasTemporarilyMoved = true;
+                    return true;
+                }
+                else{
+                    return false;
+                }
+            }
+        }
+
         private readonly Queue<TweetNotification> tweetQueue = new Queue<TweetNotification>(4);
         private bool needsTrim;
+        private bool hasTemporarilyMoved;
 
         public FormNotificationTweet(FormBrowser owner, PluginManager pluginManager) : base(owner, pluginManager, true){
             InitializeComponent();
 
-            Program.UserConfig.MuteToggled += Config_MuteToggled;
-            Disposed += (sender, args) => Program.UserConfig.MuteToggled -= Config_MuteToggled;
+            Config.MuteToggled += Config_MuteToggled;
+            Disposed += (sender, args) => Config.MuteToggled -= Config_MuteToggled;
 
-            if (Program.UserConfig.MuteNotifications){
+            if (Config.MuteNotifications){
                 PauseNotification();
             }
         }
 
-        private void FormNotificationTweet_FormClosing(object sender, FormClosingEventArgs e){
-            if (e.CloseReason == CloseReason.UserClosing){
-                tweetQueue.Clear(); // already canceled
-                TrimQueue();
-            }
-        }
+        protected override void WndProc(ref Message m){
+            if (m.Msg == 0x00A7){ // WM_NCMBUTTONDOWN
+                int hitTest = m.WParam.ToInt32();
 
-        private void TrimQueue(){
-            if (needsTrim){
-                tweetQueue.TrimExcess();
-                needsTrim = false;
+                if (hitTest == 2 || hitTest == 20){ // HTCAPTION, HTCLOSE
+                    hasTemporarilyMoved = false;
+                    MoveToVisibleLocation();
+                    return;
+                }
             }
+
+            base.WndProc(ref m);
         }
 
         // event handlers
 
         private void Config_MuteToggled(object sender, EventArgs e){
-            if (Program.UserConfig.MuteNotifications){
+            if (Config.MuteNotifications){
                 PauseNotification();
             }
             else{
@@ -59,7 +73,7 @@ namespace TweetDck.Core.Notification{
         }
 
         private void timerIdlePauseCheck_Tick(object sender, EventArgs e){
-            if (NativeMethods.GetIdleSeconds() < Program.UserConfig.NotificationIdlePauseSeconds){
+            if (NativeMethods.GetIdleSeconds() < Config.NotificationIdlePauseSeconds){
                 ResumeNotification();
                 timerIdlePauseCheck.Stop();
             }
@@ -68,11 +82,9 @@ namespace TweetDck.Core.Notification{
         // notification methods
 
         public override void ShowNotification(TweetNotification notification){
-            if (IsPaused){
-                tweetQueue.Enqueue(notification);
-            }
-            else{
-                tweetQueue.Enqueue(notification);
+            tweetQueue.Enqueue(notification);
+            
+            if (!IsPaused){
                 UpdateTitle();
 
                 if (totalTime == 0){
@@ -81,6 +93,19 @@ namespace TweetDck.Core.Notification{
             }
 
             needsTrim |= tweetQueue.Count >= TrimMinimum;
+            AnalyticsFile.DesktopNotifications.Trigger();
+        }
+
+        public override void HideNotification(){
+            base.HideNotification();
+            tweetQueue.Clear();
+
+            if (needsTrim){
+                tweetQueue.TrimExcess();
+                needsTrim = false;
+            }
+
+            hasTemporarilyMoved = false;
         }
 
         public override void FinishCurrentNotification(){
@@ -88,8 +113,7 @@ namespace TweetDck.Core.Notification{
                 LoadNextNotification();
             }
             else{
-                HideNotification(true);
-                TrimQueue();
+                HideNotification();
             }
         }
 
@@ -104,7 +128,7 @@ namespace TweetDck.Core.Notification{
 
         private void LoadNextNotification(){
             if (!IsNotificationVisible){
-                if (Program.UserConfig.NotificationNonIntrusiveMode && IsCursorOverNotificationArea && NativeMethods.GetIdleSeconds() < NonIntrusiveIdleLimit){
+                if (Config.NotificationNonIntrusiveMode && IsCursorOverNotificationArea && NativeMethods.GetIdleSeconds() < NonIntrusiveIdleLimit){
                     if (!timerCursorCheck.Enabled){
                         PauseNotification();
                         timerCursorCheck.Start();
@@ -112,7 +136,7 @@ namespace TweetDck.Core.Notification{
 
                     return;
                 }
-                else if (Program.UserConfig.NotificationIdlePauseSeconds > 0 && NativeMethods.GetIdleSeconds() >= Program.UserConfig.NotificationIdlePauseSeconds){
+                else if (Config.NotificationIdlePauseSeconds > 0 && NativeMethods.GetIdleSeconds() >= Config.NotificationIdlePauseSeconds){
                     if (!timerIdlePauseCheck.Enabled){
                         PauseNotification();
                         timerIdlePauseCheck.Start();

Core/Notification/Screenshot/FormNotificationScreenshotable.cs

@@ -2,39 +2,87 @@
 using System.Drawing;
 using System.Drawing.Imaging;
 using System.Windows.Forms;
-using TweetDck.Core.Bridge;
-using TweetDck.Core.Utils;
-using TweetDck.Resources;
+using CefSharp;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Other;
+using TweetDuck.Core.Utils;
+using TweetDuck.Data;
+using TweetDuck.Plugins;
+using TweetDuck.Resources;
 
-namespace TweetDck.Core.Notification.Screenshot{
+namespace TweetDuck.Core.Notification.Screenshot{
     sealed class FormNotificationScreenshotable : FormNotificationBase{
-        public FormNotificationScreenshotable(Action callback, Form owner) : base(owner, false){
-            browser.RegisterAsyncJsObject("$TD_NotificationScreenshot", new CallbackBridge(this, callback));
+        protected override bool CanDragWindow => false;
 
-            browser.FrameLoadEnd += (sender, args) => {
-                if (args.Frame.IsMain && browser.Address != "about:blank"){
-                    ScriptLoader.ExecuteScript(args.Frame, "window.setTimeout($TD_NotificationScreenshot.trigger, 67)", "gen:screenshot");
+        private readonly PluginManager plugins;
+        private int height;
+
+        public FormNotificationScreenshotable(Action callback, FormBrowser owner, PluginManager pluginManager, string html, int width) : base(owner, false){
+            this.plugins = pluginManager;
+
+            int realWidth = BrowserUtils.Scale(width, DpiScale);
+
+            browser.RegisterAsyncJsObject("$TD_NotificationScreenshot", new ScreenshotBridge(this, SetScreenshotHeight, callback));
+
+            browser.LoadingStateChanged += (sender, args) => {
+                if (args.IsLoading){
+                    return;
+                }
+
+                string script = ScriptLoader.LoadResourceSilent("screenshot.js");
+                        
+                if (script == null){
+                    this.InvokeAsyncSafe(callback);
+                    return;
+                }
+                
+                using(IFrame frame = args.Browser.MainFrame){
+                    ScriptLoader.ExecuteScript(frame, script.Replace("{width}", realWidth.ToString()).Replace("{frames}", TweetScreenshotManager.WaitFrames.ToString()), "gen:screenshot");
                 }
             };
+            
+            SetNotificationSize(realWidth, 1024);
+            LoadTweet(new TweetNotification(string.Empty, string.Empty, string.Empty, html, 0, string.Empty, string.Empty));
         }
 
         protected override string GetTweetHTML(TweetNotification tweet){
-            return tweet.GenerateHtml(enableCustomCSS: false);
+            string html = tweet.GenerateHtml("td-screenshot", this);
+
+            foreach(InjectedHTML injection in plugins.NotificationInjections){
+                html = injection.InjectInto(html);
+            }
+
+            return html;
         }
 
-        public void LoadNotificationForScreenshot(TweetNotification tweet, int width, int height){
-            LoadTweet(tweet);
-            SetNotificationSize(width, height);
+        private void SetScreenshotHeight(int browserHeight){
+            this.height = BrowserUtils.Scale(browserHeight, SizeScale);
         }
 
-        public void TakeScreenshot(){
+        public bool TakeScreenshot(bool ignoreHeightError = false){
+            if (!ignoreHeightError){
+                if (height == 0){
+                    FormMessage.Error("Screenshot Failed", "Could not detect screenshot size.", FormMessage.OK);
+                    return false;
+                }
+                else if (height > ClientSize.Height){
+                    FormMessage.Error("Screenshot Failed", $"Screenshot is too large: {height}px > {ClientSize.Height}px", FormMessage.OK);
+                    return false;
+                }
+            }
+
+            if (!WindowsUtils.IsAeroEnabled){
+                MoveToVisibleLocation(); // TODO make this look nicer I guess
+            }
+            
             IntPtr context = NativeMethods.GetDC(this.Handle);
 
             if (context == IntPtr.Zero){
-                MessageBox.Show("Could not retrieve a graphics context handle for the notification window to take the screenshot.", "Screenshot Failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
+                FormMessage.Error("Screenshot Failed", "Could not retrieve a graphics context handle for the notification window to take the screenshot.", FormMessage.OK);
+                return false;
             }
             else{
-                using(Bitmap bmp = new Bitmap(ClientSize.Width, ClientSize.Height, PixelFormat.Format32bppRgb)){
+                using(Bitmap bmp = new Bitmap(ClientSize.Width, Math.Max(1, height), PixelFormat.Format32bppRgb)){
                     try{
                         NativeMethods.RenderSourceIntoBitmap(context, bmp);
                     }finally{
@@ -42,6 +90,7 @@ namespace TweetDck.Core.Notification.Screenshot{
                     }
 
                     Clipboard.SetImage(bmp);
+                    return true;
                 }
             }
         }

Core/Notification/Screenshot/ScreenshotBridge.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Windows.Forms;
+using TweetDuck.Core.Controls;
+
+namespace TweetDuck.Core.Notification.Screenshot{
+    sealed class ScreenshotBridge{
+        private readonly Control owner;
+
+        private readonly Action<int> safeSetHeight;
+        private readonly Action safeTriggerScreenshot;
+
+        public ScreenshotBridge(Control owner, Action<int> safeSetHeight, Action safeTriggerScreenshot){
+            this.owner = owner;
+            this.safeSetHeight = safeSetHeight;
+            this.safeTriggerScreenshot = safeTriggerScreenshot;
+        }
+
+        public void SetHeight(int tweetHeight){
+            owner.InvokeSafe(() => safeSetHeight(tweetHeight));
+        }
+
+        public void TriggerScreenshot(){
+            owner.InvokeSafe(safeTriggerScreenshot);
+        }
+    }
+}

Core/Notification/Screenshot/TweetScreenshotManager.cs

@@ -1,32 +1,59 @@
-// Uncomment to keep screenshot windows visible for debugging
+#if DEBUG
+// Uncomment to keep screenshot windows visible for debugging
 // #define NO_HIDE_SCREENSHOTS
 
+// Uncomment to generate screenshots of individual frames for at most 1 second
+// #define GEN_SCREENSHOT_FRAMES
+#endif
+
 using System;
 using System.Windows.Forms;
-using TweetDck.Core.Controls;
+using TweetDuck.Core.Controls;
+using TweetDuck.Plugins;
 
-namespace TweetDck.Core.Notification.Screenshot{
+#if GEN_SCREENSHOT_FRAMES
+using System.Drawing.Imaging;
+using System.IO;
+using TweetDuck.Core.Utils;
+#endif
+
+namespace TweetDuck.Core.Notification.Screenshot{
     sealed class TweetScreenshotManager : IDisposable{
-        private readonly Form owner;
+        private readonly FormBrowser owner;
+        private readonly PluginManager plugins;
         private readonly Timer timeout;
         private readonly Timer disposer;
+
+        #if GEN_SCREENSHOT_FRAMES
+        private readonly Timer debugger;
+        private int frameCounter;
+
+        public const int WaitFrames = 60;
+        #else
+        public const int WaitFrames = 5;
+        #endif
         
         private FormNotificationScreenshotable screenshot;
 
-        public TweetScreenshotManager(Form owner){
+        public TweetScreenshotManager(FormBrowser owner, PluginManager pluginManager){
             this.owner = owner;
+            this.plugins = pluginManager;
 
             this.timeout = new Timer{ Interval = 8000 };
             this.timeout.Tick += timeout_Tick;
 
             this.disposer = new Timer{ Interval = 1 };
             this.disposer.Tick += disposer_Tick;
+
+            #if GEN_SCREENSHOT_FRAMES
+            this.debugger = new Timer{ Interval = 16 };
+            this.debugger.Tick += debugger_Tick;
+            #endif
         }
 
         private void timeout_Tick(object sender, EventArgs e){
             timeout.Stop();
-            screenshot.Location = ControlExtensions.InvisibleLocation;
-            disposer.Start();
+            OnFinished();
         }
 
         private void disposer_Tick(object sender, EventArgs e){
@@ -35,18 +62,22 @@ namespace TweetDck.Core.Notification.Screenshot{
             screenshot = null;
         }
 
-        public void Trigger(string html, int width, int height){
+        public void Trigger(string html, int width){
             if (screenshot != null){
                 return;
             }
 
-            screenshot = new FormNotificationScreenshotable(Callback, owner){
-                CanMoveWindow = () => false
-            };
-
-            screenshot.LoadNotificationForScreenshot(new TweetNotification(string.Empty, html, 0, string.Empty, string.Empty), width, height);
+            screenshot = new FormNotificationScreenshotable(Callback, owner, plugins, html, width);
             screenshot.Show();
             timeout.Start();
+
+            #if GEN_SCREENSHOT_FRAMES
+            StartDebugger();
+            #endif
+
+            #if !NO_HIDE_SCREENSHOTS
+            owner.IsWaiting = true;
+            #endif
         }
 
         private void Callback(){
@@ -56,20 +87,62 @@ namespace TweetDck.Core.Notification.Screenshot{
 
             timeout.Stop();
             screenshot.TakeScreenshot();
-
-            #if !(DEBUG && NO_HIDE_SCREENSHOTS)
-            screenshot.Location = ControlExtensions.InvisibleLocation;
-            disposer.Start();
+            
+            #if !NO_HIDE_SCREENSHOTS
+            OnFinished();
             #else
             screenshot.MoveToVisibleLocation();
             screenshot.FormClosed += (sender, args) => disposer.Start();
             #endif
         }
 
+        private void OnFinished(){
+            #if GEN_SCREENSHOT_FRAMES
+            debugger.Stop();
+            #endif
+
+            screenshot.Location = ControlExtensions.InvisibleLocation;
+            owner.IsWaiting = false;
+            disposer.Start();
+        }
+
         public void Dispose(){
+            #if GEN_SCREENSHOT_FRAMES
+            debugger.Dispose();
+            #endif
+
             timeout.Dispose();
             disposer.Dispose();
             screenshot?.Dispose();
         }
+
+        #if GEN_SCREENSHOT_FRAMES
+        private static readonly string DebugScreenshotPath = Path.Combine(Program.StoragePath, "TD_Screenshots");
+
+        private void StartDebugger(){
+            frameCounter = 0;
+
+            try{
+                Directory.Delete(DebugScreenshotPath, true);
+                WindowsUtils.TrySleepUntil(() => !Directory.Exists(DebugScreenshotPath), 1000, 10);
+            }catch(DirectoryNotFoundException){}
+            
+            Directory.CreateDirectory(DebugScreenshotPath);
+            debugger.Start();
+        }
+
+        private void debugger_Tick(object sender, EventArgs e){
+            if (frameCounter < 63 && screenshot.TakeScreenshot(true)){
+                try{
+                    Clipboard.GetImage()?.Save(Path.Combine(DebugScreenshotPath, "frame_"+(++frameCounter)+".png"), ImageFormat.Png);
+                }catch{
+                    System.Diagnostics.Debug.WriteLine("Failed generating frame "+frameCounter);
+                }
+            }
+            else{
+                debugger.Stop();
+            }
+        }
+        #endif
     }
 }

Core/Notification/Sound/ISoundNotificationPlayer.cs

@@ -1,12 +0,0 @@
-using System;
-
-namespace TweetDck.Core.Notification.Sound{
-    interface ISoundNotificationPlayer : IDisposable{
-        string SupportedFormats { get; }
-
-        event EventHandler<PlaybackErrorEventArgs> PlaybackError;
-
-        void Play(string file);
-        void Stop();
-    }
-}

Core/Notification/Sound/PlaybackErrorEventArgs.cs

@@ -1,13 +0,0 @@
-using System;
-
-namespace TweetDck.Core.Notification.Sound{
-    sealed class PlaybackErrorEventArgs : EventArgs{
-        public string Message { get; }
-        public bool Ignore { get; set; }
-
-        public PlaybackErrorEventArgs(string message){
-            this.Message = message;
-            this.Ignore = false;
-        }
-    }
-}

Core/Notification/Sound/SoundPlayerImplFallback.cs

@@ -1,53 +0,0 @@
-using System;
-using System.IO;
-using System.Media;
-
-namespace TweetDck.Core.Notification.Sound{
-    sealed class SoundPlayerImplFallback : ISoundNotificationPlayer{
-        string ISoundNotificationPlayer.SupportedFormats => "*.wav";
-
-        public event EventHandler<PlaybackErrorEventArgs> PlaybackError;
-
-        private readonly SoundPlayer player;
-        private bool ignorePlaybackError;
-
-        public SoundPlayerImplFallback(){
-            player = new SoundPlayer{
-                LoadTimeout = 5000
-            };
-        }
-
-        void ISoundNotificationPlayer.Play(string file){
-            if (player.SoundLocation != file){
-                player.SoundLocation = file;
-                ignorePlaybackError = false;
-            }
-
-            try{
-                player.Play();
-            }catch(FileNotFoundException e){
-                OnNotificationSoundError("File not found: "+e.FileName);
-            }catch(InvalidOperationException){
-                OnNotificationSoundError("File format was not recognized.");
-            }catch(TimeoutException){
-                OnNotificationSoundError("File took too long to load.");
-            }
-        }
-
-        void ISoundNotificationPlayer.Stop(){
-            player.Stop();
-        }
-
-        void IDisposable.Dispose(){
-            player.Dispose();
-        }
-
-        private void OnNotificationSoundError(string message){
-            if (!ignorePlaybackError && PlaybackError != null){
-                PlaybackErrorEventArgs args = new PlaybackErrorEventArgs(message);
-                PlaybackError(this, args);
-                ignorePlaybackError = args.Ignore;
-            }
-        }
-    }
-}

Core/Notification/Sound/SoundPlayerImplWMP.cs

@@ -1,113 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-using TweetDck.Core.Utils;
-using WMPLib;
-
-namespace TweetDck.Core.Notification.Sound{
-    sealed class SoundPlayerImplWMP : ISoundNotificationPlayer{
-        string ISoundNotificationPlayer.SupportedFormats => "*.wav;*.mp3;*.mp2;*.m4a;*.mid;*.midi;*.rmi;*.wma;*.aif;*.aifc;*.aiff;*.snd;*.au";
-
-        public event EventHandler<PlaybackErrorEventArgs> PlaybackError;
-
-        private readonly WindowsMediaPlayer player;
-        private bool wasTryingToPlay;
-        private bool ignorePlaybackError;
-
-        // changing the player volume also affects the value in the Windows mixer
-        // however, the initial value is always 50 or some other stupid shit
-        // so we have to tell the player to set its volume to whatever the mixer is set to
-        // using the most code required for the least functionality with a sorry excuse for an API
-        // thanks, Microsoft
-
-        public SoundPlayerImplWMP(){
-            player = new WindowsMediaPlayer();
-            player.settings.autoStart = false;
-            player.settings.enableErrorDialogs = false;
-            player.settings.invokeURLs = false;
-            player.settings.volume = (int)Math.Floor(100.0*NativeCoreAudio.GetMixerVolumeForCurrentProcess());
-            player.MediaChange += player_MediaChange;
-            player.MediaError += player_MediaError;
-        }
-
-        void ISoundNotificationPlayer.Play(string file){
-            wasTryingToPlay = true;
-
-            try{
-                if (player.URL != file){
-                    player.close();
-                    player.URL = file;
-                    ignorePlaybackError = false;
-                }
-                else{
-                    player.controls.stop();
-                }
-            
-                player.controls.play();
-            }catch(Exception e){
-                OnNotificationSoundError("An error occurred in Windows Media Player: "+e.Message);
-            }
-        }
-
-        void ISoundNotificationPlayer.Stop(){
-            try{
-                player.controls.stop();
-            }catch{
-                // ignore
-            }
-        }
-
-        void IDisposable.Dispose(){
-            player.close();
-            Marshal.ReleaseComObject(player);
-        }
-
-        private void player_MediaChange(object item){
-            IWMPMedia2 media = item as IWMPMedia2;
-
-            if (media == null){
-                OnNotificationSoundError("Unknown error.");
-                return;
-            }
-            // ReSharper disable once CompareOfFloatsByEqualityOperator
-            else if (media.Error == null && media.duration == 0.0){
-                OnNotificationSoundError("File does not contain an audio track.");
-            }
-            else if (media.Error != null){
-                OnNotificationSoundError(media.Error);
-            }
-
-            Marshal.ReleaseComObject(media);
-        }
-
-        private void player_MediaError(object pMediaObject){
-            IWMPMedia2 media = pMediaObject as IWMPMedia2;
-
-            if (media == null){
-                OnNotificationSoundError("Unknown error.");
-                return;
-            }
-            else if (media.Error != null){
-                OnNotificationSoundError(media.Error);
-            }
-
-            Marshal.ReleaseComObject(media);
-        }
-
-        private void OnNotificationSoundError(IWMPErrorItem error){
-            OnNotificationSoundError(error.errorCode == -1072885353 ? "Invalid media file." : error.errorDescription);
-            Marshal.ReleaseComObject(error);
-        }
-
-        private void OnNotificationSoundError(string message){
-            if (wasTryingToPlay){
-                wasTryingToPlay = false;
-
-                if (!ignorePlaybackError && PlaybackError != null){
-                    PlaybackErrorEventArgs args = new PlaybackErrorEventArgs(message);
-                    PlaybackError(this, args);
-                    ignorePlaybackError = args.Ignore;
-                }
-            }
-        }
-    }
-}

Core/Notification/SoundNotification.cs

@@ -1,27 +1,49 @@
-using System.Runtime.InteropServices;
-using TweetDck.Core.Notification.Sound;
+using System.Drawing;
+using System.IO;
+using System.Windows.Forms;
+using CefSharp;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Other;
+using TweetDuck.Core.Other.Settings;
 
-namespace TweetDck.Core.Notification{
+namespace TweetDuck.Core.Notification{
     static class SoundNotification{
-        private static bool? IsWMPAvailable;
+        public const string SupportedFormats = "*.wav;*.ogg;*.mp3;*.flac;*.opus;*.weba;*.webm";
+        
+        public static IResourceHandler CreateFileHandler(string path){
+            string mimeType;
 
-        public static ISoundNotificationPlayer New(){
-            if (IsWMPAvailable.HasValue){
-                if (IsWMPAvailable.Value){
-                    return new SoundPlayerImplWMP();
-                }
-                else{
-                    return new SoundPlayerImplFallback();
-                }
+            switch(Path.GetExtension(path)){
+                case ".weba":
+                case ".webm": mimeType = "audio/webm"; break;
+                case ".wav": mimeType = "audio/wav"; break;
+                case ".ogg": mimeType = "audio/ogg"; break;
+                case ".mp3": mimeType = "audio/mp3"; break;
+                case ".flac": mimeType = "audio/flac"; break;
+                case ".opus": mimeType = "audio/ogg; codecs=opus"; break;
+                default: mimeType = null; break;
             }
 
             try{
-                SoundPlayerImplWMP implWMP = new SoundPlayerImplWMP();
-                IsWMPAvailable = true;
-                return implWMP;
-            }catch(COMException){
-                IsWMPAvailable = false;
-                return new SoundPlayerImplFallback();
+                return ResourceHandler.FromFilePath(path, mimeType);
+            }catch{
+                FormBrowser browser = FormManager.TryFind<FormBrowser>();
+
+                browser?.InvokeAsyncSafe(() => {
+                    using(FormMessage form = new FormMessage("Sound Notification Error", "Could not find custom notification sound file:\n"+path, MessageBoxIcon.Error)){
+                        form.AddButton(FormMessage.Ignore, ControlType.Cancel | ControlType.Focused);
+                        
+                        Button btnViewOptions = form.AddButton("View Options");
+                        btnViewOptions.Width += 16;
+                        btnViewOptions.Location = new Point(btnViewOptions.Location.X-16, btnViewOptions.Location.Y);
+
+                        if (form.ShowDialog() == DialogResult.OK && form.ClickedButton == btnViewOptions){
+                            browser.OpenSettings(typeof(TabSettingsSounds));
+                        }
+                    }
+                });
+                
+                return null;
             }
         }
     }

Core/Notification/TweetNotification.cs

@@ -1,107 +1,73 @@
 using System;
 using System.Text;
-using TweetDck.Resources;
+using System.Windows.Forms;
+using CefSharp;
+using TweetDuck.Core.Bridge;
+using TweetDuck.Data;
+using TweetDuck.Resources;
 
-namespace TweetDck.Core.Notification{
+namespace TweetDuck.Core.Notification{
     sealed class TweetNotification{
-        private static string FontSizeClass { get; set; }
-        private static string HeadTag { get; set; }
-
-        private const string DefaultFontSizeClass = "medium";
-        private const string DefaultHeadTag = @"<meta charset='utf-8'><meta http-equiv='X-UA-Compatible' content='chrome=1'><link rel='stylesheet' href='https://ton.twimg.com/tweetdeck-web/web/css/font.5ef884f9f9.css'><link rel='stylesheet' href='https://ton.twimg.com/tweetdeck-web/web/css/app-dark.5631e0dd42.css'><style type='text/css'>body{background:#222426}</style>";
-        private const string CustomCSS = @"body:before{content:none}body{overflow-y:auto}.scroll-styled-v::-webkit-scrollbar{width:7px}.scroll-styled-v::-webkit-scrollbar-thumb{border-radius:0}.scroll-styled-v::-webkit-scrollbar-track{border-left:0}#td-skip{opacity:0;cursor:pointer;transition:opacity 0.15s ease}.td-hover #td-skip{opacity:0.75}#td-skip:hover{opacity:1}";
-
-        public static int FontSizeLevel{
-            get{
-                switch(FontSizeClass){
-                    case "largest": return 4;
-                    case "large": return 3;
-                    case "medium": return 2;
-                    case "small": return 1;
-                    default: return 0;
-                }
-            }
-        }
-
-        private static string ExampleTweetHTML;
-
-        public static TweetNotification ExampleTweet{
-            get{
-                if (ExampleTweetHTML == null){
-                    ExampleTweetHTML = ScriptLoader.LoadResource("pages/example.html", true);
-
-                    #if DEBUG
-                    ExampleTweetHTML = ExampleTweetHTML.Replace("</p>", @"</p><div style='margin-top:64px'>Scrollbar test padding...</div>");
-                    #endif
-                }
-
-                return new TweetNotification("Home", ExampleTweetHTML, 95, string.Empty, string.Empty, true);
-            }
-        }
-
-        public static void SetFontSizeClass(string newFSClass){
-            FontSizeClass = newFSClass;
-        }
-
-        public static void SetHeadTag(string headContents){
-            HeadTag = headContents;
-        }
-
+        private const string DefaultHeadLayout = @"<html class=""scroll-v os-windows dark txt-size--14"" lang=""en-US"" id=""tduck"" data-td-font=""medium"" data-td-theme=""dark""><head><meta charset=""utf-8""><link href=""https://ton.twimg.com/tweetdeck-web/web/dist/bundle.4b1f87e09d.css"" rel=""stylesheet""><style type='text/css'>body { background: rgb(34, 36, 38) !important }</style>";
+        public static readonly ResourceLink AppLogo = new ResourceLink("https://ton.twimg.com/tduck/avatar", ResourceHandler.FromByteArray(Properties.Resources.avatar, "image/png"));
+        
         public enum Position{
             TopLeft, TopRight, BottomLeft, BottomRight, Custom
         }
 
-        public string Column => column;
-        public string TweetUrl => tweetUrl;
-        public string QuoteUrl => quoteUrl;
+        public enum Size{
+            Auto, Custom
+        }
 
-        private readonly string column;
+        public string ColumnId { get; }
+        public string ChirpId { get; }
+
+        public string ColumnTitle { get; }
+        public string TweetUrl { get; }
+        public string QuoteUrl { get; }
+        
         private readonly string html;
         private readonly int characters;
-        private readonly string tweetUrl;
-        private readonly string quoteUrl;
-        private readonly bool isExample;
+        
+        public TweetNotification(string columnId, string chirpId, string title, string html, int characters, string tweetUrl, string quoteUrl){
+            this.ColumnId = columnId;
+            this.ChirpId = chirpId;
 
-        public TweetNotification(string column, string html, int characters, string tweetUrl, string quoteUrl) : this(column, html, characters, tweetUrl, quoteUrl, false){}
+            this.ColumnTitle = title;
+            this.TweetUrl = tweetUrl;
+            this.QuoteUrl = quoteUrl;
 
-        private TweetNotification(string column, string html, int characters, string tweetUrl, string quoteUrl, bool isExample){
-            this.column = column;
             this.html = html;
-            this.tweetUrl = tweetUrl;
-            this.quoteUrl = quoteUrl;
             this.characters = characters;
-            this.isExample = isExample;
         }
 
         public int GetDisplayDuration(int value){
             return 2000+Math.Max(1000, value*characters);
         }
 
-        public string GenerateHtml(string bodyClasses = null, bool enableCustomCSS = true){
-            StringBuilder build = new StringBuilder();
-            build.Append("<!DOCTYPE html>");
-            build.Append("<html class='os-windows txt-base-").Append(FontSizeClass ?? DefaultFontSizeClass).Append("'>");
-            build.Append("<head>").Append(HeadTag ?? DefaultHeadTag);
+        public string GenerateHtml(string bodyClasses, Control sync){
+            string headLayout = TweetDeckBridge.NotificationHeadLayout ?? DefaultHeadLayout;
+            string mainCSS = ScriptLoader.LoadResource("styles/notification.css", sync) ?? string.Empty;
+            string customCSS = Program.Config.User.CustomNotificationCSS ?? string.Empty;
             
-            if (enableCustomCSS){
-                build.Append("<style type='text/css'>").Append(CustomCSS).Append("</style>");
+            StringBuilder build = new StringBuilder(320 + headLayout.Length + mainCSS.Length + customCSS.Length + html.Length);
+            build.Append("<!DOCTYPE html>");
+            build.Append(headLayout);
+            build.Append("<style type='text/css'>").Append(mainCSS).Append("</style>");
 
-                if (!string.IsNullOrEmpty(Program.UserConfig.CustomNotificationCSS)){
-                    build.Append("<style type='text/css'>").Append(Program.UserConfig.CustomNotificationCSS).Append("</style>");
-                }
+            if (!string.IsNullOrWhiteSpace(customCSS)){
+                build.Append("<style type='text/css'>").Append(customCSS).Append("</style>");
             }
             
-            build.Append("</head>");
-            build.Append("<body class='scroll-styled-v");
+            build.Append("</head><body class='scroll-styled-v");
 
             if (!string.IsNullOrEmpty(bodyClasses)){
                 build.Append(' ').Append(bodyClasses);
             }
 
-            build.Append('\'').Append(isExample ? " td-example-notification" : "").Append("><div class='column' style='width:100%;height:auto;overflow:initial;'>");
+            build.Append("'><div class='column' style='width:100%!important;min-height:100vh!important;height:auto!important;overflow:initial!important;'>");
             build.Append(html);
-            build.Append("</div></body>");
-            build.Append("</html>");
+            build.Append("</div></body></html>");
             return build.ToString();
         }
     }

Core/Other/Analytics/AnalyticsFile.cs

@@ -0,0 +1,135 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Reflection;
+using TweetDuck.Data.Serialization;
+
+namespace TweetDuck.Core.Other.Analytics{
+    [SuppressMessage("ReSharper", "AutoPropertyCanBeMadeGetOnly.Local")]
+    sealed class AnalyticsFile{
+        private static readonly FileSerializer<AnalyticsFile> Serializer = new FileSerializer<AnalyticsFile>();
+
+        static AnalyticsFile(){
+            Serializer.RegisterTypeConverter(typeof(DateTime), new SingleTypeConverter<DateTime>{
+                ConvertToString = value => value.ToBinary().ToString(),
+                ConvertToObject = value => DateTime.FromBinary(long.Parse(value))
+            });
+
+            Serializer.RegisterTypeConverter(typeof(Counter), new SingleTypeConverter<Counter>{
+                ConvertToString = value => value.Value.ToString(),
+                ConvertToObject = value => int.Parse(value)
+            });
+        }
+
+        public static readonly AnalyticsFile Dummy = new AnalyticsFile();
+
+        // STATE PROPERTIES
+        
+        public DateTime LastDataCollection  { get; set; } = DateTime.MinValue;
+        public string LastCollectionVersion { get; set; } = null;
+        public string LastCollectionMessage { get; set; } = null;
+
+        // USAGE DATA
+
+        public Counter OpenOptions { get; private set; } = 0;
+        public Counter OpenPlugins { get; private set; } = 0;
+        public Counter OpenAbout   { get; private set; } = 0;
+        public Counter OpenGuide   { get; private set; } = 0;
+
+        public Counter DesktopNotifications { get; private set; } = 0;
+        public Counter SoundNotifications   { get; private set; } = 0;
+        public Counter NotificationMutes    { get; private set; } = 0;
+        
+        public Counter BrowserContextMenus           { get; private set; } = 0;
+        public Counter BrowserExtraMouseButtons      { get; private set; } = 0;
+        public Counter NotificationContextMenus      { get; private set; } = 0;
+        public Counter NotificationExtraMouseButtons { get; private set; } = 0;
+        public Counter NotificationKeyboardShortcuts { get; private set; } = 0;
+
+        public Counter BrowserReloads   { get; private set; } = 0;
+        public Counter CopiedUsernames  { get; private set; } = 0;
+        public Counter ViewedImages     { get; private set; } = 0;
+        public Counter DownloadedImages { get; private set; } = 0;
+        public Counter DownloadedVideos { get; private set; } = 0;
+        public Counter UsedROT13        { get; private set; } = 0;
+
+        public Counter TweetScreenshots { get; private set; } = 0;
+        public Counter TweetDetails     { get; private set; } = 0;
+        public Counter VideoPlays       { get; private set; } = 0;
+
+        // END OF DATA
+
+        public event EventHandler PropertyChanged;
+        
+        private readonly string file;
+        
+        private AnalyticsFile(string file){
+            this.file = file;
+        }
+
+        private AnalyticsFile(){
+            this.file = null;
+        }
+
+        private void SetupProperties(){
+            foreach(Counter counter in GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public).Where(prop => prop.PropertyType == typeof(Counter)).Select(prop => (Counter)prop.GetValue(this))){
+                counter.SetOwner(this);
+            }
+        }
+
+        public void OnPropertyChanged(){
+            PropertyChanged?.Invoke(this, EventArgs.Empty);
+        }
+
+        public void Save(){
+            if (file == null){
+                return;
+            }
+
+            try{
+                Serializer.Write(file, this);
+            }catch(Exception e){
+                Program.Reporter.HandleException("Analytics File Error", "Could not save the analytics file.", true, e);
+            }
+        }
+        
+        public static AnalyticsFile Load(string file){
+            AnalyticsFile config = new AnalyticsFile(file);
+            
+            try{
+                Serializer.ReadIfExists(file, config);
+            }catch(Exception e){
+                Program.Reporter.HandleException("Analytics File Error", "Could not open the analytics file.", true, e);
+            }
+            
+            config.SetupProperties();
+            return config;
+        }
+
+        public interface IProvider{
+            AnalyticsFile AnalyticsFile { get; }
+        }
+
+        public sealed class Counter{
+            public int Value { get; private set; }
+
+            private AnalyticsFile owner;
+
+            public Counter(int value){
+                this.Value = value;
+            }
+
+            public void SetOwner(AnalyticsFile owner){
+                this.owner = owner;
+            }
+
+            public void Trigger(){
+                ++Value;
+                owner?.OnPropertyChanged();
+            }
+
+            public static implicit operator int(Counter counter) => counter.Value;
+            public static implicit operator Counter(int value) => new Counter(value);
+        }
+    }
+}

Core/Other/Analytics/AnalyticsManager.cs

@@ -0,0 +1,158 @@
+// Uncomment to debug reports locally
+// #define ANALYTICS_LOCALHOST
+// #define ANALYTICS_INSTANT
+
+using System;
+using System.Net;
+using System.Threading.Tasks;
+using System.Timers;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Utils;
+using TweetDuck.Plugins;
+
+namespace TweetDuck.Core.Other.Analytics{
+    sealed class AnalyticsManager : IDisposable{
+        private static readonly TimeSpan CollectionInterval = TimeSpan.FromDays(14);
+
+        private static readonly Uri CollectionUrl = new Uri(
+            #if (DEBUG && ANALYTICS_LOCALHOST)
+            "http://localhost/newhome/tweetduck/~breadcrumb/request.php?type=report"
+            #else
+            "https://tweetduck.chylex.com/breadcrumb/report"
+            #endif
+            );
+        
+        public AnalyticsFile File { get; }
+
+        private readonly FormBrowser browser;
+        private readonly PluginManager plugins;
+        private readonly Timer currentTimer, saveTimer;
+
+        public AnalyticsManager(FormBrowser browser, PluginManager plugins, string file){
+            this.browser = browser;
+            this.plugins = plugins;
+
+            this.File = AnalyticsFile.Load(file);
+            this.File.PropertyChanged += File_PropertyChanged;
+
+            this.currentTimer = new Timer{ SynchronizingObject = browser };
+            this.currentTimer.Elapsed += currentTimer_Elapsed;
+
+            this.saveTimer = new Timer{ SynchronizingObject = browser, Interval = 60000 };
+            this.saveTimer.Elapsed += saveTimer_Elapsed;
+
+            if (this.File.LastCollectionVersion != Program.VersionTag){
+                ScheduleReportIn(TimeSpan.FromHours(8), string.Empty);
+            }
+            else{
+                RestartTimer();
+            }
+
+            #if (DEBUG && ANALYTICS_INSTANT)
+            SendReport();
+            #endif
+        }
+
+        public void Dispose(){
+            File.PropertyChanged -= File_PropertyChanged;
+
+            if (saveTimer.Enabled){
+                File.Save();
+            }
+
+            currentTimer.Dispose();
+            saveTimer.Dispose();
+        }
+
+        private void File_PropertyChanged(object sender, EventArgs e){
+            saveTimer.Enabled = true;
+        }
+
+        private void saveTimer_Elapsed(object sender, ElapsedEventArgs e){
+            saveTimer.Stop();
+            File.Save();
+        }
+
+        private void ScheduleReportIn(TimeSpan delay, string message = null){
+            SetLastDataCollectionTime(DateTime.Now.Subtract(CollectionInterval).Add(delay), message);
+        }
+
+        private void SetLastDataCollectionTime(DateTime dt, string message = null){
+            File.LastDataCollection = new DateTime(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, 0, dt.Kind);
+            File.LastCollectionVersion = Program.VersionTag;
+            File.LastCollectionMessage = message ?? dt.ToString("g", Program.Culture);
+
+            File.Save();
+            RestartTimer();
+        }
+
+        private void RestartTimer(){
+            TimeSpan diff = DateTime.Now.Subtract(File.LastDataCollection);
+            int minutesTillNext = (int)(CollectionInterval.TotalMinutes-Math.Floor(diff.TotalMinutes));
+            
+            currentTimer.Interval = Math.Max(minutesTillNext, 2)*60000;
+            currentTimer.Start();
+        }
+
+        private void currentTimer_Elapsed(object sender, ElapsedEventArgs e){
+            currentTimer.Stop();
+
+            TimeSpan diff = DateTime.Now.Subtract(File.LastDataCollection);
+            
+            if (Math.Floor(diff.TotalMinutes) >= CollectionInterval.TotalMinutes){
+                SendReport();
+            }
+            else{
+                RestartTimer();
+            }
+        }
+        
+        private void SendReport(){
+            AnalyticsReportGenerator.ExternalInfo info = AnalyticsReportGenerator.ExternalInfo.From(browser);
+
+            Task.Factory.StartNew(() => {
+                AnalyticsReport report = AnalyticsReportGenerator.Create(File, info, plugins);
+
+                #if (DEBUG && !ANALYTICS_INSTANT)
+                System.Diagnostics.Debugger.Break();
+                #endif
+
+                BrowserUtils.CreateWebClient().UploadValues(CollectionUrl, "POST", report.ToNameValueCollection());
+            }).ContinueWith(task => browser.InvokeAsyncSafe(() => {
+                if (task.Status == TaskStatus.RanToCompletion){
+                    SetLastDataCollectionTime(DateTime.Now);
+                }
+                else if (task.Exception != null){
+                    string message = null;
+
+                    if (task.Exception.InnerException is WebException e){
+                        switch(e.Status){
+                            case WebExceptionStatus.ConnectFailure:
+                                message = "Connection Error";
+                                break;
+
+                            case WebExceptionStatus.NameResolutionFailure:
+                                message = "DNS Error";
+                                break;
+
+                            case WebExceptionStatus.ProtocolError:
+                                HttpWebResponse response = e.Response as HttpWebResponse;
+                                message = "HTTP Error "+(response != null ? $"{(int)response.StatusCode} ({response.StatusDescription})" : "(unknown code)");
+                                break;
+                        }
+
+                        #if DEBUG
+                        System.IO.Stream responseStream = e.Response.GetResponseStream();
+
+                        if (responseStream != null){
+                            System.Diagnostics.Debug.WriteLine(new System.IO.StreamReader(responseStream).ReadToEnd());
+                        }
+                        #endif
+                    }
+
+                    ScheduleReportIn(TimeSpan.FromHours(4), message ?? "Error: "+(task.Exception.InnerException?.Message ?? task.Exception.Message));
+                }
+            }));
+        }
+    }
+}

Core/Other/Analytics/AnalyticsReport.cs

@@ -0,0 +1,57 @@
+using System.Collections;
+using System.Collections.Specialized;
+using System.Text;
+
+namespace TweetDuck.Core.Other.Analytics{
+    sealed class AnalyticsReport : IEnumerable{
+        private OrderedDictionary data = new OrderedDictionary(32);
+        private int separators;
+
+        public void Add(int ignored){ // adding separators to pretty print
+            data.Add((++separators).ToString(), null);
+        }
+
+        public void Add(string key, string value){
+            data.Add(key, value);
+        }
+
+        public AnalyticsReport FinalizeReport(){
+            if (!data.IsReadOnly){
+                data = data.AsReadOnly();
+            }
+
+            return this;
+        }
+
+        public IEnumerator GetEnumerator(){
+            return data.GetEnumerator();
+        }
+
+        public NameValueCollection ToNameValueCollection(){
+            NameValueCollection collection = new NameValueCollection();
+
+            foreach(DictionaryEntry entry in data){
+                if (entry.Value != null){
+                    collection.Add(((string)entry.Key).ToLower().Replace(' ', '_'), (string)entry.Value);
+                }
+            }
+
+            return collection;
+        }
+
+        public override string ToString(){
+            StringBuilder build = new StringBuilder(625);
+
+            foreach(DictionaryEntry entry in data){
+                if (entry.Value == null){
+                    build.AppendLine();
+                }
+                else{
+                    build.AppendLine(entry.Key+": "+entry.Value);
+                }
+            }
+
+            return build.ToString();
+        }
+    }
+}

Core/Other/Analytics/AnalyticsReportGenerator.cs

@@ -0,0 +1,325 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.IO;
+using System.Windows.Forms;
+using Microsoft.Win32;
+using TweetDuck.Configuration;
+using System.Linq;
+using System.Management;
+using System.Text.RegularExpressions;
+using TweetDuck.Core.Notification;
+using TweetDuck.Core.Utils;
+using TweetDuck.Plugins;
+using TweetDuck.Plugins.Enums;
+
+namespace TweetDuck.Core.Other.Analytics{
+    static class AnalyticsReportGenerator{
+        public static AnalyticsReport Create(AnalyticsFile file, ExternalInfo info, PluginManager plugins){
+            Dictionary<string, string> editLayoutDesign = EditLayoutDesignPluginData;
+
+            return new AnalyticsReport{
+                { "App Version"   , Program.VersionTag },
+                { "App Type"      , Program.IsPortable ? "portable" : "installed" },
+                { "App Dev Tools" , Bool(BrowserUtils.HasDevTools) },
+                0,
+                { "System Name"        , SystemName },
+                { "System Edition"     , SystemEdition },
+                { "System Environment" , Environment.Is64BitOperatingSystem ? "64-bit" : "32-bit" },
+                { "System Build"       , SystemBuild },
+                { "System Locale"      , Program.Culture.Name.ToLower() },
+                0,
+                { "RAM" , Exact(RamSize) },
+                { "GPU" , GpuVendor },
+                0,
+                { "Screen Count"      , Exact(Screen.AllScreens.Length) },
+                { "Screen Resolution" , info.Resolution ?? "(unknown)" },
+                { "Screen DPI"        , info.DPI != null ? Exact(info.DPI.Value) : "(unknown)" },
+                0,
+                { "Hardware Acceleration"     , Bool(SysConfig.HardwareAcceleration) },
+                { "Clear Cache Automatically" , Bool(SysConfig.ClearCacheAutomatically) },
+                { "Clear Cache Threshold"     , Exact(SysConfig.ClearCacheThreshold) },
+                0,
+                { "Expand Links"                  , Bool(UserConfig.ExpandLinksOnHover) },
+                { "Search In First Column"        , Bool(UserConfig.OpenSearchInFirstColumn) },
+                { "Keep Like Follow Dialogs Open" , Bool(UserConfig.KeepLikeFollowDialogsOpen) },
+                { "Best Image Quality"            , Bool(UserConfig.BestImageQuality) },
+                { "Animated Images"               , Bool(UserConfig.EnableAnimatedImages) },
+                0,
+                { "Smooth Scrolling" , Bool(UserConfig.EnableSmoothScrolling) },
+                { "Custom Browser"   , CustomBrowser },
+                { "Zoom"             , Exact(UserConfig.ZoomLevel) },
+                0,
+                { "Spell Check"                 , Bool(UserConfig.EnableSpellCheck) },
+                { "Spell Check Language"        , UserConfig.SpellCheckLanguage.ToLower() },
+                { "Translation Target Language" , UserConfig.TranslationTarget },
+                0,
+                { "Updates"          , Bool(UserConfig.EnableUpdateCheck) },
+                { "Update Dismissed" , Bool(!string.IsNullOrEmpty(UserConfig.DismissedUpdate)) },
+                0,
+                { "Tray"           , TrayMode },
+                { "Tray Highlight" , Bool(UserConfig.EnableTrayHighlight) },
+                0,
+                { "Notification Position"            , NotificationPosition },
+                { "Notification Size"                , NotificationSize },
+                { "Notification Timer"               , NotificationTimer },
+                { "Notification Timer Speed"         , RoundUp(UserConfig.NotificationDurationValue, 5) },
+                { "Notification Scroll Speed"        , Exact(UserConfig.NotificationScrollSpeed) },
+                { "Notification Column Title"        , Bool(UserConfig.DisplayNotificationColumn) },
+                { "Notification Media Previews"      , Bool(UserConfig.NotificationMediaPreviews) },
+                { "Notification Link Skip"           , Bool(UserConfig.NotificationSkipOnLinkClick) },
+                { "Notification Non-Intrusive"       , Bool(UserConfig.NotificationNonIntrusiveMode) },
+                { "Notification Idle Pause"          , Exact(UserConfig.NotificationIdlePauseSeconds) },
+                { "Custom Sound Notification"        , string.IsNullOrEmpty(UserConfig.NotificationSoundPath) ? "off" : Path.GetExtension(UserConfig.NotificationSoundPath) },
+                { "Custom Sound Notification Volume" , RoundUp(UserConfig.NotificationSoundVolume, 5) },
+                0,
+                { "Program Arguments"       , List(ProgramArguments) },
+                { "Custom CEF Arguments"    , RoundUp((UserConfig.CustomCefArgs ?? string.Empty).Length, 10) },
+                { "Custom Browser CSS"      , RoundUp((UserConfig.CustomBrowserCSS ?? string.Empty).Length, 50) },
+                { "Custom Notification CSS" , RoundUp((UserConfig.CustomNotificationCSS ?? string.Empty).Length, 50) },
+                0,
+                { "Plugins All"     , List(plugins.Plugins.Select(Plugin)) },
+                { "Plugins Enabled" , List(plugins.Plugins.Where(plugin => plugins.Config.IsEnabled(plugin)).Select(Plugin)) },
+                0,
+                { "Theme"               , Dict(editLayoutDesign, "_theme",                  "light/def") },
+                { "Column Width"        , Dict(editLayoutDesign, "columnWidth",             "310px/def") },
+                { "Font Size"           , Dict(editLayoutDesign, "fontSize",                "12px/def") },
+                { "Large Quote Font"    , Dict(editLayoutDesign, "increaseQuoteTextSize",   "false/def") },
+                { "Small Compose Font"  , Dict(editLayoutDesign, "smallComposeTextSize",    "false/def") },
+                { "Avatar Radius"       , Dict(editLayoutDesign, "avatarRadius",            "2/def") },
+                { "Hide Tweet Actions"  , Dict(editLayoutDesign, "hideTweetActions",        "true/def") },
+                { "Move Tweet Actions"  , Dict(editLayoutDesign, "moveTweetActionsToRight", "true/def") },
+                { "Theme Color Tweaks"  , Dict(editLayoutDesign, "themeColorTweaks",        "true/def") },
+                { "Revert Icons"        , Dict(editLayoutDesign, "revertIcons",             "true/def") },
+                { "Optimize Animations" , Dict(editLayoutDesign, "optimizeAnimations",      "true/def") },
+                { "Reply Account Mode"  , ReplyAccountConfigFromPlugin },
+                { "Template Count"      , Exact(TemplateCountFromPlugin) },
+                0,
+                { "Opened Options"                   , LogRound(file.OpenOptions, 4) },
+                { "Opened Plugins"                   , LogRound(file.OpenPlugins, 4) },
+                { "Opened About"                     , LogRound(file.OpenAbout, 4) },
+                { "Opened Guide"                     , LogRound(file.OpenGuide, 4) },
+                { "Desktop Notifications"            , LogRound(file.DesktopNotifications, 5) },
+                { "Sound Notifications"              , LogRound(file.SoundNotifications, 5) },
+                { "Notification Mutes"               , LogRound(file.NotificationMutes, 2) },
+                { "Browser Context Menus"            , LogRound(file.BrowserContextMenus, 2) },
+                { "Browser Extra Mouse Buttons"      , LogRound(file.BrowserExtraMouseButtons, 2) },
+                { "Notification Context Menus"       , LogRound(file.NotificationContextMenus, 2) },
+                { "Notification Extra Mouse Buttons" , LogRound(file.NotificationExtraMouseButtons, 2) },
+                { "Notification Keyboard Shortcuts"  , LogRound(file.NotificationKeyboardShortcuts, 2) },
+                { "Browser Reloads"                  , LogRound(file.BrowserReloads, 2) },
+                { "Copied Usernames"                 , LogRound(file.CopiedUsernames, 2) },
+                { "Viewed Images"                    , LogRound(file.ViewedImages, 2) },
+                { "Downloaded Images"                , LogRound(file.DownloadedImages, 2) },
+                { "Downloaded Videos"                , LogRound(file.DownloadedVideos, 2) },
+                { "Used ROT13"                       , LogRound(file.UsedROT13, 2) },
+                { "Tweet Screenshots"                , LogRound(file.TweetScreenshots, 2) },
+                { "Tweet Details"                    , LogRound(file.TweetDetails, 2) },
+                { "Video Plays"                      , LogRound(file.VideoPlays, 4) }
+            }.FinalizeReport();
+        }
+
+        private static UserConfig UserConfig => Program.Config.User;
+        private static SystemConfig SysConfig => Program.Config.System;
+
+        private static string Bool(bool value) => value ? "on" : "off";
+        private static string Exact(int value) => value.ToString();
+        private static string RoundUp(int value, int multiple) => (multiple*(int)Math.Ceiling((double)value/multiple)).ToString();
+        private static string LogRound(int value, int logBase) => (value <= 0 ? 0 : (int)Math.Pow(logBase, Math.Floor(Math.Log(value, logBase)))).ToString();
+        private static string Plugin(Plugin plugin) => plugin.Group.GetIdentifierPrefixShort()+plugin.Identifier.Substring(plugin.Group.GetIdentifierPrefix().Length);
+        private static string Dict(Dictionary<string, string> dict, string key, string def = "(unknown)") => dict.TryGetValue(key, out string value) ? value : def;
+        private static string List(IEnumerable<string> list) => string.Join("|", list.DefaultIfEmpty("(none)"));
+
+        private static string SystemName { get; }
+        private static string SystemEdition { get; }
+        private static string SystemBuild { get; }
+        private static int RamSize { get; }
+        private static string GpuVendor { get; }
+        private static string[] ProgramArguments { get; }
+
+        static AnalyticsReportGenerator(){
+            string osName, osEdition, osBuild;
+
+            try{
+                using(RegistryKey key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion", false)){
+                    // ReSharper disable once PossibleNullReferenceException
+                    osName = key.GetValue("ProductName") as string;
+                    osBuild = key.GetValue("CurrentBuild") as string;
+                    osEdition = null;
+                    
+                    if (osName != null){
+                        Match match = Regex.Match(osName, @"^(.*?\d+(?:\.\d+)?) (.*)$");
+
+                        if (match.Success){
+                            osName = match.Groups[1].Value;
+                            osEdition = match.Groups[2].Value;
+                        }
+                    }
+                }
+            }catch{
+                osName = osEdition = osBuild = null;
+            }
+
+            SystemName = osName ?? "Windows (unknown)";
+            SystemEdition = osEdition ?? "(unknown)";
+            SystemBuild = osBuild ?? "(unknown)";
+
+            try{
+                using(ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT Capacity FROM Win32_PhysicalMemory")){
+                    foreach(ManagementBaseObject obj in searcher.Get()){
+                        RamSize += (int)((ulong)obj["Capacity"]/(1024L*1024L));
+                    }
+                }
+            }catch{
+                RamSize = 0;
+            }
+
+            string gpu = null;
+
+            try{
+                using(ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT Caption FROM Win32_VideoController")){
+                    foreach(ManagementBaseObject obj in searcher.Get()){
+                        string vendor = obj["Caption"] as string;
+
+                        if (!string.IsNullOrEmpty(vendor)){
+                            gpu = vendor;
+                        }
+                    }
+                }
+            }catch{
+                // rip
+            }
+
+            GpuVendor = gpu ?? "(unknown)";
+
+            Dictionary<string, string> args = new Dictionary<string, string>();
+            Arguments.GetCurrentClean().ToDictionary(args);
+            ProgramArguments = args.Keys.Select(key => key.TrimStart('-')).ToArray();
+        }
+
+        private static string CustomBrowser{
+            get{
+                return Path.GetFileName(UserConfig.BrowserPath) ?? string.Empty;
+            }
+        }
+
+        private static string TrayMode{
+            get{
+                switch(UserConfig.TrayBehavior){
+                    case TrayIcon.Behavior.DisplayOnly: return "icon";
+                    case TrayIcon.Behavior.MinimizeToTray: return "minimize";
+                    case TrayIcon.Behavior.CloseToTray: return "close";
+                    case TrayIcon.Behavior.Combined: return "combined";
+                    default: return "off";
+                }
+            }
+        }
+
+        private static string NotificationPosition{
+            get{
+                switch(UserConfig.NotificationPosition){
+                    case TweetNotification.Position.TopLeft: return "top left";
+                    case TweetNotification.Position.TopRight: return "top right";
+                    case TweetNotification.Position.BottomLeft: return "bottom left";
+                    case TweetNotification.Position.BottomRight: return "bottom right";
+                    default: return "custom";
+                }
+            }
+        }
+
+        private static string NotificationSize{
+            get{
+                switch(UserConfig.NotificationSize){
+                    case TweetNotification.Size.Auto: return "auto";
+                    default: return RoundUp(UserConfig.CustomNotificationSize.Width, 20)+"x"+RoundUp(UserConfig.CustomNotificationSize.Height, 20);
+                }
+            }
+        }
+
+        private static string NotificationTimer{
+            get{
+                if (!UserConfig.DisplayNotificationTimer){
+                    return "off";
+                }
+                else{
+                    return UserConfig.NotificationTimerCountDown ? "count down" : "count up";
+                }
+            }
+        }
+
+        private static Dictionary<string, string> EditLayoutDesignPluginData{
+            get{
+                Dictionary<string, string> dict = new Dictionary<string, string>();
+                
+                try{
+                    string data = File.ReadAllText(Path.Combine(Program.PluginDataPath, "official", "edit-design", "config.json"));
+
+                    foreach(Match match in Regex.Matches(data, "\"(\\w+?)\":(.*?)[,}]")){
+                        dict[match.Groups[1].Value] = match.Groups[2].Value.Trim('"');
+                    }
+                }catch{
+                    // rip
+                }
+
+                return dict;
+            }
+        }
+
+        private static int TemplateCountFromPlugin{
+            get{
+                try{
+                    string data = File.ReadAllText(Path.Combine(Program.PluginDataPath, "official", "templates", "config.json"));
+                    return Math.Min(StringUtils.CountOccurrences(data, "{\"name\":"), StringUtils.CountOccurrences(data, ",\"contents\":"));
+                }catch{
+                    return 0;
+                }
+            }
+        }
+
+        private static string ReplyAccountConfigFromPlugin{
+            get{
+                try{
+                    string data = File.ReadAllText(Path.Combine(Program.PluginDataPath, "official", "reply-account", "configuration.js")).Replace(" ", "");
+
+                    Match matchType = Regex.Match(data, "defaultAccount:\"([#@])(.*?)\"(?:,|$)");
+                    Match matchAdvanced = Regex.Match(data, "useAdvancedSelector:(.*?)(?:,|$)", RegexOptions.Multiline);
+
+                    if (!matchType.Success){
+                        return data.Contains("defaultAccount:\"\"") ? "(legacy)" : "(unknown)";
+                    }
+
+                    string accType = matchType.Groups[1].Value == "#" ? matchType.Groups[2].Value : "account";
+                    return matchAdvanced.Success && !matchAdvanced.Value.Contains("false") ? "advanced/"+accType : accType;
+                }catch{
+                    return "(unknown)";
+                }
+            }
+        }
+
+        public class ExternalInfo{
+            public static ExternalInfo From(Form form){
+                if (form == null){
+                    return new ExternalInfo();
+                }
+                else{
+                    Screen screen = Screen.FromControl(form); // works on multi-monitor setups even in tray
+                    int dpi;
+
+                    using(Graphics graphics = form.CreateGraphics()){
+                        dpi = (int)graphics.DpiY;
+                    }
+
+                    return new ExternalInfo{
+                        Resolution = screen.Bounds.Width+"x"+screen.Bounds.Height,
+                        DPI = dpi
+                    };
+                }
+            }
+
+            public string Resolution { get; private set; }
+            public int? DPI { get; private set; }
+
+            private ExternalInfo(){}
+        }
+    }
+}

Core/Other/FormAbout.Designer.cs

@@ -1,4 +1,4 @@
-namespace TweetDck.Core.Other {
+namespace TweetDuck.Core.Other {
     sealed partial class FormAbout {
         /// <summary>
         /// Required designer variable.
@@ -23,7 +23,6 @@ namespace TweetDck.Core.Other {
         /// the contents of this method with the code editor.
         /// </summary>
         private void InitializeComponent() {
-            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FormAbout));
             this.pictureLogo = new System.Windows.Forms.PictureBox();
             this.labelDescription = new System.Windows.Forms.Label();
             this.labelTips = new System.Windows.Forms.LinkLabel();
@@ -38,11 +37,11 @@ namespace TweetDck.Core.Other {
             // 
             this.pictureLogo.BackgroundImageLayout = System.Windows.Forms.ImageLayout.None;
             this.pictureLogo.ErrorImage = null;
-            this.pictureLogo.Image = ((System.Drawing.Image)(resources.GetObject("pictureLogo.Image")));
             this.pictureLogo.InitialImage = null;
             this.pictureLogo.Location = new System.Drawing.Point(12, 12);
             this.pictureLogo.Name = "pictureLogo";
             this.pictureLogo.Size = new System.Drawing.Size(96, 96);
+            this.pictureLogo.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
             this.pictureLogo.TabIndex = 0;
             this.pictureLogo.TabStop = false;
             // 
@@ -51,23 +50,22 @@ namespace TweetDck.Core.Other {
             this.labelDescription.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
             | System.Windows.Forms.AnchorStyles.Left) 
             | System.Windows.Forms.AnchorStyles.Right)));
-            this.labelDescription.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238)));
+            this.labelDescription.Font = new System.Drawing.Font("Segoe UI", 9.75F);
             this.labelDescription.Location = new System.Drawing.Point(114, 12);
             this.labelDescription.Name = "labelDescription";
-            this.labelDescription.Size = new System.Drawing.Size(232, 109);
+            this.labelDescription.Size = new System.Drawing.Size(232, 113);
             this.labelDescription.TabIndex = 0;
             // 
             // labelTips
             // 
             this.labelTips.Dock = System.Windows.Forms.DockStyle.Fill;
-            this.labelTips.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238)));
+            this.labelTips.Font = new System.Drawing.Font("Segoe UI", 9.75F, System.Drawing.FontStyle.Regular);
             this.labelTips.LinkArea = new System.Windows.Forms.LinkArea(0, 0);
             this.labelTips.Location = new System.Drawing.Point(117, 0);
             this.labelTips.Margin = new System.Windows.Forms.Padding(0);
             this.labelTips.Name = "labelTips";
-            this.labelTips.Size = new System.Drawing.Size(99, 16);
+            this.labelTips.Size = new System.Drawing.Size(99, 18);
             this.labelTips.TabIndex = 1;
-            this.labelTips.TabStop = true;
             this.labelTips.Text = "Tips && Tricks";
             this.labelTips.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
             this.labelTips.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.OnLinkClicked);
@@ -76,14 +74,13 @@ namespace TweetDck.Core.Other {
             // 
             this.labelWebsite.AutoSize = true;
             this.labelWebsite.Dock = System.Windows.Forms.DockStyle.Fill;
-            this.labelWebsite.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238)));
+            this.labelWebsite.Font = new System.Drawing.Font("Segoe UI", 9.75F, System.Drawing.FontStyle.Regular);
             this.labelWebsite.LinkArea = new System.Windows.Forms.LinkArea(0, 0);
             this.labelWebsite.Location = new System.Drawing.Point(0, 0);
             this.labelWebsite.Margin = new System.Windows.Forms.Padding(0);
             this.labelWebsite.Name = "labelWebsite";
-            this.labelWebsite.Size = new System.Drawing.Size(117, 16);
+            this.labelWebsite.Size = new System.Drawing.Size(117, 18);
             this.labelWebsite.TabIndex = 0;
-            this.labelWebsite.TabStop = true;
             this.labelWebsite.Text = "Official Website";
             this.labelWebsite.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
             this.labelWebsite.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.OnLinkClicked);
@@ -99,24 +96,23 @@ namespace TweetDck.Core.Other {
             this.tablePanelLinks.Controls.Add(this.labelIssues, 2, 0);
             this.tablePanelLinks.Controls.Add(this.labelWebsite, 0, 0);
             this.tablePanelLinks.Controls.Add(this.labelTips, 1, 0);
-            this.tablePanelLinks.Location = new System.Drawing.Point(12, 124);
+            this.tablePanelLinks.Location = new System.Drawing.Point(12, 128);
             this.tablePanelLinks.Name = "tablePanelLinks";
             this.tablePanelLinks.RowCount = 1;
             this.tablePanelLinks.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 100F));
-            this.tablePanelLinks.Size = new System.Drawing.Size(334, 16);
+            this.tablePanelLinks.Size = new System.Drawing.Size(334, 18);
             this.tablePanelLinks.TabIndex = 1;
             // 
             // labelIssues
             // 
             this.labelIssues.Dock = System.Windows.Forms.DockStyle.Fill;
-            this.labelIssues.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238)));
+            this.labelIssues.Font = new System.Drawing.Font("Segoe UI", 9.75F, System.Drawing.FontStyle.Regular);
             this.labelIssues.LinkArea = new System.Windows.Forms.LinkArea(0, 0);
             this.labelIssues.Location = new System.Drawing.Point(216, 0);
             this.labelIssues.Margin = new System.Windows.Forms.Padding(0);
             this.labelIssues.Name = "labelIssues";
-            this.labelIssues.Size = new System.Drawing.Size(118, 16);
+            this.labelIssues.Size = new System.Drawing.Size(118, 18);
             this.labelIssues.TabIndex = 2;
-            this.labelIssues.TabStop = true;
             this.labelIssues.Text = "Report an Issue";
             this.labelIssues.TextAlign = System.Drawing.ContentAlignment.MiddleRight;
             this.labelIssues.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.OnLinkClicked);
@@ -126,16 +122,19 @@ namespace TweetDck.Core.Other {
             this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
             this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
             this.BackColor = System.Drawing.Color.White;
-            this.ClientSize = new System.Drawing.Size(358, 152);
+            this.ClientSize = new System.Drawing.Size(358, 156);
             this.Controls.Add(this.tablePanelLinks);
             this.Controls.Add(this.labelDescription);
             this.Controls.Add(this.pictureLogo);
             this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
+            this.HelpButton = true;
             this.MaximizeBox = false;
             this.MinimizeBox = false;
             this.Name = "FormAbout";
             this.ShowIcon = false;
             this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
+            this.HelpButtonClicked += new System.ComponentModel.CancelEventHandler(this.FormAbout_HelpButtonClicked);
+            this.HelpRequested += new System.Windows.Forms.HelpEventHandler(this.FormAbout_HelpRequested);
             ((System.ComponentModel.ISupportInitialize)(this.pictureLogo)).EndInit();
             this.tablePanelLinks.ResumeLayout(false);
             this.tablePanelLinks.PerformLayout();

Core/Other/FormAbout.cs

@@ -1,8 +1,11 @@
-using System.Windows.Forms;
-using TweetDck.Core.Utils;
+using System.ComponentModel;
+using System.Drawing;
+using System.IO;
+using System.Windows.Forms;
+using TweetDuck.Core.Utils;
 
-namespace TweetDck.Core.Other{
-    sealed partial class FormAbout : Form{
+namespace TweetDuck.Core.Other{
+    sealed partial class FormAbout : Form, FormManager.IAppDialog{
         private const string TipsLink = "https://github.com/chylex/TweetDuck/wiki";
         private const string IssuesLink = "https://github.com/chylex/TweetDuck/issues";
 
@@ -11,15 +14,33 @@ namespace TweetDck.Core.Other{
 
             Text = "About "+Program.BrandName+" "+Program.VersionTag;
 
-            labelDescription.Text = Program.BrandName+" was created by chylex as a replacement to the discontinued official TweetDeck client for Windows.\n\nThe program is available for free under the open source MIT license.";
+            labelDescription.Text = "TweetDuck was created by chylex as a replacement to the discontinued official TweetDeck client for Windows.\n\nThe program is available for free under the open source MIT license.";
             
             labelWebsite.Links.Add(new LinkLabel.Link(0, labelWebsite.Text.Length, Program.Website));
             labelTips.Links.Add(new LinkLabel.Link(0, labelTips.Text.Length, TipsLink));
             labelIssues.Links.Add(new LinkLabel.Link(0, labelIssues.Text.Length, IssuesLink));
+
+            MemoryStream logoStream = new MemoryStream(Properties.Resources.avatar);
+            pictureLogo.Image = Image.FromStream(logoStream);
+            Disposed += (sender, args) => logoStream.Dispose();
         }
 
         private void OnLinkClicked(object sender, LinkLabelLinkClickedEventArgs e){
-            BrowserUtils.OpenExternalBrowserUnsafe(e.Link.LinkData as string);
+            BrowserUtils.OpenExternalBrowser(e.Link.LinkData as string);
+        }
+
+        private void FormAbout_HelpRequested(object sender, HelpEventArgs hlpevent){
+            ShowGuide();
+        }
+
+        private void FormAbout_HelpButtonClicked(object sender, CancelEventArgs e){
+            e.Cancel = true;
+            ShowGuide();
+        }
+
+        private void ShowGuide(){
+            FormGuide.Show();
+            Close();
         }
     }
 }

Core/Other/FormAbout.resx

@@ -1,246 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
-  <data name="pictureLogo.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAAGAAAABgCAYAAADimHc4AAAABGdBTUEAALGOfPtRkwAAACBjSFJNAACH
-        DwAAjA8AAP1SAACBQAAAfXkAAOmLAAA85QAAGcxzPIV3AAAKOWlDQ1BQaG90b3Nob3AgSUNDIHByb2Zp
-        bGUAAEjHnZZ3VFTXFofPvXd6oc0wAlKG3rvAANJ7k15FYZgZYCgDDjM0sSGiAhFFRJoiSFDEgNFQJFZE
-        sRAUVLAHJAgoMRhFVCxvRtaLrqy89/Ly++Osb+2z97n77L3PWhcAkqcvl5cGSwGQyhPwgzyc6RGRUXTs
-        AIABHmCAKQBMVka6X7B7CBDJy82FniFyAl8EAfB6WLwCcNPQM4BOB/+fpFnpfIHomAARm7M5GSwRF4g4
-        JUuQLrbPipgalyxmGCVmvihBEcuJOWGRDT77LLKjmNmpPLaIxTmns1PZYu4V8bZMIUfEiK+ICzO5nCwR
-        3xKxRoowlSviN+LYVA4zAwAUSWwXcFiJIjYRMYkfEuQi4uUA4EgJX3HcVyzgZAvEl3JJS8/hcxMSBXQd
-        li7d1NqaQffkZKVwBALDACYrmcln013SUtOZvBwAFu/8WTLi2tJFRbY0tba0NDQzMv2qUP91829K3NtF
-        ehn4uWcQrf+L7a/80hoAYMyJarPziy2uCoDOLQDI3fti0zgAgKSobx3Xv7oPTTwviQJBuo2xcVZWlhGX
-        wzISF/QP/U+Hv6GvvmckPu6P8tBdOfFMYYqALq4bKy0lTcinZ6QzWRy64Z+H+B8H/nUeBkGceA6fwxNF
-        hImmjMtLELWbx+YKuGk8Opf3n5r4D8P+pMW5FonS+BFQY4yA1HUqQH7tBygKESDR+8Vd/6NvvvgwIH55
-        4SqTi3P/7zf9Z8Gl4iWDm/A5ziUohM4S8jMX98TPEqABAUgCKpAHykAd6ABDYAasgC1wBG7AG/iDEBAJ
-        VgMWSASpgA+yQB7YBApBMdgJ9oBqUAcaQTNoBcdBJzgFzoNL4Bq4AW6D+2AUTIBnYBa8BgsQBGEhMkSB
-        5CEVSBPSh8wgBmQPuUG+UBAUCcVCCRAPEkJ50GaoGCqDqqF6qBn6HjoJnYeuQIPQXWgMmoZ+h97BCEyC
-        qbASrAUbwwzYCfaBQ+BVcAK8Bs6FC+AdcCXcAB+FO+Dz8DX4NjwKP4PnEIAQERqiihgiDMQF8UeikHiE
-        j6xHipAKpAFpRbqRPuQmMorMIG9RGBQFRUcZomxRnqhQFAu1BrUeVYKqRh1GdaB6UTdRY6hZ1Ec0Ga2I
-        1kfboL3QEegEdBa6EF2BbkK3oy+ib6Mn0K8xGAwNo42xwnhiIjFJmLWYEsw+TBvmHGYQM46Zw2Kx8lh9
-        rB3WH8vECrCF2CrsUexZ7BB2AvsGR8Sp4Mxw7rgoHA+Xj6vAHcGdwQ3hJnELeCm8Jt4G749n43PwpfhG
-        fDf+On4Cv0CQJmgT7AghhCTCJkIloZVwkfCA8JJIJKoRrYmBRC5xI7GSeIx4mThGfEuSIemRXEjRJCFp
-        B+kQ6RzpLuklmUzWIjuSo8gC8g5yM/kC+RH5jQRFwkjCS4ItsUGiRqJDYkjiuSReUlPSSXK1ZK5kheQJ
-        yeuSM1J4KS0pFymm1HqpGqmTUiNSc9IUaVNpf+lU6RLpI9JXpKdksDJaMm4ybJkCmYMyF2TGKQhFneJC
-        YVE2UxopFykTVAxVm+pFTaIWU7+jDlBnZWVkl8mGyWbL1sielh2lITQtmhcthVZKO04bpr1borTEaQln
-        yfYlrUuGlszLLZVzlOPIFcm1yd2WeydPl3eTT5bfJd8p/1ABpaCnEKiQpbBf4aLCzFLqUtulrKVFS48v
-        vacIK+opBimuVTyo2K84p6Ss5KGUrlSldEFpRpmm7KicpFyufEZ5WoWiYq/CVSlXOavylC5Ld6Kn0Cvp
-        vfRZVUVVT1Whar3qgOqCmrZaqFq+WpvaQ3WCOkM9Xr1cvUd9VkNFw08jT6NF454mXpOhmai5V7NPc15L
-        Wytca6tWp9aUtpy2l3audov2Ax2yjoPOGp0GnVu6GF2GbrLuPt0berCehV6iXo3edX1Y31Kfq79Pf9AA
-        bWBtwDNoMBgxJBk6GWYathiOGdGMfI3yjTqNnhtrGEcZ7zLuM/5oYmGSYtJoct9UxtTbNN+02/R3Mz0z
-        llmN2S1zsrm7+QbzLvMXy/SXcZbtX3bHgmLhZ7HVosfig6WVJd+y1XLaSsMq1qrWaoRBZQQwShiXrdHW
-        ztYbrE9Zv7WxtBHYHLf5zdbQNtn2iO3Ucu3lnOWNy8ft1OyYdvV2o/Z0+1j7A/ajDqoOTIcGh8eO6o5s
-        xybHSSddpySno07PnU2c+c7tzvMuNi7rXM65Iq4erkWuA24ybqFu1W6P3NXcE9xb3Gc9LDzWepzzRHv6
-        eO7yHPFS8mJ5NXvNelt5r/Pu9SH5BPtU+zz21fPl+3b7wX7efrv9HqzQXMFb0ekP/L38d/s/DNAOWBPw
-        YyAmMCCwJvBJkGlQXlBfMCU4JvhI8OsQ55DSkPuhOqHC0J4wybDosOaw+XDX8LLw0QjjiHUR1yIVIrmR
-        XVHYqLCopqi5lW4r96yciLaILoweXqW9KnvVldUKq1NWn46RjGHGnIhFx4bHHol9z/RnNjDn4rziauNm
-        WS6svaxnbEd2OXuaY8cp40zG28WXxU8l2CXsTphOdEisSJzhunCruS+SPJPqkuaT/ZMPJX9KCU9pS8Wl
-        xqae5Mnwknm9acpp2WmD6frphemja2zW7Fkzy/fhN2VAGasyugRU0c9Uv1BHuEU4lmmfWZP5Jiss60S2
-        dDYvuz9HL2d7zmSue+63a1FrWWt78lTzNuWNrXNaV78eWh+3vmeD+oaCDRMbPTYe3kTYlLzpp3yT/LL8
-        V5vDN3cXKBVsLBjf4rGlpVCikF84stV2a9021DbutoHt5turtn8sYhddLTYprih+X8IqufqN6TeV33za
-        Eb9joNSydP9OzE7ezuFdDrsOl0mX5ZaN7/bb3VFOLy8qf7UnZs+VimUVdXsJe4V7Ryt9K7uqNKp2Vr2v
-        Tqy+XeNc01arWLu9dn4fe9/Qfsf9rXVKdcV17w5wD9yp96jvaNBqqDiIOZh58EljWGPft4xvm5sUmoqb
-        PhziHRo9HHS4t9mqufmI4pHSFrhF2DJ9NProje9cv+tqNWytb6O1FR8Dx4THnn4f+/3wcZ/jPScYJ1p/
-        0Pyhtp3SXtQBdeR0zHYmdo52RXYNnvQ+2dNt293+o9GPh06pnqo5LXu69AzhTMGZT2dzz86dSz83cz7h
-        /HhPTM/9CxEXbvUG9g5c9Ll4+ZL7pQt9Tn1nL9tdPnXF5srJq4yrndcsr3X0W/S3/2TxU/uA5UDHdavr
-        XTesb3QPLh88M+QwdP6m681Lt7xuXbu94vbgcOjwnZHokdE77DtTd1PuvriXeW/h/sYH6AdFD6UeVjxS
-        fNTws+7PbaOWo6fHXMf6Hwc/vj/OGn/2S8Yv7ycKnpCfVEyqTDZPmU2dmnafvvF05dOJZ+nPFmYKf5X+
-        tfa5zvMffnP8rX82YnbiBf/Fp99LXsq/PPRq2aueuYC5R69TXy/MF72Rf3P4LeNt37vwd5MLWe+x7ys/
-        6H7o/ujz8cGn1E+f/gUDmPP8usTo0wAAAAlwSFlzAAAuIgAALiIBquLdkgAAEVpJREFUeF7tXQl0VNd5
-        Thq3Tk7tc+qmiZMm7YmdJj1OT3Gd0kTMG3mJnZQEJzaSjXETx0lqNwt2jWscQGixBAJLSMhgA8YYbIyQ
-        hHYJI4lFGMwioQWxyewgMdoXtKFd4u/337lPjDRv9pk3g+A75zsMWv577/fd+9/l3Rl9johu0Y/U/OIt
-        6sfrLwIYT2de+SJ4F/j34LfB+8Ap4L9J8uvvgfy9b4DfBO8EPy9DBBwC3gCI93fgDHAuuA7cDVaDzWAX
-        OAAOgcNgP9gN8vc+A4vB9eBr4M/Be8GAMiPgDIBAXwVDwbXgEbAPJC+RDToGvgfOBr8mi/UbAsIACMFp
-        ZRaYC7aBWuL5gh3gdvBZ8C5ZHV3hVwPQaM7hS0ETqCWQnqwDE8Apsnq6wC8GoJEPgFtAzt9aYviTPJ9k
-        gkGyuj6FrgagUd8CeVIcBLUaH0gcATeD35XV9wl0MQCN4OXjn8EroFZjA5m8qooE/1o2x6vwuQGouAEs
-        A7UadyPxOPgj2SyvwacGoMILwRsh3ThLTksx4BdkEz2GTwxABb8C8pJSqxGTgTvAb8jmegSvG4CK/QvI
-        O1Wtik8mXgSnyma7Da8agAo9Auq5kfI3+Shkhmy+W/CaAajI42CvrNjNRJ7jZksZXIZXDEAFWPxA3FTp
-        xVHQLRM8NgAFPwTejD1/InkH/biUxWl4ZAAK5LP3mynnO+JV0KWJ2W0DUNCXwVOy4Fu8zhrQ6SWqJwbk
-        WxQa2Mxop6fSWyk0rYlCUhspZEs9zdxSJ8iv+WuhW5vpqYw27d93nXvB26RUduGWAQg+36KwwCULv7VF
-        iDx3Wx1tPNxCBy92UU17P7VdHaLWniE619JLu8900Nv7m+jFLBgCM9gs/l3NmCqlqU+nt+D/msYtk3LZ
-        hcsGIPB/gPaPF7jyKrW+rwNZnJCUBoraUU9H63po9No1NM8++odGac/ZDno5r45C2QitESGF59gv5dVT
-        clUHzc5gEyb8XOaVa6DDsyMU67wBCHg7WCULsEkezi9/jEptbfKLCdzrn0s30b5znWiS6xgeuUaby1so
-        NKVubDSwGZzCOG3NzTdRQXW7+NnM4+b2atUDPAPeIeXTBEK4ZMA8i+Ca5Ir+LrOOOvtHKGkfcit6kp4m
-        sBh/zDGRqaMfzfEMh5CuZiXXUOgWE72Ua6L1Jc10qqmXRkbNo4nT2PMw2sHcESvl0wTCOGcAAv0DyFtv
-        rULGyAKsO9SMUERD6EnRO+t1M4F76++zTNTUNSjK9wYutvVhzujTTGGrMG/wqNCqiwX5IsA/SxmtgDBO
-        G7DBIqhN8oR3suEqQpnRh7watcOcU31pAvfCWUgZ1Y3Xy/YlCk+Z28rlqrTTvkwpoxUQyrEBCPCvoONz
-        fVTg1xkm6hkYQajr4Mktdpd5uecrE9jg5IpWWaJvwRN1SHKtaA/PCfMLmyiq2DxPaNUN5KMKg5RzHBDO
-        KQNSLYLZJFfgVSz3tMBDeM0BrMNlr9H6fXfJ8V7AErK7f1iW5hsMjYxSSnkjPbnxLP1vbq2YE04399KV
-        vmGak9/kqF0FUs5xQFj7BuAXvwM6ddDGOfiNnQ0IYxvbTrYjVWDiwkrFW6OB83DaEd/3/obOfiq71Ekt
-        3YOkzgg8NUTxPOdgLpiV1TE6K7vzASnrGBDCoQF8b0cz6ESyqDG77BvAOI2VxJycy7bX2q4QJoYgDVxo
-        7ZPR9QVv4OzNb7OyOll8mpnWTNPXnlwnZR0DQtg2AAHuAPnCkmbwieQREFZQjzCOwfPChlJs/3mt7cFo
-        YAPn5NTRsFwa6on3kII05zUIjt4uXv9icx099u5pCn7rKBkSynoMC1K/LuUVQBi7BswcF9gBWYzfZ5vE
-        RsZZnG/powjsVsXc4IYR/DtLix2POm+C9wGrPjWfK1nWl3v6MxA+FB1xxgeX6OF3TpKSdASsIiMMMK48
-        TkpM4RwprwDC2TUgTw3uFFEZXgo2dA4glPNgu8pruyms0HxAJnaWThrBP7v2oHnfoQd48xWBelqmHe7t
-        Is2kNNJ/rj9HD648RsoKC+FVwgBj/MGDUl4BhNQ2AIH/FuTLq1aNtkfuFYWfXUEo18FGHKvrofg9DfRs
-        mknEcjQq2ABejeiFyEKTWXyUbU4z7fSLj0z06NpTELnKLLyl6BOZVDVgDM+8R8ps14AQy4Y6S1fmAXvg
-        npZ/oo0iiuro2VSYkdIgVhocX0zc0hQ2YDWWt3phIdrGp5+hW1vpZxsv0SOcZrR6uy1iFAQvLvqDlNmu
-        Ae9aCus0IQzn8/LL3QjnHbAZpZe6RE9fsL2O/jvTJFIdlzMz2URRhZflT/oer+fX0E/ePUXBttKMI3Ia
-        enNfhpRZ2wAI+XnQ4amnLXLamPdxHQ1i4+IL8AqqHvMMp6vdZ65Q8en2sXW5r/HbjZVYzVRoi+sMYZwx
-        saxWWbj1Swhn04B/BPkQSVNgu+TUAHKefB/LzMkE3s3PXgfxsbLRFNd5XlMWZT6AkDYN+JmVsE5QLEPz
-        WujXGY0iZ3N60GOHqheuDgzT4++U80SqJarz5DQUXfAcQlobACE5/fAb4jRFtkdOPatLWqmrf4RSKlvo
-        1fzL9MSGM7TuQJ04R7nR0dDRSw8mlGqL6gpXniDjkp2xyoKULyCslQH81MutCZgNWLz7+qaI83Jz9yAm
-        0A5q6/HeGb2/cPxyBxnivWEAT8T7c4Mjc+5EWCsD/gbkt4JqimyP6rGA+sRosqHgWD0Zlh/WFtUVsgHL
-        S44aI3O/hrBWBvCboN273cwTMJaHvEKZjEgsOkNKogcrIJViJVTeaIzefi/CWhnA7zJvGiesC+TVT85x
-        8wPryYYXNpl3upqiukQYsKKyR1my63sIa2UAv3WU3xelKbAj8k71lXz/nE76Em09A/Tjt5B+PF0BqUw6
-        MogN2RSEtjKAHz+6twdg8k6Yz4NOuXceFKgorm7yTv5XmXRkVIk78H2EtjLgfpBv+moL7AR5Mv5NRp1X
-        byf4GzH5n3kn/6vkkbS8dCpCWxnAnzrikQFMPiRbWFAnbkXc6OAN2BNreAPmjfwvyQbEH9I0gD/yxfM3
-        W/BxRFqTuBrYOzj+lsSNht0nG72bfphJVddgwL8jvJUBHk3C4yhNeCXfRJfaPL+p5i+8ln4Cq59KbSHd
-        ZVLloLJs7/0Ib2UAL0NbxgnpCWEC75Bnp5rog7IW6ujz7dURb+NsYxdvmswpQ0tItyiWod1KTJHmMpQ3
-        YvxhR9qCukiekGenN4tHjU9+VENPbzpLcbtq6GS9954X+BLLtp/y7uTLNG/EmozRBd9GEVYG8Gf37LEU
-        0RNy7/+o8gqdae6jQxc76eCFTqqo7aTGzsBPSRdbeuihRG/3fpANiC85qkTkaB5F8Adr8CeaaArqKsUj
-        yiJ9by14C2/keXnpqXIV5pTYPblB8zZ9BcVYGcDH0f9nKaJH5I1ZSgMduNCF8DcOjtS0k+L13C/JBize
-        EWeYn3wbihpvgHwgw+/71RbUDfIo+FNuvdWl3UAFn+a+KM59vLzyUWl+IPMbFHVd97EXZgPuAb3yKSfq
-        ZSUeBbFFNSgi8PHRwRrzut8Xvd/Ma8FR+XYfSf4FyJ+PoymqM1TvRIakNtP098/TQ5h4psWXUnzBaRQT
-        uDhZ1yknXi/uei0JHZTlpbVBr6z7IoqzNkAlRHR9Ira4E/lEcv31O5Hq9Q2Qe9bCrJPU3T+EYgILPajT
-        r96v8F3qYSL/G5bszuKOjiLHeP2FBETkj5G0FlmDapp5amsrzfiwhh5ZPeFOpCXxNSWxnGauKaed2OI7
-        8eZF3RCejXqjbj5MPWYDInJfZo1RpF0D+EOX7L4nbOzqdWqTSDN8J3Kst2sVbkF+sMGj4fmNlZR2uFas
-        uYflg3t/mLJy11lf530Q6/+3qoaw+vkOa4xibRvAgMj8oaYTRLe+eu3UnUgt8mhgIxLKKBhLvsdXltDc
-        zRV0qUXfXfKHBy7pID4ongUfKpfyOmXAf00U3ubVa0+IOCzAM+vKqOxCG6qhHzbziodvOvhq0rUk0k9Q
-        WPpLUl4BVMG2AbOyu+4CW1j8Jx1dvXaHLDx6/09XHabU0loaHNb32cG7n1zQT3w+fkgs75r6Pwl3S3kF
-        UA3bBjB+vvH8CnH1WqYLzeCukEcNVhnc459YXSaGf0evvk/O2OjovGqZdnQQn/l2NQVF5G2Qso4B1bFv
-        gCEs/X6kmhHNoCp5NHBDBPm1ShYbTKwQPZ1723T09tfTT4hnrL2D+h9N17Zdpd9uNI88UUet9viCGAFB
-        r29WpKxjQJXsG8AwLtv3sbhOpxUYjZi+5hg9s+E4zVpfRT9ZeZh+nFRKP11ZRqFry+mFD6soKreakg/V
-        iPzuz/V/TqVJ1E2s83UVX9yE2294baPV3y5AtRwboIRnT0OgUavAko++fZR++cFxKj7VQgPDI9Q3OCKE
-        HhgKjLOfc03d9ErqcX1TjiVhADLJdCnnOKB6jg1gGOP2pwsntQpAbxLzw/JSCsuqprNocCCgoaOPEgrP
-        0MOJJeZjZT17vUo++Vz6yU4poxVQTScNWJT5XfSefvNmQqMgJhuBhirxJTQ/4wRVXGqnUT9c0Drf3E3L
-        IfyPON2Ina0fer0gVoxJVcNBr31g9QZtFaiucwYwjEt2xdqcCywpRgRWOph0f7m+QuT/y+1XfbrD5Ztr
-        24/V05wtR8Wmzr/CS7JWscWrpHyaQNWdN0AJS7vDmFh2zmYqmkiZmnjF8WBCibhbuWbPeTqMyZiXnp4Y
-        wgdnfF2cl7Gc3x9Db+ccr/sEa4u87l9R3hAcnvllKZ8m0BTnDWAo4VmPGldyIXZSkRalGdwzeWTwaonP
-        gRZlV9O6vRcoq8JEu7E0LTnXSidMHSKNHK29Qofwf76Xw99/Dz8XiRXV7z48QjPeLkOqg+gwN2BEtyRv
-        WCNyQqRsNuGyAQxlya44p1KRPaqGQDxhCnrvGFlYlRZf558TcwxP+IEmuCXFI8eda6RcduGWAcaFaX9p
-        jD/0qdOp6GYia7K8pCp4UfqXpFx24ZYBDGVB6jeNKypMt0ywoPm8p9UYkW3zI8omwm0DGIbXN//AuKKy
-        VxSsVaGbiWYNhrBpdenPnHhkAAMTzUwUPnxTm6C2PWrbc1IWp+GxAQxDePavxlXkpiLazO2OKfqjlMMl
-        eMUABruPCt1kI4HbiuVm9PY/SRlchtcMYBjCMkJQMcwJN8HEzB0tqWrIGF3wvGy+W/CqAQwlLH2aknDY
-        xGthzYpPBnIHW1HRYozMeUw222143QDGtD8n3yP2CcKESZaSeAOaUFpuDM+8TzbXI/jEAIZxYepfGaIL
-        48yVngQpiVMO2qHEFq81Lkr32p819JkBKgyLMmeYD/Bu4NHAdU8sr1Ui85+SzfIafG4Aw7go4y5jbPEy
-        8TzhRpobxMitGjYu3fOOMWzrV2VzvApdDFDxw3mbpyhL92aL09RATkuibhitb35agIn2h7L6PoGuBqgw
-        hOc8Zow7UCQayyMiIPYOnONlmow7sEeJzPPoL+Q5C78YoAI76KBpMTtXK4nlLcZV6HVqz9MUyEfkMpkr
-        KnuMSz/ZpETkPCyrpwv8aoCKH8zdcPe0yG0vYum6X8wTLIivRoZczQgmVQ2izBIluvBVZeHWb8nq6IqA
-        MMASWDX9k+GN7X8wxO5JU5aXnjeLxoKxIVI4YYzKCQKrX7cUWpiJf/n7CWW1yrJ9WcaYwpeU8Cynj419
-        hYAzwBJB8zbdHhyVd78xpuA5ZfHOWEzgWeixFVgSNiBldGG0DICj4uE7PyEzvx4Q6YQ/ECm+5Cgm0jxl
-        8Y5lyhsfPw9zpyrzU3zyp8ndRUAbwFDrZViQdlvQ/NQ7kKPvNkYX3GuIKbpPWfrJFP7IFyXu4FQYM1V5
-        c//3lWV7p/A70JWobfcq4dlfN4Zn3WmYn3y7GseSgYCxulhW7Bb1p+YXb1Ev0uf+H9A3E1Z4VJUaAAAA
-        AElFTkSuQmCC
-</value>
-  </data>
-</root>

Core/Other/FormGuide.Designer.cs

@@ -0,0 +1,44 @@
+namespace TweetDuck.Core.Other {
+    partial class FormGuide {
+        /// <summary>
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing) {
+            if (disposing && (components != null)) {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Windows Form Designer generated code
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent() {
+            this.SuspendLayout();
+            // 
+            // FormGuide
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(34)))), ((int)(((byte)(34)))), ((int)(((byte)(34)))));
+            this.ClientSize = new System.Drawing.Size(424, 282);
+            this.Icon = global::TweetDuck.Properties.Resources.icon;
+            this.MinimumSize = new System.Drawing.Size(440, 320);
+            this.Name = "FormGuide";
+            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
+            this.ResumeLayout(false);
+
+        }
+
+        #endregion
+    }
+}

Core/Other/FormGuide.cs

@@ -0,0 +1,122 @@
+using System.Drawing;
+using System.Windows.Forms;
+using CefSharp;
+using CefSharp.WinForms;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Handling;
+using TweetDuck.Core.Handling.General;
+using TweetDuck.Core.Utils;
+using System.Text.RegularExpressions;
+using TweetDuck.Data;
+using TweetDuck.Resources;
+
+namespace TweetDuck.Core.Other{
+    sealed partial class FormGuide : Form, FormManager.IAppDialog{
+        private const string GuideUrl = "https://tweetduck.chylex.com/guide/v2/";
+        private const string GuidePathRegex = @"^guide(?:/v\d+)?(?:/(#.*))?";
+        
+        private static readonly ResourceLink DummyPage = new ResourceLink("http://td/dummy", ResourceHandler.FromString(""));
+
+        public static bool CheckGuideUrl(string url, out string hash){
+            if (!url.Contains("//tweetduck.chylex.com/guide")){
+                hash = null;
+                return false;
+            }
+
+            string path = url.Substring(url.IndexOf("/guide")+1);
+            Match match = Regex.Match(path, GuidePathRegex);
+
+            if (match.Success){
+                hash = match.Groups[1].Value;
+                return true;
+            }
+            else{
+                hash = null;
+                return false;
+            }
+        }
+
+        public static void Show(string hash = null){
+            string url = GuideUrl+(hash ?? string.Empty);
+            FormGuide guide = FormManager.TryFind<FormGuide>();
+            
+            if (guide == null){
+                FormBrowser owner = FormManager.TryFind<FormBrowser>();
+
+                if (owner != null){
+                    owner.AnalyticsFile.OpenGuide.Trigger();
+                    new FormGuide(url, owner).Show(owner);
+                }
+            }
+            else{
+                guide.Reload(url);
+                guide.Activate();
+            }
+        }
+
+        private readonly ChromiumWebBrowser browser;
+        private string nextUrl;
+
+        private FormGuide(string url, FormBrowser owner){
+            InitializeComponent();
+
+            Text = Program.BrandName+" Guide";
+            Size = new Size(owner.Size.Width*3/4, owner.Size.Height*3/4);
+            VisibleChanged += (sender, args) => this.MoveToCenter(owner);
+
+            ResourceHandlerFactory resourceHandlerFactory = new ResourceHandlerFactory();
+            resourceHandlerFactory.RegisterHandler(DummyPage);
+            
+            this.browser = new ChromiumWebBrowser(url){
+                MenuHandler = new ContextMenuGuide(owner),
+                JsDialogHandler = new JavaScriptDialogHandler(),
+                KeyboardHandler = new KeyboardHandlerBase(),
+                LifeSpanHandler = new LifeSpanHandler(),
+                RequestHandler = new RequestHandlerBase(true),
+                ResourceHandlerFactory = resourceHandlerFactory
+            };
+
+            browser.LoadingStateChanged += browser_LoadingStateChanged;
+            browser.FrameLoadEnd += browser_FrameLoadEnd;
+            
+            browser.BrowserSettings.BackgroundColor = (uint)BackColor.ToArgb();
+            browser.Dock = DockStyle.None;
+            browser.Location = ControlExtensions.InvisibleLocation;
+            browser.SetupZoomEvents();
+
+            Controls.Add(browser);
+
+            Disposed += (sender, args) => {
+                browser.Dispose();
+            };
+        }
+
+        private void Reload(string url){
+            nextUrl = url;
+            browser.LoadingStateChanged += browser_LoadingStateChanged;
+            browser.Dock = DockStyle.None;
+            browser.Location = ControlExtensions.InvisibleLocation;
+            browser.Load(DummyPage.Url);
+        }
+
+        private void browser_LoadingStateChanged(object sender, LoadingStateChangedEventArgs e){
+            if (!e.IsLoading){
+                if (browser.Address == DummyPage.Url){
+                    browser.Load(nextUrl);
+                }
+                else{
+                    this.InvokeAsyncSafe(() => {
+                        browser.Location = Point.Empty;
+                        browser.Dock = DockStyle.Fill;
+                    });
+
+                    browser.LoadingStateChanged -= browser_LoadingStateChanged;
+                }
+            }
+        }
+
+        private void browser_FrameLoadEnd(object sender, FrameLoadEndEventArgs e){
+            ScriptLoader.ExecuteScript(e.Frame, "Array.prototype.forEach.call(document.getElementsByTagName('A'), ele => ele.addEventListener('click', e => { e.preventDefault(); window.open(ele.getAttribute('href')); }))", "gen:links");
+        }
+    }
+}

Core/Other/FormMessage.Designer.cs

@@ -1,4 +1,4 @@
-namespace TweetDck.Core.Other {
+namespace TweetDuck.Core.Other {
     partial class FormMessage {
         /// <summary>
         /// Required designer variable.

Core/Other/FormMessage.cs

@@ -1,11 +1,66 @@
 using System;
 using System.Drawing;
 using System.Windows.Forms;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Utils;
+
+namespace TweetDuck.Core.Other{
+    [Flags]
+    enum ControlType{
+        None = 0,
+        Accept = 1, // triggered by pressing enter when a non-button is focused
+        Cancel = 2, // triggered by closing the dialog without pressing a button
+        Focused = 4 // active control after the dialog is showed
+    }
 
-namespace TweetDck.Core.Other{
     sealed partial class FormMessage : Form{
+        public const string OK = "OK";
+        public const string Yes = "Yes";
+        public const string No = "No";
+        public const string Cancel = "Cancel";
+        public const string Retry = "Retry";
+        public const string Ignore = "Ignore";
+        public const string Exit = "Exit";
+
+        public static bool Information(string caption, string text, string buttonAccept, string buttonCancel = null){
+            return Show(caption, text, MessageBoxIcon.Information, buttonAccept, buttonCancel);
+        }
+
+        public static bool Warning(string caption, string text, string buttonAccept, string buttonCancel = null){
+            return Show(caption, text, MessageBoxIcon.Warning, buttonAccept, buttonCancel);
+        }
+
+        public static bool Error(string caption, string text, string buttonAccept, string buttonCancel = null){
+            return Show(caption, text, MessageBoxIcon.Error, buttonAccept, buttonCancel);
+        }
+
+        public static bool Question(string caption, string text, string buttonAccept, string buttonCancel = null){
+            return Show(caption, text, MessageBoxIcon.Question, buttonAccept, buttonCancel);
+        }
+
+        public static bool Show(string caption, string text, MessageBoxIcon icon, string button){
+            return Show(caption, text, icon, button, null);
+        }
+
+        public static bool Show(string caption, string text, MessageBoxIcon icon, string buttonAccept, string buttonCancel){
+            using(FormMessage message = new FormMessage(caption, text, icon)){
+                if (buttonCancel == null){
+                    message.AddButton(buttonAccept, DialogResult.OK, ControlType.Cancel | ControlType.Focused);
+                }
+                else{
+                    message.AddButton(buttonCancel, DialogResult.Cancel, ControlType.Cancel);
+                    message.AddButton(buttonAccept, DialogResult.OK, ControlType.Accept | ControlType.Focused);
+                }
+
+                return message.ShowDialog() == DialogResult.OK;
+            }
+        }
+
+        // Instance
+
         public Button ClickedButton { get; private set; }
 
+        public bool HasIcon => icon != null;
         public int ActionPanelY => panelActions.Location.Y;
 
         private int ClientWidth{
@@ -13,8 +68,13 @@ namespace TweetDck.Core.Other{
             set => ClientSize = new Size(value, ClientSize.Height);
         }
 
+        private int ButtonDistance{
+            get => BrowserUtils.Scale(96, dpiScale);
+        }
+
         private readonly Icon icon;
         private readonly bool isReady;
+        private readonly float dpiScale;
 
         private int realFormWidth, minFormWidth;
         private int buttonCount;
@@ -24,9 +84,11 @@ namespace TweetDck.Core.Other{
         public FormMessage(string caption, string text, MessageBoxIcon messageIcon){
             InitializeComponent();
 
+            this.dpiScale = this.GetDPIScale();
+
             this.prevLabelWidth = labelMessage.Width;
             this.prevLabelHeight = labelMessage.Height;
-            this.minFormWidth = 40;
+            this.minFormWidth = BrowserUtils.Scale(42, dpiScale);
 
             switch(messageIcon){
                 case MessageBoxIcon.Information:
@@ -47,27 +109,31 @@ namespace TweetDck.Core.Other{
 
                 default:
                     icon = null;
-                    labelMessage.Location = new Point(labelMessage.Location.X-38, labelMessage.Location.Y);
+                    labelMessage.Location = new Point(BrowserUtils.Scale(19, dpiScale), labelMessage.Location.Y); // 19 instead of 9 due to larger height
                     break;
             }
 
             this.isReady = true;
 
             this.Text = caption;
-            this.labelMessage.Text = text;
+            this.labelMessage.Text = text.Replace("\r", "").Replace("\n", Environment.NewLine);
         }
 
         private void FormMessage_SizeChanged(object sender, EventArgs e){
             RecalculateButtonLocation();
         }
 
-        public Button AddButton(string title, DialogResult result = DialogResult.OK){
+        public Button AddButton(string title, ControlType type){
+            return AddButton(title, DialogResult.OK, type);
+        }
+
+        public Button AddButton(string title, DialogResult result = DialogResult.OK, ControlType type = ControlType.None){
             Button button = new Button{
                 Anchor = AnchorStyles.Bottom,
                 Font = SystemFonts.MessageBoxFont,
                 Location = new Point(0, 12),
-                Size = new Size(88, 26),
-                TabIndex = buttonCount,
+                Size = new Size(BrowserUtils.Scale(88, dpiScale), BrowserUtils.Scale(26, dpiScale)),
+                TabIndex = 256-buttonCount,
                 Text = title,
                 UseVisualStyleBackColor = true
             };
@@ -81,24 +147,41 @@ namespace TweetDck.Core.Other{
             panelActions.Controls.Add(button);
             ++buttonCount;
 
-            minFormWidth += 96;
+            minFormWidth += ButtonDistance;
             ClientWidth = Math.Max(realFormWidth, minFormWidth);
             RecalculateButtonLocation();
 
+            if (type.HasFlag(ControlType.Accept)){
+                AcceptButton = button;
+            }
+
+            if (type.HasFlag(ControlType.Cancel)){
+                CancelButton = button;
+            }
+
+            if (type.HasFlag(ControlType.Focused)){
+                ActiveControl = button;
+            }
+
             return button;
         }
 
         public void AddActionControl(Control control){
             panelActions.Controls.Add(control);
+            
+            control.Size = new Size(BrowserUtils.Scale(control.Width, dpiScale), BrowserUtils.Scale(control.Height, dpiScale));
 
             minFormWidth += control.Width+control.Margin.Horizontal;
             ClientWidth = Math.Max(realFormWidth, minFormWidth);
         }
         
         private void RecalculateButtonLocation(){
+            int dist = ButtonDistance;
+            int start = ClientWidth-dist;
+
             for(int index = 0; index < buttonCount; index++){
                 Control control = panelActions.Controls[index];
-                control.Location = new Point(ClientWidth-97-index*96, control.Location.Y);
+                control.Location = new Point(start-index*dist, control.Location.Y);
             }
         }
 
@@ -108,17 +191,18 @@ namespace TweetDck.Core.Other{
             }
 
             bool isMultiline = labelMessage.Height > labelMessage.MinimumSize.Height;
+            int labelOffset = BrowserUtils.Scale(8, dpiScale);
 
             if (isMultiline && !wasLabelMultiline){
-                labelMessage.Location = new Point(labelMessage.Location.X, labelMessage.Location.Y-8);
-                prevLabelHeight += 8;
+                labelMessage.Location = new Point(labelMessage.Location.X, labelMessage.Location.Y-labelOffset);
+                prevLabelHeight += labelOffset;
             }
             else if (!isMultiline && wasLabelMultiline){
-                labelMessage.Location = new Point(labelMessage.Location.X, labelMessage.Location.Y+8);
-                prevLabelHeight -= 8;
+                labelMessage.Location = new Point(labelMessage.Location.X, labelMessage.Location.Y+labelOffset);
+                prevLabelHeight -= labelOffset;
             }
 
-            realFormWidth = ClientWidth-(icon == null ? 50 : 0)+labelMessage.Width-prevLabelWidth;
+            realFormWidth = ClientWidth-(icon == null ? BrowserUtils.Scale(50, dpiScale) : 0)+labelMessage.Width-prevLabelWidth;
             ClientWidth = Math.Max(realFormWidth, minFormWidth);
             Height += labelMessage.Height-prevLabelHeight;
 
@@ -129,7 +213,7 @@ namespace TweetDck.Core.Other{
 
         protected override void OnPaint(PaintEventArgs e){
             if (icon != null){
-                e.Graphics.DrawIcon(icon, 25, 26);
+                e.Graphics.DrawIcon(icon, BrowserUtils.Scale(25, dpiScale), 1+BrowserUtils.Scale(25, dpiScale));
             }
 
             base.OnPaint(e);

Core/Other/FormPlugins.Designer.cs

@@ -1,4 +1,4 @@
-namespace TweetDck.Core.Other {
+namespace TweetDuck.Core.Other {
     partial class FormPlugins {
         /// <summary>
         /// Required designer variable.
@@ -23,20 +23,23 @@
         /// the contents of this method with the code editor.
         /// </summary>
         private void InitializeComponent() {
+            this.components = new System.ComponentModel.Container();
             this.btnClose = new System.Windows.Forms.Button();
             this.btnReload = new System.Windows.Forms.Button();
             this.btnOpenFolder = new System.Windows.Forms.Button();
-            this.tabPanelPlugins = new TweetDck.Core.Controls.TabPanel();
+            this.flowLayoutPlugins = new TweetDuck.Plugins.Controls.PluginListFlowLayout();
+            this.timerLayout = new System.Windows.Forms.Timer(this.components);
             this.SuspendLayout();
             // 
             // btnClose
             // 
             this.btnClose.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
             this.btnClose.AutoSize = true;
-            this.btnClose.Location = new System.Drawing.Point(643, 439);
+            this.btnClose.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.btnClose.Location = new System.Drawing.Point(642, 433);
             this.btnClose.Name = "btnClose";
-            this.btnClose.Padding = new System.Windows.Forms.Padding(3, 0, 3, 0);
-            this.btnClose.Size = new System.Drawing.Size(49, 23);
+            this.btnClose.Padding = new System.Windows.Forms.Padding(2, 0, 2, 0);
+            this.btnClose.Size = new System.Drawing.Size(50, 25);
             this.btnClose.TabIndex = 1;
             this.btnClose.Text = "Close";
             this.btnClose.UseVisualStyleBackColor = true;
@@ -46,10 +49,11 @@
             // 
             this.btnReload.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
             this.btnReload.AutoSize = true;
-            this.btnReload.Location = new System.Drawing.Point(131, 439);
+            this.btnReload.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.btnReload.Location = new System.Drawing.Point(141, 433);
             this.btnReload.Name = "btnReload";
-            this.btnReload.Padding = new System.Windows.Forms.Padding(3, 0, 3, 0);
-            this.btnReload.Size = new System.Drawing.Size(71, 23);
+            this.btnReload.Padding = new System.Windows.Forms.Padding(2, 0, 2, 0);
+            this.btnReload.Size = new System.Drawing.Size(74, 25);
             this.btnReload.TabIndex = 2;
             this.btnReload.Text = "Reload All";
             this.btnReload.UseVisualStyleBackColor = true;
@@ -59,36 +63,48 @@
             // 
             this.btnOpenFolder.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
             this.btnOpenFolder.AutoSize = true;
-            this.btnOpenFolder.Location = new System.Drawing.Point(12, 439);
+            this.btnOpenFolder.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.btnOpenFolder.Location = new System.Drawing.Point(12, 433);
             this.btnOpenFolder.Name = "btnOpenFolder";
-            this.btnOpenFolder.Padding = new System.Windows.Forms.Padding(3, 0, 3, 0);
-            this.btnOpenFolder.Size = new System.Drawing.Size(113, 23);
+            this.btnOpenFolder.Padding = new System.Windows.Forms.Padding(2, 0, 2, 0);
+            this.btnOpenFolder.Size = new System.Drawing.Size(123, 25);
             this.btnOpenFolder.TabIndex = 3;
             this.btnOpenFolder.Text = "Open Plugin Folder";
             this.btnOpenFolder.UseVisualStyleBackColor = true;
             this.btnOpenFolder.Click += new System.EventHandler(this.btnOpenFolder_Click);
             // 
-            // tabPanelPlugins
+            // flowLayoutPlugins
             // 
-            this.tabPanelPlugins.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
+            this.flowLayoutPlugins.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
             | System.Windows.Forms.AnchorStyles.Left) 
             | System.Windows.Forms.AnchorStyles.Right)));
-            this.tabPanelPlugins.Location = new System.Drawing.Point(12, 12);
-            this.tabPanelPlugins.Name = "tabPanelPlugins";
-            this.tabPanelPlugins.Size = new System.Drawing.Size(680, 421);
-            this.tabPanelPlugins.TabIndex = 0;
+            this.flowLayoutPlugins.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
+            this.flowLayoutPlugins.FlowDirection = System.Windows.Forms.FlowDirection.TopDown;
+            this.flowLayoutPlugins.Location = new System.Drawing.Point(12, 12);
+            this.flowLayoutPlugins.Name = "flowLayoutPlugins";
+            this.flowLayoutPlugins.Size = new System.Drawing.Size(680, 415);
+            this.flowLayoutPlugins.TabIndex = 0;
+            this.flowLayoutPlugins.WrapContents = false;
+            this.flowLayoutPlugins.Resize += new System.EventHandler(this.flowLayoutPlugins_Resize);
+            // 
+            // timerLayout
+            // 
+            this.timerLayout.Interval = 99;
+            this.timerLayout.Tick += new System.EventHandler(this.timerLayout_Tick);
             // 
             // FormPlugins
             // 
             this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
             this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-            this.ClientSize = new System.Drawing.Size(704, 474);
-            this.Controls.Add(this.tabPanelPlugins);
+            this.ClientSize = new System.Drawing.Size(704, 470);
+            this.Controls.Add(this.flowLayoutPlugins);
             this.Controls.Add(this.btnOpenFolder);
             this.Controls.Add(this.btnReload);
             this.Controls.Add(this.btnClose);
-            this.Icon = global::TweetDck.Properties.Resources.icon;
-            this.MinimumSize = new System.Drawing.Size(480, 320);
+            this.Icon = global::TweetDuck.Properties.Resources.icon;
+            this.MaximizeBox = false;
+            this.MinimizeBox = false;
+            this.MinimumSize = new System.Drawing.Size(640, 360);
             this.Name = "FormPlugins";
             this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
             this.ResumeLayout(false);
@@ -101,6 +117,7 @@
         private System.Windows.Forms.Button btnClose;
         private System.Windows.Forms.Button btnReload;
         private System.Windows.Forms.Button btnOpenFolder;
-        private TweetDck.Core.Controls.TabPanel tabPanelPlugins;
+        private Plugins.Controls.PluginListFlowLayout flowLayoutPlugins;
+        private System.Windows.Forms.Timer timerLayout;
     }
 }

Core/Other/FormPlugins.cs

@@ -3,20 +3,16 @@ using System.Diagnostics;
 using System.Drawing;
 using System.Linq;
 using System.Windows.Forms;
-using TweetDck.Core.Controls;
-using TweetDck.Plugins;
-using TweetDck.Plugins.Controls;
-using TweetDck.Plugins.Enums;
-using TweetDck.Plugins.Events;
+using TweetDuck.Configuration;
+using TweetDuck.Plugins;
+using TweetDuck.Plugins.Controls;
+
+namespace TweetDuck.Core.Other{
+    sealed partial class FormPlugins : Form, FormManager.IAppDialog{
+        private static UserConfig Config => Program.Config.User;
 
-namespace TweetDck.Core.Other{
-    sealed partial class FormPlugins : Form{
         private readonly PluginManager pluginManager;
-        private readonly TabButton tabBtnOfficial, tabBtnCustom;
-        private readonly PluginListFlowLayout flowLayoutPlugins;
-
-        private PluginGroup? selectedGroup;
-
+        
         public FormPlugins(){
             InitializeComponent();
 
@@ -25,75 +21,66 @@ namespace TweetDck.Core.Other{
 
         public FormPlugins(PluginManager pluginManager) : this(){
             this.pluginManager = pluginManager;
-            this.pluginManager.Reloaded += pluginManager_Reloaded;
-
-            this.flowLayoutPlugins = new PluginListFlowLayout();
-            this.flowLayoutPlugins.Resize += flowLayoutPlugins_Resize;
-
-            this.tabPanelPlugins.SetupTabPanel(90);
-            this.tabPanelPlugins.ReplaceContent(flowLayoutPlugins);
-
-            this.tabBtnOfficial = tabPanelPlugins.AddButton("", () => SelectGroup(PluginGroup.Official));
-            this.tabBtnCustom = tabPanelPlugins.AddButton("", () => SelectGroup(PluginGroup.Custom));
-
-            this.pluginManager_Reloaded(pluginManager, null);
 
+            if (!Config.PluginsWindowSize.IsEmpty){
+                Size targetSize = Config.PluginsWindowSize;
+                Size = new Size(Math.Max(MinimumSize.Width, targetSize.Width), Math.Max(MinimumSize.Height, targetSize.Height));
+            }
+            
             Shown += (sender, args) => {
-                Program.UserConfig.PluginsWindow.Restore(this, false);
-                this.tabPanelPlugins.SelectTab(tabBtnOfficial);
+                ReloadPluginList();
             };
 
             FormClosed += (sender, args) => {
-                Program.UserConfig.PluginsWindow.Save(this);
-                Program.UserConfig.Save();
+                Config.PluginsWindowSize = Size;
+                Config.Save();
             };
 
-            Disposed += (sender, args) => this.pluginManager.Reloaded -= pluginManager_Reloaded;
+            ResizeEnd += (sender, args) => {
+                timerLayout.Start();
+            };
         }
 
-        private void SelectGroup(PluginGroup group){
-            if (selectedGroup.HasValue && selectedGroup == group)return;
-
-            selectedGroup = group;
-            
-            ReloadPluginTab();
+        private int GetPluginOrderIndex(Plugin plugin){
+            return !plugin.CanRun ? 0 : pluginManager.Config.IsEnabled(plugin) ? 1 : 2;
         }
 
-        public void ReloadPluginTab(){
-            if (!selectedGroup.HasValue)return;
-
-            flowLayoutPlugins.SuspendLayout();
+        private void ReloadPluginList(){
             flowLayoutPlugins.Controls.Clear();
+            flowLayoutPlugins.SuspendLayout();
 
-            Plugin[] plugins = pluginManager.GetPluginsByGroup(selectedGroup.Value).OrderBy(plugin => !plugin.CanRun ? 0 : pluginManager.Config.IsEnabled(plugin) ? 1 : 2).ThenBy(plugin => plugin.Name).ToArray();
+            foreach(Plugin plugin in pluginManager.Plugins.OrderBy(GetPluginOrderIndex).ThenBy(plugin => plugin.Name)){
+                flowLayoutPlugins.Controls.Add(new PluginControl(pluginManager, plugin));
 
-            for(int index = 0; index < plugins.Length; index++){
-                flowLayoutPlugins.Controls.Add(new PluginControl(pluginManager, plugins[index]));
-
-                if (index < plugins.Length-1){
-                    flowLayoutPlugins.Controls.Add(new Panel{
-                        BackColor = Color.DimGray,
-                        Size = new Size(1, 1)
-                    });
-                }
+                flowLayoutPlugins.Controls.Add(new Panel{
+                    BackColor = Color.DimGray,
+                    Margin = new Padding(0),
+                    Size = new Size(1, 1)
+                });
             }
 
             flowLayoutPlugins.ResumeLayout(true);
-            flowLayoutPlugins_Resize(flowLayoutPlugins, new EventArgs());
+            
+            timerLayout_Tick(null, EventArgs.Empty);
+            timerLayout.Start();
         }
 
-        private void pluginManager_Reloaded(object sender, PluginErrorEventArgs e){
-            tabBtnOfficial.Text = "Official: "+pluginManager.CountPluginByGroup(PluginGroup.Official);
-            tabBtnCustom.Text = "Custom: "+pluginManager.CountPluginByGroup(PluginGroup.Custom);
+        private void timerLayout_Tick(object sender, EventArgs e){
+            timerLayout.Stop();
+            
+            // stupid WinForms scrollbars and panels
+            Padding = new Padding(Padding.Left, Padding.Top, Padding.Right+1, Padding.Bottom+1);
+            Padding = new Padding(Padding.Left, Padding.Top, Padding.Right-1, Padding.Bottom-1);
         }
 
-        private void flowLayoutPlugins_Resize(object sender, EventArgs e){
-            if (flowLayoutPlugins.Controls.Count == 0){
+        public void flowLayoutPlugins_Resize(object sender, EventArgs e){
+            Control lastPlugin = flowLayoutPlugins.Controls.OfType<PluginControl>().LastOrDefault();
+            
+            if (lastPlugin == null){
                 return;
             }
 
-            Control lastControl = flowLayoutPlugins.Controls[flowLayoutPlugins.Controls.Count-1];
-            bool showScrollBar = lastControl.Location.Y+lastControl.Height >= flowLayoutPlugins.Height;
+            bool showScrollBar = lastPlugin.Location.Y+lastPlugin.Height+1 >= flowLayoutPlugins.Height;
             int horizontalOffset = showScrollBar ? SystemInformation.VerticalScrollBarWidth : 0;
             
             flowLayoutPlugins.AutoScroll = showScrollBar;
@@ -102,18 +89,19 @@ namespace TweetDck.Core.Other{
             foreach(Control control in flowLayoutPlugins.Controls){
                 control.Width = flowLayoutPlugins.Width-control.Margin.Horizontal-horizontalOffset;
             }
-
+            
+            flowLayoutPlugins.Controls[flowLayoutPlugins.Controls.Count-1].Visible = !showScrollBar;
             flowLayoutPlugins.Focus();
         }
 
         private void btnOpenFolder_Click(object sender, EventArgs e){
-            using(Process.Start("explorer.exe", "\""+pluginManager.PathCustomPlugins+"\"")){}
+            using(Process.Start("explorer.exe", '"'+pluginManager.PathCustomPlugins+'"')){}
         }
 
         private void btnReload_Click(object sender, EventArgs e){
-            if (MessageBox.Show("This will also reload the browser window. Do you want to proceed?", "Reloading Plugins", MessageBoxButtons.YesNo, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button2) == DialogResult.Yes){
+            if (FormMessage.Warning("Reloading Plugins", "This will also reload the browser window. Do you want to proceed?", FormMessage.Yes, FormMessage.No)){
                 pluginManager.Reload();
-                ReloadPluginTab();
+                ReloadPluginList();
             }
         }
 

Core/Other/FormSettings.Designer.cs

@@ -1,4 +1,4 @@
-namespace TweetDck.Core.Other {
+namespace TweetDuck.Core.Other {
     sealed partial class FormSettings {
         /// <summary>
         /// Required designer variable.
@@ -24,53 +24,74 @@
         /// </summary>
         private void InitializeComponent() {
             this.btnClose = new System.Windows.Forms.Button();
-            this.labelTip = new System.Windows.Forms.Label();
-            this.tabPanel = new TweetDck.Core.Controls.TabPanel();
+            this.panelContents = new System.Windows.Forms.Panel();
+            this.panelButtons = new System.Windows.Forms.Panel();
+            this.btnManageOptions = new System.Windows.Forms.Button();
             this.SuspendLayout();
             // 
             // btnClose
             // 
             this.btnClose.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
             this.btnClose.AutoSize = true;
-            this.btnClose.Location = new System.Drawing.Point(443, 349);
+            this.btnClose.Font = new System.Drawing.Font("Segoe UI", 9F);
+            this.btnClose.Location = new System.Drawing.Point(747, 500);
             this.btnClose.Name = "btnClose";
-            this.btnClose.Padding = new System.Windows.Forms.Padding(3, 0, 3, 0);
-            this.btnClose.Size = new System.Drawing.Size(49, 23);
-            this.btnClose.TabIndex = 4;
+            this.btnClose.Padding = new System.Windows.Forms.Padding(2, 0, 2, 0);
+            this.btnClose.Size = new System.Drawing.Size(50, 25);
+            this.btnClose.TabIndex = 3;
             this.btnClose.Text = "Close";
             this.btnClose.UseVisualStyleBackColor = true;
             this.btnClose.Click += new System.EventHandler(this.btnClose_Click);
             // 
-            // labelTip
+            // panelContents
             // 
-            this.labelTip.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-            this.labelTip.AutoSize = true;
-            this.labelTip.Location = new System.Drawing.Point(12, 351);
-            this.labelTip.Name = "labelTip";
-            this.labelTip.Size = new System.Drawing.Size(310, 13);
-            this.labelTip.TabIndex = 5;
-            this.labelTip.Text = "Tip: Move your cursor over an option to see detailed explanation";
-            // 
-            // tabPanel
-            // 
-            this.tabPanel.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
+            this.panelContents.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
             | System.Windows.Forms.AnchorStyles.Left) 
             | System.Windows.Forms.AnchorStyles.Right)));
-            this.tabPanel.Location = new System.Drawing.Point(12, 12);
-            this.tabPanel.Name = "tabPanel";
-            this.tabPanel.Size = new System.Drawing.Size(480, 331);
-            this.tabPanel.TabIndex = 3;
+            this.panelContents.AutoScroll = true;
+            this.panelContents.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
+            this.panelContents.Location = new System.Drawing.Point(135, 12);
+            this.panelContents.Margin = new System.Windows.Forms.Padding(0, 3, 3, 3);
+            this.panelContents.Name = "panelContents";
+            this.panelContents.Size = new System.Drawing.Size(662, 482);
+            this.panelContents.TabIndex = 1;
+            // 
+            // panelButtons
+            // 
+            this.panelButtons.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
+            | System.Windows.Forms.AnchorStyles.Left)));
+            this.panelButtons.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
+            this.panelButtons.Location = new System.Drawing.Point(12, 12);
+            this.panelButtons.Margin = new System.Windows.Forms.Padding(3, 3, 0, 3);
+            this.panelButtons.Name = "panelButtons";
+            this.panelButtons.Size = new System.Drawing.Size(124, 482);
+            this.panelButtons.TabIndex = 0;
+            // 
+            // btnManageOptions
+            // 
+            this.btnManageOptions.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
+            this.btnManageOptions.AutoSize = true;
+            this.btnManageOptions.Font = new System.Drawing.Font("Segoe UI", 9F);
+            this.btnManageOptions.Location = new System.Drawing.Point(12, 500);
+            this.btnManageOptions.Name = "btnManageOptions";
+            this.btnManageOptions.Padding = new System.Windows.Forms.Padding(2, 0, 2, 0);
+            this.btnManageOptions.Size = new System.Drawing.Size(109, 25);
+            this.btnManageOptions.TabIndex = 4;
+            this.btnManageOptions.Text = "Manage Options";
+            this.btnManageOptions.UseVisualStyleBackColor = true;
+            this.btnManageOptions.Click += new System.EventHandler(this.btnManageOptions_Click);
             // 
             // FormSettings
             // 
             this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
             this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-            this.ClientSize = new System.Drawing.Size(504, 384);
-            this.Controls.Add(this.labelTip);
+            this.ClientSize = new System.Drawing.Size(809, 537);
+            this.Controls.Add(this.btnManageOptions);
+            this.Controls.Add(this.panelContents);
+            this.Controls.Add(this.panelButtons);
             this.Controls.Add(this.btnClose);
-            this.Controls.Add(this.tabPanel);
             this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
-            this.Icon = global::TweetDck.Properties.Resources.icon;
+            this.Icon = global::TweetDuck.Properties.Resources.icon;
             this.MaximizeBox = false;
             this.MinimizeBox = false;
             this.Name = "FormSettings";
@@ -82,9 +103,9 @@
         }
 
         #endregion
-
-        private Controls.TabPanel tabPanel;
         private System.Windows.Forms.Button btnClose;
-        private System.Windows.Forms.Label labelTip;
+        private System.Windows.Forms.Panel panelContents;
+        private System.Windows.Forms.Panel panelButtons;
+        private System.Windows.Forms.Button btnManageOptions;
     }
 }

Core/Other/FormSettings.cs

@@ -1,68 +1,210 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
+using System.Drawing;
 using System.Windows.Forms;
-using TweetDck.Core.Other.Settings;
-using TweetDck.Plugins;
-using TweetDck.Updates;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Handling.General;
+using TweetDuck.Core.Notification.Example;
+using TweetDuck.Core.Other.Analytics;
+using TweetDuck.Core.Other.Settings;
+using TweetDuck.Core.Other.Settings.Dialogs;
+using TweetDuck.Core.Utils;
+using TweetDuck.Plugins;
+using TweetDuck.Updates;
 
-namespace TweetDck.Core.Other{
-    sealed partial class FormSettings : Form{
-        public const int TabIndexNotification = 1;
+namespace TweetDuck.Core.Other{
+    sealed partial class FormSettings : Form, FormManager.IAppDialog{
+        public bool ShouldReloadBrowser { get; private set; }
 
         private readonly FormBrowser browser;
-        private readonly Dictionary<Type, BaseTabSettings> tabs = new Dictionary<Type, BaseTabSettings>(4);
+        private readonly PluginManager plugins;
 
-        public FormSettings(FormBrowser browser, PluginManager plugins, UpdateHandler updates, int startTabIndex = 0){
+        private readonly int buttonHeight;
+
+        private readonly Dictionary<Type, SettingsTab> tabs = new Dictionary<Type, SettingsTab>(8);
+        private SettingsTab currentTab;
+
+        public FormSettings(FormBrowser browser, PluginManager plugins, UpdateHandler updates, AnalyticsManager analytics, Type startTab){
             InitializeComponent();
 
-            Text = Program.BrandName+" Settings";
+            Text = Program.BrandName+" Options";
 
             this.browser = browser;
             this.browser.PauseNotification();
 
-            this.tabPanel.SetupTabPanel(100);
-            this.tabPanel.AddButton("General", () => SelectTab(() => new TabSettingsGeneral(updates)));
-            this.tabPanel.AddButton("Notifications", () => SelectTab(() => new TabSettingsNotifications(browser.CreateNotificationForm(false))));
-            this.tabPanel.AddButton("Sounds", () => SelectTab(() => new TabSettingsSounds()));
-            this.tabPanel.AddButton("Advanced", () => SelectTab(() => new TabSettingsAdvanced(browser.ReinjectCustomCSS, plugins)));
+            this.plugins = plugins;
+            
+            this.buttonHeight = BrowserUtils.Scale(39, this.GetDPIScale()) | 1;
 
-            this.tabPanel.SelectTab(tabPanel.Buttons.ElementAt(startTabIndex));
+            PrepareLoad();
+
+            AddButton("General", () => new TabSettingsGeneral(this.browser.ReloadColumns, updates));
+            AddButton("Notifications", () => new TabSettingsNotifications(new FormNotificationExample(this.browser, this.plugins)));
+            AddButton("Sounds", () => new TabSettingsSounds(this.browser.PlaySoundNotification));
+            AddButton("Feedback", () => new TabSettingsFeedback(analytics, AnalyticsReportGenerator.ExternalInfo.From(this.browser), this.plugins));
+            AddButton("Advanced", () => new TabSettingsAdvanced(this.browser.ReinjectCustomCSS, this.browser.OpenDevTools));
+
+            SelectTab(tabs[startTab ?? typeof(TabSettingsGeneral)]);
         }
 
-        private void SelectTab<T>(Func<T> constructor) where T : BaseTabSettings{
-            if (tabs.TryGetValue(typeof(T), out BaseTabSettings control)){
-                tabPanel.ReplaceContent(control);
-            }
-            else{
-                control = tabs[typeof(T)] = constructor();
-                control.OnReady();
-                tabPanel.ReplaceContent(control);
+        private void PrepareLoad(){
+            Program.Config.ProgramRestartRequested += Config_ProgramRestartRequested;
+        }
+
+        private void PrepareUnload(){ // TODO refactor this further later
+            currentTab.Control.OnClosing();
+            
+            Program.Config.ProgramRestartRequested -= Config_ProgramRestartRequested;
+            Program.Config.SaveAll();
+        }
+
+        private void Config_ProgramRestartRequested(object sender, EventArgs e){
+            if (FormMessage.Information("TweetDuck Options", "The application must restart for the option to take place. Do you want to restart now?", FormMessage.Yes, FormMessage.No)){
+                Program.Restart();
             }
         }
 
         private void FormSettings_FormClosing(object sender, FormClosingEventArgs e){
-            foreach(BaseTabSettings control in tabs.Values){
-                control.OnClosing();
+            PrepareUnload();
+
+            foreach(SettingsTab tab in tabs.Values){
+                if (tab.IsInitialized){
+                    tab.Control.Dispose();
+                }
             }
-
-            Program.UserConfig.Save();
-
-            foreach(BaseTabSettings control in tabs.Values){
-                control.Dispose();
-            }
-
+            
             browser.ResumeNotification();
         }
 
+        private void btnManageOptions_Click(object sender, EventArgs e){
+            PrepareUnload();
+
+            using(DialogSettingsManage dialog = new DialogSettingsManage(plugins)){
+                FormClosing -= FormSettings_FormClosing;
+                
+                if (dialog.ShowDialog() == DialogResult.OK){
+                    if (!dialog.IsRestarting){
+                        browser.ResumeNotification();
+
+                        if (dialog.ShouldReloadBrowser){
+                            BrowserProcessHandler.UpdatePrefs();
+                            ShouldReloadBrowser = true;
+                        }
+                    }
+
+                    Close();
+                }
+                else{
+                    FormClosing += FormSettings_FormClosing;
+                    PrepareLoad();
+                }
+            }
+        }
+
         private void btnClose_Click(object sender, EventArgs e){
             Close();
         }
 
-        public void ReloadUI(){
-            tabs.Clear();
-            tabPanel.Content.Controls.Clear();
-            tabPanel.ActiveButton.Callback();
+        private void AddButton<T>(string title, Func<T> constructor) where T : BaseTabSettings{
+            FlatButton btn = new FlatButton{
+                BackColor = SystemColors.Control,
+                FlatStyle = FlatStyle.Flat,
+                Font = SystemFonts.MessageBoxFont,
+                Location = new Point(0, (buttonHeight+1)*(panelButtons.Controls.Count/2)),
+                Margin = new Padding(0),
+                Size = new Size(panelButtons.Width, buttonHeight),
+                Text = title,
+                UseVisualStyleBackColor = true
+            };
+
+            btn.FlatAppearance.BorderSize = 0;
+            btn.FlatAppearance.MouseDownBackColor = Color.FromArgb(179, 213, 232);
+            btn.FlatAppearance.MouseOverBackColor = Color.FromArgb(216, 230, 237);
+            
+            panelButtons.Controls.Add(btn);
+
+            panelButtons.Controls.Add(new Panel{
+                BackColor = Color.DimGray,
+                Location = new Point(0, panelButtons.Controls[panelButtons.Controls.Count-1].Location.Y+buttonHeight),
+                Margin = new Padding(0),
+                Size = new Size(panelButtons.Width, 1)
+            });
+
+            tabs.Add(typeof(T), new SettingsTab(btn, constructor));
+
+            btn.Click += (sender, args) => SelectTab<T>();
+        }
+
+        private void SelectTab<T>() where T : BaseTabSettings{
+            SelectTab(tabs[typeof(T)]);
+        }
+
+        private void SelectTab(SettingsTab tab){
+            if (currentTab != null){
+                currentTab.Button.BackColor = SystemColors.Control;
+                currentTab.Control.OnClosing();
+            }
+            
+            tab.Button.BackColor = tab.Button.FlatAppearance.MouseDownBackColor;
+
+            if (!tab.IsInitialized){
+                foreach(Control control in tab.Control.InteractiveControls){
+                    if (control is ComboBox){
+                        control.MouseLeave += control_MouseLeave;
+                    }
+                    else if (control is TrackBar){
+                        control.MouseWheel += control_MouseWheel;
+                    }
+                }
+
+                if (tab.Control.Height < panelContents.Height-2){
+                    tab.Control.Height = panelContents.Height-2; // fixes off-by-pixel error on high DPI
+                }
+
+                tab.Control.OnReady();
+            }
+            
+            panelContents.VerticalScroll.Enabled = false; // required to stop animation that would otherwise break everything
+            panelContents.PerformLayout();
+
+            panelContents.SuspendLayout();
+            panelContents.VerticalScroll.Value = 0; // https://gfycat.com/GrotesqueTastyAstarte
+            panelContents.Controls.Clear();
+            panelContents.Controls.Add(tab.Control);
+            panelContents.ResumeLayout(true);
+
+            panelContents.VerticalScroll.Enabled = true;
+            panelContents.Focus();
+
+            currentTab = tab;
+        }
+
+        private void control_MouseLeave(object sender, EventArgs e){
+            if (sender is ComboBox cb && cb.DroppedDown){
+                return; // prevents comboboxes from closing when MouseLeave event triggers during opening animation
+            }
+
+            panelContents.Focus();
+        }
+
+        private void control_MouseWheel(object sender, MouseEventArgs e){
+            ((HandledMouseEventArgs)e).Handled = true;
+            panelContents.Focus();
+        }
+
+        private sealed class SettingsTab{
+            public Button Button { get; }
+
+            public BaseTabSettings Control => control ?? (control = constructor());
+            public bool IsInitialized => control != null;
+
+            private readonly Func<BaseTabSettings> constructor;
+            private BaseTabSettings control;
+
+            public SettingsTab(Button button, Func<BaseTabSettings> constructor){
+                this.Button = button;
+                this.constructor = constructor;
+            }
         }
     }
 }

Core/Other/FormSettings.resx

@@ -1,120 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>

Core/Other/Settings/BaseTabSettings.cs

@@ -1,21 +1,36 @@
-using System.Windows.Forms;
-using TweetDck.Configuration;
+using System.Collections.Generic;
+using System.Windows.Forms;
+using TweetDuck.Configuration;
 
-namespace TweetDck.Core.Other.Settings{
+namespace TweetDuck.Core.Other.Settings{
     class BaseTabSettings : UserControl{
-        protected static UserConfig Config => Program.UserConfig;
+        protected static UserConfig Config => Program.Config.User;
+        protected static SystemConfig SysConfig => Program.Config.System;
 
-        public BaseTabSettings(){
+        public IEnumerable<Control> InteractiveControls{
+            get{
+                IEnumerable<Control> FindInteractiveControls(Control parent){
+                    foreach(Control control in parent.Controls){
+                        if (control is Panel subPanel){
+                            foreach(Control subControl in FindInteractiveControls(subPanel)){
+                                yield return subControl;
+                            }
+                        }
+                        else{
+                            yield return control;
+                        }
+                    }
+                }
+
+                return FindInteractiveControls(this);
+            }
+        }
+
+        protected BaseTabSettings(){
             Padding = new Padding(6);
         }
 
         public virtual void OnReady(){}
         public virtual void OnClosing(){}
-
-        protected static void PromptRestart(){
-            if (MessageBox.Show("The application must restart for the setting to take place. Do you want to restart now?", Program.BrandName+" Settings", MessageBoxButtons.YesNo, MessageBoxIcon.Information) == DialogResult.Yes){
-                Program.Restart();
-            }
-        }
     }
 }

Core/Other/Settings/Dialogs/DialogSettingsAnalytics.Designer.cs

@@ -0,0 +1,94 @@
+namespace TweetDuck.Core.Other.Settings.Dialogs {
+    partial class DialogSettingsAnalytics {
+        /// <summary>
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing) {
+            if (disposing && (components != null)) {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Windows Form Designer generated code
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent() {
+            this.textBoxReport = new System.Windows.Forms.TextBox();
+            this.btnClose = new System.Windows.Forms.Button();
+            this.labelInfo = new System.Windows.Forms.Label();
+            this.SuspendLayout();
+            // 
+            // textBoxReport
+            // 
+            this.textBoxReport.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
+            | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+            this.textBoxReport.Font = new System.Drawing.Font("Courier New", 8.25F, System.Drawing.FontStyle.Regular);
+            this.textBoxReport.Location = new System.Drawing.Point(12, 45);
+            this.textBoxReport.Multiline = true;
+            this.textBoxReport.Name = "textBoxReport";
+            this.textBoxReport.ReadOnly = true;
+            this.textBoxReport.ScrollBars = System.Windows.Forms.ScrollBars.Both;
+            this.textBoxReport.Size = new System.Drawing.Size(435, 474);
+            this.textBoxReport.TabIndex = 1;
+            // 
+            // btnClose
+            // 
+            this.btnClose.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+            this.btnClose.AutoSize = true;
+            this.btnClose.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.btnClose.Location = new System.Drawing.Point(397, 525);
+            this.btnClose.Name = "btnClose";
+            this.btnClose.Padding = new System.Windows.Forms.Padding(2, 0, 2, 0);
+            this.btnClose.Size = new System.Drawing.Size(50, 25);
+            this.btnClose.TabIndex = 2;
+            this.btnClose.Text = "Close";
+            this.btnClose.UseVisualStyleBackColor = true;
+            this.btnClose.Click += new System.EventHandler(this.btnClose_Click);
+            // 
+            // labelInfo
+            // 
+            this.labelInfo.AutoSize = true;
+            this.labelInfo.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.labelInfo.Location = new System.Drawing.Point(12, 9);
+            this.labelInfo.Margin = new System.Windows.Forms.Padding(3, 0, 3, 3);
+            this.labelInfo.Name = "labelInfo";
+            this.labelInfo.Size = new System.Drawing.Size(434, 30);
+            this.labelInfo.TabIndex = 0;
+            this.labelInfo.Text = "When enabled, this data will be sent over a secure network roughly every 14 days." +
+    "\r\nSome numbers in the report were made imprecise on purpose.";
+            // 
+            // DialogSettingsAnalytics
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(459, 562);
+            this.Controls.Add(this.labelInfo);
+            this.Controls.Add(this.btnClose);
+            this.Controls.Add(this.textBoxReport);
+            this.MinimumSize = new System.Drawing.Size(475, 340);
+            this.Name = "DialogSettingsAnalytics";
+            this.ShowIcon = false;
+            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
+            this.ResumeLayout(false);
+            this.PerformLayout();
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.TextBox textBoxReport;
+        private System.Windows.Forms.Button btnClose;
+        private System.Windows.Forms.Label labelInfo;
+    }
+}

Core/Other/Settings/Dialogs/DialogSettingsAnalytics.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Windows.Forms;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Other.Analytics;
+
+namespace TweetDuck.Core.Other.Settings.Dialogs{
+    sealed partial class DialogSettingsAnalytics : Form{
+        public string CefArgs => textBoxReport.Text;
+
+        public DialogSettingsAnalytics(AnalyticsReport report){
+            InitializeComponent();
+            
+            Text = Program.BrandName+" Options - Analytics Report";
+            
+            textBoxReport.EnableMultilineShortcuts();
+            textBoxReport.Text = report.ToString().TrimEnd();
+            textBoxReport.Select(0, 0);
+        }
+
+        private void btnClose_Click(object sender, EventArgs e){
+            Close();
+        }
+    }
+}

Core/Other/Settings/Dialogs/DialogSettingsCSS.Designer.cs

@@ -1,4 +1,4 @@
-namespace TweetDck.Core.Other.Settings.Dialogs {
+namespace TweetDuck.Core.Other.Settings.Dialogs {
     partial class DialogSettingsCSS {
         /// <summary>
         /// Required designer variable.
@@ -27,42 +27,41 @@
             this.textBoxBrowserCSS = new System.Windows.Forms.TextBox();
             this.btnCancel = new System.Windows.Forms.Button();
             this.btnApply = new System.Windows.Forms.Button();
-            this.splitContainer = new System.Windows.Forms.SplitContainer();
-            this.labelBrowser = new System.Windows.Forms.Label();
-            this.labelNotification = new System.Windows.Forms.Label();
             this.textBoxNotificationCSS = new System.Windows.Forms.TextBox();
-            this.labelWarning = new System.Windows.Forms.Label();
-            this.btnOpenWiki = new System.Windows.Forms.Button();
+            this.btnOpenDevTools = new System.Windows.Forms.Button();
             this.timerTestBrowser = new System.Windows.Forms.Timer(this.components);
-            ((System.ComponentModel.ISupportInitialize)(this.splitContainer)).BeginInit();
-            this.splitContainer.Panel1.SuspendLayout();
-            this.splitContainer.Panel2.SuspendLayout();
-            this.splitContainer.SuspendLayout();
+            this.tabPanel = new System.Windows.Forms.TabControl();
+            this.tabPageBrowser = new System.Windows.Forms.TabPage();
+            this.tabPageNotification = new System.Windows.Forms.TabPage();
+            this.tabPanel.SuspendLayout();
+            this.tabPageBrowser.SuspendLayout();
+            this.tabPageNotification.SuspendLayout();
             this.SuspendLayout();
             // 
             // textBoxBrowserCSS
             // 
-            this.textBoxBrowserCSS.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
-            | System.Windows.Forms.AnchorStyles.Left) 
-            | System.Windows.Forms.AnchorStyles.Right)));
-            this.textBoxBrowserCSS.Font = new System.Drawing.Font("Courier New", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238)));
-            this.textBoxBrowserCSS.Location = new System.Drawing.Point(0, 16);
+            this.textBoxBrowserCSS.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.textBoxBrowserCSS.Font = new System.Drawing.Font("Courier New", 8.25F, System.Drawing.FontStyle.Regular);
+            this.textBoxBrowserCSS.Location = new System.Drawing.Point(3, 3);
             this.textBoxBrowserCSS.Margin = new System.Windows.Forms.Padding(0, 3, 0, 0);
             this.textBoxBrowserCSS.Multiline = true;
             this.textBoxBrowserCSS.Name = "textBoxBrowserCSS";
             this.textBoxBrowserCSS.ScrollBars = System.Windows.Forms.ScrollBars.Both;
-            this.textBoxBrowserCSS.Size = new System.Drawing.Size(373, 253);
-            this.textBoxBrowserCSS.TabIndex = 1;
+            this.textBoxBrowserCSS.Size = new System.Drawing.Size(426, 332);
+            this.textBoxBrowserCSS.TabIndex = 0;
             this.textBoxBrowserCSS.WordWrap = false;
+            this.textBoxBrowserCSS.KeyDown += new System.Windows.Forms.KeyEventHandler(this.textBoxCSS_KeyDown);
             this.textBoxBrowserCSS.KeyUp += new System.Windows.Forms.KeyEventHandler(this.textBoxBrowserCSS_KeyUp);
             // 
             // btnCancel
             // 
             this.btnCancel.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
-            this.btnCancel.Location = new System.Drawing.Point(654, 287);
+            this.btnCancel.AutoSize = true;
+            this.btnCancel.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
+            this.btnCancel.Location = new System.Drawing.Point(337, 384);
             this.btnCancel.Name = "btnCancel";
-            this.btnCancel.Padding = new System.Windows.Forms.Padding(3, 0, 3, 0);
-            this.btnCancel.Size = new System.Drawing.Size(56, 23);
+            this.btnCancel.Padding = new System.Windows.Forms.Padding(2, 0, 2, 0);
+            this.btnCancel.Size = new System.Drawing.Size(57, 25);
             this.btnCancel.TabIndex = 2;
             this.btnCancel.Text = "Cancel";
             this.btnCancel.UseVisualStyleBackColor = true;
@@ -71,122 +70,105 @@
             // btnApply
             // 
             this.btnApply.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
-            this.btnApply.Location = new System.Drawing.Point(716, 287);
+            this.btnApply.AutoSize = true;
+            this.btnApply.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
+            this.btnApply.Location = new System.Drawing.Point(400, 384);
             this.btnApply.Name = "btnApply";
-            this.btnApply.Padding = new System.Windows.Forms.Padding(3, 0, 3, 0);
-            this.btnApply.Size = new System.Drawing.Size(56, 23);
+            this.btnApply.Padding = new System.Windows.Forms.Padding(2, 0, 2, 0);
+            this.btnApply.Size = new System.Drawing.Size(52, 25);
             this.btnApply.TabIndex = 1;
             this.btnApply.Text = "Apply";
             this.btnApply.UseVisualStyleBackColor = true;
             this.btnApply.Click += new System.EventHandler(this.btnApply_Click);
             // 
-            // splitContainer
-            // 
-            this.splitContainer.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
-            | System.Windows.Forms.AnchorStyles.Left) 
-            | System.Windows.Forms.AnchorStyles.Right)));
-            this.splitContainer.Location = new System.Drawing.Point(12, 12);
-            this.splitContainer.Name = "splitContainer";
-            // 
-            // splitContainer.Panel1
-            // 
-            this.splitContainer.Panel1.Controls.Add(this.labelBrowser);
-            this.splitContainer.Panel1.Controls.Add(this.textBoxBrowserCSS);
-            this.splitContainer.Panel1MinSize = 64;
-            // 
-            // splitContainer.Panel2
-            // 
-            this.splitContainer.Panel2.Controls.Add(this.labelNotification);
-            this.splitContainer.Panel2.Controls.Add(this.textBoxNotificationCSS);
-            this.splitContainer.Panel2MinSize = 64;
-            this.splitContainer.Size = new System.Drawing.Size(760, 269);
-            this.splitContainer.SplitterDistance = 373;
-            this.splitContainer.SplitterWidth = 5;
-            this.splitContainer.TabIndex = 0;
-            // 
-            // labelBrowser
-            // 
-            this.labelBrowser.AutoSize = true;
-            this.labelBrowser.Location = new System.Drawing.Point(-3, 0);
-            this.labelBrowser.Margin = new System.Windows.Forms.Padding(0, 0, 3, 0);
-            this.labelBrowser.Name = "labelBrowser";
-            this.labelBrowser.Size = new System.Drawing.Size(45, 13);
-            this.labelBrowser.TabIndex = 0;
-            this.labelBrowser.Text = "Browser";
-            // 
-            // labelNotification
-            // 
-            this.labelNotification.AutoSize = true;
-            this.labelNotification.Location = new System.Drawing.Point(-3, 0);
-            this.labelNotification.Margin = new System.Windows.Forms.Padding(0, 0, 3, 0);
-            this.labelNotification.Name = "labelNotification";
-            this.labelNotification.Size = new System.Drawing.Size(60, 13);
-            this.labelNotification.TabIndex = 0;
-            this.labelNotification.Text = "Notification";
-            // 
             // textBoxNotificationCSS
             // 
-            this.textBoxNotificationCSS.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
-            | System.Windows.Forms.AnchorStyles.Left) 
-            | System.Windows.Forms.AnchorStyles.Right)));
-            this.textBoxNotificationCSS.Font = new System.Drawing.Font("Courier New", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238)));
-            this.textBoxNotificationCSS.Location = new System.Drawing.Point(0, 16);
+            this.textBoxNotificationCSS.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.textBoxNotificationCSS.Font = new System.Drawing.Font("Courier New", 8.25F, System.Drawing.FontStyle.Regular);
+            this.textBoxNotificationCSS.Location = new System.Drawing.Point(3, 3);
             this.textBoxNotificationCSS.Margin = new System.Windows.Forms.Padding(0, 3, 0, 0);
             this.textBoxNotificationCSS.Multiline = true;
             this.textBoxNotificationCSS.Name = "textBoxNotificationCSS";
             this.textBoxNotificationCSS.ScrollBars = System.Windows.Forms.ScrollBars.Both;
-            this.textBoxNotificationCSS.Size = new System.Drawing.Size(372, 253);
-            this.textBoxNotificationCSS.TabIndex = 1;
+            this.textBoxNotificationCSS.Size = new System.Drawing.Size(426, 332);
+            this.textBoxNotificationCSS.TabIndex = 0;
             this.textBoxNotificationCSS.WordWrap = false;
+            this.textBoxNotificationCSS.KeyDown += new System.Windows.Forms.KeyEventHandler(this.textBoxCSS_KeyDown);
             // 
-            // labelWarning
+            // btnOpenDevTools
             // 
-            this.labelWarning.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-            this.labelWarning.AutoSize = true;
-            this.labelWarning.Location = new System.Drawing.Point(91, 292);
-            this.labelWarning.Name = "labelWarning";
-            this.labelWarning.Size = new System.Drawing.Size(341, 13);
-            this.labelWarning.TabIndex = 3;
-            this.labelWarning.Text = "The code is not validated, please make sure there are no syntax errors.";
-            // 
-            // btnOpenWiki
-            // 
-            this.btnOpenWiki.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-            this.btnOpenWiki.AutoSize = true;
-            this.btnOpenWiki.Location = new System.Drawing.Point(12, 287);
-            this.btnOpenWiki.Name = "btnOpenWiki";
-            this.btnOpenWiki.Padding = new System.Windows.Forms.Padding(3, 0, 3, 0);
-            this.btnOpenWiki.Size = new System.Drawing.Size(73, 23);
-            this.btnOpenWiki.TabIndex = 4;
-            this.btnOpenWiki.Text = "Open Wiki";
-            this.btnOpenWiki.UseVisualStyleBackColor = true;
-            this.btnOpenWiki.Click += new System.EventHandler(this.btnOpenWiki_Click);
+            this.btnOpenDevTools.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
+            this.btnOpenDevTools.AutoSize = true;
+            this.btnOpenDevTools.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
+            this.btnOpenDevTools.Location = new System.Drawing.Point(12, 384);
+            this.btnOpenDevTools.Name = "btnOpenDevTools";
+            this.btnOpenDevTools.Padding = new System.Windows.Forms.Padding(2, 0, 2, 0);
+            this.btnOpenDevTools.Size = new System.Drawing.Size(104, 25);
+            this.btnOpenDevTools.TabIndex = 3;
+            this.btnOpenDevTools.Text = "Open Dev Tools";
+            this.btnOpenDevTools.UseVisualStyleBackColor = true;
+            this.btnOpenDevTools.Click += new System.EventHandler(this.btnOpenDevTools_Click);
             // 
             // timerTestBrowser
             // 
-            this.timerTestBrowser.Interval = 500;
+            this.timerTestBrowser.Interval = 400;
             this.timerTestBrowser.Tick += new System.EventHandler(this.timerTestBrowser_Tick);
             // 
+            // tabPanel
+            // 
+            this.tabPanel.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
+            | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+            this.tabPanel.Controls.Add(this.tabPageBrowser);
+            this.tabPanel.Controls.Add(this.tabPageNotification);
+            this.tabPanel.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.tabPanel.Location = new System.Drawing.Point(12, 12);
+            this.tabPanel.Name = "tabPanel";
+            this.tabPanel.SelectedIndex = 0;
+            this.tabPanel.Size = new System.Drawing.Size(440, 366);
+            this.tabPanel.TabIndex = 0;
+            this.tabPanel.SelectedIndexChanged += new System.EventHandler(this.tabPanel_SelectedIndexChanged);
+            // 
+            // tabPageBrowser
+            // 
+            this.tabPageBrowser.Controls.Add(this.textBoxBrowserCSS);
+            this.tabPageBrowser.Location = new System.Drawing.Point(4, 24);
+            this.tabPageBrowser.Name = "tabPageBrowser";
+            this.tabPageBrowser.Padding = new System.Windows.Forms.Padding(3);
+            this.tabPageBrowser.Size = new System.Drawing.Size(432, 338);
+            this.tabPageBrowser.TabIndex = 0;
+            this.tabPageBrowser.Text = "Browser";
+            this.tabPageBrowser.UseVisualStyleBackColor = true;
+            // 
+            // tabPageNotification
+            // 
+            this.tabPageNotification.Controls.Add(this.textBoxNotificationCSS);
+            this.tabPageNotification.Location = new System.Drawing.Point(4, 24);
+            this.tabPageNotification.Name = "tabPageNotification";
+            this.tabPageNotification.Padding = new System.Windows.Forms.Padding(3);
+            this.tabPageNotification.Size = new System.Drawing.Size(432, 338);
+            this.tabPageNotification.TabIndex = 1;
+            this.tabPageNotification.Text = "Notification";
+            this.tabPageNotification.UseVisualStyleBackColor = true;
+            // 
             // DialogSettingsCSS
             // 
             this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
             this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-            this.ClientSize = new System.Drawing.Size(784, 322);
-            this.Controls.Add(this.btnOpenWiki);
-            this.Controls.Add(this.labelWarning);
-            this.Controls.Add(this.splitContainer);
+            this.ClientSize = new System.Drawing.Size(464, 421);
+            this.Controls.Add(this.tabPanel);
+            this.Controls.Add(this.btnOpenDevTools);
             this.Controls.Add(this.btnApply);
             this.Controls.Add(this.btnCancel);
-            this.MinimumSize = new System.Drawing.Size(600, 160);
+            this.MinimumSize = new System.Drawing.Size(320, 240);
             this.Name = "DialogSettingsCSS";
             this.ShowIcon = false;
             this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
-            this.splitContainer.Panel1.ResumeLayout(false);
-            this.splitContainer.Panel1.PerformLayout();
-            this.splitContainer.Panel2.ResumeLayout(false);
-            this.splitContainer.Panel2.PerformLayout();
-            ((System.ComponentModel.ISupportInitialize)(this.splitContainer)).EndInit();
-            this.splitContainer.ResumeLayout(false);
+            this.tabPanel.ResumeLayout(false);
+            this.tabPageBrowser.ResumeLayout(false);
+            this.tabPageBrowser.PerformLayout();
+            this.tabPageNotification.ResumeLayout(false);
+            this.tabPageNotification.PerformLayout();
             this.ResumeLayout(false);
             this.PerformLayout();
 
@@ -197,12 +179,11 @@
         private System.Windows.Forms.TextBox textBoxBrowserCSS;
         private System.Windows.Forms.Button btnCancel;
         private System.Windows.Forms.Button btnApply;
-        private System.Windows.Forms.SplitContainer splitContainer;
         private System.Windows.Forms.TextBox textBoxNotificationCSS;
-        private System.Windows.Forms.Label labelBrowser;
-        private System.Windows.Forms.Label labelNotification;
-        private System.Windows.Forms.Label labelWarning;
-        private System.Windows.Forms.Button btnOpenWiki;
+        private System.Windows.Forms.Button btnOpenDevTools;
         private System.Windows.Forms.Timer timerTestBrowser;
+        private System.Windows.Forms.TabControl tabPanel;
+        private System.Windows.Forms.TabPage tabPageBrowser;
+        private System.Windows.Forms.TabPage tabPageNotification;
     }
 }

Core/Other/Settings/Dialogs/DialogSettingsCSS.cs

@@ -1,27 +1,118 @@
 using System;
+using System.Linq;
+using System.Text.RegularExpressions;
 using System.Windows.Forms;
-using TweetDck.Core.Controls;
-using TweetDck.Core.Utils;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Utils;
 
-namespace TweetDck.Core.Other.Settings.Dialogs{
+namespace TweetDuck.Core.Other.Settings.Dialogs{
     sealed partial class DialogSettingsCSS : Form{
         public string BrowserCSS => textBoxBrowserCSS.Text;
         public string NotificationCSS => textBoxNotificationCSS.Text;
 
         private readonly Action<string> reinjectBrowserCSS;
+        private readonly Action openDevTools;
 
-        public DialogSettingsCSS(Action<string> reinjectBrowserCSS){
+        public DialogSettingsCSS(string browserCSS, string notificationCSS, Action<string> reinjectBrowserCSS, Action openDevTools){
             InitializeComponent();
             
-            Text = Program.BrandName+" Settings - CSS";
+            Text = Program.BrandName+" Options - CSS";
 
             this.reinjectBrowserCSS = reinjectBrowserCSS;
+            this.openDevTools = openDevTools;
             
             textBoxBrowserCSS.EnableMultilineShortcuts();
-            textBoxBrowserCSS.Text = Program.UserConfig.CustomBrowserCSS ?? "";
+            textBoxBrowserCSS.Text = browserCSS ?? "";
 
             textBoxNotificationCSS.EnableMultilineShortcuts();
-            textBoxNotificationCSS.Text = Program.UserConfig.CustomNotificationCSS ?? "";
+            textBoxNotificationCSS.Text = notificationCSS ?? "";
+
+            if (!BrowserUtils.HasDevTools){
+                btnOpenDevTools.Enabled = false;
+            }
+
+            ActiveControl = textBoxBrowserCSS;
+            textBoxBrowserCSS.Select(textBoxBrowserCSS.TextLength, 0);
+        }
+
+        private void tabPanel_SelectedIndexChanged(object sender, EventArgs e){
+            TextBox tb = tabPanel.SelectedTab.Controls.OfType<TextBox>().FirstOrDefault();
+
+            if (tb != null){
+                tb.Focus();
+                tb.Select(tb.TextLength, 0);
+            }
+        }
+
+        private void textBoxCSS_KeyDown(object sender, KeyEventArgs e){
+            TextBox tb = (TextBox)sender;
+            string text = tb.Text;
+
+            if (e.KeyCode == Keys.Back && e.Modifiers == Keys.Control){
+                e.SuppressKeyPress = true;
+
+                int deleteTo = tb.SelectionStart;
+
+                if (deleteTo > 0){
+                    char initialChar = text[--deleteTo];
+                    bool shouldDeleteAlphanumeric = char.IsLetterOrDigit(initialChar);
+                
+                    while(--deleteTo >= 0){
+                        if ((shouldDeleteAlphanumeric && !char.IsLetterOrDigit(text[deleteTo])) ||
+                            (!shouldDeleteAlphanumeric && text[deleteTo] != initialChar)){
+                            break;
+                        }
+                    }
+                    
+                    if (!(deleteTo < text.Length-1 && text[deleteTo] == '\r' && text[deleteTo+1] == '\n')){
+                        ++deleteTo;
+                    }
+
+                    tb.Select(deleteTo, tb.SelectionLength+tb.SelectionStart-deleteTo);
+                    tb.SelectedText = string.Empty;
+                }
+            }
+            else if (e.KeyCode == Keys.Back && e.Modifiers == Keys.None){
+                int deleteTo = tb.SelectionStart;
+
+                if (deleteTo > 1 && text[deleteTo-1] == ' ' && text[deleteTo-2] == ' '){
+                    e.SuppressKeyPress = true;
+
+                    tb.Select(deleteTo-2, 2);
+                    tb.SelectedText = string.Empty;
+                }
+            }
+            else if (e.KeyCode == Keys.Enter && e.Modifiers == Keys.None && tb.SelectionLength == 0){
+                int insertAt = tb.SelectionStart, cursorOffset = 0;
+                string insertText;
+
+                if (insertAt == 0){
+                    return;
+                }
+                else if (text[insertAt-1] == '{'){
+                    insertText = Environment.NewLine+"  ";
+
+                    int nextBracket = insertAt < text.Length ? text.IndexOfAny(new char[]{ '{', '}' }, insertAt+1) : -1;
+
+                    if (nextBracket == -1 || text[nextBracket] == '{'){
+                        string insertExtra = Environment.NewLine+"}";
+                        insertText += insertExtra;
+                        cursorOffset -= insertExtra.Length;
+                    }
+                }
+                else{
+                    int lineStart = text.LastIndexOf('\n', tb.SelectionStart-1);
+
+                    Match match = Regex.Match(text.Substring(lineStart == -1 ? 0 : lineStart+1), "^([ \t]+)");
+                    insertText = match.Success ? Environment.NewLine+match.Groups[1].Value : null;
+                }
+
+                if (!string.IsNullOrEmpty(insertText)){
+                    e.SuppressKeyPress = true;
+                    tb.Text = text.Insert(insertAt, insertText);
+                    tb.SelectionStart = insertAt+cursorOffset+insertText.Length;
+                }
+            }
         }
 
         private void textBoxBrowserCSS_KeyUp(object sender, KeyEventArgs e){
@@ -34,8 +125,8 @@ namespace TweetDck.Core.Other.Settings.Dialogs{
             timerTestBrowser.Stop();
         }
 
-        private void btnOpenWiki_Click(object sender, EventArgs e){
-            BrowserUtils.OpenExternalBrowserUnsafe("https://github.com/chylex/TweetDuck/wiki");
+        private void btnOpenDevTools_Click(object sender, EventArgs e){
+            openDevTools();
         }
 
         private void btnApply_Click(object sender, EventArgs e){

Core/Other/Settings/Dialogs/DialogSettingsCefArgs.Designer.cs

@@ -1,4 +1,4 @@
-namespace TweetDck.Core.Other.Settings.Dialogs {
+namespace TweetDuck.Core.Other.Settings.Dialogs {
     partial class DialogSettingsCefArgs {
         /// <summary>
         /// Required designer variable.
@@ -35,20 +35,22 @@
             this.textBoxArgs.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
             | System.Windows.Forms.AnchorStyles.Left) 
             | System.Windows.Forms.AnchorStyles.Right)));
-            this.textBoxArgs.Font = new System.Drawing.Font("Courier New", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238)));
-            this.textBoxArgs.Location = new System.Drawing.Point(12, 28);
+            this.textBoxArgs.Font = new System.Drawing.Font("Courier New", 8.25F, System.Drawing.FontStyle.Regular);
+            this.textBoxArgs.Location = new System.Drawing.Point(12, 30);
             this.textBoxArgs.Multiline = true;
             this.textBoxArgs.Name = "textBoxArgs";
-            this.textBoxArgs.Size = new System.Drawing.Size(460, 193);
+            this.textBoxArgs.Size = new System.Drawing.Size(480, 189);
             this.textBoxArgs.TabIndex = 1;
             // 
             // btnCancel
             // 
             this.btnCancel.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
-            this.btnCancel.Location = new System.Drawing.Point(354, 227);
+            this.btnCancel.AutoSize = true;
+            this.btnCancel.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.btnCancel.Location = new System.Drawing.Point(377, 225);
             this.btnCancel.Name = "btnCancel";
-            this.btnCancel.Padding = new System.Windows.Forms.Padding(3, 0, 3, 0);
-            this.btnCancel.Size = new System.Drawing.Size(56, 23);
+            this.btnCancel.Padding = new System.Windows.Forms.Padding(2, 0, 2, 0);
+            this.btnCancel.Size = new System.Drawing.Size(57, 25);
             this.btnCancel.TabIndex = 3;
             this.btnCancel.Text = "Cancel";
             this.btnCancel.UseVisualStyleBackColor = true;
@@ -57,10 +59,12 @@
             // btnApply
             // 
             this.btnApply.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
-            this.btnApply.Location = new System.Drawing.Point(416, 227);
+            this.btnApply.AutoSize = true;
+            this.btnApply.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.btnApply.Location = new System.Drawing.Point(440, 225);
             this.btnApply.Name = "btnApply";
-            this.btnApply.Padding = new System.Windows.Forms.Padding(3, 0, 3, 0);
-            this.btnApply.Size = new System.Drawing.Size(56, 23);
+            this.btnApply.Padding = new System.Windows.Forms.Padding(2, 0, 2, 0);
+            this.btnApply.Size = new System.Drawing.Size(52, 25);
             this.btnApply.TabIndex = 2;
             this.btnApply.Text = "Apply";
             this.btnApply.UseVisualStyleBackColor = true;
@@ -70,10 +74,11 @@
             // 
             this.btnHelp.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
             this.btnHelp.AutoSize = true;
-            this.btnHelp.Location = new System.Drawing.Point(12, 227);
+            this.btnHelp.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.btnHelp.Location = new System.Drawing.Point(12, 225);
             this.btnHelp.Name = "btnHelp";
-            this.btnHelp.Padding = new System.Windows.Forms.Padding(3, 0, 3, 0);
-            this.btnHelp.Size = new System.Drawing.Size(124, 23);
+            this.btnHelp.Padding = new System.Windows.Forms.Padding(2, 0, 2, 0);
+            this.btnHelp.Size = new System.Drawing.Size(141, 25);
             this.btnHelp.TabIndex = 4;
             this.btnHelp.Text = "List of Chromium Args";
             this.btnHelp.UseVisualStyleBackColor = true;
@@ -82,10 +87,11 @@
             // labelWarning
             // 
             this.labelWarning.AutoSize = true;
+            this.labelWarning.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
             this.labelWarning.Location = new System.Drawing.Point(12, 9);
             this.labelWarning.Margin = new System.Windows.Forms.Padding(3, 0, 3, 3);
             this.labelWarning.Name = "labelWarning";
-            this.labelWarning.Size = new System.Drawing.Size(423, 13);
+            this.labelWarning.Size = new System.Drawing.Size(478, 15);
             this.labelWarning.TabIndex = 0;
             this.labelWarning.Text = "Warning: Some arguments may cause the program to stop working, edit at your own r" +
     "isk.";
@@ -94,13 +100,13 @@
             // 
             this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
             this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-            this.ClientSize = new System.Drawing.Size(484, 262);
+            this.ClientSize = new System.Drawing.Size(504, 262);
             this.Controls.Add(this.labelWarning);
             this.Controls.Add(this.btnHelp);
             this.Controls.Add(this.btnApply);
             this.Controls.Add(this.btnCancel);
             this.Controls.Add(this.textBoxArgs);
-            this.MinimumSize = new System.Drawing.Size(500, 160);
+            this.MinimumSize = new System.Drawing.Size(520, 160);
             this.Name = "DialogSettingsCefArgs";
             this.ShowIcon = false;
             this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;

Core/Other/Settings/Dialogs/DialogSettingsCefArgs.cs

@@ -1,39 +1,40 @@
 using System;
 using System.Windows.Forms;
-using TweetDck.Core.Controls;
-using TweetDck.Core.Utils;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Utils;
+using TweetDuck.Data;
 
-namespace TweetDck.Core.Other.Settings.Dialogs{
+namespace TweetDuck.Core.Other.Settings.Dialogs{
     sealed partial class DialogSettingsCefArgs : Form{
         public string CefArgs => textBoxArgs.Text;
 
-        public DialogSettingsCefArgs(){
+        private readonly string initialArgs;
+
+        public DialogSettingsCefArgs(string args){
             InitializeComponent();
             
-            Text = Program.BrandName+" Settings - CEF Arguments";
+            Text = Program.BrandName+" Options - CEF Arguments";
             
             textBoxArgs.EnableMultilineShortcuts();
-            textBoxArgs.Text = Program.UserConfig.CustomCefArgs ?? "";
+            textBoxArgs.Text = initialArgs = args ?? "";
             textBoxArgs.Select(textBoxArgs.Text.Length, 0);
         }
 
         private void btnHelp_Click(object sender, EventArgs e){
-            BrowserUtils.OpenExternalBrowserUnsafe("http://peter.sh/experiments/chromium-command-line-switches/");
+            BrowserUtils.OpenExternalBrowser("http://peter.sh/experiments/chromium-command-line-switches/");
         }
 
         private void btnApply_Click(object sender, EventArgs e){
-            string prevArgs = Program.UserConfig.CustomCefArgs;
-
-            if (CefArgs == prevArgs){
+            if (CefArgs == initialArgs){
                 DialogResult = DialogResult.Cancel;
                 Close();
                 return;
             }
 
-            int count = CommandLineArgsParser.ReadCefArguments(CefArgs).Count;
-            string prompt = count == 0 && !string.IsNullOrWhiteSpace(prevArgs) ? "All arguments will be removed from the settings. Continue?" : count+(count == 1 ? " argument" : " arguments")+" will be added to the settings. Continue?";
+            int count = CommandLineArgs.ReadCefArguments(CefArgs).Count;
+            string prompt = count == 0 && !string.IsNullOrWhiteSpace(initialArgs) ? "All current arguments will be removed. Continue?" : count+(count == 1 ? " argument was" : " arguments were")+" detected. Continue?";
 
-            if (MessageBox.Show(prompt, "Confirm CEF Arguments", MessageBoxButtons.OKCancel, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2) == DialogResult.OK){
+            if (FormMessage.Question("Confirm CEF Arguments", prompt, FormMessage.OK, FormMessage.Cancel)){
                 DialogResult = DialogResult.OK;
                 Close();
             }

Core/Other/Settings/Dialogs/DialogSettingsExport.Designer.cs

@@ -1,130 +0,0 @@
-namespace TweetDck.Core.Other.Settings.Dialogs {
-    partial class DialogSettingsExport {
-        /// <summary>
-        /// Required designer variable.
-        /// </summary>
-        private System.ComponentModel.IContainer components = null;
-
-        /// <summary>
-        /// Clean up any resources being used.
-        /// </summary>
-        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-        protected override void Dispose(bool disposing) {
-            if (disposing && (components != null)) {
-                components.Dispose();
-            }
-            base.Dispose(disposing);
-        }
-
-        #region Windows Form Designer generated code
-
-        /// <summary>
-        /// Required method for Designer support - do not modify
-        /// the contents of this method with the code editor.
-        /// </summary>
-        private void InitializeComponent() {
-            this.components = new System.ComponentModel.Container();
-            this.btnCancel = new System.Windows.Forms.Button();
-            this.btnApply = new System.Windows.Forms.Button();
-            this.cbConfig = new System.Windows.Forms.CheckBox();
-            this.cbSession = new System.Windows.Forms.CheckBox();
-            this.cbPluginData = new System.Windows.Forms.CheckBox();
-            this.toolTip = new System.Windows.Forms.ToolTip(this.components);
-            this.SuspendLayout();
-            // 
-            // btnCancel
-            // 
-            this.btnCancel.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
-            this.btnCancel.AutoSize = true;
-            this.btnCancel.Location = new System.Drawing.Point(176, 97);
-            this.btnCancel.Name = "btnCancel";
-            this.btnCancel.Padding = new System.Windows.Forms.Padding(3, 0, 3, 0);
-            this.btnCancel.Size = new System.Drawing.Size(56, 23);
-            this.btnCancel.TabIndex = 4;
-            this.btnCancel.Text = "Cancel";
-            this.btnCancel.UseVisualStyleBackColor = true;
-            this.btnCancel.Click += new System.EventHandler(this.btnCancel_Click);
-            // 
-            // btnApply
-            // 
-            this.btnApply.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
-            this.btnApply.AutoSize = true;
-            this.btnApply.AutoSizeMode = System.Windows.Forms.AutoSizeMode.GrowAndShrink;
-            this.btnApply.Location = new System.Drawing.Point(144, 97);
-            this.btnApply.Name = "btnApply";
-            this.btnApply.Padding = new System.Windows.Forms.Padding(3, 0, 3, 0);
-            this.btnApply.Size = new System.Drawing.Size(26, 23);
-            this.btnApply.TabIndex = 3;
-            this.btnApply.Text = " ";
-            this.btnApply.UseVisualStyleBackColor = true;
-            this.btnApply.Click += new System.EventHandler(this.btnApply_Click);
-            // 
-            // cbConfig
-            // 
-            this.cbConfig.AutoSize = true;
-            this.cbConfig.Location = new System.Drawing.Point(13, 13);
-            this.cbConfig.Name = "cbConfig";
-            this.cbConfig.Size = new System.Drawing.Size(106, 17);
-            this.cbConfig.TabIndex = 0;
-            this.cbConfig.Text = "Program Settings";
-            this.toolTip.SetToolTip(this.cbConfig, "Interface, notification, and update settings.\r\nIncludes a list of disabled plugin" +
-        "s.");
-            this.cbConfig.UseVisualStyleBackColor = true;
-            this.cbConfig.CheckedChanged += new System.EventHandler(this.cbConfig_CheckedChanged);
-            // 
-            // cbSession
-            // 
-            this.cbSession.AutoSize = true;
-            this.cbSession.Location = new System.Drawing.Point(13, 37);
-            this.cbSession.Name = "cbSession";
-            this.cbSession.Size = new System.Drawing.Size(92, 17);
-            this.cbSession.TabIndex = 1;
-            this.cbSession.Text = "Login Session";
-            this.toolTip.SetToolTip(this.cbSession, "A token that allows logging into the\r\ncurrent TweetDeck account.");
-            this.cbSession.UseVisualStyleBackColor = true;
-            this.cbSession.CheckedChanged += new System.EventHandler(this.cbSession_CheckedChanged);
-            // 
-            // cbPluginData
-            // 
-            this.cbPluginData.AutoSize = true;
-            this.cbPluginData.Location = new System.Drawing.Point(13, 61);
-            this.cbPluginData.Name = "cbPluginData";
-            this.cbPluginData.Size = new System.Drawing.Size(81, 17);
-            this.cbPluginData.TabIndex = 2;
-            this.cbPluginData.Text = "Plugin Data";
-            this.toolTip.SetToolTip(this.cbPluginData, "Data files generated by plugins.\r\nDoes not include the plugins themselves.");
-            this.cbPluginData.UseVisualStyleBackColor = true;
-            this.cbPluginData.CheckedChanged += new System.EventHandler(this.cbPluginData_CheckedChanged);
-            // 
-            // DialogSettingsExport
-            // 
-            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-            this.ClientSize = new System.Drawing.Size(244, 132);
-            this.Controls.Add(this.cbPluginData);
-            this.Controls.Add(this.cbSession);
-            this.Controls.Add(this.cbConfig);
-            this.Controls.Add(this.btnApply);
-            this.Controls.Add(this.btnCancel);
-            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
-            this.MaximizeBox = false;
-            this.MinimizeBox = false;
-            this.MinimumSize = new System.Drawing.Size(200, 170);
-            this.Name = "DialogSettingsExport";
-            this.ShowIcon = false;
-            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
-            this.ResumeLayout(false);
-            this.PerformLayout();
-
-        }
-
-        #endregion
-
-        private System.Windows.Forms.Button btnCancel;
-        private System.Windows.Forms.Button btnApply;
-        private System.Windows.Forms.CheckBox cbConfig;
-        private System.Windows.Forms.CheckBox cbSession;
-        private System.Windows.Forms.CheckBox cbPluginData;
-        private System.Windows.Forms.ToolTip toolTip;
-    }
-}

Core/Other/Settings/Dialogs/DialogSettingsExport.cs

@@ -1,80 +0,0 @@
-using System;
-using System.Windows.Forms;
-using TweetDck.Core.Other.Settings.Export;
-
-namespace TweetDck.Core.Other.Settings.Dialogs{
-    sealed partial class DialogSettingsExport : Form{
-        public static DialogSettingsExport Import(ExportFileFlags flags){
-            return new DialogSettingsExport(flags);
-        }
-
-        public static DialogSettingsExport Export(){
-            return new DialogSettingsExport(ExportFileFlags.None);
-        }
-
-        public ExportFileFlags Flags{
-            get => selectedFlags;
-
-            set{
-                // this will call events and SetFlag, which also updates the UI
-                cbConfig.Checked = value.HasFlag(ExportFileFlags.Config);
-                cbSession.Checked = value.HasFlag(ExportFileFlags.Session);
-                cbPluginData.Checked = value.HasFlag(ExportFileFlags.PluginData);
-            }
-        }
-        
-        private readonly bool isExporting;
-        private ExportFileFlags selectedFlags = ExportFileFlags.None;
-
-        private DialogSettingsExport(ExportFileFlags importFlags){
-            InitializeComponent();
-
-            this.isExporting = importFlags == ExportFileFlags.None;
-
-            if (isExporting){
-                Text = "Export Profile";
-                btnApply.Text = "Export Profile";
-                Flags = ExportFileFlags.All & ~ExportFileFlags.Session;
-            }
-            else{
-                Text = "Import Profile";
-                Flags = importFlags;
-
-                cbConfig.Enabled = cbConfig.Checked;
-                cbSession.Enabled = cbSession.Checked;
-                cbPluginData.Enabled = cbPluginData.Checked;
-            }
-        }
-
-        private void SetFlag(ExportFileFlags flag, bool enable){
-            selectedFlags = enable ? selectedFlags | flag : selectedFlags & ~flag;
-            btnApply.Enabled = selectedFlags != ExportFileFlags.None;
-
-            if (!isExporting){
-                btnApply.Text = selectedFlags.HasFlag(ExportFileFlags.Session) ? "Import && Restart" : "Import Profile";
-            }
-        }
-
-        private void cbConfig_CheckedChanged(object sender, EventArgs e){
-            SetFlag(ExportFileFlags.Config, cbConfig.Checked);
-        }
-
-        private void cbSession_CheckedChanged(object sender, EventArgs e){
-            SetFlag(ExportFileFlags.Session, cbSession.Checked);
-        }
-
-        private void cbPluginData_CheckedChanged(object sender, EventArgs e){
-            SetFlag(ExportFileFlags.PluginData, cbPluginData.Checked);
-        }
-
-        private void btnApply_Click(object sender, EventArgs e){
-            DialogResult = DialogResult.OK;
-            Close();
-        }
-
-        private void btnCancel_Click(object sender, EventArgs e){
-            DialogResult = DialogResult.Cancel;
-            Close();
-        }
-    }
-}

Core/Other/Settings/Dialogs/DialogSettingsManage.Designer.cs

@@ -0,0 +1,241 @@
+namespace TweetDuck.Core.Other.Settings.Dialogs {
+    partial class DialogSettingsManage {
+        /// <summary>
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing) {
+            if (disposing && (components != null)) {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Windows Form Designer generated code
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent() {
+            this.components = new System.ComponentModel.Container();
+            this.btnCancel = new System.Windows.Forms.Button();
+            this.btnContinue = new System.Windows.Forms.Button();
+            this.cbProgramConfig = new System.Windows.Forms.CheckBox();
+            this.cbSession = new System.Windows.Forms.CheckBox();
+            this.cbPluginData = new System.Windows.Forms.CheckBox();
+            this.toolTip = new System.Windows.Forms.ToolTip(this.components);
+            this.cbSystemConfig = new System.Windows.Forms.CheckBox();
+            this.panelSelection = new System.Windows.Forms.FlowLayoutPanel();
+            this.panelDecision = new System.Windows.Forms.FlowLayoutPanel();
+            this.radioImport = new System.Windows.Forms.RadioButton();
+            this.radioExport = new System.Windows.Forms.RadioButton();
+            this.radioReset = new System.Windows.Forms.RadioButton();
+            this.panelSelection.SuspendLayout();
+            this.panelDecision.SuspendLayout();
+            this.SuspendLayout();
+            // 
+            // btnCancel
+            // 
+            this.btnCancel.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+            this.btnCancel.AutoSize = true;
+            this.btnCancel.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.btnCancel.Location = new System.Drawing.Point(165, 92);
+            this.btnCancel.Name = "btnCancel";
+            this.btnCancel.Padding = new System.Windows.Forms.Padding(2, 0, 2, 0);
+            this.btnCancel.Size = new System.Drawing.Size(57, 25);
+            this.btnCancel.TabIndex = 4;
+            this.btnCancel.Text = "Cancel";
+            this.btnCancel.UseVisualStyleBackColor = true;
+            this.btnCancel.Click += new System.EventHandler(this.btnCancel_Click);
+            // 
+            // btnContinue
+            // 
+            this.btnContinue.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+            this.btnContinue.AutoSize = true;
+            this.btnContinue.Enabled = false;
+            this.btnContinue.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.btnContinue.Location = new System.Drawing.Point(114, 92);
+            this.btnContinue.Name = "btnContinue";
+            this.btnContinue.Padding = new System.Windows.Forms.Padding(2, 0, 2, 0);
+            this.btnContinue.Size = new System.Drawing.Size(45, 25);
+            this.btnContinue.TabIndex = 3;
+            this.btnContinue.Text = "Next";
+            this.btnContinue.UseVisualStyleBackColor = true;
+            this.btnContinue.Click += new System.EventHandler(this.btnContinue_Click);
+            // 
+            // cbProgramConfig
+            // 
+            this.cbProgramConfig.AutoSize = true;
+            this.cbProgramConfig.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.cbProgramConfig.Location = new System.Drawing.Point(3, 3);
+            this.cbProgramConfig.Margin = new System.Windows.Forms.Padding(3, 3, 3, 2);
+            this.cbProgramConfig.Name = "cbProgramConfig";
+            this.cbProgramConfig.Size = new System.Drawing.Size(117, 19);
+            this.cbProgramConfig.TabIndex = 0;
+            this.cbProgramConfig.Text = "Program Options";
+            this.toolTip.SetToolTip(this.cbProgramConfig, "Interface, notification, and update options.");
+            this.cbProgramConfig.UseVisualStyleBackColor = true;
+            this.cbProgramConfig.CheckedChanged += new System.EventHandler(this.checkBoxSelection_CheckedChanged);
+            // 
+            // cbSession
+            // 
+            this.cbSession.AutoSize = true;
+            this.cbSession.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.cbSession.Location = new System.Drawing.Point(3, 51);
+            this.cbSession.Margin = new System.Windows.Forms.Padding(3, 3, 3, 2);
+            this.cbSession.Name = "cbSession";
+            this.cbSession.Size = new System.Drawing.Size(98, 19);
+            this.cbSession.TabIndex = 2;
+            this.cbSession.Text = "Login Session";
+            this.toolTip.SetToolTip(this.cbSession, "A token that allows logging into the\r\ncurrent TweetDeck account.");
+            this.cbSession.UseVisualStyleBackColor = true;
+            this.cbSession.CheckedChanged += new System.EventHandler(this.checkBoxSelection_CheckedChanged);
+            // 
+            // cbPluginData
+            // 
+            this.cbPluginData.AutoSize = true;
+            this.cbPluginData.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.cbPluginData.Location = new System.Drawing.Point(3, 75);
+            this.cbPluginData.Margin = new System.Windows.Forms.Padding(3, 3, 3, 2);
+            this.cbPluginData.Name = "cbPluginData";
+            this.cbPluginData.Size = new System.Drawing.Size(87, 19);
+            this.cbPluginData.TabIndex = 3;
+            this.cbPluginData.Text = "Plugin Data";
+            this.toolTip.SetToolTip(this.cbPluginData, "Data files generated by plugins.\r\nDoes not include the plugins themselves.");
+            this.cbPluginData.UseVisualStyleBackColor = true;
+            this.cbPluginData.CheckedChanged += new System.EventHandler(this.checkBoxSelection_CheckedChanged);
+            // 
+            // cbSystemConfig
+            // 
+            this.cbSystemConfig.AutoSize = true;
+            this.cbSystemConfig.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.cbSystemConfig.Location = new System.Drawing.Point(3, 27);
+            this.cbSystemConfig.Margin = new System.Windows.Forms.Padding(3, 3, 3, 2);
+            this.cbSystemConfig.Name = "cbSystemConfig";
+            this.cbSystemConfig.Size = new System.Drawing.Size(109, 19);
+            this.cbSystemConfig.TabIndex = 1;
+            this.cbSystemConfig.Text = "System Options";
+            this.toolTip.SetToolTip(this.cbSystemConfig, "Hardware acceleration and cache options.");
+            this.cbSystemConfig.UseVisualStyleBackColor = true;
+            this.cbSystemConfig.CheckedChanged += new System.EventHandler(this.checkBoxSelection_CheckedChanged);
+            // 
+            // panelSelection
+            // 
+            this.panelSelection.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+            this.panelSelection.Controls.Add(this.cbProgramConfig);
+            this.panelSelection.Controls.Add(this.cbSystemConfig);
+            this.panelSelection.Controls.Add(this.cbSession);
+            this.panelSelection.Controls.Add(this.cbPluginData);
+            this.panelSelection.FlowDirection = System.Windows.Forms.FlowDirection.TopDown;
+            this.panelSelection.Location = new System.Drawing.Point(12, 12);
+            this.panelSelection.Name = "panelSelection";
+            this.panelSelection.Size = new System.Drawing.Size(210, 97);
+            this.panelSelection.TabIndex = 2;
+            this.panelSelection.Visible = false;
+            this.panelSelection.WrapContents = false;
+            // 
+            // panelDecision
+            // 
+            this.panelDecision.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+            this.panelDecision.Controls.Add(this.radioImport);
+            this.panelDecision.Controls.Add(this.radioExport);
+            this.panelDecision.Controls.Add(this.radioReset);
+            this.panelDecision.FlowDirection = System.Windows.Forms.FlowDirection.TopDown;
+            this.panelDecision.Location = new System.Drawing.Point(12, 12);
+            this.panelDecision.Name = "panelDecision";
+            this.panelDecision.Size = new System.Drawing.Size(210, 75);
+            this.panelDecision.TabIndex = 0;
+            this.panelDecision.WrapContents = false;
+            // 
+            // radioImport
+            // 
+            this.radioImport.AutoSize = true;
+            this.radioImport.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.radioImport.Location = new System.Drawing.Point(3, 3);
+            this.radioImport.Margin = new System.Windows.Forms.Padding(3, 3, 3, 2);
+            this.radioImport.Name = "radioImport";
+            this.radioImport.Size = new System.Drawing.Size(98, 19);
+            this.radioImport.TabIndex = 0;
+            this.radioImport.TabStop = true;
+            this.radioImport.Text = "Import Profile";
+            this.radioImport.UseVisualStyleBackColor = true;
+            this.radioImport.CheckedChanged += new System.EventHandler(this.radioDecision_CheckedChanged);
+            // 
+            // radioExport
+            // 
+            this.radioExport.AutoSize = true;
+            this.radioExport.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.radioExport.Location = new System.Drawing.Point(3, 27);
+            this.radioExport.Margin = new System.Windows.Forms.Padding(3, 3, 3, 2);
+            this.radioExport.Name = "radioExport";
+            this.radioExport.Size = new System.Drawing.Size(95, 19);
+            this.radioExport.TabIndex = 1;
+            this.radioExport.TabStop = true;
+            this.radioExport.Text = "Export Profile";
+            this.radioExport.UseVisualStyleBackColor = true;
+            this.radioExport.CheckedChanged += new System.EventHandler(this.radioDecision_CheckedChanged);
+            // 
+            // radioReset
+            // 
+            this.radioReset.AutoSize = true;
+            this.radioReset.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.radioReset.Location = new System.Drawing.Point(3, 51);
+            this.radioReset.Margin = new System.Windows.Forms.Padding(3, 3, 3, 2);
+            this.radioReset.Name = "radioReset";
+            this.radioReset.Size = new System.Drawing.Size(110, 19);
+            this.radioReset.TabIndex = 2;
+            this.radioReset.TabStop = true;
+            this.radioReset.Text = "Restore Defaults";
+            this.radioReset.UseVisualStyleBackColor = true;
+            this.radioReset.CheckedChanged += new System.EventHandler(this.radioDecision_CheckedChanged);
+            // 
+            // DialogSettingsManage
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(234, 129);
+            this.Controls.Add(this.btnContinue);
+            this.Controls.Add(this.btnCancel);
+            this.Controls.Add(this.panelDecision);
+            this.Controls.Add(this.panelSelection);
+            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
+            this.MaximizeBox = false;
+            this.MinimizeBox = false;
+            this.MinimumSize = new System.Drawing.Size(250, 167);
+            this.Name = "DialogSettingsManage";
+            this.ShowIcon = false;
+            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
+            this.Text = "Manage Options";
+            this.panelSelection.ResumeLayout(false);
+            this.panelSelection.PerformLayout();
+            this.panelDecision.ResumeLayout(false);
+            this.panelDecision.PerformLayout();
+            this.ResumeLayout(false);
+            this.PerformLayout();
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.Button btnCancel;
+        private System.Windows.Forms.Button btnContinue;
+        private System.Windows.Forms.CheckBox cbProgramConfig;
+        private System.Windows.Forms.CheckBox cbSystemConfig;
+        private System.Windows.Forms.CheckBox cbSession;
+        private System.Windows.Forms.CheckBox cbPluginData;
+        private System.Windows.Forms.ToolTip toolTip;
+        private System.Windows.Forms.FlowLayoutPanel panelSelection;
+        private System.Windows.Forms.FlowLayoutPanel panelDecision;
+        private System.Windows.Forms.RadioButton radioReset;
+        private System.Windows.Forms.RadioButton radioExport;
+        private System.Windows.Forms.RadioButton radioImport;
+    }
+}

Core/Other/Settings/Dialogs/DialogSettingsManage.cs

@@ -0,0 +1,244 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Windows.Forms;
+using TweetDuck.Configuration;
+using TweetDuck.Core.Management;
+using TweetDuck.Core.Utils;
+using TweetDuck.Plugins;
+
+namespace TweetDuck.Core.Other.Settings.Dialogs{
+    sealed partial class DialogSettingsManage : Form{
+        private enum State{
+            Deciding, Reset, Import, Export
+        }
+
+        private ProfileManager.Items SelectedItems{
+            get => _selectedItems;
+
+            set{
+                // this will call events and SetFlag, which also updates the UI
+                foreach(KeyValuePair<CheckBox, ProfileManager.Items> kvp in checkBoxMap){
+                    kvp.Key.Checked = value.HasFlag(kvp.Value);
+                }
+            }
+        }
+
+        private bool SelectedItemsForceRestart{
+            get => _selectedItems.HasFlag(ProfileManager.Items.Session);
+        }
+        
+        public bool IsRestarting { get; private set; }
+        public bool ShouldReloadBrowser { get; private set; }
+        
+        private readonly PluginManager plugins;
+        private readonly Dictionary<CheckBox, ProfileManager.Items> checkBoxMap = new Dictionary<CheckBox, ProfileManager.Items>(4);
+        private readonly bool openImportImmediately;
+
+        private State currentState;
+        private ProfileManager importManager;
+        private bool requestedRestartFromConfig;
+
+        private ProfileManager.Items _selectedItems = ProfileManager.Items.None;
+
+        public DialogSettingsManage(PluginManager plugins, bool openImportImmediately = false){
+            InitializeComponent();
+
+            this.plugins = plugins;
+            this.currentState = State.Deciding;
+
+            this.checkBoxMap[cbProgramConfig] = ProfileManager.Items.UserConfig;
+            this.checkBoxMap[cbSystemConfig] = ProfileManager.Items.SystemConfig;
+            this.checkBoxMap[cbSession] = ProfileManager.Items.Session;
+            this.checkBoxMap[cbPluginData] = ProfileManager.Items.PluginData;
+
+            this.openImportImmediately = openImportImmediately;
+
+            if (openImportImmediately){
+                radioImport.Checked = true;
+                btnContinue_Click(null, EventArgs.Empty);
+            }
+        }
+
+        private void radioDecision_CheckedChanged(object sender, EventArgs e){
+            btnContinue.Enabled = true;
+        }
+
+        private void checkBoxSelection_CheckedChanged(object sender, EventArgs e){
+            CheckBox cb = (CheckBox)sender;
+            SetFlag(checkBoxMap[cb], cb.Checked);
+        }
+
+        private void btnContinue_Click(object sender, EventArgs e){
+            string file;
+
+            switch(currentState){
+                case State.Deciding:
+                    // Reset
+                    if (radioReset.Checked){
+                        currentState = State.Reset;
+
+                        Text = "Restore Defaults";
+                        SelectedItems = ProfileManager.Items.UserConfig;
+                    }
+
+                    // Import
+                    else if (radioImport.Checked){
+                        using(OpenFileDialog dialog = new OpenFileDialog{
+                            AutoUpgradeEnabled = true,
+                            DereferenceLinks = true,
+                            Title = "Import TweetDuck Profile",
+                            Filter = "TweetDuck Profile (*.tdsettings)|*.tdsettings"
+                        }){
+                            if (dialog.ShowDialog() != DialogResult.OK){
+                                if (openImportImmediately){
+                                    Close();
+                                }
+
+                                return;
+                            }
+
+                            file = dialog.FileName;
+                        }
+
+                        importManager = new ProfileManager(file, plugins);
+                        currentState = State.Import;
+
+                        Text = "Import Profile";
+                        SelectedItems = importManager.FindImportItems();
+
+                        foreach(CheckBox cb in checkBoxMap.Keys){
+                            cb.Enabled = cb.Checked;
+                        }
+                    }
+
+                    // Export
+                    else if (radioExport.Checked){
+                        currentState = State.Export;
+
+                        Text = "Export Profile";
+                        btnContinue.Text = "Export Profile";
+                        SelectedItems = ProfileManager.Items.UserConfig | ProfileManager.Items.PluginData;
+                    }
+                    
+                    // Continue...
+                    panelDecision.Visible = false;
+                    panelSelection.Visible = true;
+                    Height += panelSelection.Height-panelDecision.Height;
+                    break;
+
+                case State.Reset:
+                    if (FormMessage.Warning("Reset TweetDuck Options", "This will reset the selected items. Are you sure you want to proceed?", FormMessage.Yes, FormMessage.No)){
+                        Program.Config.ProgramRestartRequested += Config_ProgramRestartRequested;
+
+                        if (SelectedItems.HasFlag(ProfileManager.Items.UserConfig)){
+                            Program.Config.User.Reset();
+                        }
+
+                        if (SelectedItems.HasFlag(ProfileManager.Items.SystemConfig)){
+                            Program.Config.System.Reset();
+                        }
+
+                        Program.Config.ProgramRestartRequested -= Config_ProgramRestartRequested;
+
+                        if (SelectedItems.HasFlag(ProfileManager.Items.PluginData)){
+                            Program.Config.Plugins.Reset();
+
+                            try{
+                                Directory.Delete(Program.PluginDataPath, true);
+                            }catch(Exception ex){
+                                Program.Reporter.HandleException("Profile Reset", "Could not delete plugin data.", true, ex);
+                            }
+                        }
+
+                        if (SelectedItemsForceRestart){
+                            RestartProgram(SelectedItems.HasFlag(ProfileManager.Items.Session) ? new string[]{ Arguments.ArgDeleteCookies } : StringUtils.EmptyArray);
+                        }
+                        else if (requestedRestartFromConfig){
+                            if (FormMessage.Information("Profile Reset", "The application must restart for some of the restored options to take place. Do you want to restart now?", FormMessage.Yes, FormMessage.No)){
+                                RestartProgram();
+                            }
+                        }
+
+                        ShouldReloadBrowser = true;
+
+                        DialogResult = DialogResult.OK;
+                        Close();
+                    }
+
+                    break;
+
+                case State.Import:
+                    if (importManager.Import(SelectedItems)){
+                        Program.Config.ProgramRestartRequested += Config_ProgramRestartRequested;
+                        Program.Config.ReloadAll();
+                        Program.Config.ProgramRestartRequested -= Config_ProgramRestartRequested;
+                        
+                        if (SelectedItemsForceRestart){
+                            RestartProgram(SelectedItems.HasFlag(ProfileManager.Items.Session) ? new string[]{ Arguments.ArgImportCookies } : StringUtils.EmptyArray);
+                        }
+                        else if (requestedRestartFromConfig){
+                            if (FormMessage.Information("Profile Import", "The application must restart for some of the imported options to take place. Do you want to restart now?", FormMessage.Yes, FormMessage.No)){
+                                RestartProgram();
+                            }
+                        }
+                    }
+                    
+                    ShouldReloadBrowser = true;
+
+                    DialogResult = DialogResult.OK;
+                    Close();
+                    break;
+
+                case State.Export:
+                    using(SaveFileDialog dialog = new SaveFileDialog{
+                        AddExtension = true,
+                        AutoUpgradeEnabled = true,
+                        OverwritePrompt = true,
+                        DefaultExt = "tdsettings",
+                        FileName = "TweetDuck.tdsettings",
+                        Title = "Export TweetDuck Profile",
+                        Filter = "TweetDuck Profile (*.tdsettings)|*.tdsettings"
+                    }){
+                        if (dialog.ShowDialog() != DialogResult.OK){
+                            return;
+                        }
+
+                        file = dialog.FileName;
+                    }
+                    
+                    new ProfileManager(file, plugins).Export(SelectedItems);
+
+                    DialogResult = DialogResult.OK;
+                    Close();
+                    break;
+            }
+        }
+
+        private void btnCancel_Click(object sender, EventArgs e){
+            DialogResult = DialogResult.Cancel;
+            Close();
+        }
+
+        private void Config_ProgramRestartRequested(object sender, EventArgs e){
+            requestedRestartFromConfig = true;
+        }
+
+        private void SetFlag(ProfileManager.Items flag, bool enable){
+            _selectedItems = enable ? _selectedItems | flag : _selectedItems & ~flag;
+            btnContinue.Enabled = _selectedItems != ProfileManager.Items.None;
+            
+            if (currentState == State.Import){
+                btnContinue.Text = SelectedItemsForceRestart ? "Import && Restart" : "Import Profile";
+            }
+            else if (currentState == State.Reset){
+                btnContinue.Text = SelectedItemsForceRestart ? "Restore && Restart" : "Restore Defaults";
+            }
+        }
+
+        private void RestartProgram(params string[] extraArgs){
+            IsRestarting = true;
+            Program.Restart(extraArgs);
+        }
+    }
+}

Core/Other/Settings/Dialogs/DialogSettingsRestart.Designer.cs

@@ -1,4 +1,4 @@
-namespace TweetDck.Core.Other.Settings.Dialogs {
+namespace TweetDuck.Core.Other.Settings.Dialogs {
     partial class DialogSettingsRestart {
         /// <summary>
         /// Required designer variable.
@@ -28,22 +28,24 @@
             this.btnRestart = new System.Windows.Forms.Button();
             this.cbLogging = new System.Windows.Forms.CheckBox();
             this.toolTip = new System.Windows.Forms.ToolTip(this.components);
-            this.cbDebugUpdates = new System.Windows.Forms.CheckBox();
-            this.labelLocale = new System.Windows.Forms.Label();
-            this.comboLocale = new System.Windows.Forms.ComboBox();
-            this.labelDataFolder = new System.Windows.Forms.Label();
             this.tbDataFolder = new System.Windows.Forms.TextBox();
+            this.tbShortcutTarget = new System.Windows.Forms.TextBox();
+            this.labelDataFolder = new System.Windows.Forms.Label();
+            this.labelShortcutTarget = new System.Windows.Forms.Label();
+            this.flowPanel = new System.Windows.Forms.FlowLayoutPanel();
+            this.flowPanel.SuspendLayout();
             this.SuspendLayout();
             // 
             // btnCancel
             // 
             this.btnCancel.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
             this.btnCancel.AutoSize = true;
-            this.btnCancel.Location = new System.Drawing.Point(160, 171);
+            this.btnCancel.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.btnCancel.Location = new System.Drawing.Point(215, 146);
             this.btnCancel.Name = "btnCancel";
-            this.btnCancel.Padding = new System.Windows.Forms.Padding(3, 0, 3, 0);
-            this.btnCancel.Size = new System.Drawing.Size(56, 23);
-            this.btnCancel.TabIndex = 7;
+            this.btnCancel.Padding = new System.Windows.Forms.Padding(2, 0, 2, 0);
+            this.btnCancel.Size = new System.Drawing.Size(57, 25);
+            this.btnCancel.TabIndex = 2;
             this.btnCancel.Text = "Cancel";
             this.btnCancel.UseVisualStyleBackColor = true;
             this.btnCancel.Click += new System.EventHandler(this.btnCancel_Click);
@@ -52,11 +54,12 @@
             // 
             this.btnRestart.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
             this.btnRestart.AutoSize = true;
-            this.btnRestart.Location = new System.Drawing.Point(97, 171);
+            this.btnRestart.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.btnRestart.Location = new System.Drawing.Point(152, 146);
             this.btnRestart.Name = "btnRestart";
-            this.btnRestart.Padding = new System.Windows.Forms.Padding(3, 0, 3, 0);
-            this.btnRestart.Size = new System.Drawing.Size(57, 23);
-            this.btnRestart.TabIndex = 6;
+            this.btnRestart.Padding = new System.Windows.Forms.Padding(2, 0, 2, 0);
+            this.btnRestart.Size = new System.Drawing.Size(57, 25);
+            this.btnRestart.TabIndex = 1;
             this.btnRestart.Text = "Restart";
             this.btnRestart.UseVisualStyleBackColor = true;
             this.btnRestart.Click += new System.EventHandler(this.btnRestart_Click);
@@ -64,75 +67,85 @@
             // cbLogging
             // 
             this.cbLogging.AutoSize = true;
-            this.cbLogging.Location = new System.Drawing.Point(12, 12);
+            this.cbLogging.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.cbLogging.Location = new System.Drawing.Point(3, 3);
+            this.cbLogging.Margin = new System.Windows.Forms.Padding(3, 3, 3, 2);
             this.cbLogging.Name = "cbLogging";
-            this.cbLogging.Size = new System.Drawing.Size(64, 17);
+            this.cbLogging.Size = new System.Drawing.Size(70, 19);
             this.cbLogging.TabIndex = 0;
             this.cbLogging.Text = "Logging";
-            this.toolTip.SetToolTip(this.cbLogging, "Logging JavaScript output into a\r\ndebug.txt file in the data folder.");
+            this.toolTip.SetToolTip(this.cbLogging, "Logs JavaScript output into TD_Console.txt file in the data folder.");
             this.cbLogging.UseVisualStyleBackColor = true;
             // 
-            // cbDebugUpdates
+            // tbDataFolder
             // 
-            this.cbDebugUpdates.AutoSize = true;
-            this.cbDebugUpdates.Location = new System.Drawing.Point(12, 35);
-            this.cbDebugUpdates.Name = "cbDebugUpdates";
-            this.cbDebugUpdates.Size = new System.Drawing.Size(127, 17);
-            this.cbDebugUpdates.TabIndex = 1;
-            this.cbDebugUpdates.Text = "Pre-Release Updates";
-            this.toolTip.SetToolTip(this.cbDebugUpdates, "Allows updating to pre-releases.");
-            this.cbDebugUpdates.UseVisualStyleBackColor = true;
+            this.tbDataFolder.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.tbDataFolder.Location = new System.Drawing.Point(3, 54);
+            this.tbDataFolder.Name = "tbDataFolder";
+            this.tbDataFolder.Size = new System.Drawing.Size(260, 23);
+            this.tbDataFolder.TabIndex = 2;
+            this.toolTip.SetToolTip(this.tbDataFolder, "Path to the data folder. Must be either an absolute path,\r\nor a simple folder nam" +
+        "e that will be created in LocalAppData.");
             // 
-            // labelLocale
+            // tbShortcutTarget
             // 
-            this.labelLocale.AutoSize = true;
-            this.labelLocale.Location = new System.Drawing.Point(12, 67);
-            this.labelLocale.Margin = new System.Windows.Forms.Padding(3, 12, 3, 0);
-            this.labelLocale.Name = "labelLocale";
-            this.labelLocale.Size = new System.Drawing.Size(39, 13);
-            this.labelLocale.TabIndex = 2;
-            this.labelLocale.Text = "Locale";
-            // 
-            // comboLocale
-            // 
-            this.comboLocale.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+            this.tbShortcutTarget.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
             | System.Windows.Forms.AnchorStyles.Right)));
-            this.comboLocale.FormattingEnabled = true;
-            this.comboLocale.Location = new System.Drawing.Point(15, 83);
-            this.comboLocale.Name = "comboLocale";
-            this.comboLocale.Size = new System.Drawing.Size(201, 21);
-            this.comboLocale.TabIndex = 3;
+            this.tbShortcutTarget.Cursor = System.Windows.Forms.Cursors.Hand;
+            this.tbShortcutTarget.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.tbShortcutTarget.Location = new System.Drawing.Point(3, 110);
+            this.tbShortcutTarget.Name = "tbShortcutTarget";
+            this.tbShortcutTarget.ReadOnly = true;
+            this.tbShortcutTarget.Size = new System.Drawing.Size(260, 23);
+            this.tbShortcutTarget.TabIndex = 4;
+            this.tbShortcutTarget.Click += new System.EventHandler(this.tbShortcutTarget_Click);
             // 
             // labelDataFolder
             // 
             this.labelDataFolder.AutoSize = true;
-            this.labelDataFolder.Location = new System.Drawing.Point(12, 119);
+            this.labelDataFolder.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.labelDataFolder.Location = new System.Drawing.Point(3, 36);
             this.labelDataFolder.Margin = new System.Windows.Forms.Padding(3, 12, 3, 0);
             this.labelDataFolder.Name = "labelDataFolder";
-            this.labelDataFolder.Size = new System.Drawing.Size(62, 13);
-            this.labelDataFolder.TabIndex = 4;
+            this.labelDataFolder.Size = new System.Drawing.Size(67, 15);
+            this.labelDataFolder.TabIndex = 1;
             this.labelDataFolder.Text = "Data Folder";
             // 
-            // tbDataFolder
+            // labelShortcutTarget
             // 
-            this.tbDataFolder.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+            this.labelShortcutTarget.AutoSize = true;
+            this.labelShortcutTarget.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.labelShortcutTarget.Location = new System.Drawing.Point(3, 92);
+            this.labelShortcutTarget.Margin = new System.Windows.Forms.Padding(3, 12, 3, 0);
+            this.labelShortcutTarget.Name = "labelShortcutTarget";
+            this.labelShortcutTarget.Size = new System.Drawing.Size(171, 15);
+            this.labelShortcutTarget.TabIndex = 3;
+            this.labelShortcutTarget.Text = "Shortcut Target (click to select)";
+            // 
+            // flowPanel
+            // 
+            this.flowPanel.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
+            | System.Windows.Forms.AnchorStyles.Left) 
             | System.Windows.Forms.AnchorStyles.Right)));
-            this.tbDataFolder.Location = new System.Drawing.Point(15, 135);
-            this.tbDataFolder.Name = "tbDataFolder";
-            this.tbDataFolder.Size = new System.Drawing.Size(201, 20);
-            this.tbDataFolder.TabIndex = 5;
+            this.flowPanel.Controls.Add(this.cbLogging);
+            this.flowPanel.Controls.Add(this.labelDataFolder);
+            this.flowPanel.Controls.Add(this.tbDataFolder);
+            this.flowPanel.Controls.Add(this.labelShortcutTarget);
+            this.flowPanel.Controls.Add(this.tbShortcutTarget);
+            this.flowPanel.FlowDirection = System.Windows.Forms.FlowDirection.TopDown;
+            this.flowPanel.Location = new System.Drawing.Point(9, 9);
+            this.flowPanel.Margin = new System.Windows.Forms.Padding(0);
+            this.flowPanel.Name = "flowPanel";
+            this.flowPanel.Size = new System.Drawing.Size(266, 136);
+            this.flowPanel.TabIndex = 0;
+            this.flowPanel.WrapContents = false;
             // 
             // DialogSettingsRestart
             // 
             this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
             this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-            this.ClientSize = new System.Drawing.Size(228, 206);
-            this.Controls.Add(this.tbDataFolder);
-            this.Controls.Add(this.labelDataFolder);
-            this.Controls.Add(this.comboLocale);
-            this.Controls.Add(this.labelLocale);
-            this.Controls.Add(this.cbDebugUpdates);
-            this.Controls.Add(this.cbLogging);
+            this.ClientSize = new System.Drawing.Size(284, 183);
+            this.Controls.Add(this.flowPanel);
             this.Controls.Add(this.btnRestart);
             this.Controls.Add(this.btnCancel);
             this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
@@ -141,6 +154,8 @@
             this.Name = "DialogSettingsRestart";
             this.ShowIcon = false;
             this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
+            this.flowPanel.ResumeLayout(false);
+            this.flowPanel.PerformLayout();
             this.ResumeLayout(false);
             this.PerformLayout();
 
@@ -152,10 +167,10 @@
         private System.Windows.Forms.Button btnRestart;
         private System.Windows.Forms.CheckBox cbLogging;
         private System.Windows.Forms.ToolTip toolTip;
-        private System.Windows.Forms.CheckBox cbDebugUpdates;
-        private System.Windows.Forms.Label labelLocale;
-        private System.Windows.Forms.ComboBox comboLocale;
         private System.Windows.Forms.Label labelDataFolder;
         private System.Windows.Forms.TextBox tbDataFolder;
+        private System.Windows.Forms.TextBox tbShortcutTarget;
+        private System.Windows.Forms.Label labelShortcutTarget;
+        private System.Windows.Forms.FlowLayoutPanel flowPanel;
     }
 }

Core/Other/Settings/Dialogs/DialogSettingsRestart.cs

@@ -1,55 +1,54 @@
 using System;
-using System.IO;
-using System.Linq;
 using System.Windows.Forms;
-using TweetDck.Configuration;
-using TweetDck.Core.Utils;
+using TweetDuck.Configuration;
+using TweetDuck.Data;
 
-namespace TweetDck.Core.Other.Settings.Dialogs{
+namespace TweetDuck.Core.Other.Settings.Dialogs{
     sealed partial class DialogSettingsRestart : Form{
-        private const string DefaultLocale = "en-US";
-
         public CommandLineArgs Args { get; private set; }
 
         public DialogSettingsRestart(CommandLineArgs currentArgs){
             InitializeComponent();
 
-            try{
-                object[] locales = Directory.EnumerateFiles(Path.Combine(Program.ProgramPath, "locales"), "*.pak", SearchOption.TopDirectoryOnly).Select(Path.GetFileNameWithoutExtension).ToArray<object>();
-                comboLocale.Items.AddRange(locales);
-            }catch{
-                comboLocale.Items.Add(DefaultLocale);
+            cbLogging.Checked = currentArgs.HasFlag(Arguments.ArgLogging);
+            cbLogging.CheckedChanged += control_Change;
+            
+            if (Program.IsPortable){
+                tbDataFolder.Text = "Not available in portable version";
+                tbDataFolder.Enabled = false;
+            }
+            else{
+                tbDataFolder.Text = currentArgs.GetValue(Arguments.ArgDataFolder, string.Empty);
+                tbDataFolder.TextChanged += control_Change;
             }
 
-            cbLogging.Checked = currentArgs.HasFlag(Arguments.ArgLogging);
-            cbDebugUpdates.Checked = currentArgs.HasFlag(Arguments.ArgDebugUpdates);
-            comboLocale.SelectedItem = currentArgs.GetValue(Arguments.ArgLocale, DefaultLocale);
-            tbDataFolder.Text = currentArgs.GetValue(Arguments.ArgDataFolder, string.Empty);
+            control_Change(this, EventArgs.Empty);
 
             Text = Program.BrandName+" Arguments";
         }
 
-        private void btnRestart_Click(object sender, EventArgs e){
+        private void control_Change(object sender, EventArgs e){
             Args = new CommandLineArgs();
             
             if (cbLogging.Checked){
                 Args.AddFlag(Arguments.ArgLogging);
             }
             
-            if (cbDebugUpdates.Checked){
-                Args.AddFlag(Arguments.ArgDebugUpdates);
-            }
-
-            string locale = comboLocale.SelectedItem as string;
-
-            if (!string.IsNullOrWhiteSpace(locale) && locale != DefaultLocale){
-                Args.SetValue(Arguments.ArgLocale, locale);
-            }
-
-            if (!string.IsNullOrWhiteSpace(tbDataFolder.Text)){
+            if (!string.IsNullOrWhiteSpace(tbDataFolder.Text) && tbDataFolder.Enabled){
                 Args.SetValue(Arguments.ArgDataFolder, tbDataFolder.Text);
             }
 
+            tbShortcutTarget.Text = $@"""{Application.ExecutablePath}""{(Args.Count > 0 ? " " : "")}{Args}";
+            tbShortcutTarget.Select(tbShortcutTarget.Text.Length, 0);
+        }
+
+        private void tbShortcutTarget_Click(object sender, EventArgs e){
+            if (tbShortcutTarget.SelectionLength == 0){
+                tbShortcutTarget.SelectAll();
+            }
+        }
+
+        private void btnRestart_Click(object sender, EventArgs e){
             DialogResult = DialogResult.OK;
             Close();
         }

Core/Other/Settings/Dialogs/DialogSettingsSearchEngine.Designer.cs

@@ -0,0 +1,109 @@
+namespace TweetDuck.Core.Other.Settings.Dialogs {
+    partial class DialogSettingsSearchEngine {
+        /// <summary>
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing) {
+            if (disposing && (components != null)) {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Windows Form Designer generated code
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent() {
+            this.textBoxUrl = new System.Windows.Forms.TextBox();
+            this.btnCancel = new System.Windows.Forms.Button();
+            this.btnApply = new System.Windows.Forms.Button();
+            this.labelInfo = new System.Windows.Forms.Label();
+            this.SuspendLayout();
+            // 
+            // textBoxUrl
+            // 
+            this.textBoxUrl.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
+            | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+            this.textBoxUrl.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.textBoxUrl.Location = new System.Drawing.Point(12, 30);
+            this.textBoxUrl.Name = "textBoxUrl";
+            this.textBoxUrl.Size = new System.Drawing.Size(310, 23);
+            this.textBoxUrl.TabIndex = 1;
+            // 
+            // btnCancel
+            // 
+            this.btnCancel.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+            this.btnCancel.AutoSize = true;
+            this.btnCancel.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.btnCancel.Location = new System.Drawing.Point(207, 59);
+            this.btnCancel.Name = "btnCancel";
+            this.btnCancel.Padding = new System.Windows.Forms.Padding(2, 0, 2, 0);
+            this.btnCancel.Size = new System.Drawing.Size(57, 25);
+            this.btnCancel.TabIndex = 3;
+            this.btnCancel.Text = "Cancel";
+            this.btnCancel.UseVisualStyleBackColor = true;
+            this.btnCancel.Click += new System.EventHandler(this.btnCancel_Click);
+            // 
+            // btnApply
+            // 
+            this.btnApply.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+            this.btnApply.AutoSize = true;
+            this.btnApply.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.btnApply.Location = new System.Drawing.Point(270, 59);
+            this.btnApply.Name = "btnApply";
+            this.btnApply.Padding = new System.Windows.Forms.Padding(2, 0, 2, 0);
+            this.btnApply.Size = new System.Drawing.Size(52, 25);
+            this.btnApply.TabIndex = 2;
+            this.btnApply.Text = "Apply";
+            this.btnApply.UseVisualStyleBackColor = true;
+            this.btnApply.Click += new System.EventHandler(this.btnApply_Click);
+            // 
+            // labelInfo
+            // 
+            this.labelInfo.AutoSize = true;
+            this.labelInfo.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular);
+            this.labelInfo.Location = new System.Drawing.Point(12, 9);
+            this.labelInfo.Margin = new System.Windows.Forms.Padding(3, 0, 3, 3);
+            this.labelInfo.Name = "labelInfo";
+            this.labelInfo.Size = new System.Drawing.Size(287, 15);
+            this.labelInfo.TabIndex = 0;
+            this.labelInfo.Text = "The search query will be added at the end of the URL.";
+            // 
+            // DialogSettingsSearchEngine
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(334, 96);
+            this.Controls.Add(this.labelInfo);
+            this.Controls.Add(this.btnApply);
+            this.Controls.Add(this.btnCancel);
+            this.Controls.Add(this.textBoxUrl);
+            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
+            this.MaximizeBox = false;
+            this.MinimizeBox = false;
+            this.Name = "DialogSettingsSearchEngine";
+            this.ShowIcon = false;
+            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
+            this.ResumeLayout(false);
+            this.PerformLayout();
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.TextBox textBoxUrl;
+        private System.Windows.Forms.Button btnCancel;
+        private System.Windows.Forms.Button btnApply;
+        private System.Windows.Forms.Label labelInfo;
+    }
+}

Core/Other/Settings/Dialogs/DialogSettingsSearchEngine.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Windows.Forms;
+
+namespace TweetDuck.Core.Other.Settings.Dialogs{
+    sealed partial class DialogSettingsSearchEngine : Form{
+        public string Url => textBoxUrl.Text;
+
+        public DialogSettingsSearchEngine(){
+            InitializeComponent();
+            
+            Text = Program.BrandName+" Options - Custom Search Engine";
+            
+            textBoxUrl.Text = Program.Config.User.SearchEngineUrl ?? "";
+            textBoxUrl.Select(textBoxUrl.Text.Length, 0);
+        }
+        
+        private void btnApply_Click(object sender, EventArgs e){
+            DialogResult = DialogResult.OK;
+            Close();
+        }
+
+        private void btnCancel_Click(object sender, EventArgs e){
+            DialogResult = DialogResult.Cancel;
+            Close();
+        }
+    }
+}

Core/Other/Settings/Export/ExportFileFlags.cs

@@ -1,12 +0,0 @@
-using System;
-
-namespace TweetDck.Core.Other.Settings.Export{
-    [Flags]
-    enum ExportFileFlags{
-        None = 0,
-        Config = 1,
-        Session = 2,
-        PluginData = 4,
-        All = Config|Session|PluginData
-    }
-}

Core/Other/Settings/TabSettingsAdvanced.Designer.cs

@@ -1,4 +1,4 @@
-namespace TweetDck.Core.Other.Settings {
+namespace TweetDuck.Core.Other.Settings {
     partial class TabSettingsAdvanced {
         /// <summary> 
         /// Required designer variable.
@@ -25,7 +25,6 @@
         private void InitializeComponent() {
             this.components = new System.ComponentModel.Container();
             this.btnClearCache = new System.Windows.Forms.Button();
-            this.checkHardwareAcceleration = new System.Windows.Forms.CheckBox();
             this.toolTip = new System.Windows.Forms.ToolTip(this.components);
             this.btnEditCefArgs = new System.Windows.Forms.Button();
             this.btnEditCSS = new System.Windows.Forms.Button();
@@ -33,211 +32,257 @@
             this.btnRestart = new System.Windows.Forms.Button();
             this.btnOpenAppFolder = new System.Windows.Forms.Button();
             this.btnOpenDataFolder = new System.Windows.Forms.Button();
-            this.btnReset = new System.Windows.Forms.Button();
-            this.btnImport = new System.Windows.Forms.Button();
-            this.btnExport = new System.Windows.Forms.Button();
-            this.groupPerformance = new System.Windows.Forms.GroupBox();
-            this.groupConfiguration = new System.Windows.Forms.GroupBox();
-            this.groupApp = new System.Windows.Forms.GroupBox();
-            this.groupPerformance.SuspendLayout();
-            this.groupConfiguration.SuspendLayout();
-            this.groupApp.SuspendLayout();
+            this.numClearCacheThreshold = new TweetDuck.Core.Controls.NumericUpDownEx();
+            this.checkClearCacheAuto = new System.Windows.Forms.CheckBox();
+            this.labelApp = new System.Windows.Forms.Label();
+            this.panelAppButtons = new System.Windows.Forms.Panel();
+            this.labelCache = new System.Windows.Forms.Label();
+            this.panelClearCacheAuto = new System.Windows.Forms.Panel();
+            this.panelConfiguration = new System.Windows.Forms.Panel();
+            this.labelConfiguration = new System.Windows.Forms.Label();
+            this.flowPanel = new System.Windows.Forms.FlowLayoutPanel();
+            ((System.ComponentModel.ISupportInitialize)(this.numClearCacheThreshold)).BeginInit();
+            this.panelAppButtons.SuspendLayout();
+            this.panelClearCacheAuto.SuspendLayout();
+            this.panelConfiguration.SuspendLayout();
+            this.flowPanel.SuspendLayout();
             this.SuspendLayout();
             // 
             // btnClearCache
             // 
-            this.btnClearCache.Location = new System.Drawing.Point(6, 44);
+            this.btnClearCache.Font = new System.Drawing.Font("Segoe UI", 9F);
+            this.btnClearCache.Location = new System.Drawing.Point(5, 135);
+            this.btnClearCache.Margin = new System.Windows.Forms.Padding(5, 3, 3, 3);
             this.btnClearCache.Name = "btnClearCache";
-            this.btnClearCache.Size = new System.Drawing.Size(171, 23);
-            this.btnClearCache.TabIndex = 1;
-            this.btnClearCache.Text = "Clear Cache (calculating)";
-            this.toolTip.SetToolTip(this.btnClearCache, "Clearing cache will free up space taken by downloaded images and other resources." +
-        "");
+            this.btnClearCache.Size = new System.Drawing.Size(143, 25);
+            this.btnClearCache.TabIndex = 3;
+            this.btnClearCache.Text = "Clear Cache (...)";
             this.btnClearCache.UseVisualStyleBackColor = true;
             // 
-            // checkHardwareAcceleration
-            // 
-            this.checkHardwareAcceleration.AutoSize = true;
-            this.checkHardwareAcceleration.Location = new System.Drawing.Point(9, 21);
-            this.checkHardwareAcceleration.Margin = new System.Windows.Forms.Padding(6, 5, 3, 3);
-            this.checkHardwareAcceleration.Name = "checkHardwareAcceleration";
-            this.checkHardwareAcceleration.Size = new System.Drawing.Size(134, 17);
-            this.checkHardwareAcceleration.TabIndex = 0;
-            this.checkHardwareAcceleration.Text = "Hardware Acceleration";
-            this.toolTip.SetToolTip(this.checkHardwareAcceleration, "Uses your graphics card to improve performance.\r\nDisable if you experience issues" +
-        " with rendering.");
-            this.checkHardwareAcceleration.UseVisualStyleBackColor = true;
-            // 
             // btnEditCefArgs
             // 
-            this.btnEditCefArgs.Location = new System.Drawing.Point(6, 19);
+            this.btnEditCefArgs.Font = new System.Drawing.Font("Segoe UI", 9F);
+            this.btnEditCefArgs.Location = new System.Drawing.Point(5, 3);
+            this.btnEditCefArgs.Margin = new System.Windows.Forms.Padding(5, 3, 3, 3);
             this.btnEditCefArgs.Name = "btnEditCefArgs";
-            this.btnEditCefArgs.Size = new System.Drawing.Size(171, 23);
+            this.btnEditCefArgs.Size = new System.Drawing.Size(143, 25);
             this.btnEditCefArgs.TabIndex = 0;
             this.btnEditCefArgs.Text = "Edit CEF Arguments";
-            this.toolTip.SetToolTip(this.btnEditCefArgs, "Set custom command line arguments for Chromium Embedded Framework.");
             this.btnEditCefArgs.UseVisualStyleBackColor = true;
             // 
             // btnEditCSS
             // 
-            this.btnEditCSS.Location = new System.Drawing.Point(6, 48);
+            this.btnEditCSS.Font = new System.Drawing.Font("Segoe UI", 9F);
+            this.btnEditCSS.Location = new System.Drawing.Point(154, 3);
             this.btnEditCSS.Name = "btnEditCSS";
-            this.btnEditCSS.Size = new System.Drawing.Size(171, 23);
+            this.btnEditCSS.Size = new System.Drawing.Size(143, 25);
             this.btnEditCSS.TabIndex = 1;
             this.btnEditCSS.Text = "Edit CSS";
-            this.toolTip.SetToolTip(this.btnEditCSS, "Set custom CSS for browser and notification windows.");
             this.btnEditCSS.UseVisualStyleBackColor = true;
             // 
             // btnRestartArgs
             // 
-            this.btnRestartArgs.Location = new System.Drawing.Point(6, 106);
+            this.btnRestartArgs.Font = new System.Drawing.Font("Segoe UI", 9F);
+            this.btnRestartArgs.Location = new System.Drawing.Point(154, 32);
             this.btnRestartArgs.Name = "btnRestartArgs";
-            this.btnRestartArgs.Size = new System.Drawing.Size(171, 23);
+            this.btnRestartArgs.Size = new System.Drawing.Size(143, 25);
             this.btnRestartArgs.TabIndex = 3;
             this.btnRestartArgs.Text = "Restart with Arguments";
-            this.toolTip.SetToolTip(this.btnRestartArgs, "Restarts the program with customizable\r\ncommand line arguments.");
             this.btnRestartArgs.UseVisualStyleBackColor = true;
             // 
             // btnRestart
             // 
-            this.btnRestart.Location = new System.Drawing.Point(6, 77);
+            this.btnRestart.Font = new System.Drawing.Font("Segoe UI", 9F);
+            this.btnRestart.Location = new System.Drawing.Point(154, 3);
             this.btnRestart.Name = "btnRestart";
-            this.btnRestart.Size = new System.Drawing.Size(171, 23);
+            this.btnRestart.Size = new System.Drawing.Size(143, 25);
             this.btnRestart.TabIndex = 2;
             this.btnRestart.Text = "Restart the Program";
-            this.toolTip.SetToolTip(this.btnRestart, "Restarts the program using the same command\r\nline arguments that were used at lau" +
-        "nch.");
             this.btnRestart.UseVisualStyleBackColor = true;
             // 
             // btnOpenAppFolder
             // 
-            this.btnOpenAppFolder.Location = new System.Drawing.Point(6, 19);
+            this.btnOpenAppFolder.Font = new System.Drawing.Font("Segoe UI", 9F);
+            this.btnOpenAppFolder.Location = new System.Drawing.Point(5, 3);
+            this.btnOpenAppFolder.Margin = new System.Windows.Forms.Padding(5, 3, 3, 3);
             this.btnOpenAppFolder.Name = "btnOpenAppFolder";
-            this.btnOpenAppFolder.Size = new System.Drawing.Size(171, 23);
+            this.btnOpenAppFolder.Size = new System.Drawing.Size(143, 25);
             this.btnOpenAppFolder.TabIndex = 0;
             this.btnOpenAppFolder.Text = "Open Program Folder";
-            this.toolTip.SetToolTip(this.btnOpenAppFolder, "Opens the folder where the app is located.");
             this.btnOpenAppFolder.UseVisualStyleBackColor = true;
             // 
             // btnOpenDataFolder
             // 
-            this.btnOpenDataFolder.Location = new System.Drawing.Point(6, 48);
+            this.btnOpenDataFolder.Font = new System.Drawing.Font("Segoe UI", 9F);
+            this.btnOpenDataFolder.Location = new System.Drawing.Point(5, 32);
+            this.btnOpenDataFolder.Margin = new System.Windows.Forms.Padding(5, 3, 3, 3);
             this.btnOpenDataFolder.Name = "btnOpenDataFolder";
-            this.btnOpenDataFolder.Size = new System.Drawing.Size(171, 23);
+            this.btnOpenDataFolder.Size = new System.Drawing.Size(143, 25);
             this.btnOpenDataFolder.TabIndex = 1;
             this.btnOpenDataFolder.Text = "Open Data Folder";
-            this.toolTip.SetToolTip(this.btnOpenDataFolder, "Opens the folder where your profile data is located.");
             this.btnOpenDataFolder.UseVisualStyleBackColor = true;
             // 
-            // btnReset
+            // numClearCacheThreshold
             // 
-            this.btnReset.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-            this.btnReset.AutoSize = true;
-            this.btnReset.Location = new System.Drawing.Point(190, 268);
-            this.btnReset.Name = "btnReset";
-            this.btnReset.Padding = new System.Windows.Forms.Padding(3, 0, 3, 0);
-            this.btnReset.Size = new System.Drawing.Size(102, 23);
-            this.btnReset.TabIndex = 5;
-            this.btnReset.Text = "Restore Defaults";
-            this.btnReset.UseVisualStyleBackColor = true;
+            this.numClearCacheThreshold.Font = new System.Drawing.Font("Segoe UI", 9F);
+            this.numClearCacheThreshold.Increment = new decimal(new int[] {
+            50,
+            0,
+            0,
+            0});
+            this.numClearCacheThreshold.Location = new System.Drawing.Point(210, 5);
+            this.numClearCacheThreshold.Maximum = new decimal(new int[] {
+            1000,
+            0,
+            0,
+            0});
+            this.numClearCacheThreshold.Minimum = new decimal(new int[] {
+            100,
+            0,
+            0,
+            0});
+            this.numClearCacheThreshold.Name = "numClearCacheThreshold";
+            this.numClearCacheThreshold.Size = new System.Drawing.Size(89, 23);
+            this.numClearCacheThreshold.TabIndex = 1;
+            this.numClearCacheThreshold.TextAlign = System.Windows.Forms.HorizontalAlignment.Right;
+            this.numClearCacheThreshold.TextSuffix = " MB";
+            this.numClearCacheThreshold.Value = new decimal(new int[] {
+            250,
+            0,
+            0,
+            0});
             // 
-            // btnImport
+            // checkClearCacheAuto
             // 
-            this.btnImport.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-            this.btnImport.AutoSize = true;
-            this.btnImport.Location = new System.Drawing.Point(100, 268);
-            this.btnImport.Name = "btnImport";
-            this.btnImport.Padding = new System.Windows.Forms.Padding(3, 0, 3, 0);
-            this.btnImport.Size = new System.Drawing.Size(84, 23);
-            this.btnImport.TabIndex = 4;
-            this.btnImport.Text = "Import Profile";
-            this.btnImport.UseVisualStyleBackColor = true;
+            this.checkClearCacheAuto.AutoSize = true;
+            this.checkClearCacheAuto.Font = new System.Drawing.Font("Segoe UI", 9F);
+            this.checkClearCacheAuto.Location = new System.Drawing.Point(6, 6);
+            this.checkClearCacheAuto.Margin = new System.Windows.Forms.Padding(6, 6, 0, 2);
+            this.checkClearCacheAuto.Name = "checkClearCacheAuto";
+            this.checkClearCacheAuto.Size = new System.Drawing.Size(201, 19);
+            this.checkClearCacheAuto.TabIndex = 0;
+            this.checkClearCacheAuto.Text = "Clear Automatically When Above";
+            this.checkClearCacheAuto.UseVisualStyleBackColor = true;
             // 
-            // btnExport
+            // labelApp
             // 
-            this.btnExport.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-            this.btnExport.AutoSize = true;
-            this.btnExport.AutoSizeMode = System.Windows.Forms.AutoSizeMode.GrowAndShrink;
-            this.btnExport.Location = new System.Drawing.Point(9, 268);
-            this.btnExport.Name = "btnExport";
-            this.btnExport.Padding = new System.Windows.Forms.Padding(3, 0, 3, 0);
-            this.btnExport.Size = new System.Drawing.Size(85, 23);
-            this.btnExport.TabIndex = 3;
-            this.btnExport.Text = "Export Profile";
-            this.btnExport.UseVisualStyleBackColor = true;
+            this.labelApp.AutoSize = true;
+            this.labelApp.Font = new System.Drawing.Font("Segoe UI Semibold", 10.5F, System.Drawing.FontStyle.Bold);
+            this.labelApp.Location = new System.Drawing.Point(0, 0);
+            this.labelApp.Margin = new System.Windows.Forms.Padding(0, 0, 0, 1);
+            this.labelApp.Name = "labelApp";
+            this.labelApp.Size = new System.Drawing.Size(97, 19);
+            this.labelApp.TabIndex = 0;
+            this.labelApp.Text = "APPLICATION";
             // 
-            // groupPerformance
+            // panelAppButtons
             // 
-            this.groupPerformance.Controls.Add(this.checkHardwareAcceleration);
-            this.groupPerformance.Controls.Add(this.btnClearCache);
-            this.groupPerformance.Location = new System.Drawing.Point(9, 9);
-            this.groupPerformance.Name = "groupPerformance";
-            this.groupPerformance.Size = new System.Drawing.Size(183, 74);
-            this.groupPerformance.TabIndex = 0;
-            this.groupPerformance.TabStop = false;
-            this.groupPerformance.Text = "Performance";
+            this.panelAppButtons.Controls.Add(this.btnOpenDataFolder);
+            this.panelAppButtons.Controls.Add(this.btnOpenAppFolder);
+            this.panelAppButtons.Controls.Add(this.btnRestart);
+            this.panelAppButtons.Controls.Add(this.btnRestartArgs);
+            this.panelAppButtons.Location = new System.Drawing.Point(0, 20);
+            this.panelAppButtons.Margin = new System.Windows.Forms.Padding(0);
+            this.panelAppButtons.Name = "panelAppButtons";
+            this.panelAppButtons.Size = new System.Drawing.Size(300, 62);
+            this.panelAppButtons.TabIndex = 1;
             // 
-            // groupConfiguration
+            // labelCache
             // 
-            this.groupConfiguration.Controls.Add(this.btnEditCSS);
-            this.groupConfiguration.Controls.Add(this.btnEditCefArgs);
-            this.groupConfiguration.Location = new System.Drawing.Point(9, 89);
-            this.groupConfiguration.Name = "groupConfiguration";
-            this.groupConfiguration.Size = new System.Drawing.Size(183, 77);
-            this.groupConfiguration.TabIndex = 1;
-            this.groupConfiguration.TabStop = false;
-            this.groupConfiguration.Text = "Configuration";
+            this.labelCache.AutoSize = true;
+            this.labelCache.Font = new System.Drawing.Font("Segoe UI Semibold", 10.5F, System.Drawing.FontStyle.Bold);
+            this.labelCache.Location = new System.Drawing.Point(0, 112);
+            this.labelCache.Margin = new System.Windows.Forms.Padding(0, 30, 0, 1);
+            this.labelCache.Name = "labelCache";
+            this.labelCache.Size = new System.Drawing.Size(123, 19);
+            this.labelCache.TabIndex = 2;
+            this.labelCache.Text = "BROWSER CACHE";
             // 
-            // groupApp
+            // panelClearCacheAuto
             // 
-            this.groupApp.Controls.Add(this.btnOpenDataFolder);
-            this.groupApp.Controls.Add(this.btnOpenAppFolder);
-            this.groupApp.Controls.Add(this.btnRestartArgs);
-            this.groupApp.Controls.Add(this.btnRestart);
-            this.groupApp.Location = new System.Drawing.Point(198, 9);
-            this.groupApp.Name = "groupApp";
-            this.groupApp.Size = new System.Drawing.Size(183, 135);
-            this.groupApp.TabIndex = 2;
-            this.groupApp.TabStop = false;
-            this.groupApp.Text = "App";
+            this.panelClearCacheAuto.Controls.Add(this.checkClearCacheAuto);
+            this.panelClearCacheAuto.Controls.Add(this.numClearCacheThreshold);
+            this.panelClearCacheAuto.Location = new System.Drawing.Point(0, 163);
+            this.panelClearCacheAuto.Margin = new System.Windows.Forms.Padding(0);
+            this.panelClearCacheAuto.Name = "panelClearCacheAuto";
+            this.panelClearCacheAuto.Size = new System.Drawing.Size(300, 28);
+            this.panelClearCacheAuto.TabIndex = 4;
+            // 
+            // panelConfiguration
+            // 
+            this.panelConfiguration.Controls.Add(this.btnEditCSS);
+            this.panelConfiguration.Controls.Add(this.btnEditCefArgs);
+            this.panelConfiguration.Location = new System.Drawing.Point(0, 241);
+            this.panelConfiguration.Margin = new System.Windows.Forms.Padding(0);
+            this.panelConfiguration.Name = "panelConfiguration";
+            this.panelConfiguration.Size = new System.Drawing.Size(300, 31);
+            this.panelConfiguration.TabIndex = 6;
+            // 
+            // labelConfiguration
+            // 
+            this.labelConfiguration.AutoSize = true;
+            this.labelConfiguration.Font = new System.Drawing.Font("Segoe UI Semibold", 10.5F, System.Drawing.FontStyle.Bold);
+            this.labelConfiguration.Location = new System.Drawing.Point(0, 221);
+            this.labelConfiguration.Margin = new System.Windows.Forms.Padding(0, 30, 0, 1);
+            this.labelConfiguration.Name = "labelConfiguration";
+            this.labelConfiguration.Size = new System.Drawing.Size(123, 19);
+            this.labelConfiguration.TabIndex = 5;
+            this.labelConfiguration.Text = "CONFIGURATION";
+            // 
+            // flowPanel
+            // 
+            this.flowPanel.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
+            | System.Windows.Forms.AnchorStyles.Left)));
+            this.flowPanel.Controls.Add(this.labelApp);
+            this.flowPanel.Controls.Add(this.panelAppButtons);
+            this.flowPanel.Controls.Add(this.labelCache);
+            this.flowPanel.Controls.Add(this.btnClearCache);
+            this.flowPanel.Controls.Add(this.panelClearCacheAuto);
+            this.flowPanel.Controls.Add(this.labelConfiguration);
+            this.flowPanel.Controls.Add(this.panelConfiguration);
+            this.flowPanel.FlowDirection = System.Windows.Forms.FlowDirection.TopDown;
+            this.flowPanel.Location = new System.Drawing.Point(9, 9);
+            this.flowPanel.Name = "flowPanel";
+            this.flowPanel.Size = new System.Drawing.Size(300, 462);
+            this.flowPanel.TabIndex = 0;
+            this.flowPanel.WrapContents = false;
             // 
             // TabSettingsAdvanced
             // 
             this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
             this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-            this.Controls.Add(this.groupApp);
-            this.Controls.Add(this.groupConfiguration);
-            this.Controls.Add(this.groupPerformance);
-            this.Controls.Add(this.btnReset);
-            this.Controls.Add(this.btnImport);
-            this.Controls.Add(this.btnExport);
+            this.Controls.Add(this.flowPanel);
             this.Name = "TabSettingsAdvanced";
-            this.Size = new System.Drawing.Size(478, 300);
-            this.groupPerformance.ResumeLayout(false);
-            this.groupPerformance.PerformLayout();
-            this.groupConfiguration.ResumeLayout(false);
-            this.groupApp.ResumeLayout(false);
+            this.Size = new System.Drawing.Size(631, 480);
+            ((System.ComponentModel.ISupportInitialize)(this.numClearCacheThreshold)).EndInit();
+            this.panelAppButtons.ResumeLayout(false);
+            this.panelClearCacheAuto.ResumeLayout(false);
+            this.panelClearCacheAuto.PerformLayout();
+            this.panelConfiguration.ResumeLayout(false);
+            this.flowPanel.ResumeLayout(false);
+            this.flowPanel.PerformLayout();
             this.ResumeLayout(false);
-            this.PerformLayout();
 
         }
 
         #endregion
 
         private System.Windows.Forms.Button btnClearCache;
-        private System.Windows.Forms.CheckBox checkHardwareAcceleration;
         private System.Windows.Forms.ToolTip toolTip;
-        private System.Windows.Forms.Button btnReset;
-        private System.Windows.Forms.Button btnImport;
-        private System.Windows.Forms.Button btnExport;
-        private System.Windows.Forms.GroupBox groupPerformance;
-        private System.Windows.Forms.GroupBox groupConfiguration;
         private System.Windows.Forms.Button btnEditCefArgs;
         private System.Windows.Forms.Button btnEditCSS;
-        private System.Windows.Forms.GroupBox groupApp;
         private System.Windows.Forms.Button btnRestartArgs;
         private System.Windows.Forms.Button btnRestart;
         private System.Windows.Forms.Button btnOpenAppFolder;
         private System.Windows.Forms.Button btnOpenDataFolder;
+        private System.Windows.Forms.Label labelApp;
+        private System.Windows.Forms.Panel panelAppButtons;
+        private System.Windows.Forms.Label labelCache;
+        private System.Windows.Forms.Panel panelClearCacheAuto;
+        private System.Windows.Forms.Panel panelConfiguration;
+        private System.Windows.Forms.Label labelConfiguration;
+        private Controls.NumericUpDownEx numClearCacheThreshold;
+        private System.Windows.Forms.CheckBox checkClearCacheAuto;
+        private System.Windows.Forms.FlowLayoutPanel flowPanel;
     }
 }

Core/Other/Settings/TabSettingsAdvanced.cs

@@ -1,191 +1,71 @@
 using System;
 using System.Diagnostics;
+using System.Threading.Tasks;
 using System.Windows.Forms;
-using TweetDck.Configuration;
-using TweetDck.Core.Controls;
-using TweetDck.Core.Other.Settings.Dialogs;
-using TweetDck.Core.Other.Settings.Export;
-using TweetDck.Core.Utils;
-using TweetDck.Plugins;
+using TweetDuck.Configuration;
+using TweetDuck.Core.Controls;
+using TweetDuck.Core.Management;
+using TweetDuck.Core.Other.Settings.Dialogs;
+using TweetDuck.Core.Utils;
 
-namespace TweetDck.Core.Other.Settings{
-    partial class TabSettingsAdvanced : BaseTabSettings{
+namespace TweetDuck.Core.Other.Settings{
+    sealed partial class TabSettingsAdvanced : BaseTabSettings{
         private readonly Action<string> reinjectBrowserCSS;
-        private readonly PluginManager plugins;
+        private readonly Action openDevTools;
 
-        public TabSettingsAdvanced(Action<string> reinjectBrowserCSS, PluginManager plugins){
+        public TabSettingsAdvanced(Action<string> reinjectBrowserCSS, Action openDevTools){
             InitializeComponent();
 
             this.reinjectBrowserCSS = reinjectBrowserCSS;
-            this.plugins = plugins;
+            this.openDevTools = openDevTools;
 
-            checkHardwareAcceleration.Checked = HardwareAcceleration.IsEnabled;
+            // application
+            
+            toolTip.SetToolTip(btnOpenAppFolder, "Opens the folder where the app is located.");
+            toolTip.SetToolTip(btnOpenDataFolder, "Opens the folder where your profile data is located.");
+            toolTip.SetToolTip(btnRestart, "Restarts the program using the same command\r\nline arguments that were used at launch.");
+            toolTip.SetToolTip(btnRestartArgs, "Restarts the program with customizable\r\ncommand line arguments.");
 
-            BrowserCache.CalculateCacheSize(bytes => this.InvokeSafe(() => {
-                if (bytes == -1L){
-                    btnClearCache.Text = "Clear Cache (unknown size)";
-                }
-                else{
-                    btnClearCache.Text = "Clear Cache ("+(int)Math.Ceiling(bytes/(1024.0*1024.0))+" MB)";
-                }
-            }));
+            // browser cache
+
+            toolTip.SetToolTip(btnClearCache, "Clearing cache will free up space taken by downloaded images and other resources.");
+            toolTip.SetToolTip(checkClearCacheAuto, "Automatically clears cache when its size exceeds the set threshold. Note that cache can only be cleared when closing TweetDuck.");
+
+            checkClearCacheAuto.Checked = SysConfig.ClearCacheAutomatically;
+            numClearCacheThreshold.Enabled = checkClearCacheAuto.Checked;
+            numClearCacheThreshold.SetValueSafe(SysConfig.ClearCacheThreshold);
+            
+            BrowserCache.GetCacheSize(task => {
+                string text = task.Status == TaskStatus.RanToCompletion ? (int)Math.Ceiling(task.Result/(1024.0*1024.0))+" MB" : "unknown";
+                this.InvokeSafe(() => btnClearCache.Text = $"Clear Cache ({text})");
+            });
+
+            // configuration
+
+            toolTip.SetToolTip(btnEditCefArgs, "Set custom command line arguments for Chromium Embedded Framework.");
+            toolTip.SetToolTip(btnEditCSS, "Set custom CSS for browser and notification windows.");
         }
 
         public override void OnReady(){
-            btnClearCache.Click += btnClearCache_Click;
-            checkHardwareAcceleration.CheckedChanged += checkHardwareAcceleration_CheckedChanged;
-
-            btnEditCefArgs.Click += btnEditCefArgs_Click;
-            btnEditCSS.Click += btnEditCSS_Click;
-
-            btnExport.Click += btnExport_Click;
-            btnImport.Click += btnImport_Click;
-            btnReset.Click += btnReset_Click;
-            
             btnOpenAppFolder.Click += btnOpenAppFolder_Click;
             btnOpenDataFolder.Click += btnOpenDataFolder_Click;
             btnRestart.Click += btnRestart_Click;
             btnRestartArgs.Click += btnRestartArgs_Click;
-        }
 
-        private void btnClearCache_Click(object sender, EventArgs e){
-            btnClearCache.Enabled = false;
-            BrowserCache.SetClearOnExit();
-
-            MessageBox.Show("Cache will be automatically cleared when "+Program.BrandName+" exits.", "Clear Cache", MessageBoxButtons.OK, MessageBoxIcon.Information);
-        }
-
-        private void checkHardwareAcceleration_CheckedChanged(object sender, EventArgs e){
-            bool succeeded = false;
-
-            if (checkHardwareAcceleration.Checked){
-                if (HardwareAcceleration.CanEnable){
-                    succeeded = HardwareAcceleration.Enable();
-                }
-                else{
-                    MessageBox.Show("Cannot enable hardware acceleration, the libraries libEGL.dll and libGLESv2.dll could not be restored.", Program.BrandName+" Settings", MessageBoxButtons.OK, MessageBoxIcon.Error);
-                }
-            }
-            else{
-                succeeded = HardwareAcceleration.Disable();
-            }
-
-            if (succeeded){
-                PromptRestart();
-            }
-            else{
-                checkHardwareAcceleration.CheckedChanged -= checkHardwareAcceleration_CheckedChanged;
-                checkHardwareAcceleration.Checked = HardwareAcceleration.IsEnabled;
-                checkHardwareAcceleration.CheckedChanged += checkHardwareAcceleration_CheckedChanged;
-            }
-        }
-
-        private void btnEditCefArgs_Click(object sender, EventArgs e){
-            DialogSettingsCefArgs form = new DialogSettingsCefArgs();
-
-            if (form.ShowDialog(ParentForm) == DialogResult.OK){
-                Config.CustomCefArgs = form.CefArgs;
-                form.Dispose();
-                PromptRestart();
-            }
-            else{
-                form.Dispose();
-            }
-        }
-
-        private void btnEditCSS_Click(object sender, EventArgs e){
-            using(DialogSettingsCSS form = new DialogSettingsCSS(reinjectBrowserCSS)){
-                if (form.ShowDialog(ParentForm) == DialogResult.OK){
-                    Config.CustomBrowserCSS = form.BrowserCSS;
-                    Config.CustomNotificationCSS = form.NotificationCSS;
-                }
-
-                reinjectBrowserCSS(Config.CustomBrowserCSS); // reinject on cancel too, because the CSS is updated while typing
-            }
-        }
-
-        private void btnExport_Click(object sender, EventArgs e){
-            ExportFileFlags flags;
-
-            using(DialogSettingsExport dialog = DialogSettingsExport.Export()){
-                if (dialog.ShowDialog() != DialogResult.OK){
-                    return;
-                }
-
-                flags = dialog.Flags;
-            }
-
-            string file;
-
-            using(SaveFileDialog dialog = new SaveFileDialog{
-                AddExtension = true,
-                AutoUpgradeEnabled = true,
-                OverwritePrompt = true,
-                DefaultExt = "tdsettings",
-                FileName = Program.BrandName+".tdsettings",
-                Title = "Export "+Program.BrandName+" Settings",
-                Filter = Program.BrandName+" Settings (*.tdsettings)|*.tdsettings"
-            }){
-                if (dialog.ShowDialog() != DialogResult.OK){
-                    return;
-                }
-
-                file = dialog.FileName;
-            }
-
-            Program.UserConfig.Save();
-
-            ExportManager manager = new ExportManager(file, plugins);
+            btnClearCache.Click += btnClearCache_Click;
+            checkClearCacheAuto.CheckedChanged += checkClearCacheAuto_CheckedChanged;
             
-            if (!manager.Export(flags)){
-                Program.Reporter.HandleException("Profile Export Error", "An exception happened while exporting "+Program.BrandName+" settings.", true, manager.LastException);
-            }
+            btnEditCefArgs.Click += btnEditCefArgs_Click;
+            btnEditCSS.Click += btnEditCSS_Click;
         }
 
-        private void btnImport_Click(object sender, EventArgs e){
-            string file;
-
-            using(OpenFileDialog dialog = new OpenFileDialog{
-                AutoUpgradeEnabled = true,
-                DereferenceLinks = true,
-                Title = "Import "+Program.BrandName+" Settings",
-                Filter = Program.BrandName+" Settings (*.tdsettings)|*.tdsettings"
-            }){
-                if (dialog.ShowDialog() != DialogResult.OK){
-                    return;
-                }
-
-                file = dialog.FileName;
-            }
-
-            ExportManager manager = new ExportManager(file, plugins);
-            ExportFileFlags flags;
-
-            using(DialogSettingsExport dialog = DialogSettingsExport.Import(manager.GetImportFlags())){
-                if (dialog.ShowDialog() != DialogResult.OK){
-                    return;
-                }
-
-                flags = dialog.Flags;
-            }
-
-            if (manager.Import(flags)){
-                if (!manager.IsRestarting){
-                    ((FormSettings)ParentForm).ReloadUI();
-                }
-            }
-            else{
-                Program.Reporter.HandleException("Profile Import Error", "An exception happened while importing "+Program.BrandName+" settings.", true, manager.LastException);
-            }
-        }
-
-        private void btnReset_Click(object sender, EventArgs e){
-            if (MessageBox.Show("This will reset all of your program settings. Plugins will not be affected. Do you want to proceed?", "Reset "+Program.BrandName+" Settings", MessageBoxButtons.YesNo, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button2) == DialogResult.Yes){
-                Program.ResetConfig();
-                ((FormSettings)ParentForm).ReloadUI();
-            }
+        public override void OnClosing(){
+            SysConfig.ClearCacheAutomatically = checkClearCacheAuto.Checked;
+            SysConfig.ClearCacheThreshold = (int)numClearCacheThreshold.Value;
         }
 
+        #region Application
+        
         private void btnOpenAppFolder_Click(object sender, EventArgs e){
             using(Process.Start("explorer.exe", "\""+Program.ProgramPath+"\"")){}
         }
@@ -205,5 +85,73 @@ namespace TweetDck.Core.Other.Settings{
                 }
             }
         }
+
+        #endregion
+        #region Browser Cache
+
+        private void btnClearCache_Click(object sender, EventArgs e){
+            btnClearCache.Enabled = false;
+            BrowserCache.SetClearOnExit();
+            FormMessage.Information("Clear Cache", "Cache will be automatically cleared when TweetDuck exits.", FormMessage.OK);
+        }
+
+        private void checkClearCacheAuto_CheckedChanged(object sender, EventArgs e){
+            numClearCacheThreshold.Enabled = checkClearCacheAuto.Checked;
+        }
+
+        #endregion
+        #region Configuration
+
+        private void btnEditCefArgs_Click(object sender, EventArgs e){
+            DialogSettingsCefArgs form = new DialogSettingsCefArgs(Config.CustomCefArgs);
+
+            form.VisibleChanged += (sender2, args2) => {
+                form.MoveToCenter(ParentForm);
+            };
+
+            form.FormClosed += (sender2, args2) => {
+                RestoreParentForm();
+
+                if (form.DialogResult == DialogResult.OK){
+                    Config.CustomCefArgs = form.CefArgs;
+                }
+
+                form.Dispose();
+            };
+            
+            form.Show(ParentForm);
+            NativeMethods.SetFormDisabled(ParentForm, true);
+        }
+
+        private void btnEditCSS_Click(object sender, EventArgs e){
+            DialogSettingsCSS form = new DialogSettingsCSS(Config.CustomBrowserCSS, Config.CustomNotificationCSS, reinjectBrowserCSS, openDevTools);
+
+            form.VisibleChanged += (sender2, args2) => {
+                form.MoveToCenter(ParentForm);
+            };
+
+            form.FormClosed += (sender2, args2) => {
+                RestoreParentForm();
+
+                if (form.DialogResult == DialogResult.OK){
+                    Config.CustomBrowserCSS = form.BrowserCSS;
+                    Config.CustomNotificationCSS = form.NotificationCSS;
+                }
+
+                reinjectBrowserCSS(Config.CustomBrowserCSS); // reinject on cancel too, because the CSS is updated while typing
+                form.Dispose();
+            };
+            
+            form.Show(ParentForm);
+            NativeMethods.SetFormDisabled(ParentForm, true);
+        }
+
+        private void RestoreParentForm(){
+            if (ParentForm != null){ // when the parent is closed first, ParentForm is null in FormClosed event
+                NativeMethods.SetFormDisabled(ParentForm, false);
+            }
+        }
+
+        #endregion
     }
 }