Release 1.19

Closes #297

.gitattributes

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

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+github: chylex
+patreon: chylex
+ko_fi: chylex

Application/LockHandler.cs

@@ -0,0 +1,58 @@
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using TweetDuck.Utils;
+using TweetLib.Core.Application;
+
+namespace TweetDuck.Application{
+    class LockHandler : IAppLockHandler{
+        private const int WaitRetryDelay = 250;
+        private const int RestoreFailTimeout = 2000;
+        private const int CloseNaturallyTimeout = 10000;
+        private const int CloseKillTimeout = 5000;
+
+        bool IAppLockHandler.RestoreProcess(Process process){
+            if (process.MainWindowHandle == IntPtr.Zero){ // restore if the original process is in tray
+                NativeMethods.BroadcastMessage(Program.WindowRestoreMessage, (uint)process.Id, 0);
+
+                if (WindowsUtils.TrySleepUntil(() => CheckProcessExited(process) || (process.MainWindowHandle != IntPtr.Zero && process.Responding), RestoreFailTimeout, WaitRetryDelay)){
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        bool IAppLockHandler.CloseProcess(Process process){
+            try{
+                if (process.CloseMainWindow()){
+                    // ReSharper disable once AccessToDisposedClosure
+                    WindowsUtils.TrySleepUntil(() => CheckProcessExited(process), CloseNaturallyTimeout, WaitRetryDelay);
+                }
+
+                if (!process.HasExited){
+                    process.Kill();
+                    // ReSharper disable once AccessToDisposedClosure
+                    WindowsUtils.TrySleepUntil(() => CheckProcessExited(process), CloseKillTimeout, WaitRetryDelay);
+                }
+
+                if (process.HasExited){
+                    process.Dispose();
+                    return true;
+                }
+                else{
+                    return false;
+                }
+            }catch(Exception ex) when (ex is InvalidOperationException || ex is Win32Exception){
+                bool hasExited = CheckProcessExited(process);
+                process.Dispose();
+                return hasExited;
+            }
+        }
+
+        private static bool CheckProcessExited(Process process){
+            process.Refresh();
+            return process.HasExited;
+        }
+    }
+}

Application/SystemHandler.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using TweetLib.Core.Application;
+
+namespace TweetDuck.Application{
+    class SystemHandler : IAppSystemHandler{
+        void IAppSystemHandler.OpenAssociatedProgram(string path){
+            try{
+                using(Process.Start(new ProcessStartInfo{
+                    FileName = path,
+                    ErrorDialog = true
+                })){}
+            }catch(Exception e){
+                Program.Reporter.HandleException("Error Opening Program", "Could not open the associated program for " + path, true, e);
+            }
+        }
+
+        void IAppSystemHandler.OpenFileExplorer(string path){
+            if (File.Exists(path)){
+                using(Process.Start("explorer.exe", "/select,\"" + path.Replace('/', '\\') + "\"")){}
+            }
+            else if (Directory.Exists(path)){
+                using(Process.Start("explorer.exe", '"' + path.Replace('/', '\\') + '"')){}
+            }
+        }
+    }
+}

Browser/Adapters/CefScriptExecutor.cs

@@ -0,0 +1,41 @@
+using System.IO;
+using CefSharp;
+using TweetLib.Core.Browser;
+
+namespace TweetDuck.Browser.Adapters{
+    sealed class CefScriptExecutor : IScriptExecutor{
+        private readonly IWebBrowser browser;
+
+        public CefScriptExecutor(IWebBrowser browser){
+            this.browser = browser;
+        }
+
+        public void RunFunction(string name, params object[] args){
+            browser.ExecuteScriptAsync(name, args);
+        }
+
+        public void RunScript(string identifier, string script){
+            using IFrame frame = browser.GetMainFrame();
+            RunScript(frame, script, identifier);
+        }
+
+        public bool RunFile(string file){
+            using IFrame frame = browser.GetMainFrame();
+            return RunFile(frame, file);
+        }
+
+        // Helpers
+
+        public static void RunScript(IFrame frame, string script, string identifier){
+            if (script != null){
+                frame.ExecuteJavaScriptAsync(script, identifier, 1);
+            }
+        }
+
+        public static bool RunFile(IFrame frame, string file){
+            string script = Program.Resources.Load(file);
+            RunScript(frame, script, "root:" + Path.GetFileNameWithoutExtension(file));
+            return script != null;
+        }
+    }
+}

Browser/Bridge/PropertyBridge.cs

@@ -0,0 +1,38 @@
+using System.Text;
+using TweetDuck.Configuration;
+using TweetLib.Core;
+using TweetLib.Core.Utils;
+
+namespace TweetDuck.Browser.Bridge{
+    static class PropertyBridge{
+        public enum Environment{
+            Browser, Notification
+        }
+
+        public static string GenerateScript(Environment environment){
+            static string Bool(bool value) => value ? "true;" : "false;";
+            static string Str(string value) => $"\"{value}\";";
+
+            UserConfig config = Program.Config.User;
+            StringBuilder build = new StringBuilder(384).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));
+                build.Append("x.firstDayOfWeek=").Append(config.CalendarFirstDay == -1 ? LocaleUtils.GetJQueryDayOfWeek(Lib.Culture.DateTimeFormat.FirstDayOfWeek) : config.CalendarFirstDay);
+            }
+
+            if (environment == Environment.Notification){
+                build.Append("x.skipOnLinkClick=").Append(Bool(config.NotificationSkipOnLinkClick));
+            }
+            
+            return build.Append("})(window.$TDX=window.$TDX||{});if(window.TDGF_onPropertiesUpdated)window.TDGF_onPropertiesUpdated()").ToString();
+        }
+    }
+}

Browser/Bridge/TweetDeckBridge.cs

@@ -0,0 +1,161 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+using CefSharp;
+using TweetDuck.Browser.Handling;
+using TweetDuck.Browser.Notification;
+using TweetDuck.Controls;
+using TweetDuck.Dialogs;
+using TweetDuck.Management;
+using TweetDuck.Utils;
+using TweetLib.Core.Features.Notifications;
+using TweetLib.Core.Utils;
+
+namespace TweetDuck.Browser.Bridge{
+    [SuppressMessage("ReSharper", "UnusedMember.Global")]
+    class TweetDeckBridge{
+        public static void ResetStaticProperties(){
+            FormNotificationBase.FontSize = null;
+            FormNotificationBase.HeadLayout = null;
+        }
+
+        private readonly FormBrowser form;
+        private readonly FormNotificationMain notification;
+
+        protected TweetDeckBridge(FormBrowser form, FormNotificationMain notification){
+            this.form = form;
+            this.notification = notification;
+        }
+
+        // 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(() => {
+                    FormNotificationBase.FontSize = fontSize;
+                    FormNotificationBase.HeadLayout = headLayout;
+                });
+            }
+
+            public void SetRightClickedLink(string type, string url){
+                ContextMenuBase.CurrentInfo.SetLink(type, url);
+            }
+
+            public void SetRightClickedChirp(string tweetUrl, string quoteUrl, string chirpAuthors, string chirpImages){
+                ContextMenuBase.CurrentInfo.SetChirp(tweetUrl, quoteUrl, chirpAuthors, chirpImages);
+            }
+
+            public void DisplayTooltip(string text){
+                form.InvokeAsyncSafe(() => form.DisplayTooltip(text));
+            }
+        }
+
+        // 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);
+            }
+        }
+
+        // Global
+
+        public void OnTweetPopup(string columnId, string chirpId, string columnName, string tweetHtml, int tweetCharacters, string tweetUrl, string quoteUrl){
+            notification.InvokeAsyncSafe(() => {
+                form.OnTweetNotification();
+                notification.ShowNotification(new DesktopNotification(columnId, chirpId, columnName, tweetHtml, tweetCharacters, tweetUrl, quoteUrl));
+            });
+        }
+
+        public void OnTweetSound(){
+            form.InvokeAsyncSafe(() => {
+                form.OnTweetNotification();
+                form.OnTweetSound();
+            });
+        }
+
+        public void ScreenshotTweet(string html, int width){
+            form.InvokeAsyncSafe(() => form.OnTweetScreenshotReady(html, width));
+        }
+
+        public void PlayVideo(string videoUrl, string tweetUrl, string username, IJavascriptCallback callShowOverlay){
+            form.InvokeAsyncSafe(() => form.PlayVideo(videoUrl, tweetUrl, username, callShowOverlay));
+        }
+        
+        public void StopVideo(){
+            form.InvokeAsyncSafe(form.StopVideo);
+        }
+
+        public void FixClipboard(){
+            form.InvokeAsyncSafe(ClipboardManager.StripHtmlStyles);
+        }
+
+        public void OpenBrowser(string url){
+            form.InvokeAsyncSafe(() => BrowserUtils.OpenExternalBrowser(url));
+        }
+
+        public void MakeGetRequest(string url, IJavascriptCallback onSuccess, IJavascriptCallback onError){
+            Task.Run(async () => {
+                var client = WebUtils.NewClient(BrowserUtils.UserAgentVanilla);
+
+                try{
+                    var result = await client.DownloadStringTaskAsync(url);
+                    await onSuccess.ExecuteAsync(result);
+                }catch(Exception e){
+                    await onError.ExecuteAsync(e.Message);
+                }finally{
+                    onSuccess.Dispose();
+                    onError.Dispose();
+                    client.Dispose();
+                }
+            });
+        }
+
+        public int GetIdleSeconds(){
+            return NativeMethods.GetIdleSeconds();
+        }
+
+        public void Alert(string type, string contents){
+            MessageBoxIcon icon = type switch{
+                "error"   => MessageBoxIcon.Error,
+                "warning" => MessageBoxIcon.Warning,
+                "info"    => MessageBoxIcon.Information,
+                _         => MessageBoxIcon.None
+            };
+
+            FormMessage.Show("TweetDuck Browser Message", contents, icon, FormMessage.OK);
+        }
+
+        public void CrashDebug(string message){
+            #if DEBUG
+            System.Diagnostics.Debug.WriteLine(message);
+            System.Diagnostics.Debugger.Break();
+            #endif
+        }
+    }
+}

Browser/Bridge/UpdateBridge.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Windows.Forms;
+using TweetDuck.Controls;
+using TweetLib.Core.Systems.Updates;
+
+namespace TweetDuck.Browser.Bridge{
+    [SuppressMessage("ReSharper", "UnusedMember.Global")]
+    class UpdateBridge{
+        private readonly UpdateHandler updates;
+        private readonly Control sync;
+
+        private UpdateInfo nextUpdate = null;
+
+        public event EventHandler<UpdateInfo> UpdateAccepted;
+        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 OnUpdateDismissed(){
+            HandleInteractionEvent(UpdateDismissed);
+
+            nextUpdate?.DeleteInstaller();
+            nextUpdate = null;
+        }
+    }
+}

Browser/Data/ContextInfo.cs

@@ -0,0 +1,161 @@
+using System;
+using CefSharp;
+using TweetLib.Core.Utils;
+
+namespace TweetDuck.Browser.Data{
+    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;
+
+                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);
+                }
+            }
+        }
+    }
+}

Browser/Data/ResourceHandlers.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Concurrent;
+using CefSharp;
+
+namespace TweetDuck.Browser.Data{
+    sealed class ResourceHandlers{
+        private readonly ConcurrentDictionary<string, IResourceHandler> handlers = new ConcurrentDictionary<string, IResourceHandler>(StringComparer.OrdinalIgnoreCase);
+
+        public bool HasHandler(IRequest request){
+            return handlers.ContainsKey(request.Url);
+        }
+
+        public IResourceHandler GetHandler(IRequest request){
+            return handlers.TryGetValue(request.Url, out var handler) ? handler : null;
+        }
+
+        public bool Register(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 Register(ResourceLink link){
+            return Register(link.Url, link.Handler);
+        }
+
+        public bool Unregister(string url){
+            return handlers.TryRemove(url, out IResourceHandler _);
+        }
+
+        public bool Unregister(ResourceLink link){
+            return Unregister(link.Url);
+        }
+    }
+}

Browser/Data/ResourceLink.cs

@@ -0,0 +1,13 @@
+using CefSharp;
+
+namespace TweetDuck.Browser.Data{
+    sealed class ResourceLink{
+        public string Url { get; }
+        public IResourceHandler Handler { get; }
+
+        public ResourceLink(string url, IResourceHandler handler){
+            this.Url = url;
+            this.Handler = handler;
+        }
+    }
+}

Browser/Data/WindowState.cs

@@ -1,12 +1,10 @@
-using System;
-using System.Drawing;
+using System.Drawing;
 using System.Windows.Forms;
-using TweetDuck.Core.Controls;
-using TweetDuck.Core.Utils;
-using TweetDuck.Data.Serialization;
+using TweetDuck.Controls;
+using TweetLib.Core.Serialization.Converters;
+using TweetLib.Core.Utils;
 
-namespace TweetDuck.Data{
-    [Serializable] // TODO remove attribute with UserConfigLegacy
+namespace TweetDuck.Browser.Data{
     sealed class WindowState{
         private Rectangle rect;
         private bool isMaximized;

Browser/FormBrowser.Designer.cs

@@ -1,21 +1,10 @@
-namespace TweetDuck.Core {
+namespace TweetDuck.Browser {
     sealed partial class FormBrowser {
         /// <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>
@@ -24,7 +13,7 @@
         /// </summary>
         private void InitializeComponent() {
             this.components = new System.ComponentModel.Container();
-            this.trayIcon = new TweetDuck.Core.TrayIcon(this.components);
+            this.trayIcon = new TrayIcon(this.components);
             this.toolTip = new System.Windows.Forms.ToolTip(this.components);
             this.timerResize = new System.Windows.Forms.Timer(this.components);
             this.SuspendLayout();
@@ -38,18 +27,18 @@
             // 
             this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
             this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-            this.BackColor = TweetDuck.Core.Utils.TwitterUtils.BackgroundColor;
-            this.ClientSize = new System.Drawing.Size(324, 386);
+            this.BackColor = TweetDuck.Utils.TwitterUtils.BackgroundColor;
+            this.ClientSize = new System.Drawing.Size(1008, 730);
             this.Icon = Properties.Resources.icon;
-            this.Location = TweetDuck.Core.Controls.ControlExtensions.InvisibleLocation;
-            this.MinimumSize = new System.Drawing.Size(340, 424);
+            this.Location = TweetDuck.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.LocationChanged += new System.EventHandler(this.FormBrowser_LocationChanged);
             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);
 

Browser/FormBrowser.cs

@@ -0,0 +1,613 @@
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using System.IO;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+using CefSharp;
+using TweetDuck.Browser.Bridge;
+using TweetDuck.Browser.Handling;
+using TweetDuck.Browser.Handling.General;
+using TweetDuck.Browser.Notification;
+using TweetDuck.Browser.Notification.Screenshot;
+using TweetDuck.Configuration;
+using TweetDuck.Controls;
+using TweetDuck.Dialogs;
+using TweetDuck.Dialogs.Settings;
+using TweetDuck.Management;
+using TweetDuck.Management.Analytics;
+using TweetDuck.Plugins;
+using TweetDuck.Updates;
+using TweetDuck.Utils;
+using TweetLib.Core.Features.Plugins;
+using TweetLib.Core.Features.Plugins.Events;
+using TweetLib.Core.Systems.Updates;
+
+namespace TweetDuck.Browser{
+    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 UpdateInstaller UpdateInstaller { get; private set; }
+        private bool ignoreUpdateCheckError;
+        
+        public AnalyticsFile AnalyticsFile => analytics?.File ?? AnalyticsFile.Dummy;
+
+        #pragma warning disable IDE0069 // Disposable fields should be disposed
+        private readonly TweetDeckBrowser browser;
+        private readonly FormNotificationTweet notification;
+        #pragma warning restore IDE0069 // Disposable fields should be disposed
+
+        private readonly PluginManager plugins;
+        private readonly UpdateHandler updates;
+        private readonly ContextMenu contextMenu;
+        private readonly UpdateBridge updateBridge;
+
+        private bool isLoaded;
+        private FormWindowState prevState;
+        
+        private TweetScreenshotManager notificationScreenshotManager;
+        private VideoPlayer videoPlayer;
+        private AnalyticsManager analytics;
+
+        public FormBrowser(PluginSchemeFactory pluginScheme){
+            InitializeComponent();
+
+            Text = Program.BrandName;
+            
+            this.plugins = new PluginManager(Program.Config.Plugins, Program.PluginPath, Program.PluginDataPath);
+            this.plugins.Reloaded += plugins_Reloaded;
+            this.plugins.Executed += plugins_Executed;
+            this.plugins.Reload();
+            pluginScheme.Setup(plugins);
+
+            this.notification = new FormNotificationTweet(this, plugins);
+            this.notification.Show();
+            
+            this.updates = new UpdateHandler(new UpdateCheckClient(Program.InstallerPath), TaskScheduler.FromCurrentSynchronizationContext());
+            this.updates.CheckFinished += updates_CheckFinished;
+
+            this.updateBridge = new UpdateBridge(updates, this);
+            this.updateBridge.UpdateAccepted += updateBridge_UpdateAccepted;
+            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
+
+            Disposed += (sender, args) => {
+                Config.MuteToggled -= Config_MuteToggled;
+                Config.TrayBehaviorChanged -= Config_TrayBehaviorChanged;
+                browser.Dispose();
+            };
+
+            Config.MuteToggled += Config_MuteToggled;
+
+            this.trayIcon.ClickRestore += trayIcon_ClickRestore;
+            this.trayIcon.ClickClose += trayIcon_ClickClose;
+            Config.TrayBehaviorChanged += Config_TrayBehaviorChanged;
+
+            UpdateTray();
+
+            if (Config.MuteNotifications){
+                UpdateFormIcon();
+            }
+
+            if (Config.AllowDataCollection){
+                analytics = new AnalyticsManager(this, plugins, Program.AnalyticsFilePath);
+            }
+
+            RestoreWindow();
+        }
+
+        protected override void Dispose(bool disposing){
+            if (disposing){
+                components?.Dispose();
+
+                updates.Dispose();
+                contextMenu.Dispose();
+
+                notificationScreenshotManager?.Dispose();
+                videoPlayer?.Dispose();
+                analytics?.Dispose();
+            }
+
+            base.Dispose(disposing);
+        }
+
+        private void ShowChildForm(Form form){
+            form.VisibleChanged += (sender, args) => form.MoveToCenter(this);
+            form.Show(this);
+        }
+
+        public void ForceClose(){
+            trayIcon.Visible = false; // checked in FormClosing event
+            Close();
+        }
+
+        // window setup
+
+        private void RestoreWindow(){
+            Config.BrowserWindow.Restore(this, true);
+            browser.PrepareSize(ClientSize);
+
+            prevState = WindowState;
+            isLoaded = true;
+        }
+
+        private void UpdateFormIcon(){ // TODO fix to show icon in taskbar too
+            Icon = Config.MuteNotifications ? Properties.Resources.icon_muted : Properties.Resources.icon;
+        }
+
+        private void UpdateTray(){
+            trayIcon.Visible = Config.TrayBehavior.ShouldDisplayIcon();
+        }
+
+        // event handlers
+
+        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;
+
+            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){
+            if (!isLoaded){
+                return;
+            }
+
+            if (WindowState != prevState){
+                prevState = WindowState;
+
+                if (WindowState == FormWindowState.Minimized){
+                    if (Config.TrayBehavior.ShouldHideOnMinimize()){
+                        Hide(); // hides taskbar too?! welp that works I guess
+                    }
+                }
+                else{
+                    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();
+            browser.PrepareSize(ClientSize); // needed to pre-size browser control when launched in maximized state
+            
+            if (Location != ControlExtensions.InvisibleLocation){
+                Config.BrowserWindow.Save(this);
+                Config.Save();
+            }
+        }
+
+        private void FormBrowser_FormClosing(object sender, FormClosingEventArgs e){
+            if (!isLoaded){
+                return;
+            }
+
+            if (Config.TrayBehavior.ShouldHideOnClose() && trayIcon.Visible && e.CloseReason == CloseReason.UserClosing){
+                Hide(); // hides taskbar too?! welp that works I guess
+                e.Cancel = true;
+            }
+        }
+
+        private void FormBrowser_FormClosed(object sender, FormClosedEventArgs e){
+            if (isLoaded && UpdateInstaller == null){
+                updateBridge.Cleanup();
+            }
+        }
+
+        private void Config_MuteToggled(object sender, EventArgs e){
+            UpdateFormIcon();
+            AnalyticsFile.NotificationMutes.Trigger();
+        }
+
+        private void Config_TrayBehaviorChanged(object sender, EventArgs e){
+            UpdateTray();
+        }
+
+        private void trayIcon_ClickRestore(object sender, EventArgs e){
+            Show();
+            RestoreWindow();
+            Activate();
+            UpdateTray();
+        }
+
+        private void trayIcon_ClickClose(object sender, EventArgs e){
+            ForceClose();
+        }
+        
+        private void plugins_Reloaded(object sender, PluginErrorEventArgs e){
+            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);
+            }
+
+            if (isLoaded){
+                browser.ReloadToTweetDeck();
+            }
+        }
+        
+        private void plugins_Executed(object sender, PluginErrorEventArgs e){
+            if (e.HasErrors){
+                this.InvokeAsyncSafe(() => {
+                    FormMessage.Error("Error Executing Plugins", "Failed to execute the following plugins:\n\n" + string.Join("\n\n", e.Errors), FormMessage.OK);
+                });
+            }
+        }
+
+        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 updateBridge_UpdateAccepted(object sender, UpdateInfo update){
+            FormManager.CloseAllDialogs();
+
+            if (!string.IsNullOrEmpty(Config.DismissedUpdate)){
+                Config.DismissedUpdate = null;
+                Config.Save();
+            }
+
+            void OnFinished(){
+                UpdateDownloadStatus status = update.DownloadStatus;
+
+                if (status == UpdateDownloadStatus.Done){
+                    UpdateInstaller = new UpdateInstaller(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_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 me = Process.GetCurrentProcess();
+
+                if (me.Id == 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();
+                }
+
+                return;
+            }
+
+            base.WndProc(ref m);
+        }
+
+        // bridge methods
+
+        public void PauseNotification(){
+            notification.PauseNotification();
+        }
+
+        public void ResumeNotification(){
+            notification.ResumeNotification();
+        }
+        
+        public void ReinjectCustomCSS(string css){
+            browser.ReinjectCustomCSS(css);
+        }
+
+        public void ReloadToTweetDeck(){
+            Program.Resources.OnReloadTriggered();
+            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(null);
+        }
+        
+        public void OpenSettings(Type startTab){
+            if (!FormManager.TryBringToFront<FormSettings>()){
+                bool prevEnableUpdateCheck = Config.EnableUpdateCheck;
+
+                FormSettings form = new FormSettings(this, plugins, updates, analytics, startTab);
+                
+                form.FormClosed += (sender, args) => {
+                    if (!prevEnableUpdateCheck && Config.EnableUpdateCheck){
+                        Config.DismissedUpdate = null;
+                        Config.Save();
+                        
+                        updates.Check(true);
+                    }
+
+                    if (!Config.EnableTrayHighlight){
+                        trayIcon.HasNotifications = false;
+                    }
+
+                    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 (!FormManager.TryBringToFront<FormAbout>()){
+                AnalyticsFile.OpenAbout.Trigger();
+                ShowChildForm(new FormAbout());
+            }
+        }
+
+        public void OpenPlugins(){
+            if (!FormManager.TryBringToFront<FormPlugins>()){
+                AnalyticsFile.OpenPlugins.Trigger();
+                ShowChildForm(new FormPlugins(plugins));
+            }
+        }
+
+        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 OnTweetNotification(){ // may be called multiple times, once for each type of notification
+            if (Config.EnableTrayHighlight && !ContainsFocus){
+                trayIcon.HasNotifications = true;
+            }
+        }
+
+        public void OnTweetSound(){
+            AnalyticsFile.SoundNotifications.Trigger();
+        }
+
+        public void PlayVideo(string videoUrl, string tweetUrl, string username, IJavascriptCallback callShowOverlay){
+            string playerPath = Config.VideoPlayerPath;
+
+            if (playerPath == null || !File.Exists(playerPath)){
+                if (videoPlayer == null){
+                    videoPlayer = new VideoPlayer(this);
+                    videoPlayer.ProcessExited += (sender, args) => browser.HideVideoOverlay(true);
+                }
+                
+                callShowOverlay.ExecuteAsync();
+                callShowOverlay.Dispose();
+
+                videoPlayer.Launch(videoUrl, tweetUrl, username);
+            }
+            else{
+                callShowOverlay.Dispose();
+
+                string quotedUrl = '"' + videoUrl + '"';
+                string playerArgs = Config.VideoPlayerPathArgs == null ? quotedUrl : Config.VideoPlayerPathArgs + ' ' + quotedUrl;
+                
+                try{
+                    using(Process.Start(playerPath, playerArgs)){}
+                }catch(Exception e){
+                    Program.Reporter.HandleException("Error Opening Video Player", "Could not open the video player.", true, e);
+                }
+            }
+            
+            AnalyticsFile.VideoPlays.Trigger();
+        }
+
+        public void StopVideo(){
+            videoPlayer?.Close();
+        }
+
+        public bool ProcessBrowserKey(Keys key){
+            if (videoPlayer != null && videoPlayer.Running){
+                videoPlayer.SendKeyEvent(key);
+                return true;
+            }
+
+            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){
+            if (string.IsNullOrEmpty(text)){
+                toolTip.Hide(this);
+            }
+            else{
+                Point position = PointToClient(Cursor.Position);
+                position.Offset(20, 10);
+                toolTip.Show(text, this, position);
+            }
+        }
+    }
+}

Browser/Handling/ContextMenuBase.cs

@@ -0,0 +1,244 @@
+using System;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Windows.Forms;
+using CefSharp;
+using TweetDuck.Browser.Adapters;
+using TweetDuck.Browser.Data;
+using TweetDuck.Browser.Notification;
+using TweetDuck.Configuration;
+using TweetDuck.Controls;
+using TweetDuck.Dialogs;
+using TweetDuck.Management;
+using TweetDuck.Management.Analytics;
+using TweetDuck.Utils;
+using TweetLib.Core.Features.Twitter;
+using TweetLib.Core.Utils;
+
+namespace TweetDuck.Browser.Handling{
+    abstract class ContextMenuBase : IContextMenuHandler{
+        public static ContextInfo CurrentInfo { get; } = new ContextInfo();
+
+        protected static UserConfig Config => Program.Config.User;
+        private static 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 MenuCopyImage       = (CefMenuCommand)26506;
+        private const CefMenuCommand MenuSaveMedia       = (CefMenuCommand)26507;
+        private const CefMenuCommand MenuSaveTweetImages = (CefMenuCommand)26508;
+        private const CefMenuCommand MenuSearchInBrowser = (CefMenuCommand)26509;
+        private const CefMenuCommand MenuReadApplyROT13  = (CefMenuCommand)26510;
+        private const CefMenuCommand MenuOpenDevTools    = (CefMenuCommand)26599;
+        
+        protected ContextInfo.ContextData Context { get; private set; }
+
+        private readonly AnalyticsFile.IProvider analytics;
+
+        protected ContextMenuBase(AnalyticsFile.IProvider analytics){
+            this.analytics = analytics;
+        }
+
+        public virtual void OnBeforeContextMenu(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, IMenuModel model){
+            if (!TwitterUrls.IsTweetDeck(frame.Url) || browser.IsLoading){
+                Context = CurrentInfo.Reset();
+            }
+            else{
+                Context = CurrentInfo.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();
+            }
+
+            static string TextOpen(string name) => "Open " + name + " in browser";
+            static string TextCopy(string name) => "Copy " + name + " address";
+            static string TextSave(string name) => "Save " + name + " as...";
+            
+            if (Context.Types.HasFlag(ContextInfo.ContextType.Link) && !Context.UnsafeLinkUrl.EndsWith("tweetdeck.twitter.com/#", StringComparison.Ordinal)){
+                if (TwitterUrls.RegexAccount.IsMatch(Context.UnsafeLinkUrl)){
+                    model.AddItem(MenuOpenLinkUrl, TextOpen("account"));
+                    model.AddItem(MenuCopyLinkUrl, TextCopy("account"));
+                    model.AddItem(MenuCopyUsername, "Copy account username");
+                }
+                else{
+                    model.AddItem(MenuOpenLinkUrl, TextOpen("link"));
+                    model.AddItem(MenuCopyLinkUrl, TextCopy("link"));
+                }
+
+                model.AddSeparator();
+            }
+
+            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 != FormNotificationBase.AppLogo.Url){
+                model.AddItem(MenuViewImage, "View image in photo viewer");
+                model.AddItem(MenuOpenMediaUrl, TextOpen("image"));
+                model.AddItem(MenuCopyMediaUrl, TextCopy("image"));
+                model.AddItem(MenuCopyImage, "Copy 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){
+            Control control = browserControl.AsControl();
+
+            switch(commandId){
+                case MenuOpenLinkUrl:
+                    OpenBrowser(control, Context.LinkUrl);
+                    break;
+
+                case MenuCopyLinkUrl:
+                    SetClipboardText(control, Context.UnsafeLinkUrl);
+                    break;
+
+                case MenuCopyUsername: {
+                    string url = Context.UnsafeLinkUrl;
+                    Match match = TwitterUrls.RegexAccount.Match(url);
+
+                    SetClipboardText(control, match.Success ? match.Groups[1].Value : url);
+                    control.InvokeAsyncSafe(analytics.AnalyticsFile.CopiedUsernames.Trigger);
+                    break;
+                }
+
+                case MenuOpenMediaUrl:
+                    OpenBrowser(control, TwitterUrls.GetMediaLink(Context.MediaUrl, ImageQuality));
+                    break;
+
+                case MenuCopyMediaUrl:
+                    SetClipboardText(control, TwitterUrls.GetMediaLink(Context.MediaUrl, ImageQuality));
+                    break;
+
+                case MenuCopyImage: {
+                    string url = Context.MediaUrl;
+
+                    control.InvokeAsyncSafe(() => {
+                        TwitterUtils.CopyImage(url, ImageQuality);
+                    });
+                    
+                    break;
+                }
+
+                case MenuViewImage: {
+                    string url = Context.MediaUrl;
+
+                    control.InvokeAsyncSafe(() => {
+                        TwitterUtils.ViewImage(url, ImageQuality);
+                        analytics.AnalyticsFile.ViewedImages.Trigger();
+                    });
+                    
+                    break;
+                }
+
+                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.OpenDevToolsCustom();
+                    break;
+            }
+
+            return false;
+        }
+
+        public virtual void OnContextMenuDismissed(IWebBrowser browserControl, IBrowser browser, IFrame frame){
+            Context = CurrentInfo.Reset();
+        }
+
+        public virtual bool RunContextMenu(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, IMenuModel model, IRunContextMenuCallback callback){
+            return false;
+        }
+
+        protected static void DeselectAll(IFrame frame){
+            CefScriptExecutor.RunScript(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(() => ClipboardManager.SetText(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){
+            if (model.Count > 0 && model.GetTypeAt(model.Count - 1) == MenuItemType.Separator){
+                model.RemoveAt(model.Count - 1);
+            }
+        }
+
+        protected static void AddSeparator(IMenuModel model){
+            if (model.Count > 0 && model.GetTypeAt(model.Count - 1) != MenuItemType.Separator){ // do not add separators if there is nothing to separate
+                model.AddSeparator();
+            }
+        }
+    }
+}

Browser/Handling/ContextMenuBrowser.cs

@@ -0,0 +1,179 @@
+using System.Windows.Forms;
+using CefSharp;
+using TweetDuck.Browser.Data;
+using TweetDuck.Controls;
+using TweetLib.Core.Features.Twitter;
+
+namespace TweetDuck.Browser.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 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 = "Options";
+        private const string TitlePlugins = "Plugins";
+        private const string TitleAboutProgram = "About " + Program.BrandName;
+
+        private readonly FormBrowser form;
+        
+        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 (isSelecting){
+                if (isEditing){
+                    model.AddSeparator();
+                    model.AddItem(MenuWriteApplyROT13, "Apply ROT13");
+                }
+
+                model.AddSeparator();
+            }
+
+            base.OnBeforeContextMenu(browserControl, browser, frame, parameters, model);
+
+            if (isSelecting && !isEditing && TwitterUrls.IsTweetDeck(frame.Url)){
+                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(MenuGlobal, Program.BrandName);
+            
+                globalMenu.AddItem(CefMenuCommand.Reload, TitleReloadBrowser);
+                globalMenu.AddCheckItem(MenuMute, TitleMuteNotifications);
+                globalMenu.SetChecked(MenuMute, Config.MuteNotifications);
+                globalMenu.AddSeparator();
+
+                globalMenu.AddItem(MenuSettings, TitleSettings);
+                globalMenu.AddItem(MenuPlugins, TitlePlugins);
+                globalMenu.AddItem(MenuAbout, TitleAboutProgram);
+                
+                AddDebugMenuItems(globalMenu);
+            }
+
+            RemoveSeparatorIfLast(model);
+            
+            form.InvokeAsyncSafe(form.AnalyticsFile.BrowserContextMenus.Trigger);
+        }
+
+        public override bool OnContextMenuCommand(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, CefMenuCommand commandId, CefEventFlags eventFlags){
+            if (base.OnContextMenuCommand(browserControl, browser, frame, parameters, commandId, eventFlags)){
+                return true;
+            }
+
+            switch(commandId){
+                case CefMenuCommand.Reload:
+                    form.InvokeAsyncSafe(form.ReloadToTweetDeck);
+                    return true;
+
+                case MenuSettings:
+                    form.InvokeAsyncSafe(form.OpenSettings);
+                    return true;
+
+                case MenuAbout:
+                    form.InvokeAsyncSafe(form.OpenAbout);
+                    return true;
+
+                case MenuPlugins:
+                    form.InvokeAsyncSafe(form.OpenPlugins);
+                    return true;
+
+                case MenuMute:
+                    form.InvokeAsyncSafe(ToggleMuteNotifications);
+                    return true;
+
+                case MenuOpenTweetUrl:
+                    OpenBrowser(form, Context.Chirp.TweetUrl);
+                    return true;
+
+                case MenuCopyTweetUrl:
+                    SetClipboardText(form, Context.Chirp.TweetUrl);
+                    return true;
+
+                case MenuScreenshotTweet:
+                    form.InvokeAsyncSafe(form.TriggerTweetScreenshot);
+                    return true;
+
+                case MenuOpenQuotedTweetUrl:
+                    OpenBrowser(form, Context.Chirp.QuoteUrl);
+                    return true;
+
+                case MenuCopyQuotedTweetUrl:
+                    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;
+        }
+
+        public static ContextMenu CreateMenu(FormBrowser form){
+            ContextMenu menu = new ContextMenu();
+
+            menu.MenuItems.Add(TitleReloadBrowser, (sender, args) => form.ReloadToTweetDeck());
+            menu.MenuItems.Add(TitleMuteNotifications, (sender, args) => ToggleMuteNotifications());
+            menu.MenuItems.Add("-");
+            menu.MenuItems.Add(TitleSettings, (sender, args) => form.OpenSettings());
+            menu.MenuItems.Add(TitlePlugins, (sender, args) => form.OpenPlugins());
+            menu.MenuItems.Add(TitleAboutProgram,  (sender, args) => form.OpenAbout());
+
+            menu.Popup += (sender, args) => {
+                menu.MenuItems[1].Checked = Config.MuteNotifications;
+                form.AnalyticsFile.BrowserContextMenus.Trigger();
+            };
+
+            return menu;
+        }
+
+        private static void ToggleMuteNotifications(){
+            Config.MuteNotifications = !Config.MuteNotifications;
+            Config.Save();
+        }
+    }
+}

Browser/Handling/ContextMenuGuide.cs

@@ -0,0 +1,14 @@
+using CefSharp;
+using TweetDuck.Management.Analytics;
+
+namespace TweetDuck.Browser.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);
+        }
+    }
+}

Browser/Handling/ContextMenuNotification.cs

@@ -1,13 +1,14 @@
 using CefSharp;
-using TweetDuck.Core.Controls;
-using TweetDuck.Core.Notification;
+using TweetDuck.Browser.Notification;
+using TweetDuck.Controls;
 
-namespace TweetDuck.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.Browser.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 TweetDuck.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 (HasDevTools){
             AddDebugMenuItems(model);
-            }
-
             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 TweetDuck.Core.Handling{
                 return true;
             }
 
-            switch((int)commandId){
+            switch(commandId){
                 case MenuSkipTweet:
                     form.InvokeAsyncSafe(form.FinishCurrentNotification);
                     return true;
@@ -67,12 +70,16 @@ namespace TweetDuck.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;
             }
 

Browser/Handling/DragHandlerBrowser.cs

@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using CefSharp;
+using CefSharp.Enums;
+
+namespace TweetDuck.Browser.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, IFrame frame, IList<DraggableRegion> regions){}
+    }
+}

Browser/Handling/Filters/ResponseFilterBase.cs

@@ -0,0 +1,72 @@
+using System;
+using System.IO;
+using System.Text;
+using CefSharp;
+
+namespace TweetDuck.Browser.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();
+    }
+}

Browser/Handling/Filters/ResponseFilterVendor.cs

@@ -0,0 +1,20 @@
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace TweetDuck.Browser.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(){}
+    }
+}

Browser/Handling/General/BrowserProcessHandler.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Threading.Tasks;
+using CefSharp;
+using TweetDuck.Configuration;
+
+namespace TweetDuck.Browser.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(){}
+    }
+}

Browser/Handling/General/FileDialogHandler.cs

@@ -0,0 +1,61 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Windows.Forms;
+using CefSharp;
+
+namespace TweetDuck.Browser.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.SelectMany(ParseFileType).Where(filter => !string.IsNullOrEmpty(filter)).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)?.ToLower();
+                        callback.Continue(acceptFilters.FindIndex(filter => ParseFileType(filter).Contains(ext)), dialog.FileNames.ToList());
+                    }
+                    else{
+                        callback.Cancel();
+                    }
+
+                    callback.Dispose();
+                }
+
+                return true;
+            }
+            else{
+                callback.Dispose();
+                return false;
+            }
+        }
+
+        private static IEnumerable<string> ParseFileType(string type){
+            if (string.IsNullOrEmpty(type)){
+                return new string[0];
+            }
+            
+            if (type[0] == '.'){
+                return new string[]{ type };
+            }
+
+            switch(type){
+                case "image/jpeg": return new string[]{ ".jpg", ".jpeg" };
+                case "image/png": return new string[]{ ".png" };
+                case "image/gif": return new string[]{ ".gif" };
+                case "image/webp": return new string[]{ ".webp" };
+                case "video/mp4": return new string[]{ ".mp4" };
+                case "video/quicktime": return new string[]{ ".mov", ".qt" };
+            }
+
+            System.Diagnostics.Debugger.Break();
+            return new string[0];
+        }
+    }
+}

Browser/Handling/General/JavaScriptDialogHandler.cs

@@ -1,43 +1,65 @@
 using System.Drawing;
 using System.Windows.Forms;
 using CefSharp;
-using CefSharp.WinForms;
-using TweetDuck.Core.Controls;
-using TweetDuck.Core.Other;
-using TweetDuck.Core.Utils;
+using TweetDuck.Controls;
+using TweetDuck.Dialogs;
+using TweetDuck.Utils;
+
+namespace TweetDuck.Browser.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){
+                icon = text.Substring(0, pipe) switch{
+                    "error"    => MessageBoxIcon.Error,
+                    "warning"  => MessageBoxIcon.Warning,
+                    "info"     => MessageBoxIcon.Information,
+                    "question" => MessageBoxIcon.Question,
+                    _          => MessageBoxIcon.None
+                };
+
+                if (icon != MessageBoxIcon.None){
+                    text = text.Substring(pipe + 1);
+                }
+            }
+
+            return new FormMessage(caption, text, icon);
+        }
 
-namespace TweetDuck.Core.Handling.General{
-    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(() => {
+            browserControl.AsControl().InvokeSafe(() => {
                 FormMessage form;
                 TextBox input = null;
 
                 if (dialogType == CefJsDialogType.Alert){
-                    form = new FormMessage("Browser Message", messageText, MessageBoxIcon.None);
+                    form = CreateMessageForm("Browser Message", messageText);
                     form.AddButton(FormMessage.OK, ControlType.Accept | ControlType.Focused);
                 }
                 else if (dialogType == CefJsDialogType.Confirm){
-                    form = new FormMessage("Browser Confirmation", messageText, MessageBoxIcon.None);
+                    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 = new FormMessage("Browser Prompt", messageText, MessageBoxIcon.None);
+                    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,
-                        Location = new Point(BrowserUtils.Scale(22, dpiScale), form.ActionPanelY-BrowserUtils.Scale(46, dpiScale)),
-                        Size = new Size(form.ClientSize.Width-BrowserUtils.Scale(44, dpiScale), 20)
+                        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;
+                    form.Height += input.Size.Height + input.Margin.Vertical;
                 }
                 else{
                     callback.Continue(false);
@@ -60,7 +82,8 @@ namespace TweetDuck.Core.Handling.General{
             return true;
         }
 
-        bool IJsDialogHandler.OnJSBeforeUnload(IWebBrowser browserControl, IBrowser browser, string message, bool isReload, IJsDialogCallback callback){
+        bool IJsDialogHandler.OnBeforeUnloadDialog(IWebBrowser browserControl, IBrowser browser, string messageText, bool isReload, IJsDialogCallback callback){
+            callback.Dispose();
             return false;
         }
 

Browser/Handling/General/LifeSpanHandler.cs

@@ -1,17 +1,20 @@
 using CefSharp;
-using TweetDuck.Core.Utils;
+using TweetDuck.Controls;
+using TweetDuck.Utils;
 
-namespace TweetDuck.Core.Handling.General{
-    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;
+namespace TweetDuck.Browser.Handling.General{
+    sealed class LifeSpanHandler : ILifeSpanHandler{
+        private static bool IsPopupAllowed(string url){
+            return url.StartsWith("https://twitter.com/teams/authorize?");
+        }
 
+        public static bool HandleLinkClick(IWebBrowser browserControl, WindowOpenDisposition targetDisposition, string targetUrl){
             switch(targetDisposition){
                 case WindowOpenDisposition.NewBackgroundTab:
                 case WindowOpenDisposition.NewForegroundTab:
-                case WindowOpenDisposition.NewPopup:
+                case WindowOpenDisposition.NewPopup when !IsPopupAllowed(targetUrl):
                 case WindowOpenDisposition.NewWindow:
-                    BrowserUtils.OpenExternalBrowser(targetUrl);
+                    browserControl.AsControl().InvokeAsyncSafe(() => BrowserUtils.OpenExternalBrowser(targetUrl));
                     return true;
 
                 default:
@@ -19,6 +22,11 @@ namespace TweetDuck.Core.Handling.General{
             }
         }
 
+        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){

Browser/Handling/KeyboardHandlerBase.cs

@@ -0,0 +1,47 @@
+using System.Windows.Forms;
+using CefSharp;
+using TweetDuck.Controls;
+using TweetDuck.Dialogs;
+using TweetDuck.Utils;
+
+namespace TweetDuck.Browser.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){
+                    browserControl.OpenDevToolsCustom();
+                }
+                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("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;
+        }
+    }
+}

Browser/Handling/KeyboardHandlerBrowser.cs

@@ -0,0 +1,20 @@
+using System.Windows.Forms;
+using CefSharp;
+
+namespace TweetDuck.Browser.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);
+        }
+    }
+}

Browser/Handling/KeyboardHandlerNotification.cs

@@ -0,0 +1,44 @@
+using System.Windows.Forms;
+using CefSharp;
+using TweetDuck.Browser.Notification;
+using TweetDuck.Controls;
+
+namespace TweetDuck.Browser.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;
+            }
+        }
+    }
+}

Browser/Handling/RequestHandlerBase.cs

@@ -0,0 +1,23 @@
+using CefSharp;
+using CefSharp.Handler;
+using TweetDuck.Browser.Handling.General;
+
+namespace TweetDuck.Browser.Handling{
+    class RequestHandlerBase : RequestHandler{
+        private readonly bool autoReload;
+
+        public RequestHandlerBase(bool autoReload){
+            this.autoReload = autoReload;
+        }
+
+        protected override bool OnOpenUrlFromTab(IWebBrowser browserControl, IBrowser browser, IFrame frame, string targetUrl, WindowOpenDisposition targetDisposition, bool userGesture){
+            return LifeSpanHandler.HandleLinkClick(browserControl, targetDisposition, targetUrl);
+        }
+        
+        protected override void OnRenderProcessTerminated(IWebBrowser browserControl, IBrowser browser, CefTerminationStatus status){
+            if (autoReload){
+                browser.Reload();
+            }
+        }
+    }
+}

Browser/Handling/RequestHandlerBrowser.cs

@@ -0,0 +1,23 @@
+using CefSharp;
+using TweetLib.Core.Features.Twitter;
+
+namespace TweetDuck.Browser.Handling{
+    sealed class RequestHandlerBrowser : RequestHandlerBase{
+        public string BlockNextUserNavUrl { get; set; }
+
+        public RequestHandlerBrowser() : base(true){}
+
+        protected 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;
+            }
+            else if (request.TransitionType.HasFlag(TransitionType.ForwardBack) && TwitterUrls.IsTweetDeck(frame.Url)){
+                return true;
+            }
+
+            return base.OnBeforeBrowse(browserControl, browser, frame, request, userGesture, isRedirect);
+        }
+    }
+}

Browser/Handling/ResourceHandlerNotification.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Specialized;
+using System.IO;
+using System.Text;
+using CefSharp;
+using CefSharp.Callback;
+
+namespace TweetDuck.Browser.Handling{
+    sealed class ResourceHandlerNotification : IResourceHandler{
+        private readonly NameValueCollection headers = new NameValueCollection(0);
+        private MemoryStream dataIn;
+
+        public void SetHTML(string html){
+            dataIn?.Dispose();
+            dataIn = ResourceHandler.GetMemoryStream(html, Encoding.UTF8);
+        }
+
+        public void Dispose(){
+            if (dataIn != null){
+                dataIn.Dispose();
+                dataIn = null;
+            }
+        }
+
+        bool IResourceHandler.Open(IRequest request, out bool handleRequest, ICallback callback){
+            callback.Dispose();
+            handleRequest = true;
+
+            if (dataIn != null){
+                dataIn.Position = 0;
+            }
+
+            return true;
+        }
+
+        void IResourceHandler.GetResponseHeaders(IResponse response, out long responseLength, out string redirectUrl){
+            redirectUrl = null;
+
+            response.MimeType = "text/html";
+            response.StatusCode = 200;
+            response.StatusText = "OK";
+            response.Headers = headers;
+            responseLength = dataIn?.Length ?? 0;
+        }
+
+        bool IResourceHandler.Read(Stream dataOut, out int bytesRead, IResourceReadCallback callback){
+            callback?.Dispose(); // TODO unnecessary null check once ReadResponse is removed
+
+            try{
+                byte[] buffer = new byte[Math.Min(dataIn.Length - dataIn.Position, dataOut.Length)];
+                int length = buffer.Length;
+
+                dataIn.Read(buffer, 0, length);
+                dataOut.Write(buffer, 0, length);
+                bytesRead = length;
+            }catch{ // catch IOException, possibly NullReferenceException if dataIn is null
+                bytesRead = 0;
+            }
+
+            return bytesRead > 0;
+        }
+
+        bool IResourceHandler.Skip(long bytesToSkip, out long bytesSkipped, IResourceSkipCallback callback){
+            bytesSkipped = -2; // ERR_FAILED
+            callback.Dispose();
+            return false;
+        }
+
+        bool IResourceHandler.ProcessRequest(IRequest request, ICallback callback){
+            return ((IResourceHandler)this).Open(request, out bool _, callback);
+        }
+
+        bool IResourceHandler.ReadResponse(Stream dataOut, out int bytesRead, ICallback callback){
+            return ((IResourceHandler)this).Read(dataOut, out bytesRead, null);
+        }
+
+        void IResourceHandler.Cancel(){}
+    }
+}

Browser/Handling/ResourceRequestHandler.cs

@@ -0,0 +1,35 @@
+using System.Diagnostics.CodeAnalysis;
+using CefSharp;
+using TweetDuck.Browser.Data;
+
+namespace TweetDuck.Browser.Handling{
+    abstract class ResourceRequestHandler : CefSharp.Handler.ResourceRequestHandler{
+        private class SelfFactoryImpl : IResourceRequestHandlerFactory{
+            private readonly ResourceRequestHandler me;
+
+            public SelfFactoryImpl(ResourceRequestHandler me){
+                this.me = me;
+            }
+
+            bool IResourceRequestHandlerFactory.HasHandlers { get; } = true;
+
+            [SuppressMessage("ReSharper", "RedundantAssignment")]
+            IResourceRequestHandler IResourceRequestHandlerFactory.GetResourceRequestHandler(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request, bool isNavigation, bool isDownload, string requestInitiator, ref bool disableDefaultHandling){
+                disableDefaultHandling = me.ResourceHandlers.HasHandler(request);
+                return me;
+            }
+        }
+
+        public IResourceRequestHandlerFactory SelfFactory { get; }
+        public ResourceHandlers ResourceHandlers { get; }
+
+        protected ResourceRequestHandler(){
+            this.SelfFactory = new SelfFactoryImpl(this);
+            this.ResourceHandlers = new ResourceHandlers();
+        }
+
+        protected override IResourceHandler GetResourceHandler(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request){
+            return ResourceHandlers.GetHandler(request);
+        }
+    }
+}

Browser/Handling/ResourceRequestHandlerBase.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Linq;
+using System.Text.RegularExpressions;
+using CefSharp;
+using TweetDuck.Utils;
+using TweetLib.Core.Utils;
+
+namespace TweetDuck.Browser.Handling{
+    class ResourceRequestHandlerBase : ResourceRequestHandler{
+        private static readonly Regex TweetDeckResourceUrl = new Regex(@"/dist/(.*?)\.(.*?)\.(css|js)$");
+        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(',')){
+                var (key, hash) = StringUtils.SplitInTwo(rule, '=') ?? throw new ArgumentException("A rule must have one '=' character: " + rule);
+
+                if (hash.All(chr => char.IsDigit(chr) || (chr >= 'a' && chr <= 'f'))){
+                    TweetDeckHashes.Add(key, hash);
+                }
+                else{
+                    throw new ArgumentException("Invalid hash characters: " + rule);
+                }
+            }
+        }
+
+        protected override CefReturnValue OnBeforeResourceLoad(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request, IRequestCallback callback){
+            if (request.ResourceType == ResourceType.CspReport){
+                callback.Dispose();
+                return CefReturnValue.Cancel;
+            }
+
+            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);
+        }
+
+        protected 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);
+        }
+    }
+}

Browser/Handling/ResourceRequestHandlerBrowser.cs

@@ -0,0 +1,52 @@
+using CefSharp;
+using TweetDuck.Browser.Handling.Filters;
+using TweetDuck.Utils;
+using TweetLib.Core.Features.Twitter;
+
+namespace TweetDuck.Browser.Handling{
+    class ResourceRequestHandlerBrowser : ResourceRequestHandlerBase{
+        private const string UrlVendorResource = "/dist/vendor";
+        private const string UrlLoadingSpinner = "/backgrounds/spinner_blue";
+        private const string UrlVersionCheck = "/web/dist/version.json";
+
+        protected 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 = TwitterUrls.TweetDeck; // redirect plain twitter.com requests, fixes bugs with login 2FA
+                }
+            }
+            else if (request.ResourceType == ResourceType.Image){
+                if (request.Url.Contains(UrlLoadingSpinner)){
+                    request.Url = TwitterUtils.LoadingSpinner.Url;
+                }
+            }
+            else if (request.ResourceType == ResourceType.Script){
+                string url = request.Url;
+
+                if (url.Contains("analytics.")){
+                    callback.Dispose();
+                    return CefReturnValue.Cancel;
+                }
+                else if (url.Contains(UrlVendorResource)){
+                    request.SetHeaderByName("Accept-Encoding", "identity", overwrite: true);
+                }
+            }
+            else if (request.ResourceType == ResourceType.Xhr){
+                if (request.Url.Contains(UrlVersionCheck)){
+                    callback.Dispose();
+                    return CefReturnValue.Cancel;
+                }
+            }
+
+            return base.OnBeforeResourceLoad(browserControl, browser, frame, request, callback);
+        }
+
+        protected 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.Headers["Content-Length"], out int totalBytes)){
+                return new ResponseFilterVendor(totalBytes);
+            }
+
+            return base.GetResourceResponseFilter(browserControl, browser, frame, request, response);
+        }
+    }
+}

Browser/Notification/Example/FormNotificationExample.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Windows.Forms;
+using CefSharp;
+using TweetDuck.Controls;
+using TweetLib.Core.Features.Notifications;
+using TweetLib.Core.Features.Plugins;
+
+namespace TweetDuck.Browser.Notification.Example{
+    sealed class FormNotificationExample : FormNotificationMain{
+        public override bool RequiresResize => true;
+        protected override bool CanDragWindow => Config.NotificationPosition == DesktopNotification.Position.Custom;
+
+        protected override FormBorderStyle NotificationBorderStyle{
+            get{
+                if (Config.NotificationSize == DesktopNotification.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 DesktopNotification exampleNotification;
+
+        public FormNotificationExample(FormBrowser owner, PluginManager pluginManager) : base(owner, pluginManager, false){
+            browser.LoadingStateChanged += browser_LoadingStateChanged;
+
+            string exampleTweetHTML = Program.Resources.LoadSilent("pages/example.html")?.Replace("{avatar}", AppLogo.Url) ?? string.Empty;
+
+            #if DEBUG
+            exampleTweetHTML = exampleTweetHTML.Replace("</p>", @"</p><div style='margin-top:256px'>Scrollbar test padding...</div>");
+            #endif
+
+            exampleNotification = new DesktopNotification(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();
+        }
+    }
+}

Browser/Notification/FormNotificationBase.Designer.cs

@@ -1,21 +1,10 @@
-namespace TweetDuck.Core.Notification {
+namespace TweetDuck.Browser.Notification {
     partial class FormNotificationBase {
         /// <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>
@@ -34,7 +23,7 @@
             this.BackColor = System.Drawing.SystemColors.Control;
             this.ClientSize = new System.Drawing.Size(284, 122);
             this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow;
-            this.Location = TweetDuck.Core.Controls.ControlExtensions.InvisibleLocation;
+            this.Location = TweetDuck.Controls.ControlExtensions.InvisibleLocation;
             this.MaximizeBox = false;
             this.MinimizeBox = false;
             this.Name = "FormNotification";

Browser/Notification/FormNotificationBase.cs

@@ -0,0 +1,259 @@
+using System.Drawing;
+using System.Windows.Forms;
+using CefSharp;
+using CefSharp.WinForms;
+using TweetDuck.Browser.Data;
+using TweetDuck.Browser.Handling;
+using TweetDuck.Browser.Handling.General;
+using TweetDuck.Configuration;
+using TweetDuck.Controls;
+using TweetDuck.Management.Analytics;
+using TweetDuck.Utils;
+using TweetLib.Core.Features.Notifications;
+using TweetLib.Core.Features.Twitter;
+
+namespace TweetDuck.Browser.Notification{
+    abstract partial class FormNotificationBase : Form, AnalyticsFile.IProvider{
+        public static readonly ResourceLink AppLogo = new ResourceLink("https://ton.twimg.com/tduck/avatar", ResourceHandler.FromByteArray(Properties.Resources.avatar, "image/png"));
+
+        protected const string BlankURL = TwitterUrls.TweetDeck + "/?blank";
+
+        public static string FontSize = null;
+        public static string HeadLayout = null;
+
+        protected static UserConfig Config => Program.Config.User;
+        
+        protected static int FontSizeLevel{
+            get => FontSize switch{
+                "largest"  => 4,
+                "large"    => 3,
+                "small"    => 1,
+                "smallest" => 0,
+                _          => 2
+            };
+        }
+
+        protected virtual Point PrimaryLocation{
+            get{
+                Screen screen;
+
+                if (Config.NotificationDisplay > 0 && Config.NotificationDisplay <= Screen.AllScreens.Length){
+                    screen = Screen.AllScreens[Config.NotificationDisplay - 1];
+                }
+                else{
+                    screen = Screen.FromControl(owner);
+                }
+            
+                int edgeDist = Config.NotificationEdgeDistance;
+
+                switch(Config.NotificationPosition){
+                    case DesktopNotification.Position.TopLeft:
+                        return new Point(screen.WorkingArea.X + edgeDist, screen.WorkingArea.Y + edgeDist);
+
+                    case DesktopNotification.Position.TopRight:
+                        return new Point(screen.WorkingArea.X + screen.WorkingArea.Width - edgeDist - Width, screen.WorkingArea.Y + edgeDist);
+
+                    case DesktopNotification.Position.BottomLeft:
+                        return new Point(screen.WorkingArea.X + edgeDist, screen.WorkingArea.Y + screen.WorkingArea.Height - edgeDist - Height);
+
+                    case DesktopNotification.Position.BottomRight:
+                        return new Point(screen.WorkingArea.X + screen.WorkingArea.Width - edgeDist - Width, screen.WorkingArea.Y + screen.WorkingArea.Height - edgeDist - Height);
+
+                    case DesktopNotification.Position.Custom:
+                        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 Location;
+            }
+        }
+
+        protected bool IsNotificationVisible => Location != ControlExtensions.InvisibleLocation;
+        protected virtual bool CanDragWindow => true;
+
+        public new Point Location{
+            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;
+        
+        protected override bool ShowWithoutActivation => true;
+        
+        protected float DpiScale { get; }
+        protected double SizeScale => DpiScale * Config.ZoomLevel / 100.0;
+
+        protected readonly FormBrowser owner;
+
+        #pragma warning disable IDE0069 // Disposable fields should be disposed
+        protected readonly ChromiumWebBrowser browser;
+        #pragma warning restore IDE0069 // Disposable fields should be disposed
+
+        private readonly ResourceHandlerNotification resourceHandler = new ResourceHandlerNotification();
+
+        private DesktopNotification currentNotification;
+        private int pauseCounter;
+        
+        public string CurrentTweetUrl => currentNotification?.TweetUrl;
+        public string CurrentQuoteUrl => currentNotification?.QuoteUrl;
+
+        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; }
+
+        protected FormNotificationBase(FormBrowser owner, bool enableContextMenu){
+            InitializeComponent();
+
+            this.owner = owner;
+            this.owner.FormClosed += owner_FormClosed;
+            
+            var resourceRequestHandler = new ResourceRequestHandlerBase();
+            var resourceHandlers = resourceRequestHandler.ResourceHandlers;
+
+            resourceHandlers.Register(BlankURL, ResourceHandler.FromString(string.Empty));
+            resourceHandlers.Register(TwitterUrls.TweetDeck, this.resourceHandler);
+            resourceHandlers.Register(AppLogo);
+
+            this.browser = new ChromiumWebBrowser(BlankURL){
+                MenuHandler = new ContextMenuNotification(this, enableContextMenu),
+                JsDialogHandler = new JavaScriptDialogHandler(),
+                LifeSpanHandler = new LifeSpanHandler(),
+                RequestHandler = new RequestHandlerBase(false),
+                ResourceRequestHandlerFactory = resourceRequestHandler.SelfFactory
+            };
+
+            this.browser.Dock = DockStyle.None;
+            this.browser.ClientSize = ClientSize;
+            this.browser.SetupZoomEvents();
+
+            Controls.Add(browser);
+
+            Disposed += (sender, args) => {
+                this.owner.FormClosed -= owner_FormClosed;
+                this.browser.Dispose();
+            };
+
+            DpiScale = this.GetDPIScale();
+
+            // ReSharper disable once VirtualMemberCallInContructor
+            UpdateTitle();
+        }
+
+        protected override void Dispose(bool disposing){
+            if (disposing){
+                components?.Dispose();
+                resourceHandler.Dispose();
+            }
+
+            base.Dispose(disposing);
+        }
+
+        protected override void WndProc(ref Message m){
+            if (m.Msg == 0x0112 && (m.WParam.ToInt32() & 0xFFF0) == 0xF010 && !CanDragWindow){ // WM_SYSCOMMAND, SC_MOVE
+                return;
+            }
+
+            base.WndProc(ref m);
+        }
+
+        // event handlers
+
+        private void owner_FormClosed(object sender, FormClosedEventArgs e){
+            Close();
+        }
+
+        // notification methods
+
+        public virtual void HideNotification(){
+            browser.Load(BlankURL);
+            DisplayTooltip(null);
+
+            Location = ControlExtensions.InvisibleLocation;
+            currentNotification = null;
+        }
+
+        public virtual void FinishCurrentNotification(){}
+
+        public virtual void PauseNotification(){
+            if (pauseCounter++ == 0 && IsNotificationVisible){
+                Location = ControlExtensions.InvisibleLocation;
+            }
+        }
+
+        public virtual void ResumeNotification(){
+            if (pauseCounter > 0){
+                --pauseCounter;
+            }
+        }
+
+        protected abstract string GetTweetHTML(DesktopNotification tweet);
+
+        protected virtual void LoadTweet(DesktopNotification tweet){
+            currentNotification = tweet;
+            resourceHandler.SetHTML(GetTweetHTML(tweet));
+
+            browser.Load(TwitterUrls.TweetDeck);
+            DisplayTooltip(null);
+        }
+
+        protected virtual void SetNotificationSize(int width, int height){
+            browser.ClientSize = ClientSize = new Size(BrowserUtils.Scale(width, SizeScale), BrowserUtils.Scale(height, SizeScale));
+        }
+
+        protected virtual void UpdateTitle(){
+            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(){
+            bool needsReactivating = Location == ControlExtensions.InvisibleLocation;
+            Location = PrimaryLocation;
+
+            if (needsReactivating){
+                NativeMethods.SetFormPos(this, NativeMethods.HWND_TOPMOST, NativeMethods.SWP_NOACTIVATE);
+            }
+        }
+
+        public void DisplayTooltip(string text){
+            if (string.IsNullOrEmpty(text)){
+                toolTip.Hide(this);
+            }
+            else{
+                Point position = PointToClient(Cursor.Position);
+                position.Offset(20, 5);
+                toolTip.Show(text, this, position);
+            }
+        }
+    }
+}

Browser/Notification/FormNotificationMain.Designer.cs

@@ -1,4 +1,4 @@
-namespace TweetDuck.Core.Notification {
+namespace TweetDuck.Browser.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 TweetDuck.Core.Controls.FlatProgressBar();
+            this.progressBarTimer = new TweetDuck.Controls.FlatProgressBar();
             this.SuspendLayout();
             // 
             // timerDisplayDelay
@@ -49,7 +49,7 @@
             this.progressBarTimer.Margin = new System.Windows.Forms.Padding(0);
             this.progressBarTimer.Maximum = 1000;
             this.progressBarTimer.Name = "progressBarTimer";
-            this.progressBarTimer.Size = new System.Drawing.Size(284, TimerBarHeight);
+            this.progressBarTimer.Size = new System.Drawing.Size(284, 4);
             this.progressBarTimer.TabIndex = 1;
             // 
             // FormNotification

Browser/Notification/FormNotificationMain.cs

@@ -1,28 +1,23 @@
-using CefSharp;
-using System;
+using System;
 using System.Drawing;
 using System.Windows.Forms;
-using TweetDuck.Core.Bridge;
-using TweetDuck.Core.Controls;
-using TweetDuck.Core.Handling;
-using TweetDuck.Core.Utils;
-using TweetDuck.Data;
+using CefSharp;
+using TweetDuck.Browser.Adapters;
+using TweetDuck.Browser.Bridge;
+using TweetDuck.Browser.Handling;
+using TweetDuck.Controls;
 using TweetDuck.Plugins;
-using TweetDuck.Plugins.Enums;
-using TweetDuck.Resources;
-
-namespace TweetDuck.Core.Notification{
-    partial class FormNotificationMain : FormNotificationBase{
-        private const string NotificationScriptFile = "notification.js";
-        private const int TimerBarHeight = 4;
-
-        private static readonly string NotificationScriptIdentifier = ScriptLoader.GetRootIdentifier(NotificationScriptFile);
-        private static readonly string PluginScriptIdentifier = ScriptLoader.GetRootIdentifier(PluginManager.PluginNotificationScriptFile);
-
-        private static readonly string NotificationJS = ScriptLoader.LoadResource(NotificationScriptFile);
-        private static readonly string PluginJS = ScriptLoader.LoadResource(PluginManager.PluginNotificationScriptFile);
+using TweetDuck.Utils;
+using TweetLib.Core.Data;
+using TweetLib.Core.Features.Notifications;
+using TweetLib.Core.Features.Plugins;
+using TweetLib.Core.Features.Plugins.Enums;
+using TweetLib.Core.Features.Twitter;
 
+namespace TweetDuck.Browser.Notification{
+    abstract partial class FormNotificationMain : FormNotificationBase{
         private readonly PluginManager plugins;
+        private readonly int timerBarHeight;
 
         protected int timeLeft, totalTime;
         protected bool pausedDuringNotification;
@@ -31,12 +26,14 @@ namespace TweetDuck.Core.Notification{
         private IntPtr mouseHook;
         private bool blockXButtonUp;
 
+        private int currentOpacity;
+
         private bool? prevDisplayTimer;
         private int? prevFontSize;
 
-        public bool RequiresResize{
+        public virtual bool RequiresResize{
             get{
-                return !prevDisplayTimer.HasValue || !prevFontSize.HasValue || prevDisplayTimer != Program.UserConfig.DisplayNotificationTimer || prevFontSize != TweetNotification.FontSizeLevel || CanResizeWindow;
+                return !prevDisplayTimer.HasValue || !prevFontSize.HasValue || prevDisplayTimer != Config.DisplayNotificationTimer || prevFontSize != FontSizeLevel;
             }
 
             set{
@@ -45,57 +42,57 @@ namespace TweetDuck.Core.Notification{
                     prevFontSize = null;
                 }
                 else{
-                    prevDisplayTimer = Program.UserConfig.DisplayNotificationTimer;
-                    prevFontSize = TweetNotification.FontSizeLevel;
+                    prevDisplayTimer = Config.DisplayNotificationTimer;
+                    prevFontSize = FontSizeLevel;
                 }
             }
         }
 
         private int BaseClientWidth{
-            get{
-                switch(Program.UserConfig.NotificationSize){
-                    default:
-                        return BrowserUtils.Scale(284, SizeScale*(1.0+0.05*TweetNotification.FontSizeLevel));
-
-                    case TweetNotification.Size.Custom:
-                        return Program.UserConfig.CustomNotificationSize.Width;
-                }
-            }
+            get => Config.NotificationSize switch{
+                DesktopNotification.Size.Custom => Config.CustomNotificationSize.Width,
+                _ => BrowserUtils.Scale(284, SizeScale * (1.0 + 0.05 * FontSizeLevel))
+            };
         }
 
         private int BaseClientHeight{
-            get{
-                switch(Program.UserConfig.NotificationSize){
-                    default:
-                        return BrowserUtils.Scale(122, SizeScale*(1.0+0.075*TweetNotification.FontSizeLevel));
-
-                    case TweetNotification.Size.Custom:
-                        return Program.UserConfig.CustomNotificationSize.Height;
-                }
-            }
+            get => Config.NotificationSize switch{
+                DesktopNotification.Size.Custom => Config.CustomNotificationSize.Height,
+                _ => BrowserUtils.Scale(122, SizeScale * (1.0 + 0.08 * FontSizeLevel))
+            };
         }
 
-        public Size BrowserSize{
-            get => Program.UserConfig.DisplayNotificationTimer ? new Size(ClientSize.Width, ClientSize.Height-TimerBarHeight) : ClientSize;
-        }
+        protected virtual string BodyClasses => IsCursorOverBrowser ? "td-notification td-hover" : "td-notification";
         
-        public FormNotificationMain(FormBrowser owner, PluginManager pluginManager, bool enableContextMenu) : base(owner, enableContextMenu){
+        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;
+            this.timerBarHeight = BrowserUtils.Scale(4, DpiScale);
             
             browser.KeyboardHandler = new KeyboardHandlerNotification(this);
-            
-            browser.RegisterAsyncJsObject("$TD", new TweetDeckBridge(owner, this));
-            browser.RegisterAsyncJsObject("$TDP", plugins.Bridge);
+            browser.RegisterJsBridge("$TD", new TweetDeckBridge.Notification(owner, this));
 
             browser.LoadingStateChanged += Browser_LoadingStateChanged;
             browser.FrameLoadEnd += Browser_FrameLoadEnd;
 
+            plugins.Register(PluginEnvironment.Notification, new PluginDispatcher(browser, url => TwitterUrls.IsTweetDeck(url) && url != BlankURL));
+
             mouseHookDelegate = MouseHookProc;
             Disposed += (sender, args) => StopMouseHook(true);
         }
 
+        // helpers
+
+        private void SetOpacity(int opacity){
+            if (currentOpacity != opacity){
+                currentOpacity = opacity;
+                Opacity = opacity / 100.0;
+            }
+        }
+
         // mouse wheel hook
 
         private void StartMouseHook(){
@@ -116,8 +113,16 @@ namespace TweetDuck.Core.Notification{
             if (nCode == 0){
                 int eventType = wParam.ToInt32();
 
-                if (eventType == NativeMethods.WM_MOUSEWHEEL && browser.Bounds.Contains(PointToClient(Cursor.Position))){
-                    browser.SendMouseWheelEvent(0, 0, 0, BrowserUtils.Scale(NativeMethods.GetMouseHookData(lParam), Program.UserConfig.NotificationScrollSpeed/100.0), CefEventFlags.None);
+                if (eventType == NativeMethods.WM_MOUSEWHEEL && IsCursorOverBrowser){
+                    int delta = BrowserUtils.Scale(NativeMethods.GetMouseHookData(lParam), Config.NotificationScrollSpeed * 0.01);
+
+                    if (Config.EnableSmoothScrolling){
+                        browser.ExecuteScriptAsync("window.TDGF_scrollSmoothly", (int)Math.Round(-delta / 0.6));
+                    }
+                    else{
+                        browser.SendMouseWheelEvent(0, 0, 0, delta, CefEventFlags.None);
+                    }
+
                     return NativeMethods.HOOK_HANDLED;
                 }
                 else if (eventType == NativeMethods.WM_XBUTTONDOWN && DesktopBounds.Contains(Cursor.Position)){
@@ -131,6 +136,7 @@ namespace TweetDuck.Core.Notification{
                     }
                     
                     blockXButtonUp = true;
+                    this.InvokeAsyncSafe(AnalyticsFile.NotificationExtraMouseButtons.Trigger);
                     return NativeMethods.HOOK_HANDLED;
                 }
                 else if (eventType == NativeMethods.WM_XBUTTONUP && blockXButtonUp){
@@ -151,13 +157,13 @@ namespace TweetDuck.Core.Notification{
 
         private void FormNotification_FormClosing(object sender, FormClosingEventArgs e){
             if (e.CloseReason == CloseReason.UserClosing){
-                HideNotification(true);
+                HideNotification();
                 e.Cancel = true;
             }
         }
 
         private void Browser_LoadingStateChanged(object sender, LoadingStateChangedEventArgs e){
-            if (!e.IsLoading && browser.Address != "about:blank"){
+            if (!e.IsLoading && browser.Address != BlankURL){
                 this.InvokeSafe(() => {
                     Visible = true; // ensures repaint before moving the window to a visible location
                     timerDisplayDelay.Start();
@@ -166,15 +172,11 @@ namespace TweetDuck.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.Environment.Notification));
-                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 != BlankURL){
+                frame.ExecuteJavaScriptAsync(PropertyBridge.GenerateScript(PropertyBridge.Environment.Notification));
+                CefScriptExecutor.RunFile(frame, "notification.js");
             }
         }
 
@@ -184,12 +186,25 @@ namespace TweetDuck.Core.Notification{
         }
 
         private void timerHideProgress_Tick(object sender, EventArgs e){
-            if (Bounds.Contains(Cursor.Position) || FreezeTimer || ContextMenuOpen)return;
+            bool isCursorInside = Bounds.Contains(Cursor.Position);
+
+            if (isCursorInside){
+                StartMouseHook();
+                SetOpacity(100);
+            }
+            else{
+                StopMouseHook(false);
+                SetOpacity(Config.NotificationWindowOpacity);
+            }
+
+            if (isCursorInside || FreezeTimer || ContextMenuOpen){
+                return;
+            }
 
             timeLeft -= timerProgress.Interval;
 
-            int value = BrowserUtils.Scale(1025, (totalTime-timeLeft)/(double)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();
@@ -198,25 +213,14 @@ namespace TweetDuck.Core.Notification{
 
         // notification methods
 
-        public virtual void ShowNotification(TweetNotification notification){
+        public virtual void ShowNotification(DesktopNotification notification){
             LoadTweet(notification);
         }
 
-        public void ShowNotificationForSettings(bool reset){
-            if (reset){
-                LoadTweet(TweetNotification.ExampleTweet);
-            }
-            else{
-                PrepareAndDisplayWindow();
-            }
+        public override void HideNotification(){
+            base.HideNotification();
             
-            UpdateTitle();
-        }
-
-        public override void HideNotification(bool loadBlank){
-            base.HideNotification(loadBlank);
-            
-            progressBarTimer.Value = Program.UserConfig.NotificationTimerCountDown ? 1000 : 0;
+            progressBarTimer.Value = Config.NotificationTimerCountDown ? progressBarTimer.Maximum : progressBarTimer.Minimum;
             timerProgress.Stop();
             totalTime = 0;
 
@@ -246,27 +250,27 @@ namespace TweetDuck.Core.Notification{
             }
         }
 
-        protected override string GetTweetHTML(TweetNotification tweet){
-            string html = base.GetTweetHTML(tweet);
+        protected override string GetTweetHTML(DesktopNotification tweet){
+            string html = tweet.GenerateHtml(BodyClasses, HeadLayout, Config.CustomNotificationCSS);
 
-            foreach(InjectedHTML injection in plugins.Bridge.NotificationInjections){
-                html = injection.Inject(html);
+            foreach(InjectedHTML injection in plugins.NotificationInjections){
+                html = injection.InjectInto(html);
             }
 
             return html;
         }
 
-        protected override void LoadTweet(TweetNotification tweet){
+        protected override void LoadTweet(DesktopNotification 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+TimerBarHeight);
+            if (Config.DisplayNotificationTimer){
+                ClientSize = new Size(width, height + timerBarHeight);
                 progressBarTimer.Visible = true;
             }
             else{
@@ -277,17 +281,17 @@ namespace TweetDuck.Core.Notification{
             browser.ClientSize = new Size(width, height);
         }
         
-        private void PrepareAndDisplayWindow(){
+        protected void PrepareAndDisplayWindow(){
             if (RequiresResize){
                 RequiresResize = false;
                 SetNotificationSize(BaseClientWidth, BaseClientHeight);
             }
 
+            SetOpacity(IsCursorOverBrowser ? 100 : Config.NotificationWindowOpacity);
             MoveToVisibleLocation();
-            StartMouseHook();
         }
 
-        protected override void OnNotificationReady(){
+        protected virtual void OnNotificationReady(){
             PrepareAndDisplayWindow();
             timerProgress.Start();
         }

Browser/Notification/FormNotificationTweet.Designer.cs

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

Browser/Notification/FormNotificationTweet.cs

@@ -1,49 +1,64 @@
 using System;
 using System.Collections.Generic;
 using System.Drawing;
-using TweetDuck.Plugins;
 using System.Windows.Forms;
-using TweetDuck.Core.Utils;
+using TweetDuck.Utils;
+using TweetLib.Core.Features.Notifications;
+using TweetLib.Core.Features.Plugins;
 
-namespace TweetDuck.Core.Notification{
+namespace TweetDuck.Browser.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);
 
-        private readonly Queue<TweetNotification> tweetQueue = new Queue<TweetNotification>(4);
+        protected override bool CanDragWindow{
+            get{
+                if (ModifierKeys.HasFlag(Keys.Alt)){
+                    hasTemporarilyMoved = true;
+                    return true;
+                }
+                else{
+                    return false;
+                }
+            }
+        }
+
+        private readonly Queue<DesktopNotification> tweetQueue = new Queue<DesktopNotification>(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();
+
+                if (hitTest == 2 || hitTest == 20){ // HTCAPTION, HTCLOSE
+                    hasTemporarilyMoved = false;
+                    MoveToVisibleLocation();
+                    return;
                 }
             }
 
-        private void TrimQueue(){
-            if (needsTrim){
-                tweetQueue.TrimExcess();
-                needsTrim = false;
-            }
+            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 +74,7 @@ namespace TweetDuck.Core.Notification{
         }
 
         private void timerIdlePauseCheck_Tick(object sender, EventArgs e){
-            if (NativeMethods.GetIdleSeconds() < Program.UserConfig.NotificationIdlePauseSeconds){
+            if (NativeMethods.GetIdleSeconds() < Config.NotificationIdlePauseSeconds){
                 ResumeNotification();
                 timerIdlePauseCheck.Stop();
             }
@@ -67,12 +82,10 @@ namespace TweetDuck.Core.Notification{
 
         // notification methods
 
-        public override void ShowNotification(TweetNotification notification){
-            if (IsPaused){
-                tweetQueue.Enqueue(notification);
-            }
-            else{
+        public override void ShowNotification(DesktopNotification notification){
             tweetQueue.Enqueue(notification);
+            
+            if (!IsPaused){
                 UpdateTitle();
 
                 if (totalTime == 0){
@@ -81,6 +94,19 @@ namespace TweetDuck.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 +114,7 @@ namespace TweetDuck.Core.Notification{
                 LoadNextNotification();
             }
             else{
-                HideNotification(true);
-                TrimQueue();
+                HideNotification();
             }
         }
 
@@ -104,7 +129,7 @@ namespace TweetDuck.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 +137,7 @@ namespace TweetDuck.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();
@@ -129,7 +154,7 @@ namespace TweetDuck.Core.Notification{
             base.UpdateTitle();
 
             if (tweetQueue.Count > 0){
-                Text = Text+" ("+tweetQueue.Count+" more left)";
+                Text = Text + " (" + tweetQueue.Count + " more left)";
             }
         }
 

Browser/Notification/Screenshot/FormNotificationScreenshotable.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Windows.Forms;
+using CefSharp;
+using TweetDuck.Browser.Adapters;
+using TweetDuck.Controls;
+using TweetDuck.Dialogs;
+using TweetDuck.Utils;
+using TweetLib.Core.Data;
+using TweetLib.Core.Features.Notifications;
+using TweetLib.Core.Features.Plugins;
+
+namespace TweetDuck.Browser.Notification.Screenshot{
+    sealed class FormNotificationScreenshotable : FormNotificationBase{
+        protected override bool CanDragWindow => false;
+
+        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.RegisterJsBridge("$TD_NotificationScreenshot", new ScreenshotBridge(this, SetScreenshotHeight, callback));
+
+            browser.LoadingStateChanged += (sender, args) => {
+                if (args.IsLoading){
+                    return;
+                }
+
+                string script = Program.Resources.LoadSilent("screenshot.js");
+                
+                if (script == null){
+                    this.InvokeAsyncSafe(callback);
+                    return;
+                }
+
+                using IFrame frame = args.Browser.MainFrame;
+                CefScriptExecutor.RunScript(frame, script.Replace("{width}", realWidth.ToString()).Replace("{frames}", TweetScreenshotManager.WaitFrames.ToString()), "gen:screenshot");
+            };
+            
+            SetNotificationSize(realWidth, 1024);
+            LoadTweet(new DesktopNotification(string.Empty, string.Empty, string.Empty, html, 0, string.Empty, string.Empty));
+        }
+
+        protected override string GetTweetHTML(DesktopNotification tweet){
+            string html = tweet.GenerateHtml("td-screenshot", HeadLayout, Config.CustomNotificationCSS);
+
+            foreach(InjectedHTML injection in plugins.NotificationInjections){
+                html = injection.InjectInto(html);
+            }
+
+            return html;
+        }
+
+        private void SetScreenshotHeight(int browserHeight){
+            this.height = BrowserUtils.Scale(browserHeight, SizeScale);
+        }
+
+        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){
+                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, Math.Max(1, height), PixelFormat.Format32bppRgb);
+
+                try{
+                    NativeMethods.RenderSourceIntoBitmap(context, bmp);
+                }finally{
+                    NativeMethods.ReleaseDC(this.Handle, context);
+                }
+
+                Clipboard.SetImage(bmp);
+                return true;
+            }
+        }
+    }
+}

Browser/Notification/Screenshot/ScreenshotBridge.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Windows.Forms;
+using TweetDuck.Controls;
+
+namespace TweetDuck.Browser.Notification.Screenshot{
+    [SuppressMessage("ReSharper", "UnusedMember.Global")]
+    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);
+        }
+    }
+}

Browser/Notification/Screenshot/TweetScreenshotManager.cs

@@ -0,0 +1,148 @@
+#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 TweetDuck.Controls;
+using TweetLib.Core.Features.Plugins;
+
+#if GEN_SCREENSHOT_FRAMES
+using System.Drawing.Imaging;
+using System.IO;
+using TweetDuck.Core.Utils;
+#endif
+
+namespace TweetDuck.Browser.Notification.Screenshot{
+    sealed class TweetScreenshotManager : IDisposable{
+        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(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();
+            OnFinished();
+        }
+
+        private void disposer_Tick(object sender, EventArgs e){
+            disposer.Stop();
+            screenshot.Dispose();
+            screenshot = null;
+        }
+
+        public void Trigger(string html, int width){
+            if (screenshot != null){
+                return;
+            }
+
+            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(){
+            if (!timeout.Enabled){
+                return;
+            }
+
+            timeout.Stop();
+            screenshot.TakeScreenshot();
+            
+            #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
+    }
+}

Browser/Notification/SoundNotification.cs

@@ -0,0 +1,48 @@
+using System.Drawing;
+using System.IO;
+using System.Windows.Forms;
+using CefSharp;
+using TweetDuck.Controls;
+using TweetDuck.Dialogs;
+using TweetDuck.Dialogs.Settings;
+using TweetDuck.Management;
+
+namespace TweetDuck.Browser.Notification{
+    static class SoundNotification{
+        public const string SupportedFormats = "*.wav;*.ogg;*.mp3;*.flac;*.opus;*.weba;*.webm";
+        
+        public static IResourceHandler CreateFileHandler(string path){
+            string mimeType = Path.GetExtension(path) switch{
+                ".weba" => "audio/webm",
+                ".webm" => "audio/webm",
+                ".wav"  => "audio/wav",
+                ".ogg"  => "audio/ogg",
+                ".mp3"  => "audio/mp3",
+                ".flac" => "audio/flac",
+                ".opus" => "audio/ogg; codecs=opus",
+                _       => null
+            };
+
+            try{
+                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;
+            }
+        }
+    }
+}

Browser/TrayIcon.Designer.cs

@@ -1,21 +1,10 @@
-namespace TweetDuck.Core {
+namespace TweetDuck.Browser {
     partial class TrayIcon {
         /// <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> 

Browser/TrayIcon.cs

@@ -1,26 +1,29 @@
 using System;
 using System.ComponentModel;
 using System.Windows.Forms;
+using TweetDuck.Configuration;
+using Res = TweetDuck.Properties.Resources;
 
-namespace TweetDuck.Core{
-    partial class TrayIcon : Component{
+namespace TweetDuck.Browser{
+    sealed partial class TrayIcon : Component{
         public enum Behavior{ // keep order
             Disabled, DisplayOnly, MinimizeToTray, CloseToTray, Combined
         }
 
+        private static UserConfig Config => Program.Config.User;
+
         public event EventHandler ClickRestore;
         public event EventHandler ClickClose;
 
         public bool Visible{
-            get => notifyIcon.Visible;
-
-            set{
-                if (value){
-                    notifyIcon.Icon = Properties.Resources.icon_tray;
+            get{
+                return notifyIcon.Visible;
             }
 
+            set{
                 notifyIcon.Visible = value;
                 hasNotifications = false;
+                UpdateIcon();
             }
         }
 
@@ -30,9 +33,9 @@ namespace TweetDuck.Core{
             }
 
             set{
-                if (hasNotifications != value && Visible){
-                    notifyIcon.Icon = value ? Properties.Resources.icon_tray_new : Properties.Resources.icon_tray;
+                if (hasNotifications != value){
                     hasNotifications = value;
+                    UpdateIcon();
                 }
             }
         }
@@ -51,14 +54,36 @@ namespace TweetDuck.Core{
                 
             this.notifyIcon.ContextMenu = contextMenu;
             this.notifyIcon.Text = Program.BrandName;
+
+            Config.MuteToggled += Config_MuteToggled;
+            Disposed += (sender, args) => Config.MuteToggled -= Config_MuteToggled;
         }
 
         public TrayIcon(IContainer container) : this(){
             container.Add(this);
         }
 
+        protected override void Dispose(bool disposing){
+            if (disposing){
+                components?.Dispose();
+                contextMenu.Dispose();
+            }
+
+            base.Dispose(disposing);
+        }
+
+        private void UpdateIcon(){
+            if (Visible){
+                notifyIcon.Icon = hasNotifications ? Res.icon_tray_new : Config.MuteNotifications ? Res.icon_tray_muted : Res.icon_tray;
+            }
+        }
+
         // event handlers
 
+        private void Config_MuteToggled(object sender, EventArgs e){
+            UpdateIcon();
+        }
+
         private void trayIcon_MouseClick(object sender, MouseEventArgs e){
             if (e.Button == MouseButtons.Left){
                 menuItemRestore_Click(sender, e);
@@ -66,7 +91,7 @@ namespace TweetDuck.Core{
         }
 
         private void contextMenu_Popup(object sender, EventArgs e){
-            contextMenu.MenuItems[1].Checked = Program.UserConfig.MuteNotifications;
+            contextMenu.MenuItems[1].Checked = Config.MuteNotifications;
         }
 
         private void menuItemRestore_Click(object sender, EventArgs e){
@@ -74,8 +99,8 @@ namespace TweetDuck.Core{
         }
 
         private void menuItemMuteNotifications_Click(object sender, EventArgs e){
-            Program.UserConfig.MuteNotifications = !contextMenu.MenuItems[1].Checked;
-            Program.UserConfig.Save();
+            Config.MuteNotifications = !contextMenu.MenuItems[1].Checked;
+            Config.Save();
         }
 
         private void menuItemClose_Click(object sender, EventArgs e){

Browser/TweetDeckBrowser.cs

@@ -0,0 +1,289 @@
+using System;
+using System.Drawing;
+using System.Text;
+using System.Windows.Forms;
+using CefSharp;
+using CefSharp.WinForms;
+using TweetDuck.Browser.Adapters;
+using TweetDuck.Browser.Bridge;
+using TweetDuck.Browser.Data;
+using TweetDuck.Browser.Handling;
+using TweetDuck.Browser.Handling.General;
+using TweetDuck.Browser.Notification;
+using TweetDuck.Configuration;
+using TweetDuck.Controls;
+using TweetDuck.Plugins;
+using TweetDuck.Utils;
+using TweetLib.Core.Features.Plugins;
+using TweetLib.Core.Features.Plugins.Enums;
+using TweetLib.Core.Features.Twitter;
+using TweetLib.Core.Utils;
+
+namespace TweetDuck.Browser{
+    sealed class TweetDeckBrowser : IDisposable{
+        private static UserConfig Config => Program.Config.User;
+
+        private const string ErrorUrl = "http://td/error";
+        private const string TwitterStyleUrl = "https://abs.twimg.com/tduck/css";
+
+        public bool Ready { get; private set; }
+
+        public bool Enabled{
+            get => browser.Enabled;
+            set => browser.Enabled = value;
+        }
+
+        public bool IsTweetDeckWebsite{
+            get{
+                if (!Ready){
+                    return false;
+                }
+
+                using IFrame frame = browser.GetBrowser().MainFrame;
+                return TwitterUrls.IsTweetDeck(frame.Url);
+            }
+        }
+        
+        private readonly ChromiumWebBrowser browser;
+        private readonly ResourceHandlers resourceHandlers;
+
+        private string prevSoundNotificationPath = null;
+
+        public TweetDeckBrowser(FormBrowser owner, PluginManager plugins, TweetDeckBridge tdBridge, UpdateBridge updateBridge){
+            var resourceRequestHandler = new ResourceRequestHandlerBrowser();
+            resourceHandlers = resourceRequestHandler.ResourceHandlers;
+
+            resourceHandlers.Register(FormNotificationBase.AppLogo);
+            resourceHandlers.Register(TwitterUtils.LoadingSpinner);
+
+            RequestHandlerBrowser requestHandler = new RequestHandlerBrowser();
+            
+            this.browser = new ChromiumWebBrowser(TwitterUrls.TweetDeck){
+                DialogHandler = new FileDialogHandler(),
+                DragHandler = new DragHandlerBrowser(requestHandler),
+                MenuHandler = new ContextMenuBrowser(owner),
+                JsDialogHandler = new JavaScriptDialogHandler(),
+                KeyboardHandler = new KeyboardHandlerBrowser(owner),
+                LifeSpanHandler = new LifeSpanHandler(),
+                RequestHandler = requestHandler,
+                ResourceRequestHandlerFactory = resourceRequestHandler.SelfFactory
+            };
+
+            this.browser.LoadingStateChanged += browser_LoadingStateChanged;
+            this.browser.FrameLoadStart += browser_FrameLoadStart;
+            this.browser.FrameLoadEnd += browser_FrameLoadEnd;
+            this.browser.LoadError += browser_LoadError;
+
+            this.browser.RegisterJsBridge("$TD", tdBridge);
+            this.browser.RegisterJsBridge("$TDU", updateBridge);
+            
+            this.browser.BrowserSettings.BackgroundColor = (uint)TwitterUtils.BackgroundColor.ToArgb();
+            this.browser.Dock = DockStyle.None;
+            this.browser.Location = ControlExtensions.InvisibleLocation;
+            this.browser.SetupZoomEvents();
+            
+            owner.Controls.Add(browser);
+            plugins.Register(PluginEnvironment.Browser, new PluginDispatcher(browser, TwitterUrls.IsTweetDeck));
+            
+            Config.MuteToggled += Config_MuteToggled;
+            Config.SoundNotificationChanged += Config_SoundNotificationInfoChanged;
+        }
+
+        // setup and management
+
+        public void PrepareSize(Size size){
+            if (!Ready){
+                browser.Size = size;
+            }
+        }
+
+        private void OnBrowserReady(){
+            if (!Ready){
+                browser.Location = Point.Empty;
+                browser.Dock = DockStyle.Fill;
+                Ready = true;
+            }
+        }
+
+        public void Focus(){
+            browser.Focus();
+        }
+
+        public void Dispose(){
+            Config.MuteToggled -= Config_MuteToggled;
+            Config.SoundNotificationChanged -= Config_SoundNotificationInfoChanged;
+            
+            browser.Dispose();
+        }
+
+        // event handlers
+
+        private void browser_LoadingStateChanged(object sender, LoadingStateChangedEventArgs e){
+            if (!e.IsLoading){
+                foreach(string word in TwitterUtils.DictionaryWords){
+                    browser.AddWordToDictionary(word);
+                }
+
+                browser.BeginInvoke(new Action(OnBrowserReady));
+                browser.LoadingStateChanged -= browser_LoadingStateChanged;
+            }
+        }
+
+        private void browser_FrameLoadStart(object sender, FrameLoadStartEventArgs e){
+            IFrame frame = e.Frame;
+
+            if (frame.IsMain){
+                string url = frame.Url;
+
+                if (TwitterUrls.IsTwitter(url)){
+                    string css = Program.Resources.Load("styles/twitter.css");
+                    resourceHandlers.Register(TwitterStyleUrl, ResourceHandler.FromString(css, mimeType: "text/css"));
+
+                    CefScriptExecutor.RunFile(frame, "twitter.js");
+                }
+                
+                if (!TwitterUrls.IsTwitterLogin2Factor(url)){
+                    frame.ExecuteJavaScriptAsync(TwitterUtils.BackgroundColorOverride);
+                }
+            }
+        }
+
+        private void browser_FrameLoadEnd(object sender, FrameLoadEndEventArgs e){
+            IFrame frame = e.Frame;
+            string url = frame.Url;
+
+            if (frame.IsMain){
+                if (TwitterUrls.IsTweetDeck(url)){
+                    UpdateProperties();
+                    CefScriptExecutor.RunFile(frame, "code.js");
+
+                    InjectBrowserCSS();
+                    ReinjectCustomCSS(Config.CustomBrowserCSS);
+                    Config_SoundNotificationInfoChanged(null, EventArgs.Empty);
+
+                    TweetDeckBridge.ResetStaticProperties();
+
+                    if (Arguments.HasFlag(Arguments.ArgIgnoreGDPR)){
+                        CefScriptExecutor.RunScript(frame, "TD.storage.Account.prototype.requiresConsent = function(){ return false; }", "gen:gdpr");
+                    }
+
+                    if (Config.FirstRun){
+                        CefScriptExecutor.RunFile(frame, "introduction.js");
+                    }
+                }
+
+                CefScriptExecutor.RunFile(frame, "update.js");
+            }
+
+            if (url == ErrorUrl){
+                resourceHandlers.Unregister(ErrorUrl);
+            }
+        }
+
+        private void browser_LoadError(object sender, LoadErrorEventArgs e){
+            if (e.ErrorCode == CefErrorCode.Aborted){
+                return;
+            }
+
+            if (!e.FailedUrl.StartsWith("http://td/", StringComparison.Ordinal)){
+                string errorPage = Program.Resources.LoadSilent("pages/error.html");
+
+                if (errorPage != null){
+                    string errorName = Enum.GetName(typeof(CefErrorCode), e.ErrorCode);
+                    string errorTitle = StringUtils.ConvertPascalCaseToScreamingSnakeCase(errorName ?? string.Empty);
+
+                    resourceHandlers.Register(ErrorUrl, ResourceHandler.FromString(errorPage.Replace("{err}", errorTitle)));
+                    browser.Load(ErrorUrl);
+                }
+            }
+        }
+
+        private void Config_MuteToggled(object sender, EventArgs e){
+            UpdateProperties();
+        }
+
+        private void Config_SoundNotificationInfoChanged(object sender, EventArgs e){
+            const string soundUrl = "https://ton.twimg.com/tduck/updatesnd";
+
+            bool hasCustomSound = Config.IsCustomSoundNotificationSet;
+            string newNotificationPath = Config.NotificationSoundPath;
+            
+            if (prevSoundNotificationPath != newNotificationPath){
+                prevSoundNotificationPath = newNotificationPath;
+
+                if (hasCustomSound){
+                    resourceHandlers.Register(soundUrl, SoundNotification.CreateFileHandler(newNotificationPath));
+                }
+                else{
+                    resourceHandlers.Unregister(soundUrl);
+                }
+            }
+
+            browser.ExecuteScriptAsync("TDGF_setSoundNotificationData", hasCustomSound, Config.NotificationSoundVolume);
+        }
+
+        // external handling
+
+        public void HideVideoOverlay(bool focus){
+            if (focus){
+                browser.GetBrowser().GetHost().SendFocusEvent(true);
+            }
+
+            browser.ExecuteScriptAsync("$('#td-video-player-overlay').remove()");
+        }
+
+        // javascript calls
+
+        public void ReloadToTweetDeck(){
+            browser.ExecuteScriptAsync($"if(window.TDGF_reload)window.TDGF_reload();else window.location.href='{TwitterUrls.TweetDeck}'");
+        }
+
+        public void UpdateProperties(){
+            browser.ExecuteScriptAsync(PropertyBridge.GenerateScript(PropertyBridge.Environment.Browser));
+        }
+
+        public void InjectBrowserCSS(){
+            browser.ExecuteScriptAsync("TDGF_injectBrowserCSS", Program.Resources.Load("styles/browser.css")?.TrimEnd() ?? string.Empty);
+        }
+
+        public void ReinjectCustomCSS(string css){
+            browser.ExecuteScriptAsync("TDGF_reinjectCustomCSS", css?.Replace(Environment.NewLine, " ") ?? string.Empty);
+        }
+
+        public void OnMouseClickExtra(IntPtr param){
+            browser.ExecuteScriptAsync("TDGF_onMouseClickExtra", (param.ToInt32() >> 16) & 0xFFFF);
+        }
+
+        public void ShowTweetDetail(string columnId, string chirpId, string fallbackUrl){
+            browser.ExecuteScriptAsync("TDGF_showTweetDetail", columnId, chirpId, fallbackUrl);
+        }
+
+        public void AddSearchColumn(string query){
+            browser.ExecuteScriptAsync("TDGF_performSearch", query);
+        }
+
+        public void TriggerTweetScreenshot(){
+            browser.ExecuteScriptAsync("TDGF_triggerScreenshot()");
+        }
+
+        public void ReloadColumns(){
+            browser.ExecuteScriptAsync("TDGF_reloadColumns()");
+        }
+
+        public void PlaySoundNotification(){
+            browser.ExecuteScriptAsync("TDGF_playSoundNotification()");
+        }
+
+        public void ApplyROT13(){
+            browser.ExecuteScriptAsync("TDGF_applyROT13()");
+        }
+
+        public void ShowUpdateNotification(string versionTag, string releaseNotes){
+            browser.ExecuteScriptAsync("TDUF_displayNotification", versionTag, Convert.ToBase64String(Encoding.GetEncoding("iso-8859-1").GetBytes(releaseNotes)));
+        }
+
+        public void OpenDevTools(){
+            browser.OpenDevToolsCustom();
+        }
+    }
+}

Configuration/Arguments.cs

@@ -1,17 +1,18 @@
 using System;
-using TweetDuck.Data;
+using TweetLib.Core.Collections;
 
 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
@@ -21,14 +22,15 @@ namespace TweetDuck.Configuration{
             return Current.HasFlag(flag);
         }
 
-        public static string GetValue(string key, string defaultValue){
-            return Current.GetValue(key, defaultValue);
+        public static string GetValue(string key){
+            return Current.GetValue(key);
         }
 
         public static CommandLineArgs GetCurrentClean(){
             CommandLineArgs args = Current.Clone();
             args.RemoveFlag(ArgRestart);
             args.RemoveFlag(ArgImportCookies);
+            args.RemoveFlag(ArgDeleteCookies);
             args.RemoveFlag(ArgUpdated);
             return args;
         }

Configuration/ConfigManager.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Drawing;
+using TweetDuck.Browser.Data;
+using TweetLib.Core.Features.Plugins.Config;
+using TweetLib.Core.Serialization.Converters;
+using TweetLib.Core.Systems.Configuration;
+using TweetLib.Core.Utils;
+
+namespace TweetDuck.Configuration{
+    sealed class ConfigManager : IConfigManager{
+        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<PluginConfig> 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<PluginConfig>(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();
+        }
+
+        void IConfigManager.TriggerProgramRestartRequested(){
+            ProgramRestartRequested?.Invoke(this, EventArgs.Empty);
+        }
+
+        IConfigInstance<BaseConfig> IConfigManager.GetInstanceInfo(BaseConfig instance){
+            Type instanceType = instance.GetType();
+            return Array.Find(infoList, info => info.Instance.GetType() == instanceType); // TODO handle null
+        }
+    }
+}

Configuration/PluginConfig.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using TweetLib.Core.Features.Plugins;
+using TweetLib.Core.Features.Plugins.Config;
+using TweetLib.Core.Features.Plugins.Events;
+using TweetLib.Core.Systems.Configuration;
+
+namespace TweetDuck.Configuration{
+    sealed class PluginConfig : BaseConfig, IPluginConfig{
+        private static readonly string[] DefaultDisabled = {
+            "official/clear-columns",
+            "official/reply-account"
+        };
+
+        // CONFIGURATION DATA
+
+        private readonly HashSet<string> disabled = new HashSet<string>(DefaultDisabled);
+
+        // EVENTS
+        
+        public event EventHandler<PluginChangedStateEventArgs> PluginChangedState;
+        
+        // END OF CONFIG
+
+        public PluginConfig(IConfigManager configManager) : base(configManager){}
+
+        protected override BaseConfig ConstructWithDefaults(IConfigManager configManager){
+            return new PluginConfig(configManager);
+        }
+
+        // INTERFACE IMPLEMENTATION
+
+        IEnumerable<string> IPluginConfig.DisabledPlugins => disabled;
+
+        void IPluginConfig.Reset(IEnumerable<string> newDisabledPlugins){
+            disabled.Clear();
+            disabled.UnionWith(newDisabledPlugins);
+        }
+
+        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);
+        }
+    }
+}

Configuration/SystemConfig.cs

@@ -1,70 +1,28 @@
-using System;
-using System.IO;
-using TweetDuck.Core.Utils;
-using TweetDuck.Data.Serialization;
+using TweetLib.Core.Systems.Configuration;
 
 namespace TweetDuck.Configuration{
-    sealed class SystemConfig{
-        private static readonly FileSerializer<SystemConfig> Serializer = new FileSerializer<SystemConfig>{
-            OnReadUnknownProperty = (obj, property, value) => false
-        };
-
-        public static readonly bool IsHardwareAccelerationSupported = File.Exists(Path.Combine(Program.ProgramPath, "libEGL.dll")) &&
-                                                                      File.Exists(Path.Combine(Program.ProgramPath, "libGLESv2.dll"));
+    sealed class SystemConfig : BaseConfig{
 
         // CONFIGURATION DATA
         
-        private bool _hardwareAcceleration = true;
+        public bool _hardwareAcceleration = true;
+        
+        public bool ClearCacheAutomatically { get; set; } = true;
+        public int ClearCacheThreshold      { get; set; } = 250;
 
         // SPECIAL PROPERTIES
         
         public bool HardwareAcceleration{
-            get => _hardwareAcceleration && IsHardwareAccelerationSupported;
-            set => _hardwareAcceleration = value;
+            get => _hardwareAcceleration;
+            set => UpdatePropertyWithRestartRequest(ref _hardwareAcceleration, value);
         }
         
         // END OF CONFIG
 
-        private readonly string file;
+        public SystemConfig(IConfigManager configManager) : base(configManager){}
 
-        private SystemConfig(string file){
-            this.file = file;
-        }
-
-        public bool Save(){
-            try{
-                WindowsUtils.CreateDirectoryForFile(file);
-                Serializer.Write(file, this);
-                return true;
-            }catch(Exception e){
-                Program.Reporter.HandleException("Configuration Error", "Could not save the system configuration file.", true, e);
-                return false;
-            }
-        }
-        
-        public static SystemConfig Load(string file){
-            SystemConfig config = new SystemConfig(file);
-            
-            try{
-                Serializer.Read(file, config);
-                return config;
-            }catch(FileNotFoundException){
-            }catch(DirectoryNotFoundException){
-            }catch(FormatException){
-                try{
-                    using(Stream stream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read)){
-                        config.HardwareAcceleration = stream.ReadByte() > 0;
-                    }
-
-                    config.Save();
-                }catch(Exception e){
-                    Program.Reporter.HandleException("Configuration Error", "Could not update the system configuration file.", true, e);
-                }
-            }catch(Exception e){
-                Program.Reporter.HandleException("Configuration Error", "Could not open the system configuration file. If you continue, you will lose system specific configuration such as Hardware Acceleration.", true, e);
-            }
-
-            return config;
+        protected override BaseConfig ConstructWithDefaults(IConfigManager configManager){
+            return new SystemConfig(configManager);
         }
     }
 }

Configuration/UserConfig.cs

@@ -1,50 +1,49 @@
 using System;
 using System.Drawing;
-using System.IO;
-using TweetDuck.Core;
-using TweetDuck.Core.Controls;
-using TweetDuck.Core.Notification;
-using TweetDuck.Core.Utils;
-using TweetDuck.Data;
-using TweetDuck.Data.Serialization;
+using TweetDuck.Browser;
+using TweetDuck.Browser.Data;
+using TweetDuck.Controls;
+using TweetLib.Core.Features.Notifications;
+using TweetLib.Core.Features.Twitter;
+using TweetLib.Core.Systems.Configuration;
 
 namespace TweetDuck.Configuration{
-    sealed class UserConfig{
-        private static readonly FileSerializer<UserConfig> Serializer = new FileSerializer<UserConfig>{
-            OnReadUnknownProperty = (obj, property, value) => false
-        };
-
-        static UserConfig(){
-            Serializer.RegisterTypeConverter(typeof(WindowState), WindowState.Converter);
-
-            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]);
-                }
-            });
-            
-            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]);
-                }
-            });
-        }
+    sealed class UserConfig : BaseConfig{
         
         // CONFIGURATION DATA
 
+        public bool FirstRun            { get; set; } = true;
+        public bool AllowDataCollection { get; set; } = false;
+
         public WindowState BrowserWindow { get; set; } = new WindowState();
-        public WindowState PluginsWindow { get; set; } = new WindowState();
+        public Size PluginsWindowSize    { get; set; } = Size.Empty;
 
         public bool ExpandLinksOnHover        { get; set; } = true;
-        public bool SwitchAccountSelectors { 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 EnableSpellCheck       { get; set; } = false;
+        public bool EnableAnimatedImages      { get; set; } = true;
+
+        private bool _enableSmoothScrolling = true;
+        private bool _enableTouchAdjustment = false;
+        private string _customCefArgs       = null;
+
+        public string BrowserPath            { get; set; } = null;
+        public string BrowserPathArgs        { get; set; } = null;
+        public bool IgnoreTrackingUrlWarning { get; set; } = false;
+        public string SearchEngineUrl        { get; set; } = null;
         private int _zoomLevel                             = 100;
-        private bool _muteNotifications;
+        
+        public string VideoPlayerPath     { get; set; } = null;
+        public string VideoPlayerPathArgs { get; set; } = null;
+        public int VideoPlayerVolume      { get; set; } = 50;
+        
+        public bool EnableSpellCheck { get; set; } = false;
+        private string _spellCheckLanguage         = "en-US";
+
+        public string TranslationTarget { get; set; } = "en";
+        public int  CalendarFirstDay    { get; set; } = -1;
         
         private TrayIcon.Behavior _trayBehavior       = TrayIcon.Behavior.Disabled;
         public bool EnableTrayHighlight { get; set; } = true;
@@ -62,69 +61,77 @@ namespace TweetDuck.Configuration{
         public bool NotificationTimerCountDown { get; set; } = false;
         public int NotificationDurationValue   { get; set; } = 25;
 
-        public TweetNotification.Position NotificationPosition { get; set; } = TweetNotification.Position.TopRight;
+        public DesktopNotification.Position NotificationPosition { get; set; } = DesktopNotification.Position.TopRight;
         public Point CustomNotificationPosition                  { get; set; } = ControlExtensions.InvisibleLocation;
         public int NotificationDisplay                           { get; set; } = 0;
         public int NotificationEdgeDistance                      { get; set; } = 8;
+        public int NotificationWindowOpacity                     { get; set; } = 100;
 
-        public TweetNotification.Size NotificationSize { get; set; } = TweetNotification.Size.Auto;
+        public DesktopNotification.Size NotificationSize { get; set; } = DesktopNotification.Size.Auto;
         public Size CustomNotificationSize               { get; set; } = Size.Empty;
-        public int NotificationScrollSpeed             { get; set; } = 10;
+        public int NotificationScrollSpeed               { get; set; } = 100;
         
         private string _notificationSoundPath;
+        private int _notificationSoundVolume = 100;
+
+        private bool _muteNotifications;
 
-        public string CustomCefArgs         { get; set; } = null;
         public string CustomBrowserCSS      { get; set; } = null;
         public string CustomNotificationCSS { get; set; } = null;
 
-        public bool EnableBrowserGCReload { get; set; } = false;
-        public int BrowserMemoryThreshold { get; set; } = 350;
+        public bool DevToolsWindowOnTop     { get; set; } = true;
         
         // 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 ImageQuality TwitterImageQuality => BestImageQuality ? ImageQuality.Best : 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());
-                }
-            }
+            set => UpdatePropertyWithEvent(ref _muteNotifications, value, MuteToggled);
         }
 
         public int ZoomLevel{
             get => _zoomLevel;
-
-            set{
-                if (_zoomLevel != value){
-                    _zoomLevel = value;
-                    ZoomLevelChanged?.Invoke(this, new EventArgs());
+            set => UpdatePropertyWithEvent(ref _zoomLevel, value, ZoomLevelChanged);
         }
-            }
-        }
-
-        public double ZoomMultiplier => _zoomLevel/100.0;
         
         public TrayIcon.Behavior TrayBehavior{
             get => _trayBehavior;
+            set => UpdatePropertyWithEvent(ref _trayBehavior, value, TrayBehaviorChanged);
+        }
         
-            set{
-                if (_trayBehavior != value){
-                    _trayBehavior = value;
-                    TrayBehaviorChanged?.Invoke(this, new EventArgs());
+        public bool EnableSmoothScrolling{
+            get => _enableSmoothScrolling;
+            set => UpdatePropertyWithRestartRequest(ref _enableSmoothScrolling, value);
         }
+
+        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
@@ -132,68 +139,14 @@ namespace TweetDuck.Configuration{
         public event EventHandler MuteToggled;
         public event EventHandler ZoomLevelChanged;
         public event EventHandler TrayBehaviorChanged;
+        public event EventHandler SoundNotificationChanged;
 
         // END OF CONFIG
         
-        private readonly string file;
+        public UserConfig(IConfigManager configManager) : base(configManager){}
 
-        public UserConfig(string file){ // TODO make private after removing UserConfigLegacy
-            this.file = file;
-        }
-
-        public bool Save(){
-            try{
-                WindowsUtils.CreateDirectoryForFile(file);
-
-                if (File.Exists(file)){
-                    string backupFile = GetBackupFile(file);
-                    File.Delete(backupFile);
-                    File.Move(file, backupFile);
-                }
-
-                Serializer.Write(file, this);
-                return true;
-            }catch(Exception e){
-                Program.Reporter.HandleException("Configuration Error", "Could not save the configuration file.", true, e);
-                return false;
-            }
-        }
-        
-        public static UserConfig Load(string file){
-            Exception firstException = null;
-
-            for(int attempt = 0; attempt < 2; attempt++){
-                try{
-                    UserConfig config = new UserConfig(file);
-                    Serializer.Read(attempt == 0 ? file : GetBackupFile(file), config);
-                    return config;
-                }catch(FileNotFoundException){
-                }catch(DirectoryNotFoundException){
-                    break;
-                }catch(FormatException){
-                    UserConfig config = UserConfigLegacy.Load(file);
-                    config.Save();
-                    return config;
-                }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, your program options will be reset.", true, e);
-                    }
-                }
-            }
-
-            if (firstException != null){
-                Program.Reporter.HandleException("Configuration Error", "Could not open the configuration file.", true, firstException);
-            }
-
-            return new UserConfig(file);
-        }
-
-        public static string GetBackupFile(string file){
-            return file+".bak";
+        protected override BaseConfig ConstructWithDefaults(IConfigManager configManager){
+            return new UserConfig(configManager);
         }
     }
 }

Configuration/UserConfigLegacy.cs

@@ -1,210 +0,0 @@
-using System;
-using System.Drawing;
-using System.IO;
-using System.Runtime.Serialization;
-using System.Runtime.Serialization.Formatters.Binary;
-using TweetDuck.Core;
-using TweetDuck.Core.Controls;
-using TweetDuck.Core.Notification;
-using TweetDuck.Data;
-
-namespace TweetDuck.Configuration{
-    [Serializable]
-    sealed class UserConfigLegacy{ // TODO remove eventually
-        private static readonly IFormatter Formatter = new BinaryFormatter{ Binder = new LegacyBinder() };
-
-        private class LegacyBinder : SerializationBinder{
-            public override Type BindToType(string assemblyName, string typeName){
-                return Type.GetType(string.Format("{0}, {1}", typeName.Replace("TweetDck", "TweetDuck").Replace(".UserConfig", ".UserConfigLegacy").Replace("Core.Utils.WindowState", "Data.WindowState"), assemblyName.Replace("TweetDck", "TweetDuck")));
-            }
-        }
-        
-        private const int CurrentFileVersion = 11;
-
-        // START OF CONFIGURATION
-
-        public WindowState BrowserWindow { get; set; }
-        public WindowState PluginsWindow { 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 int NotificationIdlePauseSeconds { get; set; }
-        public int NotificationDurationValue { get; set; }
-        public int NotificationScrollSpeed { get; set; }
-
-        public TweetNotification.Position NotificationPosition { get; set; }
-        public Point CustomNotificationPosition { get; set; }
-        public int NotificationEdgeDistance { get; set; }
-        public int NotificationDisplay { get; set; }
-
-        public TweetNotification.Size NotificationSize { get; set; }
-        public Size CustomNotificationSize { get; set; }
-
-        public bool EnableSpellCheck { get; set; }
-        public bool ExpandLinksOnHover { get; set; }
-        public bool SwitchAccountSelectors { get; set; }
-        public bool EnableTrayHighlight { get; set; }
-
-        public bool EnableUpdateCheck { get; set; }
-        public string DismissedUpdate { get; set; }
-
-        public string CustomCefArgs { get; set; }
-        public string CustomBrowserCSS { get; set; }
-        public string CustomNotificationCSS { get; set; }
-        
-        public string NotificationSoundPath{
-            get => string.IsNullOrEmpty(notificationSoundPath) ? string.Empty : notificationSoundPath;
-            set => notificationSoundPath = value;
-        }
-
-        public bool MuteNotifications{
-            get => muteNotifications;
-            set => muteNotifications = value;
-        }
-
-        public int ZoomLevel{
-            get => zoomLevel;
-            set => zoomLevel = value;
-        }
-
-        public TrayIcon.Behavior TrayBehavior{
-            get => trayBehavior;
-            set => trayBehavior = value;
-        }
-
-        // END OF CONFIGURATION
-        
-        [NonSerialized]
-        private string file;
-
-        private int fileVersion;
-        private bool muteNotifications;
-        private int zoomLevel;
-        private string notificationSoundPath;
-        private TrayIcon.Behavior trayBehavior;
-
-        private UserConfigLegacy(string file){
-            this.file = file;
-
-            BrowserWindow = new WindowState();
-            ZoomLevel = 100;
-            DisplayNotificationTimer = true;
-            NotificationNonIntrusiveMode = true;
-            NotificationPosition = TweetNotification.Position.TopRight;
-            CustomNotificationPosition = ControlExtensions.InvisibleLocation;
-            NotificationSize = TweetNotification.Size.Auto;
-            NotificationEdgeDistance = 8;
-            NotificationDurationValue = 25;
-            NotificationScrollSpeed = 100;
-            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 <= 5){
-                DisplayNotificationTimer = true;
-                EnableUpdateCheck = true;
-                ExpandLinksOnHover = true;
-                BrowserWindow = new WindowState();
-                PluginsWindow = new WindowState();
-                EnableTrayHighlight = true;
-                NotificationDurationValue = 25;
-                fileVersion = 6;
-            }
-
-            if (fileVersion == 6){
-                NotificationNonIntrusiveMode = true;
-                ++fileVersion;
-            }
-
-            if (fileVersion == 7){
-                ZoomLevel = 100;
-                ++fileVersion;
-            }
-
-            if (fileVersion == 8){
-                SwitchAccountSelectors = true;
-                ++fileVersion;
-            }
-
-            if (fileVersion == 9){
-                NotificationScrollSpeed = 100;
-                ++fileVersion;
-            }
-
-            if (fileVersion == 10){
-                NotificationSize = TweetNotification.Size.Auto;
-                ++fileVersion;
-            }
-
-            // update the version
-            fileVersion = CurrentFileVersion;
-        }
-
-        public UserConfig ConvertLegacy(){
-            return new UserConfig(file){
-                BrowserWindow = BrowserWindow,
-                PluginsWindow = PluginsWindow,
-                DisplayNotificationColumn = DisplayNotificationColumn,
-                DisplayNotificationTimer = DisplayNotificationTimer,
-                NotificationTimerCountDown = NotificationTimerCountDown,
-                NotificationSkipOnLinkClick = NotificationSkipOnLinkClick,
-                NotificationNonIntrusiveMode = NotificationNonIntrusiveMode,
-                NotificationIdlePauseSeconds = NotificationIdlePauseSeconds,
-                NotificationDurationValue = NotificationDurationValue,
-                NotificationScrollSpeed = NotificationScrollSpeed,
-                NotificationPosition = NotificationPosition,
-                CustomNotificationPosition = CustomNotificationPosition,
-                NotificationEdgeDistance = NotificationEdgeDistance,
-                NotificationDisplay = NotificationDisplay,
-                NotificationSize = NotificationSize,
-                CustomNotificationSize = CustomNotificationSize,
-                EnableSpellCheck = EnableSpellCheck,
-                ExpandLinksOnHover = ExpandLinksOnHover,
-                SwitchAccountSelectors = SwitchAccountSelectors,
-                EnableTrayHighlight = EnableTrayHighlight,
-                EnableUpdateCheck = EnableUpdateCheck,
-                DismissedUpdate = DismissedUpdate,
-                CustomCefArgs = CustomCefArgs,
-                CustomBrowserCSS = CustomBrowserCSS,
-                CustomNotificationCSS = CustomNotificationCSS,
-                NotificationSoundPath = NotificationSoundPath,
-                MuteNotifications = MuteNotifications,
-                ZoomLevel = ZoomLevel,
-                TrayBehavior = TrayBehavior
-            };
-        }
-        
-        public static UserConfig Load(string file){
-            UserConfigLegacy config = null;
-            
-            try{
-                using(Stream stream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read)){
-                    if ((config = Formatter.Deserialize(stream) as UserConfigLegacy) != null){
-                        config.file = file;
-                    }
-                }
-
-                config?.UpgradeFile();
-            }catch(FileNotFoundException){
-            }catch(DirectoryNotFoundException){
-            }catch(Exception e){
-                Program.Reporter.HandleException("Configuration Error", "Could not open the configuration file.", true, e);
-            }
-
-            return (config ?? new UserConfigLegacy(file)).ConvertLegacy();
-        }
-    }
-}

Controls/ControlExtensions.cs

@@ -1,10 +1,9 @@
-using System;
+using System;
 using System.Drawing;
 using System.Linq;
 using System.Windows.Forms;
-using TweetDuck.Core.Utils;
 
-namespace TweetDuck.Core.Controls{
+namespace TweetDuck.Controls{
     static class ControlExtensions{
         public static readonly Point InvisibleLocation = new Point(-32000, -32000);
 
@@ -22,9 +21,8 @@ namespace TweetDuck.Core.Controls{
         }
 
         public static float GetDPIScale(this Control control){
-            using(Graphics graphics = control.CreateGraphics()){
-                return graphics.DpiY/96F;
-            }
+            using Graphics graphics = control.CreateGraphics();
+            return graphics.DpiY / 96F;
         }
 
         public static bool IsFullyOutsideView(this Form form){
@@ -32,17 +30,17 @@ namespace TweetDuck.Core.Controls{
         }
 
         public static void MoveToCenter(this Form targetForm, Form parentForm){
-            targetForm.Location = new Point(parentForm.Location.X+parentForm.Width/2-targetForm.Width/2, parentForm.Location.Y+parentForm.Height/2-targetForm.Height/2);
+            targetForm.Location = new Point(parentForm.Location.X + (parentForm.Width / 2) - (targetForm.Width / 2), parentForm.Location.Y + (parentForm.Height / 2) - (targetForm.Height / 2));
         }
 
         public static void SetValueInstant(this ProgressBar bar, int value){
             if (value == bar.Maximum){
                 bar.Value = value;
-                bar.Value = value-1;
+                bar.Value = value - 1;
                 bar.Value = value;
             }
             else{
-                bar.Value = value+1;
+                bar.Value = value + 1;
                 bar.Value = value;
             }
         }
@@ -61,16 +59,11 @@ namespace TweetDuck.Core.Controls{
 
         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);
+                trackBar.Value = trackBar.SmallChange * (int)Math.Floor(((double)trackBar.Value / trackBar.SmallChange) + 0.5);
                 return false;
             }
-            else return true;
-        }
 
-        public static void SetElevated(this Button button){
-            button.Text = " "+button.Text;
-            button.FlatStyle = FlatStyle.System;
-            NativeMethods.SendMessage(button.Handle, NativeMethods.BCM_SETSHIELD, new UIntPtr(0), new IntPtr(1));
+            return true;
         }
 
         public static void EnableMultilineShortcuts(this TextBox textBox){

Controls/FlatButton.cs

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

Controls/FlatProgressBar.cs

@@ -1,7 +1,8 @@
-using System.Drawing;
+using System;
+using System.Drawing;
 using System.Windows.Forms;
 
-namespace TweetDuck.Core.Controls{
+namespace TweetDuck.Controls{
     sealed class FlatProgressBar : ProgressBar{
         private readonly SolidBrush brush;
 
@@ -13,7 +14,7 @@ namespace TweetDuck.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){
@@ -22,8 +23,8 @@ namespace TweetDuck.Core.Controls{
             }
 
             Rectangle rect = e.ClipRectangle;
-            rect.Width = (int)(rect.Width*((double)Value/Maximum));
-            e.Graphics.FillRectangle(brush,rect);
+            rect.Width = (int)(rect.Width * ((double)Value / Maximum));
+            e.Graphics.FillRectangle(brush, rect);
         }
 
         protected override void Dispose(bool disposing){

Controls/FlowLayoutPanelNoHScroll.cs

@@ -0,0 +1,14 @@
+using System.Windows.Forms;
+using TweetDuck.Utils;
+
+namespace TweetDuck.Controls{
+    sealed class FlowLayoutPanelNoHScroll : FlowLayoutPanel{
+        protected override void WndProc(ref Message m){
+            if (m.Msg == 0x85){ // WM_NCPAINT
+                NativeMethods.ShowScrollBar(Handle, NativeMethods.SB_HORZ, false); // basically fuck the horizontal scrollbar very much
+            }
+
+            base.WndProc(ref m);
+        }
+    }
+}

Controls/LabelVertical.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace TweetDuck.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;
+            }
+        }
+    }
+}

Controls/NumericUpDownEx.cs

@@ -1,7 +1,7 @@
 using System.ComponentModel;
 using System.Windows.Forms;
 
-namespace TweetDuck.Core.Controls{
+namespace TweetDuck.Controls{
     sealed class NumericUpDownEx : NumericUpDown{
         public string TextSuffix { get; set ; }
 

Core/Bridge/CallbackBridge.cs

@@ -1,19 +0,0 @@
-using System;
-using System.Windows.Forms;
-using TweetDuck.Core.Controls;
-
-namespace TweetDuck.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,32 +0,0 @@
-using System.Text;
-
-namespace TweetDuck.Core.Bridge{
-    static class PropertyBridge{
-        public enum Environment{
-            Browser, Notification
-        }
-
-        public static string GenerateScript(Environment environment){
-            string Bool(bool value){
-                return value ? "true;" : "false;";
-            }
-
-            StringBuilder build = new StringBuilder().Append("(function(x){");
-
-            build.Append("x.expandLinksOnHover=").Append(Bool(Program.UserConfig.ExpandLinksOnHover));
-            
-            if (environment == Environment.Browser){
-                build.Append("x.switchAccountSelectors=").Append(Bool(Program.UserConfig.SwitchAccountSelectors));
-                build.Append("x.muteNotifications=").Append(Bool(Program.UserConfig.MuteNotifications));
-                build.Append("x.hasCustomNotificationSound=").Append(Bool(Program.UserConfig.NotificationSoundPath.Length > 0));
-                build.Append("x.notificationMediaPreviews=").Append(Bool(Program.UserConfig.NotificationMediaPreviews));
-            }
-
-            if (environment == Environment.Notification){
-                build.Append("x.skipOnLinkClick=").Append(Bool(Program.UserConfig.NotificationSkipOnLinkClick));
-            }
-            
-            return build.Append("})(window.$TDX=window.$TDX||{})").ToString();
-        }
-    }
-}

Core/Bridge/TweetDeckBridge.cs

@@ -1,127 +0,0 @@
-using System.Windows.Forms;
-using TweetDuck.Core.Controls;
-using TweetDuck.Core.Notification;
-using TweetDuck.Core.Other;
-using TweetDuck.Core.Utils;
-
-namespace TweetDuck.Core.Bridge{
-    sealed class TweetDeckBridge{
-        public static string LastRightClickedLink = string.Empty;
-        public static string LastRightClickedImage = string.Empty;
-        public static string LastHighlightedTweet = string.Empty;
-        public static string LastHighlightedQuotedTweet = string.Empty;
-        public static string[] LastHighlightedTweetImages = StringUtils.EmptyArray;
-
-        public static void ResetStaticProperties(){
-            LastRightClickedLink = LastRightClickedImage = LastHighlightedTweet = LastHighlightedQuotedTweet = string.Empty;
-            LastHighlightedTweetImages = StringUtils.EmptyArray;
-        }
-
-        private readonly FormBrowser form;
-        private readonly FormNotificationMain notification;
-
-        public TweetDeckBridge(FormBrowser form, FormNotificationMain notification){
-            this.form = form;
-            this.notification = notification;
-        }
-
-        public void LoadFontSizeClass(string fsClass){
-            form.InvokeAsyncSafe(() => {
-               TweetNotification.SetFontSizeClass(fsClass);
-            });
-        }
-
-        public void LoadNotificationHeadContents(string headContents){
-            form.InvokeAsyncSafe(() => {
-               TweetNotification.SetHeadTag(headContents); 
-            });
-        }
-
-        public void SetLastRightClickedLink(string link){
-            form.InvokeAsyncSafe(() => LastRightClickedLink = link);
-        }
-
-        public void SetLastRightClickedImage(string link){
-            form.InvokeAsyncSafe(() => LastRightClickedImage = link);
-        }
-
-        public void SetLastHighlightedTweet(string link, string quotedLink, string imageList){
-            form.InvokeAsyncSafe(() => {
-                LastHighlightedTweet = link;
-                LastHighlightedQuotedTweet = quotedLink;
-                LastHighlightedTweetImages = imageList.Split(';');
-            });
-        }
-
-        public void OpenContextMenu(){
-            form.InvokeAsyncSafe(form.OpenContextMenu);
-        }
-
-        public void OnTweetPopup(string columnName, string tweetHtml, int tweetCharacters, string tweetUrl, string quoteUrl){
-            notification.InvokeAsyncSafe(() => {
-                form.OnTweetNotification();
-                notification.ShowNotification(new TweetNotification(columnName, tweetHtml, tweetCharacters, tweetUrl, quoteUrl));
-            });
-        }
-
-        public void OnTweetSound(){
-            form.InvokeAsyncSafe(() => {
-                form.OnTweetNotification();
-                form.PlayNotificationSound();
-            });
-        }
-
-        public void DisplayTooltip(string text, bool showInNotification){
-            if (showInNotification){
-                notification.InvokeAsyncSafe(() => notification.DisplayTooltip(text));
-            }
-            else{
-                form.InvokeAsyncSafe(() => form.DisplayTooltip(text));
-            }
-        }
-
-        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 FixClipboard(){
-            form.InvokeAsyncSafe(WindowsUtils.ClipboardStripHtmlStyles);
-        }
-
-        public int GetIdleSeconds(){
-            return NativeMethods.GetIdleSeconds();
-        }
-
-        public void OpenBrowser(string url){
-            BrowserUtils.OpenExternalBrowser(url);
-        }
-
-        public void Alert(string type, string contents){
-            MessageBoxIcon icon;
-
-            switch(type){
-                case "error": icon = MessageBoxIcon.Error; break;
-                case "warning": icon = MessageBoxIcon.Warning; break;
-                case "info": icon = MessageBoxIcon.Information; break;
-                default: icon = MessageBoxIcon.None; break;
-            }
-
-            FormMessage.Show("TweetDuck Browser Message", contents, icon, FormMessage.OK);
-        }
-
-        public void CrashDebug(string message){
-            #if DEBUG
-            Log(message);
-            System.Diagnostics.Debugger.Break();
-            #endif
-        }
-
-        public void Log(string data){
-            System.Diagnostics.Debug.WriteLine(data);
-        }
-    }
-}

Core/Controls/LabelVertical.cs

@@ -1,23 +0,0 @@
-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)-2; // 2 = random
-
-            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/FormBrowser.cs

@@ -1,531 +0,0 @@
-using CefSharp;
-using CefSharp.WinForms;
-using System;
-using System.Drawing;
-using System.Linq;
-using System.Windows.Forms;
-using TweetDuck.Configuration;
-using TweetDuck.Core.Bridge;
-using TweetDuck.Core.Controls;
-using TweetDuck.Core.Handling;
-using TweetDuck.Core.Handling.General;
-using TweetDuck.Core.Notification;
-using TweetDuck.Core.Notification.Screenshot;
-using TweetDuck.Core.Other;
-using TweetDuck.Core.Other.Settings;
-using TweetDuck.Core.Utils;
-using TweetDuck.Plugins;
-using TweetDuck.Plugins.Enums;
-using TweetDuck.Plugins.Events;
-using TweetDuck.Resources;
-using TweetDuck.Updates;
-using TweetDuck.Updates.Events;
-using TweetLib.Audio;
-
-namespace TweetDuck.Core{
-    sealed partial class FormBrowser : Form{
-        private static UserConfig Config => Program.UserConfig;
-
-        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 readonly ChromiumWebBrowser browser;
-        private readonly PluginManager plugins;
-        private readonly UpdateHandler updates;
-        private readonly FormNotificationTweet notification;
-        private readonly ContextMenu contextMenu;
-        private readonly MemoryUsageTracker memoryUsageTracker;
-
-        private bool isLoaded;
-        private bool isBrowserReady;
-        private FormWindowState prevState;
-
-        private TweetScreenshotManager notificationScreenshotManager;
-        private SoundNotification soundNotification;
-
-        public FormBrowser(PluginManager pluginManager, UpdaterSettings updaterSettings){
-            InitializeComponent();
-
-            Text = Program.BrandName;
-
-            this.plugins = pluginManager;
-            this.plugins.Reloaded += plugins_Reloaded;
-            this.plugins.PluginChangedState += plugins_PluginChangedState;
-
-            this.contextMenu = ContextMenuBrowser.CreateMenu(this);
-            this.memoryUsageTracker = new MemoryUsageTracker("TDGF_tryRunCleanup");
-
-            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(),
-                RequestHandler = new RequestHandlerBrowser()
-            };
-
-            #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)TwitterUtils.BackgroundColor.ToArgb();
-            browser.Dock = DockStyle.None;
-            browser.Location = ControlExtensions.InvisibleLocation;
-            Controls.Add(browser);
-
-            Controls.Add(new MenuStrip{ Visible = false }); // fixes Alt freezing the program in Win 10 Anniversary Update
-
-            Disposed += (sender, args) => {
-                memoryUsageTracker.Dispose();
-
-                browser.Dispose();
-                contextMenu.Dispose();
-
-                notificationScreenshotManager?.Dispose();
-                soundNotification?.Dispose();
-            };
-
-            this.trayIcon.ClickRestore += trayIcon_ClickRestore;
-            this.trayIcon.ClickClose += trayIcon_ClickClose;
-            Config.TrayBehaviorChanged += Config_TrayBehaviorChanged;
-
-            UpdateTrayIcon();
-
-            Config.MuteToggled += Config_MuteToggled;
-            Config.ZoomLevelChanged += Config_ZoomLevelChanged;
-
-            this.updates = new UpdateHandler(browser, updaterSettings);
-            this.updates.UpdateAccepted += updates_UpdateAccepted;
-            this.updates.UpdateDismissed += updates_UpdateDismissed;
-
-            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);
-        }
-
-        public void ForceClose(){
-            trayIcon.Visible = false; // checked in FormClosing event
-            Close();
-        }
-
-        // window setup
-
-        private void RestoreWindow(){
-            Config.BrowserWindow.Restore(this, true);
-            prevState = WindowState;
-            isLoaded = true;
-        }
-
-        private void OnBrowserReady(){
-            if (!isBrowserReady){
-                browser.Location = Point.Empty;
-                browser.Dock = DockStyle.Fill;
-                isBrowserReady = true;
-            }
-        }
-
-        private void UpdateTrayIcon(){
-            trayIcon.Visible = Config.TrayBehavior.ShouldDisplayIcon();
-        }
-
-        // active event handlers
-
-        private void browser_LoadingStateChanged(object sender, LoadingStateChangedEventArgs e){
-            if (!e.IsLoading){
-                foreach(string word in TwitterUtils.DictionaryWords){
-                    browser.AddWordToDictionary(word);
-                }
-
-                BeginInvoke(new Action(OnBrowserReady));
-                browser.LoadingStateChanged -= browser_LoadingStateChanged;
-            }
-        }
-
-        private void browser_FrameLoadStart(object sender, FrameLoadStartEventArgs e){
-            if (e.Frame.IsMain){
-                memoryUsageTracker.Stop();
-
-                if (Config.ZoomLevel != 100){
-                    BrowserUtils.SetZoomLevel(browser.GetBrowser(), Config.ZoomLevel);
-                }
-
-                if (TwitterUtils.IsTwitterWebsite(e.Frame)){
-                    ScriptLoader.ExecuteFile(e.Frame, "twitter.js");
-                }
-            }
-        }
-
-        private void browser_FrameLoadEnd(object sender, FrameLoadEndEventArgs e){
-            if (e.Frame.IsMain && TwitterUtils.IsTweetDeckWebsite(e.Frame)){
-                e.Frame.ExecuteJavaScriptAsync(TwitterUtils.BackgroundColorFix);
-
-                UpdateProperties(PropertyBridge.Environment.Browser);
-                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();
-
-                if (Config.EnableBrowserGCReload){
-                    memoryUsageTracker.Start(this, e.Browser, Config.BrowserMemoryThreshold);
-                }
-            }
-        }
-
-        private void browser_LoadError(object sender, LoadErrorEventArgs e){
-            if (e.ErrorCode == CefErrorCode.Aborted){
-                return;
-            }
-
-            if (!e.FailedUrl.StartsWith("http://td/", StringComparison.Ordinal)){
-                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;
-
-            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){
-            if (!isLoaded)return;
-
-            if (WindowState != prevState){
-                prevState = WindowState;
-
-                if (WindowState == FormWindowState.Minimized){
-                    if (Config.TrayBehavior.ShouldHideOnMinimize()){
-                        Hide(); // hides taskbar too?! welp that works I guess
-                    }
-                }
-                else{
-                    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();
-            }
-        }
-
-        private void FormBrowser_FormClosing(object sender, FormClosingEventArgs e){
-            if (!isLoaded)return;
-
-            if (Config.TrayBehavior.ShouldHideOnClose() && trayIcon.Visible && e.CloseReason == CloseReason.UserClosing){
-                Hide(); // hides taskbar too?! welp that works I guess
-                e.Cancel = true;
-            }
-        }
-
-        private void FormBrowser_FormClosed(object sender, FormClosedEventArgs e){
-            if (isLoaded && UpdateInstallerPath == null){
-                updates.CleanupDownload();
-            }
-        }
-
-        private void Config_MuteToggled(object sender, EventArgs e){
-            UpdateProperties(PropertyBridge.Environment.Browser);
-        }
-
-        private void Config_ZoomLevelChanged(object sender, EventArgs e){
-            BrowserUtils.SetZoomLevel(browser.GetBrowser(), Config.ZoomLevel);
-        }
-
-        private void Config_TrayBehaviorChanged(object sender, EventArgs e){
-            UpdateTrayIcon();
-        }
-
-        private void trayIcon_ClickRestore(object sender, EventArgs e){
-            Show();
-            RestoreWindow();
-            Activate();
-            UpdateTrayIcon();
-        }
-
-        private void trayIcon_ClickClose(object sender, EventArgs e){
-            ForceClose();
-        }
-        
-        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){
-            this.InvokeAsyncSafe(() => {
-                foreach(Form form in Application.OpenForms.Cast<Form>().Reverse()){
-                    if (form is FormSettings || form is FormPlugins || form is FormAbout){
-                        form.Close();
-                    }
-                }
-            
-                updates.BeginUpdateDownload(this, e.UpdateInfo, update => {
-                    if (update.DownloadStatus == UpdateDownloadStatus.Done){
-                        UpdateInstallerPath = update.InstallerPath;
-                    }
-
-                    ForceClose();
-                });
-            });
-        }
-
-        private void updates_UpdateDismissed(object sender, UpdateDismissedEventArgs e){
-            this.InvokeAsyncSafe(() => {
-                Config.DismissedUpdate = e.VersionTag;
-                Config.Save();
-            });
-        }
-
-        private void soundNotification_PlaybackError(object sender, PlaybackErrorEventArgs e){
-            e.Ignore = true;
-
-            using(FormMessage form = new FormMessage("Notification Sound Error", "Could not play custom notification sound.\n"+e.Message, MessageBoxIcon.Error)){
-                form.AddButton(FormMessage.Ignore, ControlType.Cancel | ControlType.Focused);
-
-                Button btnOpenSettings = form.AddButton("View Options");
-                btnOpenSettings.Width += 16;
-                btnOpenSettings.Location = new Point(btnOpenSettings.Location.X-16, btnOpenSettings.Location.Y);
-
-                if (form.ShowDialog() == DialogResult.OK && form.ClickedButton == btnOpenSettings){
-                    OpenSettings(typeof(TabSettingsSounds));
-                }
-            }
-        }
-
-        protected override void WndProc(ref Message m){
-            if (isLoaded){
-                if (m.Msg == Program.WindowRestoreMessage){
-                    if (WindowsUtils.CurrentProcessID == m.WParam.ToInt32()){
-                        trayIcon_ClickRestore(trayIcon, new EventArgs());
-                    }
-
-                    return;
-                }
-                else if (m.Msg == Program.SubProcessMessage){
-                    int processId = m.WParam.ToInt32();
-
-                    if (WindowsUtils.IsChildProcess(processId)){ // child process is checked in two places for safety
-                        BrowserProcesses.Link(m.LParam.ToInt32(), processId);
-                    }
-
-                    return;
-                }
-            }
-            
-            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);
-        }
-
-        public void PauseNotification(){
-            notification.PauseNotification();
-        }
-
-        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.Environment environment){
-            browser.ExecuteScriptAsync(PropertyBridge.GenerateScript(environment));
-        }
-
-        public void ReloadToTweetDeck(){
-            browser.ExecuteScriptAsync($"gc&&gc();window.location.href='{TwitterUtils.TweetDeckURL}'");
-        }
-
-        // callback handlers
-
-        public void OpenContextMenu(){
-            contextMenu.Show(this, PointToClient(Cursor.Position));
-        }
-
-        public void OpenSettings(){
-            OpenSettings(null);
-        }
-
-        public void OpenSettings(Type startTab){
-            if (!TryBringToFront<FormSettings>()){
-                bool prevEnableUpdateCheck = Config.EnableUpdateCheck;
-
-                FormSettings form = new FormSettings(this, plugins, updates, startTab);
-
-                form.FormClosed += (sender, args) => {
-                    if (!prevEnableUpdateCheck && Config.EnableUpdateCheck){
-                        updates.DismissUpdate(string.Empty);
-                        updates.Check(false);
-                    }
-
-                    if (!Config.EnableTrayHighlight){
-                        trayIcon.HasNotifications = false;
-                    }
-
-                    if (Config.EnableBrowserGCReload){
-                        memoryUsageTracker.Start(this, browser.GetBrowser(), Config.BrowserMemoryThreshold);
-                    }
-                    else{
-                        memoryUsageTracker.Stop();
-                    }
-                    
-                    UpdateProperties(PropertyBridge.Environment.Browser);
-
-                    notification.RequiresResize = true;
-                    form.Dispose();
-                };
-
-                ShowChildForm(form);
-            }
-        }
-
-        public void OpenAbout(){
-            if (!TryBringToFront<FormAbout>()){
-                ShowChildForm(new FormAbout());
-            }
-        }
-
-        public void OpenPlugins(){
-            if (!TryBringToFront<FormPlugins>()){
-                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 PlayNotificationSound(){
-            if (Config.NotificationSoundPath.Length == 0){
-                return;
-            }
-
-            if (soundNotification == null){
-                soundNotification = new SoundNotification();
-                soundNotification.PlaybackError += soundNotification_PlaybackError;
-            }
-
-            soundNotification.Play(Config.NotificationSoundPath);
-        }
-
-        public void OnTweetScreenshotReady(string html, int width, int height){
-            if (notificationScreenshotManager == null){
-                notificationScreenshotManager = new TweetScreenshotManager(this, plugins);
-            }
-
-            notificationScreenshotManager.Trigger(html, width, height);
-        }
-
-        public void DisplayTooltip(string text){
-            if (string.IsNullOrEmpty(text)){
-                toolTip.Hide(this);
-            }
-            else{
-                Point position = PointToClient(Cursor.Position);
-                position.Offset(20, 10);
-                toolTip.Show(text, this, position);
-            }
-        }
-
-        public void TriggerTweetScreenshot(){
-            browser.ExecuteScriptAsync("TDGF_triggerScreenshot()");
-        }
-    }
-}

Core/Handling/ContextMenuBase.cs

@@ -1,144 +0,0 @@
-using System;
-using System.IO;
-using System.Text.RegularExpressions;
-using System.Windows.Forms;
-using CefSharp;
-using TweetDuck.Core.Bridge;
-using TweetDuck.Core.Controls;
-using TweetDuck.Core.Utils;
-
-namespace TweetDuck.Core.Handling{
-    abstract class ContextMenuBase : IContextMenuHandler{
-        protected static readonly bool HasDevTools = File.Exists(Path.Combine(Program.ProgramPath, "devtools_resources.pak"));
-
-        private static TwitterUtils.ImageQuality ImageQuality => Program.UserConfig.TwitterImageQuality;
-
-        private static string GetLink(IContextMenuParams parameters){
-            return string.IsNullOrEmpty(TweetDeckBridge.LastRightClickedLink) ? parameters.UnfilteredLinkUrl : TweetDeckBridge.LastRightClickedLink;
-        }
-
-        private static string GetImage(IContextMenuParams parameters){
-            return string.IsNullOrEmpty(TweetDeckBridge.LastRightClickedImage) ? parameters.SourceUrl : TweetDeckBridge.LastRightClickedImage;
-        }
-
-        private const int MenuOpenLinkUrl = 26500;
-        private const int MenuCopyLinkUrl = 26501;
-        private const int MenuCopyUsername = 26502;
-        private const int MenuOpenImageUrl = 26503;
-        private const int MenuCopyImageUrl = 26504;
-        private const int MenuSaveImage = 26505;
-        private const int MenuSaveAllImages = 26506;
-        private const int MenuOpenDevTools = 26599;
-
-        private readonly Form form;
-        
-        private string[] lastHighlightedTweetImageList;
-
-        protected ContextMenuBase(Form form){
-            this.form = form;
-        }
-
-        public virtual void OnBeforeContextMenu(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, IMenuModel model){
-            bool hasTweetImage = !string.IsNullOrEmpty(TweetDeckBridge.LastRightClickedImage);
-            lastHighlightedTweetImageList = TweetDeckBridge.LastHighlightedTweetImages;
-
-            if (!TwitterUtils.IsTweetDeckWebsite(frame) || browser.IsLoading){
-                lastHighlightedTweetImageList = StringUtils.EmptyArray;
-            }
-
-            if (parameters.TypeFlags.HasFlag(ContextMenuType.Link) && !parameters.UnfilteredLinkUrl.EndsWith("tweetdeck.twitter.com/#", StringComparison.Ordinal) && !hasTweetImage){
-                if (TwitterUtils.RegexAccount.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");
-                }
-                else{
-                    model.AddItem((CefMenuCommand)MenuOpenLinkUrl, "Open link in browser");
-                    model.AddItem((CefMenuCommand)MenuCopyLinkUrl, "Copy link address");
-                }
-
-                model.AddSeparator();
-            }
-
-            if ((parameters.TypeFlags.HasFlag(ContextMenuType.Media) && parameters.HasImageContents) || hasTweetImage){
-                model.AddItem((CefMenuCommand)MenuOpenImageUrl, "Open image in browser");
-                model.AddItem((CefMenuCommand)MenuCopyImageUrl, "Copy image address");
-                model.AddItem((CefMenuCommand)MenuSaveImage, "Save image as...");
-
-                if (lastHighlightedTweetImageList.Length > 1){
-                    model.AddItem((CefMenuCommand)MenuSaveAllImages, "Save all images as...");
-                }
-
-                model.AddSeparator();
-            }
-        }
-
-        public virtual bool OnContextMenuCommand(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, CefMenuCommand commandId, CefEventFlags eventFlags){
-            switch((int)commandId){
-                case MenuOpenLinkUrl:
-                    BrowserUtils.OpenExternalBrowser(parameters.LinkUrl);
-                    break;
-
-                case MenuCopyLinkUrl:
-                    SetClipboardText(GetLink(parameters));
-                    break;
-
-                case MenuOpenImageUrl:
-                    BrowserUtils.OpenExternalBrowser(TwitterUtils.GetImageLink(GetImage(parameters), ImageQuality));
-                    break;
-
-                case MenuSaveImage:
-                    TwitterUtils.DownloadImage(GetImage(parameters), ImageQuality);
-                    break;
-
-                case MenuSaveAllImages:
-                    TwitterUtils.DownloadImages(lastHighlightedTweetImageList, ImageQuality);
-                    break;
-
-                case MenuCopyImageUrl:
-                    SetClipboardText(TwitterUtils.GetImageLink(GetImage(parameters), ImageQuality));
-                    break;
-
-                case MenuCopyUsername:
-                    Match match = TwitterUtils.RegexAccount.Match(parameters.UnfilteredLinkUrl);
-                    SetClipboardText(match.Success ? match.Groups[1].Value : parameters.UnfilteredLinkUrl);
-                    break;
-                    
-                case MenuOpenDevTools:
-                    browserControl.ShowDevTools();
-                    break;
-            }
-
-            return false;
-        }
-
-        public virtual void OnContextMenuDismissed(IWebBrowser browserControl, IBrowser browser, IFrame frame){
-            TweetDeckBridge.LastRightClickedLink = string.Empty;
-            TweetDeckBridge.LastRightClickedImage = string.Empty;
-        }
-
-        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 AddDebugMenuItems(IMenuModel model){
-            model.AddItem((CefMenuCommand)MenuOpenDevTools, "Open dev tools");
-        }
-
-        protected static void RemoveSeparatorIfLast(IMenuModel model){
-            if (model.Count > 0 && model.GetTypeAt(model.Count-1) == MenuItemType.Separator){
-                model.RemoveAt(model.Count-1);
-            }
-        }
-
-        protected static void AddSeparator(IMenuModel model){
-            if (model.Count > 0 && model.GetTypeAt(model.Count-1) != MenuItemType.Separator){ // do not add separators if there is nothing to separate
-                model.AddSeparator();
-            }
-        }
-    }
-}

Core/Handling/ContextMenuBrowser.cs

@@ -1,166 +0,0 @@
-using CefSharp;
-using System.Windows.Forms;
-using TweetDuck.Core.Bridge;
-using TweetDuck.Core.Controls;
-using TweetDuck.Core.Utils;
-
-namespace TweetDuck.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;
-        
-        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 string TitleReloadBrowser = "Reload browser";
-        private const string TitleMuteNotifications = "Mute notifications";
-        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){
-            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 (!TwitterUtils.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)){
-                    model.AddSeparator();
-                    model.AddItem((CefMenuCommand)MenuOpenQuotedTweetUrl, "Open quoted tweet in browser");
-                    model.AddItem((CefMenuCommand)MenuCopyQuotedTweetUrl, "Copy quoted tweet address");
-                }
-
-                model.AddSeparator();
-            }
-
-            if ((parameters.TypeFlags & (ContextMenuType.Editable | ContextMenuType.Selection)) == 0){
-                AddSeparator(model);
-
-                IMenuModel globalMenu = model.Count == 0 ? model : model.AddSubMenu((CefMenuCommand)MenuGlobal, Program.BrandName);
-            
-                globalMenu.AddItem(CefMenuCommand.Reload, TitleReloadBrowser);
-                globalMenu.AddCheckItem((CefMenuCommand)MenuMute, TitleMuteNotifications);
-                globalMenu.SetChecked((CefMenuCommand)MenuMute, Program.UserConfig.MuteNotifications);
-                globalMenu.AddSeparator();
-
-                globalMenu.AddItem((CefMenuCommand)MenuSettings, TitleSettings);
-                globalMenu.AddItem((CefMenuCommand)MenuPlugins, TitlePlugins);
-                globalMenu.AddItem((CefMenuCommand)MenuAbout, TitleAboutProgram);
-
-                if (HasDevTools){
-                    globalMenu.AddSeparator();
-                    AddDebugMenuItems(globalMenu);
-                }
-            }
-
-            RemoveSeparatorIfLast(model);
-        }
-
-        public override bool OnContextMenuCommand(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, CefMenuCommand commandId, CefEventFlags eventFlags){
-            if (base.OnContextMenuCommand(browserControl, browser, frame, parameters, commandId, eventFlags)){
-                return true;
-            }
-
-            switch((int)commandId){
-                case (int)CefMenuCommand.Reload:
-                    form.InvokeAsyncSafe(form.ReloadToTweetDeck);
-                    return true;
-
-                case MenuSettings:
-                    form.InvokeAsyncSafe(form.OpenSettings);
-                    return true;
-
-                case MenuAbout:
-                    form.InvokeAsyncSafe(form.OpenAbout);
-                    return true;
-
-                case MenuPlugins:
-                    form.InvokeAsyncSafe(form.OpenPlugins);
-                    return true;
-
-                case MenuMute:
-                    form.InvokeAsyncSafe(ToggleMuteNotifications);
-                    return true;
-
-                case MenuOpenTweetUrl:
-                    BrowserUtils.OpenExternalBrowser(lastHighlightedTweet);
-                    return true;
-
-                case MenuCopyTweetUrl:
-                    SetClipboardText(lastHighlightedTweet);
-                    return true;
-
-                case MenuScreenshotTweet:
-                    form.InvokeAsyncSafe(form.TriggerTweetScreenshot);
-                    return true;
-
-                case MenuOpenQuotedTweetUrl:
-                    BrowserUtils.OpenExternalBrowser(lastHighlightedQuotedTweet);
-                    return true;
-
-                case MenuCopyQuotedTweetUrl:
-                    SetClipboardText(lastHighlightedQuotedTweet);
-                    return true;
-            }
-
-            return false;
-        }
-
-        public static ContextMenu CreateMenu(FormBrowser form){
-            ContextMenu menu = new ContextMenu();
-
-            menu.MenuItems.Add(TitleReloadBrowser, (sender, args) => form.ReloadToTweetDeck());
-            menu.MenuItems.Add(TitleMuteNotifications, (sender, args) => ToggleMuteNotifications());
-            menu.MenuItems.Add("-");
-            menu.MenuItems.Add(TitleSettings, (sender, args) => form.OpenSettings());
-            menu.MenuItems.Add(TitlePlugins, (sender, args) => form.OpenPlugins());
-            menu.MenuItems.Add(TitleAboutProgram,  (sender, args) => form.OpenAbout());
-
-            menu.Popup += (sender, args) => {
-                menu.MenuItems[1].Checked = Program.UserConfig.MuteNotifications;
-            };
-
-            return menu;
-        }
-
-        private static void ToggleMuteNotifications(){
-            Program.UserConfig.MuteNotifications = !Program.UserConfig.MuteNotifications;
-            Program.UserConfig.Save();
-        }
-    }
-}

Core/Handling/General/BrowserProcessHandler.cs

@@ -1,15 +0,0 @@
-using System;
-using CefSharp;
-
-namespace TweetDuck.Core.Handling.General{
-    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/General/RequestHandlerBase.cs

@@ -1,68 +0,0 @@
-using System.Security.Cryptography.X509Certificates;
-using CefSharp;
-
-namespace TweetDuck.Core.Handling.General{
-    abstract class RequestHandlerBase : IRequestHandler{
-        // Browser
-
-        public virtual void OnRenderViewReady(IWebBrowser browserControl, IBrowser browser){}
-
-        public virtual void OnRenderProcessTerminated(IWebBrowser browserControl, IBrowser browser, CefTerminationStatus status){}
-
-        public virtual bool OnBeforeBrowse(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request, bool isRedirect){
-            return false;
-        }
-
-        public virtual bool OnOpenUrlFromTab(IWebBrowser browserControl, IBrowser browser, IFrame frame, string targetUrl, WindowOpenDisposition targetDisposition, bool userGesture){
-            return false;
-        }
-
-        public virtual bool OnProtocolExecution(IWebBrowser browserControl, IBrowser browser, string url){
-            return false;
-        }
-
-        // Resources
-
-        public virtual CefReturnValue OnBeforeResourceLoad(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request, IRequestCallback callback){
-            return CefReturnValue.Continue;
-        }
-
-        public virtual void OnResourceRedirect(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request, IResponse response, ref string newUrl){}
-
-        public virtual bool OnResourceResponse(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request, IResponse response){
-            return false;
-        }
-
-        public virtual IResponseFilter GetResourceResponseFilter(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request, IResponse response){
-            return null;
-        }
-
-        public virtual void OnResourceLoadComplete(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request, IResponse response, UrlRequestStatus status, long receivedContentLength){}
-
-        // JavaScript & Plugins
-
-        public virtual bool OnQuotaRequest(IWebBrowser browserControl, IBrowser browser, string originUrl, long newSize, IRequestCallback callback){
-            callback.Dispose();
-            return false;
-        }
-
-        public virtual void OnPluginCrashed(IWebBrowser browserControl, IBrowser browser, string pluginPath){}
-
-        // Auth
-
-        public virtual bool GetAuthCredentials(IWebBrowser browserControl, IBrowser browser, IFrame frame, bool isProxy, string host, int port, string realm, string scheme, IAuthCallback callback){
-            callback.Dispose();
-            return false;
-        }
-
-        public virtual bool OnSelectClientCertificate(IWebBrowser browserControl, IBrowser browser, bool isProxy, string host, int port, X509Certificate2Collection certificates, ISelectClientCertificateCallback callback){
-            callback.Dispose();
-            return false;
-        }
-
-        public virtual bool OnCertificateError(IWebBrowser browserControl, IBrowser browser, CefErrorCode errorCode, string requestUrl, ISslInfo sslInfo, IRequestCallback callback){
-            callback.Dispose();
-            return false;
-        }
-    }
-}

Core/Handling/KeyboardHandlerNotification.cs

@@ -1,38 +0,0 @@
-using CefSharp;
-using System.Windows.Forms;
-using TweetDuck.Core.Controls;
-using TweetDuck.Core.Notification;
-
-namespace TweetDuck.Core.Handling {
-    sealed class KeyboardHandlerNotification : IKeyboardHandler{
-        private readonly FormNotificationBase notification;
-
-        public KeyboardHandlerNotification(FormNotificationBase notification){
-            this.notification = notification;
-        }
-
-        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://")){
-                switch((Keys)windowsKeyCode){
-                    case Keys.Enter:
-                        notification.InvokeAsyncSafe(notification.FinishCurrentNotification);
-                        return true;
-
-                    case Keys.Escape:
-                        notification.InvokeAsyncSafe(() => notification.HideNotification(true));
-                        return true;
-
-                    case Keys.Space:
-                        notification.InvokeAsyncSafe(() => notification.FreezeTimer = !notification.FreezeTimer);
-                        return true;
-                }
-            }
-
-            return false;
-        }
-
-        bool IKeyboardHandler.OnKeyEvent(IWebBrowser browserControl, IBrowser browser, KeyType type, int windowsKeyCode, int nativeKeyCode, CefEventFlags modifiers, bool isSystemKey){
-            return false;
-        }
-    }
-}

Core/Handling/RequestHandlerBrowser.cs

@@ -1,18 +0,0 @@
-using CefSharp;
-using TweetDuck.Core.Handling.General;
-
-namespace TweetDuck.Core.Handling{
-    class RequestHandlerBrowser : RequestHandlerBase{
-        public override void OnRenderProcessTerminated(IWebBrowser browserControl, IBrowser browser, CefTerminationStatus status){
-            browser.Reload();
-        }
-
-        public override CefReturnValue OnBeforeResourceLoad(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request, IRequestCallback callback){
-            if (request.ResourceType == ResourceType.Script && request.Url.Contains("analytics.")){
-                return CefReturnValue.Cancel;
-            }
-
-            return CefReturnValue.Continue;
-        }
-    }
-}

Core/Handling/ResourceHandlerNotification.cs

@@ -1,63 +0,0 @@
-using CefSharp;
-using System.Collections.Specialized;
-using System.IO;
-using System.Text;
-
-namespace TweetDuck.Core.Handling{
-    class ResourceHandlerNotification : IResourceHandler{
-        private readonly NameValueCollection headers = new NameValueCollection(0);
-        private MemoryStream dataIn;
-
-        public void SetHTML(string html){
-            dataIn?.Dispose();
-            dataIn = ResourceHandler.GetMemoryStream(html, Encoding.UTF8);
-        }
-
-        public void Dispose(){
-            if (dataIn != null){
-                dataIn.Dispose();
-                dataIn = null;
-            }
-        }
-
-        bool IResourceHandler.ProcessRequest(IRequest request, ICallback callback){
-            callback.Continue();
-            return true;
-        }
-
-        void IResourceHandler.GetResponseHeaders(IResponse response, out long responseLength, out string redirectUrl){
-            redirectUrl = null;
-
-            response.MimeType = "text/html";
-            response.StatusCode = 200;
-            response.StatusText = "OK";
-            response.ResponseHeaders = headers;
-            responseLength = dataIn?.Length ?? -1;
-        }
-
-        bool IResourceHandler.ReadResponse(Stream dataOut, out int bytesRead, ICallback callback){
-            callback.Dispose();
-
-            try{
-                int length = (int)dataIn.Length;
-
-                dataIn.CopyTo(dataOut, length);
-                bytesRead = length;
-                return true;
-            }catch{ // catch IOException, possibly NullReferenceException if dataIn is null
-                bytesRead = 0;
-                return false;
-            }
-        }
-
-        bool IResourceHandler.CanGetCookie(Cookie cookie){
-            return true;
-        }
-
-        bool IResourceHandler.CanSetCookie(Cookie cookie){
-            return true;
-        }
-
-        void IResourceHandler.Cancel(){}
-    }
-}

Core/Notification/FormNotificationBase.cs

@@ -1,232 +0,0 @@
-using CefSharp;
-using CefSharp.WinForms;
-using System;
-using System.Drawing;
-using System.Windows.Forms;
-using TweetDuck.Configuration;
-using TweetDuck.Core.Controls;
-using TweetDuck.Core.Handling;
-using TweetDuck.Core.Handling.General;
-using TweetDuck.Core.Utils;
-
-namespace TweetDuck.Core.Notification{
-    partial class FormNotificationBase : Form{
-        protected Point PrimaryLocation{
-            get{
-                UserConfig config = Program.UserConfig;
-                Screen screen;
-
-                if (config.NotificationDisplay > 0 && config.NotificationDisplay <= Screen.AllScreens.Length){
-                    screen = Screen.AllScreens[config.NotificationDisplay-1];
-                }
-                else{
-                    screen = Screen.FromControl(owner);
-                }
-            
-                int edgeDist = config.NotificationEdgeDistance;
-
-                switch(config.NotificationPosition){
-                    case TweetNotification.Position.TopLeft:
-                        return new Point(screen.WorkingArea.X+edgeDist, screen.WorkingArea.Y+edgeDist);
-
-                    case TweetNotification.Position.TopRight:
-                        return new Point(screen.WorkingArea.X+screen.WorkingArea.Width-edgeDist-Width, screen.WorkingArea.Y+edgeDist);
-
-                    case TweetNotification.Position.BottomLeft:
-                        return new Point(screen.WorkingArea.X+edgeDist, screen.WorkingArea.Y+screen.WorkingArea.Height-edgeDist-Height);
-
-                    case TweetNotification.Position.BottomRight:
-                        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();
-                        }
-
-                        return config.CustomNotificationPosition;
-                }
-
-                return Location;
-            }
-        }
-
-        public bool IsNotificationVisible => Location != ControlExtensions.InvisibleLocation;
-
-        public new Point Location{
-            get => base.Location;
-
-            set{
-                Visible = (base.Location = value) != ControlExtensions.InvisibleLocation;
-                FormBorderStyle = GetBorderStyle(CanResizeWindow);
-            }
-        }
-
-        public bool CanResizeWindow{
-            get => FormBorderStyle == FormBorderStyle.Sizable || FormBorderStyle == FormBorderStyle.SizableToolWindow;
-            set => FormBorderStyle = GetBorderStyle(value);
-        }
-        
-        public Func<bool> CanMoveWindow { get; set; } = () => true;
-        protected override bool ShowWithoutActivation => true;
-
-        protected double SizeScale => dpiScale*Program.UserConfig.ZoomMultiplier;
-
-        protected readonly Form owner;
-        protected readonly ChromiumWebBrowser browser;
-        
-        private readonly ResourceHandlerNotification resourceHandler = new ResourceHandlerNotification();
-        private readonly float dpiScale;
-
-        private string currentColumn;
-        private int pauseCounter;
-
-        public bool IsPaused => pauseCounter > 0;
-
-        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){
-            InitializeComponent();
-
-            this.owner = owner;
-            this.owner.FormClosed += owner_FormClosed;
-
-            this.browser = new ChromiumWebBrowser("about:blank"){
-                MenuHandler = new ContextMenuNotification(this, enableContextMenu),
-                JsDialogHandler = new JavaScriptDialogHandler(),
-                LifeSpanHandler = new LifeSpanHandler()
-            };
-
-            this.browser.Dock = DockStyle.None;
-            this.browser.ClientSize = ClientSize;
-            this.browser.IsBrowserInitializedChanged += Browser_IsBrowserInitializedChanged;
-
-            #if DEBUG
-            this.browser.ConsoleMessage += BrowserUtils.HandleConsoleMessage;
-            #endif
-
-            this.dpiScale = this.GetDPIScale();
-
-            DefaultResourceHandlerFactory handlerFactory = (DefaultResourceHandlerFactory)browser.ResourceHandlerFactory;
-            handlerFactory.RegisterHandler(TwitterUtils.TweetDeckURL, this.resourceHandler);
-
-            Controls.Add(browser);
-
-            Disposed += (sender, args) => {
-                this.browser.Dispose();
-                this.owner.FormClosed -= owner_FormClosed;
-            };
-
-            // 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
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-
-        // event handlers
-
-        private void owner_FormClosed(object sender, FormClosedEventArgs e){
-            Close();
-        }
-
-        private void Browser_IsBrowserInitializedChanged(object sender, IsBrowserInitializedChangedEventArgs e){
-            if (e.IsBrowserInitialized){
-                Initialized?.Invoke(this, new EventArgs());
-
-                int identifier = browser.GetBrowser().Identifier;
-                Disposed += (sender2, args2) => BrowserProcesses.Forget(identifier);
-            }
-        }
-
-        // notification methods
-
-        public virtual void HideNotification(bool loadBlank){
-            if (loadBlank){
-                browser.Load("about:blank");
-            }
-
-            Location = ControlExtensions.InvisibleLocation;
-            currentColumn = null;
-        }
-
-        public virtual void FinishCurrentNotification(){}
-
-        public virtual void PauseNotification(){
-            if (pauseCounter++ == 0 && IsNotificationVisible){
-                Location = ControlExtensions.InvisibleLocation;
-            }
-        }
-
-        public virtual void ResumeNotification(){
-            if (pauseCounter > 0){
-                --pauseCounter;
-            }
-        }
-
-        protected virtual string GetTweetHTML(TweetNotification tweet){
-            string bodyClasses = browser.Bounds.Contains(PointToClient(Cursor.Position)) ? "td-hover" : string.Empty;
-            return tweet.GenerateHtml(bodyClasses);
-        }
-
-        protected virtual void LoadTweet(TweetNotification tweet){
-            CurrentTweetUrl = tweet.TweetUrl;
-            CurrentQuoteUrl = tweet.QuoteUrl;
-            currentColumn = tweet.Column;
-
-            resourceHandler.SetHTML(GetTweetHTML(tweet));
-            browser.Load(TwitterUtils.TweetDeckURL);
-        }
-
-        protected virtual void SetNotificationSize(int width, int height){
-            browser.ClientSize = ClientSize = new Size(BrowserUtils.Scale(width, SizeScale), BrowserUtils.Scale(height, SizeScale));
-        }
-
-        protected virtual void OnNotificationReady(){
-            MoveToVisibleLocation();
-        }
-
-        protected virtual void UpdateTitle(){
-            Text = string.IsNullOrEmpty(currentColumn) || !Program.UserConfig.DisplayNotificationColumn ? Program.BrandName : Program.BrandName+" - "+currentColumn;
-        }
-
-        public void MoveToVisibleLocation(){
-            bool needsReactivating = Location == ControlExtensions.InvisibleLocation;
-            Location = PrimaryLocation;
-
-            if (needsReactivating){
-                NativeMethods.SetFormPos(this, NativeMethods.HWND_TOPMOST, NativeMethods.SWP_NOACTIVATE);
-            }
-        }
-
-        public void DisplayTooltip(string text){
-            if (string.IsNullOrEmpty(text)){
-                toolTip.Hide(this);
-            }
-            else{
-                Point position = PointToClient(Cursor.Position);
-                position.Offset(20, 5);
-                toolTip.Show(text, this, position);
-            }
-        }
-
-        private FormBorderStyle GetBorderStyle(bool sizable){
-            if (WindowsUtils.ShouldAvoidToolWindow && Visible){ // Visible = workaround for alt+tab
-                return sizable ? FormBorderStyle.Sizable : FormBorderStyle.FixedSingle;
-            }
-            else{
-                return sizable ? FormBorderStyle.SizableToolWindow : FormBorderStyle.FixedToolWindow;
-            }
-        }
-    }
-}

Core/Notification/Screenshot/FormNotificationScreenshotable.cs

@@ -1,65 +0,0 @@
-using System;
-using System.Drawing;
-using System.Drawing.Imaging;
-using System.Windows.Forms;
-using CefSharp;
-using TweetDuck.Core.Bridge;
-using TweetDuck.Core.Other;
-using TweetDuck.Core.Utils;
-using TweetDuck.Data;
-using TweetDuck.Plugins;
-using TweetDuck.Resources;
-
-namespace TweetDuck.Core.Notification.Screenshot{
-    sealed class FormNotificationScreenshotable : FormNotificationBase{
-        private readonly PluginManager plugins;
-
-        public FormNotificationScreenshotable(Action callback, Form owner, PluginManager pluginManager) : base(owner, false){
-            this.plugins = pluginManager;
-
-            browser.RegisterAsyncJsObject("$TD_NotificationScreenshot", new CallbackBridge(this, callback));
-
-            browser.LoadingStateChanged += (sender, args) => {
-                if (!args.IsLoading){
-                    using(IFrame frame = args.Browser.MainFrame){
-                        ScriptLoader.ExecuteScript(frame, "window.setTimeout($TD_NotificationScreenshot.trigger, 129)", "gen:screenshot");
-                    }
-                }
-            };
-        }
-        
-        protected override string GetTweetHTML(TweetNotification tweet){
-            string html = tweet.GenerateHtml("td-screenshot", false);
-
-            foreach(InjectedHTML injection in plugins.Bridge.NotificationInjections){
-                html = injection.Inject(html);
-            }
-
-            return html;
-        }
-
-        public void LoadNotificationForScreenshot(TweetNotification tweet, int width, int height){
-            LoadTweet(tweet);
-            SetNotificationSize(width, height);
-        }
-
-        public void TakeScreenshot(){
-            IntPtr context = NativeMethods.GetDC(this.Handle);
-
-            if (context == IntPtr.Zero){
-                FormMessage.Error("Screenshot Failed", "Could not retrieve a graphics context handle for the notification window to take the screenshot.", FormMessage.OK);
-            }
-            else{
-                using(Bitmap bmp = new Bitmap(ClientSize.Width, ClientSize.Height, PixelFormat.Format32bppRgb)){
-                    try{
-                        NativeMethods.RenderSourceIntoBitmap(context, bmp);
-                    }finally{
-                        NativeMethods.ReleaseDC(this.Handle, context);
-                    }
-
-                    Clipboard.SetImage(bmp);
-                }
-            }
-        }
-    }
-}

Core/Notification/Screenshot/TweetScreenshotManager.cs

@@ -1,86 +0,0 @@
-// Uncomment to keep screenshot windows visible for debugging
-// #define NO_HIDE_SCREENSHOTS
-
-using System;
-using System.Windows.Forms;
-using TweetDuck.Core.Controls;
-using TweetDuck.Plugins;
-
-namespace TweetDuck.Core.Notification.Screenshot{
-    sealed class TweetScreenshotManager : IDisposable{
-        private readonly FormBrowser owner;
-        private readonly PluginManager plugins;
-        private readonly Timer timeout;
-        private readonly Timer disposer;
-        
-        private FormNotificationScreenshotable screenshot;
-
-        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;
-        }
-
-        private void timeout_Tick(object sender, EventArgs e){
-            timeout.Stop();
-            OnFinished();
-        }
-
-        private void disposer_Tick(object sender, EventArgs e){
-            disposer.Stop();
-            screenshot.Dispose();
-            screenshot = null;
-        }
-
-        public void Trigger(string html, int width, int height){
-            if (screenshot != null){
-                return;
-            }
-
-            screenshot = new FormNotificationScreenshotable(Callback, owner, plugins){
-                CanMoveWindow = () => false
-            };
-
-            screenshot.LoadNotificationForScreenshot(new TweetNotification(string.Empty, html, 0, string.Empty, string.Empty), width, height);
-            screenshot.Show();
-            timeout.Start();
-
-            #if !(DEBUG && NO_HIDE_SCREENSHOTS)
-            owner.IsWaiting = true;
-            #endif
-        }
-
-        private void Callback(){
-            if (!timeout.Enabled){
-                return;
-            }
-
-            timeout.Stop();
-            screenshot.TakeScreenshot();
-
-            #if !(DEBUG && NO_HIDE_SCREENSHOTS)
-            OnFinished();
-            #else
-            screenshot.MoveToVisibleLocation();
-            screenshot.FormClosed += (sender, args) => disposer.Start();
-            #endif
-        }
-
-        private void OnFinished(){
-            screenshot.Location = ControlExtensions.InvisibleLocation;
-            owner.IsWaiting = false;
-            disposer.Start();
-        }
-
-        public void Dispose(){
-            timeout.Dispose();
-            disposer.Dispose();
-            screenshot?.Dispose();
-        }
-    }
-}

Core/Notification/SoundNotification.cs

@@ -1,28 +0,0 @@
-using System;
-using TweetLib.Audio;
-
-namespace TweetDuck.Core.Notification{
-    sealed class SoundNotification : IDisposable{
-        public string SupportedFormats => player.SupportedFormats;
-        public event EventHandler<PlaybackErrorEventArgs> PlaybackError;
-
-        private readonly AudioPlayer player;
-
-        public SoundNotification(){
-            this.player = AudioPlayer.New();
-            this.player.PlaybackError += Player_PlaybackError;
-        }
-
-        public void Play(string file){
-            player.Play(file);
-        }
-
-        private void Player_PlaybackError(object sender, PlaybackErrorEventArgs e){
-            PlaybackError?.Invoke(this, e);
-        }
-
-        public void Dispose(){
-            player.Dispose();
-        }
-    }
-}

Core/Notification/TweetNotification.cs

@@ -1,110 +0,0 @@
-using System;
-using System.Text;
-using TweetDuck.Resources;
-
-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}.media-size-medium{height:calc(100vh - 16px)!important;max-height:240px;border-radius:1px!important}.js-quote-detail .media-size-medium{height:calc(100vh - 28px)!important;}.js-media.margin-vm, .js-media-preview-container.margin-vm{margin-bottom:0!important}";
-
-        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:256px'>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;
-        }
-
-        public enum Position{
-            TopLeft, TopRight, BottomLeft, BottomRight, Custom
-        }
-
-        public enum Size{
-            Auto, Custom
-        }
-
-        public string Column { get; }
-        public string TweetUrl { get; }
-        public string QuoteUrl { get; }
-        
-        private readonly string html;
-        private readonly int characters;
-        private readonly bool isExample;
-
-        public TweetNotification(string column, string html, int characters, string tweetUrl, string quoteUrl) : this(column, html, characters, tweetUrl, quoteUrl, false){}
-
-        private TweetNotification(string column, string html, int characters, string tweetUrl, string quoteUrl, bool isExample){
-            this.Column = column;
-            this.TweetUrl = tweetUrl;
-            this.QuoteUrl = quoteUrl;
-
-            this.html = html;
-            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);
-            
-            if (enableCustomCSS){
-                build.Append("<style type='text/css'>").Append(CustomCSS).Append("</style>");
-
-                if (!string.IsNullOrEmpty(Program.UserConfig.CustomNotificationCSS)){
-                    build.Append("<style type='text/css'>").Append(Program.UserConfig.CustomNotificationCSS).Append("</style>");
-                }
-            }
-            
-            build.Append("</head>");
-            build.Append("<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(html);
-            build.Append("</div></body>");
-            build.Append("</html>");
-            return build.ToString();
-        }
-    }
-}

Core/Other/FormAbout.cs

@@ -1,25 +0,0 @@
-using System.Windows.Forms;
-using TweetDuck.Core.Utils;
-
-namespace TweetDuck.Core.Other{
-    sealed partial class FormAbout : Form{
-        private const string TipsLink = "https://github.com/chylex/TweetDuck/wiki";
-        private const string IssuesLink = "https://github.com/chylex/TweetDuck/issues";
-
-        public FormAbout(){
-            InitializeComponent();
-
-            Text = "About "+Program.BrandName+" "+Program.VersionTag;
-
-            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));
-        }
-
-        private void OnLinkClicked(object sender, LinkLabelLinkClickedEventArgs e){
-            BrowserUtils.OpenExternalBrowserUnsafe(e.Link.LinkData as string);
-        }
-    }
-}

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/FormSettings.cs

@@ -1,161 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Drawing;
-using System.Windows.Forms;
-using TweetDuck.Core.Controls;
-using TweetDuck.Core.Other.Settings;
-using TweetDuck.Core.Other.Settings.Dialogs;
-using TweetDuck.Core.Utils;
-using TweetDuck.Plugins;
-using TweetDuck.Updates;
-
-namespace TweetDuck.Core.Other{
-    sealed partial class FormSettings : Form{
-        private readonly FormBrowser browser;
-        private readonly PluginManager plugins;
-
-        private readonly int buttonHeight;
-
-        private readonly Dictionary<Type, SettingsTab> tabs = new Dictionary<Type, SettingsTab>(4);
-        private SettingsTab currentTab;
-
-        public FormSettings(FormBrowser browser, PluginManager plugins, UpdateHandler updates, Type startTab){
-            InitializeComponent();
-
-            Text = Program.BrandName+" Options";
-
-            this.browser = browser;
-            this.browser.PauseNotification();
-
-            this.plugins = plugins;
-            
-            this.buttonHeight = BrowserUtils.Scale(39, this.GetDPIScale()) | 1;
-
-            AddButton("General", () => new TabSettingsGeneral(updates));
-            AddButton("Notifications", () => new TabSettingsNotifications(browser.CreateNotificationForm(false)));
-            AddButton("Sounds", () => new TabSettingsSounds());
-            AddButton("Advanced", () => new TabSettingsAdvanced(browser.ReinjectCustomCSS));
-
-            SelectTab(tabs[startTab ?? typeof(TabSettingsGeneral)]);
-        }
-
-        private void FormSettings_FormClosing(object sender, FormClosingEventArgs e){
-            foreach(SettingsTab tab in tabs.Values){
-                if (tab.IsInitialized){
-                    tab.Control.OnClosing();
-                    tab.Control.Dispose();
-                }
-            }
-            
-            Program.UserConfig.Save();
-            browser.ResumeNotification();
-        }
-
-        private void btnManageOptions_Click(object sender, EventArgs e){
-            using(DialogSettingsManage dialog = new DialogSettingsManage(plugins)){
-                if (dialog.ShowDialog() == DialogResult.OK && dialog.ShouldReloadUI){
-                    foreach(SettingsTab tab in tabs.Values){
-                        tab.Control = null;
-                    }
-
-                    SelectTab(currentTab);
-                }
-            }
-        }
-
-        private void btnClose_Click(object sender, EventArgs e){
-            Close();
-        }
-
-        private void AddButton<T>(string title, Func<T> constructor) where T : BaseTabSettings{
-            FlatButton btn = new FlatButton{
-                BackColor = SystemColors.Control,
-                FlatStyle = FlatStyle.Flat,
-                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;
-            }
-            
-            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;
-                    }
-                }
-
-                tab.Control.OnReady();
-            }
-            
-            panelContents.SuspendLayout();
-            panelContents.VerticalScroll.Value = 0; // https://gfycat.com/GrotesqueTastyAstarte
-            panelContents.Controls.Clear();
-            panelContents.Controls.Add(tab.Control);
-            panelContents.ResumeLayout(true);
-            panelContents.Focus();
-
-            currentTab = tab;
-        }
-
-        private void control_MouseLeave(object sender, EventArgs e){
-            panelContents.Focus();
-        }
-
-        private void control_MouseWheel(object sender, MouseEventArgs e){
-            ((HandledMouseEventArgs)e).Handled = true;
-            panelContents.Focus();
-        }
-
-        private class SettingsTab{
-            public Button Button { get; }
-
-            public BaseTabSettings Control{
-                get => control ?? (control = constructor());
-                set => control = value;
-            }
-
-            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,33 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Windows.Forms;
-using TweetDuck.Configuration;
-
-namespace TweetDuck.Core.Other.Settings{
-    class BaseTabSettings : UserControl{
-        protected static UserConfig Config => Program.UserConfig;
-
-        public IEnumerable<Control> InteractiveControls{
-            get{
-                foreach(Panel panel in Controls.OfType<Panel>()){
-                    foreach(Control control in panel.Controls){
-                        yield return control;
-                    }
-                }
-            }
-        }
-
-        public BaseTabSettings(){
-            Padding = new Padding(6);
-        }
-
-        public virtual void OnReady(){}
-        public virtual void OnClosing(){}
-
-        protected static void PromptRestart(){
-            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();
-            }
-        }
-    }
-}

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

@@ -1,203 +0,0 @@
-namespace TweetDuck.Core.Other.Settings.Dialogs {
-    partial class DialogSettingsCSS {
-        /// <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.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.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.SuspendLayout();
-            // 
-            // textBoxBrowserCSS
-            // 
-            this.textBoxBrowserCSS.Dock = System.Windows.Forms.DockStyle.Bottom;
-            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.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(378, 253);
-            this.textBoxBrowserCSS.TabIndex = 1;
-            this.textBoxBrowserCSS.WordWrap = false;
-            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.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 = 2;
-            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.Location = new System.Drawing.Point(716, 287);
-            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.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 = 378;
-            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.Dock = System.Windows.Forms.DockStyle.Bottom;
-            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.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(377, 253);
-            this.textBoxNotificationCSS.TabIndex = 1;
-            this.textBoxNotificationCSS.WordWrap = false;
-            // 
-            // labelWarning
-            // 
-            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.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);
-            // 
-            // timerTestBrowser
-            // 
-            this.timerTestBrowser.Interval = 500;
-            this.timerTestBrowser.Tick += new System.EventHandler(this.timerTestBrowser_Tick);
-            // 
-            // 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.Controls.Add(this.btnApply);
-            this.Controls.Add(this.btnCancel);
-            this.MinimumSize = new System.Drawing.Size(600, 160);
-            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.ResumeLayout(false);
-            this.PerformLayout();
-
-        }
-
-        #endregion
-
-        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.Timer timerTestBrowser;
-    }
-}

Core/Other/Settings/Dialogs/DialogSettingsCSS.cs

@@ -1,51 +0,0 @@
-using System;
-using System.Windows.Forms;
-using TweetDuck.Core.Controls;
-using TweetDuck.Core.Utils;
-
-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;
-
-        public DialogSettingsCSS(Action<string> reinjectBrowserCSS){
-            InitializeComponent();
-            
-            Text = Program.BrandName+" Options - CSS";
-
-            this.reinjectBrowserCSS = reinjectBrowserCSS;
-            
-            textBoxBrowserCSS.EnableMultilineShortcuts();
-            textBoxBrowserCSS.Text = Program.UserConfig.CustomBrowserCSS ?? "";
-
-            textBoxNotificationCSS.EnableMultilineShortcuts();
-            textBoxNotificationCSS.Text = Program.UserConfig.CustomNotificationCSS ?? "";
-        }
-
-        private void textBoxBrowserCSS_KeyUp(object sender, KeyEventArgs e){
-            timerTestBrowser.Stop();
-            timerTestBrowser.Start();
-        }
-
-        private void timerTestBrowser_Tick(object sender, EventArgs e){
-            reinjectBrowserCSS(textBoxBrowserCSS.Text);
-            timerTestBrowser.Stop();
-        }
-
-        private void btnOpenWiki_Click(object sender, EventArgs e){
-            BrowserUtils.OpenExternalBrowserUnsafe("https://github.com/chylex/TweetDuck/wiki");
-        }
-
-        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.cs

@@ -1,170 +0,0 @@
-using System;
-using System.Windows.Forms;
-using TweetDuck.Core.Other.Settings.Export;
-using TweetDuck.Plugins;
-
-namespace TweetDuck.Core.Other.Settings.Dialogs{
-    sealed partial class DialogSettingsManage : Form{
-        private enum State{
-            Deciding, Import, Export
-        }
-
-        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);
-            }
-        }
-
-        public bool ShouldReloadUI { get; private set; }
-        
-        private readonly PluginManager plugins;
-        private State currentState;
-
-        private ExportManager importManager;
-        private ExportFileFlags selectedFlags = ExportFileFlags.None;
-
-        public DialogSettingsManage(PluginManager plugins){
-            InitializeComponent();
-
-            this.plugins = plugins;
-            this.currentState = State.Deciding;
-        }
-
-        private void radioDecision_CheckedChanged(object sender, EventArgs e){
-            btnContinue.Enabled = true;
-        }
-
-        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 btnContinue_Click(object sender, EventArgs e){
-            string file;
-
-            switch(currentState){
-                case State.Deciding:
-                    // Reset
-                    if (radioReset.Checked){
-                        if (FormMessage.Warning("Reset TweetDuck Options", "This will reset all of your program options. Plugins will not be affected. Do you want to proceed?", FormMessage.Yes, FormMessage.No)){
-                            Program.ResetConfig();
-
-                            ShouldReloadUI = true;
-                            DialogResult = DialogResult.OK;
-                            Close();
-                        }
-
-                        return;
-                    }
-
-                    // 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){
-                                return;
-                            }
-
-                            file = dialog.FileName;
-                        }
-
-                        importManager = new ExportManager(file, plugins);
-                        currentState = State.Import;
-
-                        Text = "Import Profile";
-                        Flags = importManager.GetImportFlags();
-
-                        cbConfig.Enabled = cbConfig.Checked;
-                        cbSession.Enabled = cbSession.Checked;
-                        cbPluginData.Enabled = cbPluginData.Checked;
-                    }
-
-                    // Export
-                    else if (radioExport.Checked){
-                        currentState = State.Export;
-
-                        Text = "Export Profile";
-                        btnContinue.Text = "Export Profile";
-                        Flags = ExportFileFlags.All & ~ExportFileFlags.Session;
-                    }
-                    
-                    // Continue...
-                    panelDecision.Visible = false;
-                    panelExport.Visible = true;
-                    break;
-
-                case State.Import:
-                    if (importManager.Import(Flags)){
-                        if (!importManager.IsRestarting){
-                            ShouldReloadUI = true;
-                        }
-                    }
-                    else{
-                        Program.Reporter.HandleException("Profile Import Error", "An exception happened while importing TweetDuck profile.", true, importManager.LastException);
-                    }
-                    
-                    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;
-                    }
-
-                    Program.UserConfig.Save();
-                    ExportManager manager = new ExportManager(file, plugins);
-
-                    if (!manager.Export(Flags)){
-                        Program.Reporter.HandleException("Profile Export Error", "An exception happened while exporting TweetDuck profile.", true, manager.LastException);
-                    }
-
-                    DialogResult = DialogResult.OK;
-                    Close();
-                    break;
-            }
-        }
-
-        private void btnCancel_Click(object sender, EventArgs e){
-            DialogResult = DialogResult.Cancel;
-            Close();
-        }
-
-        private void SetFlag(ExportFileFlags flag, bool enable){
-            selectedFlags = enable ? selectedFlags | flag : selectedFlags & ~flag;
-            btnContinue.Enabled = selectedFlags != ExportFileFlags.None;
-
-            if (currentState == State.Import){
-                btnContinue.Text = selectedFlags.HasFlag(ExportFileFlags.Session) ? "Import && Restart" : "Import Profile";
-            }
-        }
-    }
-}

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

@@ -1,159 +0,0 @@
-namespace TweetDuck.Core.Other.Settings.Dialogs {
-    partial class DialogSettingsRestart {
-        /// <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.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.SuspendLayout();
-            // 
-            // 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(160, 171);
-            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.Text = "Cancel";
-            this.btnCancel.UseVisualStyleBackColor = true;
-            this.btnCancel.Click += new System.EventHandler(this.btnCancel_Click);
-            // 
-            // btnRestart
-            // 
-            this.btnRestart.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
-            this.btnRestart.Location = new System.Drawing.Point(97, 171);
-            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.Text = "Restart";
-            this.btnRestart.UseVisualStyleBackColor = true;
-            this.btnRestart.Click += new System.EventHandler(this.btnRestart_Click);
-            // 
-            // cbLogging
-            // 
-            this.cbLogging.AutoSize = true;
-            this.cbLogging.Location = new System.Drawing.Point(12, 12);
-            this.cbLogging.Name = "cbLogging";
-            this.cbLogging.Size = new System.Drawing.Size(64, 17);
-            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.cbLogging.UseVisualStyleBackColor = true;
-            // 
-            // cbDebugUpdates
-            // 
-            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;
-            // 
-            // labelLocale
-            // 
-            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) 
-            | 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;
-            // 
-            // labelDataFolder
-            // 
-            this.labelDataFolder.AutoSize = true;
-            this.labelDataFolder.Location = new System.Drawing.Point(12, 119);
-            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.Text = "Data Folder";
-            // 
-            // tbDataFolder
-            // 
-            this.tbDataFolder.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | 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;
-            // 
-            // 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.Controls.Add(this.btnRestart);
-            this.Controls.Add(this.btnCancel);
-            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
-            this.MaximizeBox = false;
-            this.MinimizeBox = false;
-            this.Name = "DialogSettingsRestart";
-            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 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;
-    }
-}

Core/Other/Settings/Dialogs/DialogSettingsRestart.cs

@@ -1,62 +0,0 @@
-using System;
-using System.IO;
-using System.Linq;
-using System.Windows.Forms;
-using TweetDuck.Configuration;
-using TweetDuck.Data;
-
-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);
-            cbDebugUpdates.Checked = currentArgs.HasFlag(Arguments.ArgDebugUpdates);
-            comboLocale.SelectedItem = currentArgs.GetValue(Arguments.ArgLocale, DefaultLocale);
-            tbDataFolder.Text = currentArgs.GetValue(Arguments.ArgDataFolder, string.Empty);
-
-            Text = Program.BrandName+" Arguments";
-        }
-
-        private void btnRestart_Click(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)){
-                Args.SetValue(Arguments.ArgDataFolder, tbDataFolder.Text);
-            }
-
-            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 TweetDuck.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,302 +0,0 @@
-namespace TweetDuck.Core.Other.Settings {
-    partial class TabSettingsAdvanced {
-        /// <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.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();
-            this.btnRestartArgs = new System.Windows.Forms.Button();
-            this.btnRestart = new System.Windows.Forms.Button();
-            this.btnOpenAppFolder = new System.Windows.Forms.Button();
-            this.btnOpenDataFolder = new System.Windows.Forms.Button();
-            this.numMemoryThreshold = new TweetDuck.Core.Controls.NumericUpDownEx();
-            this.checkBrowserGCReload = new System.Windows.Forms.CheckBox();
-            this.labelApp = new System.Windows.Forms.Label();
-            this.panelApp = new System.Windows.Forms.Panel();
-            this.labelPerformance = new System.Windows.Forms.Label();
-            this.panelPerformance = new System.Windows.Forms.Panel();
-            this.labelMemoryUsage = new System.Windows.Forms.Label();
-            this.panelConfiguration = new System.Windows.Forms.Panel();
-            this.labelConfiguration = new System.Windows.Forms.Label();
-            ((System.ComponentModel.ISupportInitialize)(this.numMemoryThreshold)).BeginInit();
-            this.panelApp.SuspendLayout();
-            this.panelPerformance.SuspendLayout();
-            this.panelConfiguration.SuspendLayout();
-            this.SuspendLayout();
-            // 
-            // btnClearCache
-            // 
-            this.btnClearCache.Location = new System.Drawing.Point(5, 28);
-            this.btnClearCache.Margin = new System.Windows.Forms.Padding(5, 3, 3, 3);
-            this.btnClearCache.Name = "btnClearCache";
-            this.btnClearCache.Size = new System.Drawing.Size(144, 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.UseVisualStyleBackColor = true;
-            // 
-            // checkHardwareAcceleration
-            // 
-            this.checkHardwareAcceleration.AutoSize = true;
-            this.checkHardwareAcceleration.Location = new System.Drawing.Point(6, 5);
-            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(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(144, 23);
-            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(155, 3);
-            this.btnEditCSS.Name = "btnEditCSS";
-            this.btnEditCSS.Size = new System.Drawing.Size(144, 23);
-            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(155, 32);
-            this.btnRestartArgs.Name = "btnRestartArgs";
-            this.btnRestartArgs.Size = new System.Drawing.Size(144, 23);
-            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(155, 3);
-            this.btnRestart.Name = "btnRestart";
-            this.btnRestart.Size = new System.Drawing.Size(144, 23);
-            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 launch.");
-            this.btnRestart.UseVisualStyleBackColor = true;
-            // 
-            // btnOpenAppFolder
-            // 
-            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(144, 23);
-            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(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(144, 23);
-            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;
-            // 
-            // numMemoryThreshold
-            // 
-            this.numMemoryThreshold.Increment = new decimal(new int[] {
-            50,
-            0,
-            0,
-            0});
-            this.numMemoryThreshold.Location = new System.Drawing.Point(202, 82);
-            this.numMemoryThreshold.Maximum = new decimal(new int[] {
-            3000,
-            0,
-            0,
-            0});
-            this.numMemoryThreshold.Minimum = new decimal(new int[] {
-            200,
-            0,
-            0,
-            0});
-            this.numMemoryThreshold.Name = "numMemoryThreshold";
-            this.numMemoryThreshold.Size = new System.Drawing.Size(97, 20);
-            this.numMemoryThreshold.TabIndex = 4;
-            this.numMemoryThreshold.TextSuffix = " MB";
-            this.toolTip.SetToolTip(this.numMemoryThreshold, "Minimum amount of memory usage by the browser process to trigger the cleanup.\r\nThis is not a limit, the usage is allowed to exceed this value.");
-            this.numMemoryThreshold.Value = new decimal(new int[] {
-            350,
-            0,
-            0,
-            0});
-            // 
-            // checkBrowserGCReload
-            // 
-            this.checkBrowserGCReload.AutoSize = true;
-            this.checkBrowserGCReload.Location = new System.Drawing.Point(6, 84);
-            this.checkBrowserGCReload.Margin = new System.Windows.Forms.Padding(6, 5, 3, 3);
-            this.checkBrowserGCReload.Name = "checkBrowserGCReload";
-            this.checkBrowserGCReload.Size = new System.Drawing.Size(190, 17);
-            this.checkBrowserGCReload.TabIndex = 3;
-            this.checkBrowserGCReload.Text = "Enable Browser Memory Threshold";
-            this.toolTip.SetToolTip(this.checkBrowserGCReload, "Automatically reloads TweetDeck to save memory. This option only works\r\nif the browser is in a \'default state\', i.e. all modals and drawers are closed,\r\nand all columns are scrolled to top. Some notifications may be lost.");
-            this.checkBrowserGCReload.UseVisualStyleBackColor = true;
-            // 
-            // labelApp
-            // 
-            this.labelApp.AutoSize = true;
-            this.labelApp.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238)));
-            this.labelApp.Location = new System.Drawing.Point(6, 8);
-            this.labelApp.Margin = new System.Windows.Forms.Padding(0, 2, 0, 0);
-            this.labelApp.Name = "labelApp";
-            this.labelApp.Size = new System.Drawing.Size(38, 20);
-            this.labelApp.TabIndex = 0;
-            this.labelApp.Text = "App";
-            // 
-            // panelApp
-            // 
-            this.panelApp.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
-            | System.Windows.Forms.AnchorStyles.Right)));
-            this.panelApp.Controls.Add(this.btnOpenDataFolder);
-            this.panelApp.Controls.Add(this.btnOpenAppFolder);
-            this.panelApp.Controls.Add(this.btnRestart);
-            this.panelApp.Controls.Add(this.btnRestartArgs);
-            this.panelApp.Location = new System.Drawing.Point(9, 31);
-            this.panelApp.Name = "panelApp";
-            this.panelApp.Size = new System.Drawing.Size(322, 59);
-            this.panelApp.TabIndex = 1;
-            // 
-            // labelPerformance
-            // 
-            this.labelPerformance.AutoSize = true;
-            this.labelPerformance.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238)));
-            this.labelPerformance.Location = new System.Drawing.Point(6, 114);
-            this.labelPerformance.Margin = new System.Windows.Forms.Padding(0, 21, 0, 0);
-            this.labelPerformance.Name = "labelPerformance";
-            this.labelPerformance.Size = new System.Drawing.Size(100, 20);
-            this.labelPerformance.TabIndex = 2;
-            this.labelPerformance.Text = "Performance";
-            // 
-            // panelPerformance
-            // 
-            this.panelPerformance.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
-            | System.Windows.Forms.AnchorStyles.Right)));
-            this.panelPerformance.Controls.Add(this.checkBrowserGCReload);
-            this.panelPerformance.Controls.Add(this.numMemoryThreshold);
-            this.panelPerformance.Controls.Add(this.labelMemoryUsage);
-            this.panelPerformance.Controls.Add(this.checkHardwareAcceleration);
-            this.panelPerformance.Controls.Add(this.btnClearCache);
-            this.panelPerformance.Location = new System.Drawing.Point(9, 137);
-            this.panelPerformance.Name = "panelPerformance";
-            this.panelPerformance.Size = new System.Drawing.Size(322, 105);
-            this.panelPerformance.TabIndex = 3;
-            // 
-            // labelMemoryUsage
-            // 
-            this.labelMemoryUsage.AutoSize = true;
-            this.labelMemoryUsage.Location = new System.Drawing.Point(3, 66);
-            this.labelMemoryUsage.Margin = new System.Windows.Forms.Padding(3, 12, 3, 0);
-            this.labelMemoryUsage.Name = "labelMemoryUsage";
-            this.labelMemoryUsage.Size = new System.Drawing.Size(78, 13);
-            this.labelMemoryUsage.TabIndex = 2;
-            this.labelMemoryUsage.Text = "Memory Usage";
-            // 
-            // panelConfiguration
-            // 
-            this.panelConfiguration.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
-            | System.Windows.Forms.AnchorStyles.Right)));
-            this.panelConfiguration.Controls.Add(this.btnEditCSS);
-            this.panelConfiguration.Controls.Add(this.btnEditCefArgs);
-            this.panelConfiguration.Location = new System.Drawing.Point(9, 289);
-            this.panelConfiguration.Name = "panelConfiguration";
-            this.panelConfiguration.Size = new System.Drawing.Size(322, 29);
-            this.panelConfiguration.TabIndex = 5;
-            // 
-            // labelConfiguration
-            // 
-            this.labelConfiguration.AutoSize = true;
-            this.labelConfiguration.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238)));
-            this.labelConfiguration.Location = new System.Drawing.Point(6, 266);
-            this.labelConfiguration.Margin = new System.Windows.Forms.Padding(0, 21, 0, 0);
-            this.labelConfiguration.Name = "labelConfiguration";
-            this.labelConfiguration.Size = new System.Drawing.Size(104, 20);
-            this.labelConfiguration.TabIndex = 4;
-            this.labelConfiguration.Text = "Configuration";
-            // 
-            // TabSettingsAdvanced
-            // 
-            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-            this.Controls.Add(this.labelConfiguration);
-            this.Controls.Add(this.panelConfiguration);
-            this.Controls.Add(this.panelPerformance);
-            this.Controls.Add(this.labelPerformance);
-            this.Controls.Add(this.panelApp);
-            this.Controls.Add(this.labelApp);
-            this.Name = "TabSettingsAdvanced";
-            this.Size = new System.Drawing.Size(340, 328);
-            ((System.ComponentModel.ISupportInitialize)(this.numMemoryThreshold)).EndInit();
-            this.panelApp.ResumeLayout(false);
-            this.panelPerformance.ResumeLayout(false);
-            this.panelPerformance.PerformLayout();
-            this.panelConfiguration.ResumeLayout(false);
-            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 btnEditCefArgs;
-        private System.Windows.Forms.Button btnEditCSS;
-        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 panelApp;
-        private System.Windows.Forms.Label labelPerformance;
-        private System.Windows.Forms.Panel panelPerformance;
-        private System.Windows.Forms.Panel panelConfiguration;
-        private System.Windows.Forms.Label labelConfiguration;
-        private System.Windows.Forms.Label labelMemoryUsage;
-        private Controls.NumericUpDownEx numMemoryThreshold;
-        private System.Windows.Forms.CheckBox checkBrowserGCReload;
-    }
-}

Core/Other/Settings/TabSettingsAdvanced.cs

@@ -1,142 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Windows.Forms;
-using TweetDuck.Configuration;
-using TweetDuck.Core.Controls;
-using TweetDuck.Core.Other.Settings.Dialogs;
-using TweetDuck.Core.Utils;
-
-namespace TweetDuck.Core.Other.Settings{
-    partial class TabSettingsAdvanced : BaseTabSettings{
-        private readonly Action<string> reinjectBrowserCSS;
-
-        public TabSettingsAdvanced(Action<string> reinjectBrowserCSS){
-            InitializeComponent();
-
-            this.reinjectBrowserCSS = reinjectBrowserCSS;
-
-            if (SystemConfig.IsHardwareAccelerationSupported){
-                checkHardwareAcceleration.Checked = Program.SystemConfig.HardwareAcceleration;
-            }
-            else{
-                checkHardwareAcceleration.Enabled = false;
-                checkHardwareAcceleration.Checked = false;
-            }
-
-            checkBrowserGCReload.Checked = Config.EnableBrowserGCReload;
-            numMemoryThreshold.Enabled = checkBrowserGCReload.Checked;
-            numMemoryThreshold.SetValueSafe(Config.BrowserMemoryThreshold);
-
-            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)";
-                }
-            }));
-        }
-
-        public override void OnReady(){
-            btnClearCache.Click += btnClearCache_Click;
-            checkHardwareAcceleration.CheckedChanged += checkHardwareAcceleration_CheckedChanged;
-
-            checkBrowserGCReload.CheckedChanged += checkBrowserGCReload_CheckedChanged;
-            numMemoryThreshold.ValueChanged += numMemoryThreshold_ValueChanged;
-
-            btnEditCefArgs.Click += btnEditCefArgs_Click;
-            btnEditCSS.Click += btnEditCSS_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();
-            FormMessage.Information("Clear Cache", "Cache will be automatically cleared when TweetDuck exits.", FormMessage.OK);
-        }
-
-        private void checkHardwareAcceleration_CheckedChanged(object sender, EventArgs e){
-            Program.SystemConfig.HardwareAcceleration = checkHardwareAcceleration.Checked;
-            Program.SystemConfig.Save();
-            PromptRestart();
-        }
-
-        private void checkBrowserGCReload_CheckedChanged(object sender, EventArgs e){
-            Config.EnableBrowserGCReload = checkBrowserGCReload.Checked;
-            numMemoryThreshold.Enabled = checkBrowserGCReload.Checked;
-        }
-
-        private void numMemoryThreshold_ValueChanged(object sender, EventArgs e){
-            Config.BrowserMemoryThreshold = (int)numMemoryThreshold.Value;
-        }
-
-        private void btnEditCefArgs_Click(object sender, EventArgs e){
-            DialogSettingsCefArgs form = new DialogSettingsCefArgs();
-
-            form.VisibleChanged += (sender2, args2) => {
-                form.MoveToCenter(ParentForm);
-            };
-
-            form.FormClosed += (sender2, args2) => {
-                NativeMethods.SetFormDisabled(ParentForm, false);
-
-                if (form.DialogResult == DialogResult.OK){
-                    Config.CustomCefArgs = form.CefArgs;
-                    PromptRestart();
-                    form.Dispose();
-                }
-                else form.Dispose();
-            };
-            
-            form.Show(ParentForm);
-            NativeMethods.SetFormDisabled(ParentForm, true);
-        }
-
-        private void btnEditCSS_Click(object sender, EventArgs e){
-            DialogSettingsCSS form = new DialogSettingsCSS(reinjectBrowserCSS);
-
-            form.VisibleChanged += (sender2, args2) => {
-                form.MoveToCenter(ParentForm);
-            };
-
-            form.FormClosed += (sender2, args2) => {
-                NativeMethods.SetFormDisabled(ParentForm, false);
-
-                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 btnOpenAppFolder_Click(object sender, EventArgs e){
-            using(Process.Start("explorer.exe", "\""+Program.ProgramPath+"\"")){}
-        }
-
-        private void btnOpenDataFolder_Click(object sender, EventArgs e){
-            using(Process.Start("explorer.exe", "\""+Program.StoragePath+"\"")){}
-        }
-
-        private void btnRestart_Click(object sender, EventArgs e){
-            Program.Restart();
-        }
-
-        private void btnRestartArgs_Click(object sender, EventArgs e){
-            using(DialogSettingsRestart dialog = new DialogSettingsRestart(Arguments.GetCurrentClean())){
-                if (dialog.ShowDialog() == DialogResult.OK){
-                    Program.RestartWithArgs(dialog.Args);
-                }
-            }
-        }
-    }
-}

Core/Other/Settings/TabSettingsGeneral.Designer.cs

@@ -1,318 +0,0 @@
-namespace TweetDuck.Core.Other.Settings {
-    partial class TabSettingsGeneral {
-        /// <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.components = new System.ComponentModel.Container();
-            this.checkExpandLinks = new System.Windows.Forms.CheckBox();
-            this.comboBoxTrayType = new System.Windows.Forms.ComboBox();
-            this.toolTip = new System.Windows.Forms.ToolTip(this.components);
-            this.checkTrayHighlight = new System.Windows.Forms.CheckBox();
-            this.checkSpellCheck = new System.Windows.Forms.CheckBox();
-            this.checkUpdateNotifications = new System.Windows.Forms.CheckBox();
-            this.btnCheckUpdates = new System.Windows.Forms.Button();
-            this.labelZoomValue = new System.Windows.Forms.Label();
-            this.checkSwitchAccountSelectors = new System.Windows.Forms.CheckBox();
-            this.labelTrayIcon = new System.Windows.Forms.Label();
-            this.trackBarZoom = new System.Windows.Forms.TrackBar();
-            this.labelZoom = new System.Windows.Forms.Label();
-            this.zoomUpdateTimer = new System.Windows.Forms.Timer(this.components);
-            this.labelUI = new System.Windows.Forms.Label();
-            this.panelUI = new System.Windows.Forms.Panel();
-            this.labelTray = new System.Windows.Forms.Label();
-            this.panelUpdates = new System.Windows.Forms.Panel();
-            this.panelTray = new System.Windows.Forms.Panel();
-            this.labelUpdates = new System.Windows.Forms.Label();
-            this.checkBestImageQuality = new System.Windows.Forms.CheckBox();
-            ((System.ComponentModel.ISupportInitialize)(this.trackBarZoom)).BeginInit();
-            this.panelUI.SuspendLayout();
-            this.panelUpdates.SuspendLayout();
-            this.panelTray.SuspendLayout();
-            this.SuspendLayout();
-            // 
-            // checkExpandLinks
-            // 
-            this.checkExpandLinks.AutoSize = true;
-            this.checkExpandLinks.Location = new System.Drawing.Point(6, 5);
-            this.checkExpandLinks.Margin = new System.Windows.Forms.Padding(6, 5, 3, 3);
-            this.checkExpandLinks.Name = "checkExpandLinks";
-            this.checkExpandLinks.Size = new System.Drawing.Size(166, 17);
-            this.checkExpandLinks.TabIndex = 0;
-            this.checkExpandLinks.Text = "Expand Links When Hovered";
-            this.toolTip.SetToolTip(this.checkExpandLinks, "Expands links inside the tweets. If disabled,\r\nthe full links show up in a tooltip instead.");
-            this.checkExpandLinks.UseVisualStyleBackColor = true;
-            // 
-            // comboBoxTrayType
-            // 
-            this.comboBoxTrayType.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
-            this.comboBoxTrayType.FormattingEnabled = true;
-            this.comboBoxTrayType.Location = new System.Drawing.Point(5, 5);
-            this.comboBoxTrayType.Margin = new System.Windows.Forms.Padding(5, 5, 3, 3);
-            this.comboBoxTrayType.Name = "comboBoxTrayType";
-            this.comboBoxTrayType.Size = new System.Drawing.Size(144, 21);
-            this.comboBoxTrayType.TabIndex = 0;
-            this.toolTip.SetToolTip(this.comboBoxTrayType, "Changes behavior of the Tray icon.\r\nRight-click the icon for an action menu.");
-            // 
-            // checkTrayHighlight
-            // 
-            this.checkTrayHighlight.AutoSize = true;
-            this.checkTrayHighlight.Location = new System.Drawing.Point(6, 56);
-            this.checkTrayHighlight.Margin = new System.Windows.Forms.Padding(6, 5, 3, 3);
-            this.checkTrayHighlight.Name = "checkTrayHighlight";
-            this.checkTrayHighlight.Size = new System.Drawing.Size(103, 17);
-            this.checkTrayHighlight.TabIndex = 2;
-            this.checkTrayHighlight.Text = "Enable Highlight";
-            this.toolTip.SetToolTip(this.checkTrayHighlight, "Highlights the tray icon if there are new tweets.\r\nOnly works for columns with popup or audio notifications.\r\nThe icon resets when the main window is restored.");
-            this.checkTrayHighlight.UseVisualStyleBackColor = true;
-            // 
-            // checkSpellCheck
-            // 
-            this.checkSpellCheck.AutoSize = true;
-            this.checkSpellCheck.Location = new System.Drawing.Point(6, 74);
-            this.checkSpellCheck.Margin = new System.Windows.Forms.Padding(6, 3, 3, 3);
-            this.checkSpellCheck.Name = "checkSpellCheck";
-            this.checkSpellCheck.Size = new System.Drawing.Size(119, 17);
-            this.checkSpellCheck.TabIndex = 3;
-            this.checkSpellCheck.Text = "Enable Spell Check";
-            this.toolTip.SetToolTip(this.checkSpellCheck, "Underlines words that are spelled incorrectly.");
-            this.checkSpellCheck.UseVisualStyleBackColor = true;
-            // 
-            // checkUpdateNotifications
-            // 
-            this.checkUpdateNotifications.AutoSize = true;
-            this.checkUpdateNotifications.Location = new System.Drawing.Point(6, 5);
-            this.checkUpdateNotifications.Margin = new System.Windows.Forms.Padding(6, 5, 3, 3);
-            this.checkUpdateNotifications.Name = "checkUpdateNotifications";
-            this.checkUpdateNotifications.Size = new System.Drawing.Size(165, 17);
-            this.checkUpdateNotifications.TabIndex = 0;
-            this.checkUpdateNotifications.Text = "Check Updates Automatically";
-            this.toolTip.SetToolTip(this.checkUpdateNotifications, "Checks for updates every hour.\r\nIf an update is dismissed, it will not appear again.");
-            this.checkUpdateNotifications.UseVisualStyleBackColor = true;
-            // 
-            // btnCheckUpdates
-            // 
-            this.btnCheckUpdates.Location = new System.Drawing.Point(5, 28);
-            this.btnCheckUpdates.Margin = new System.Windows.Forms.Padding(5, 3, 3, 3);
-            this.btnCheckUpdates.Name = "btnCheckUpdates";
-            this.btnCheckUpdates.Size = new System.Drawing.Size(144, 23);
-            this.btnCheckUpdates.TabIndex = 1;
-            this.btnCheckUpdates.Text = "Check Updates Now";
-            this.toolTip.SetToolTip(this.btnCheckUpdates, "Forces an update check, even for updates that had been dismissed.");
-            this.btnCheckUpdates.UseVisualStyleBackColor = true;
-            // 
-            // labelZoomValue
-            // 
-            this.labelZoomValue.BackColor = System.Drawing.Color.Transparent;
-            this.labelZoomValue.Location = new System.Drawing.Point(141, 123);
-            this.labelZoomValue.Margin = new System.Windows.Forms.Padding(0, 0, 3, 0);
-            this.labelZoomValue.Name = "labelZoomValue";
-            this.labelZoomValue.Size = new System.Drawing.Size(38, 13);
-            this.labelZoomValue.TabIndex = 6;
-            this.labelZoomValue.Text = "100%";
-            this.labelZoomValue.TextAlign = System.Drawing.ContentAlignment.TopRight;
-            this.toolTip.SetToolTip(this.labelZoomValue, "Changes the zoom level.\r\nAlso affects notifications and screenshots.");
-            // 
-            // checkSwitchAccountSelectors
-            // 
-            this.checkSwitchAccountSelectors.AutoSize = true;
-            this.checkSwitchAccountSelectors.Location = new System.Drawing.Point(6, 28);
-            this.checkSwitchAccountSelectors.Margin = new System.Windows.Forms.Padding(6, 3, 3, 3);
-            this.checkSwitchAccountSelectors.Name = "checkSwitchAccountSelectors";
-            this.checkSwitchAccountSelectors.Size = new System.Drawing.Size(172, 17);
-            this.checkSwitchAccountSelectors.TabIndex = 1;
-            this.checkSwitchAccountSelectors.Text = "Shift Selects Multiple Accounts";
-            this.toolTip.SetToolTip(this.checkSwitchAccountSelectors, "When (re)tweeting, click to select a single account or hold Shift to\r\nselect multiple accounts, instead of TweetDeck\'s default behavior.");
-            this.checkSwitchAccountSelectors.UseVisualStyleBackColor = true;
-            // 
-            // labelTrayIcon
-            // 
-            this.labelTrayIcon.AutoSize = true;
-            this.labelTrayIcon.Location = new System.Drawing.Point(3, 38);
-            this.labelTrayIcon.Margin = new System.Windows.Forms.Padding(3, 9, 3, 0);
-            this.labelTrayIcon.Name = "labelTrayIcon";
-            this.labelTrayIcon.Size = new System.Drawing.Size(52, 13);
-            this.labelTrayIcon.TabIndex = 1;
-            this.labelTrayIcon.Text = "Tray Icon";
-            // 
-            // trackBarZoom
-            // 
-            this.trackBarZoom.AutoSize = false;
-            this.trackBarZoom.BackColor = System.Drawing.SystemColors.Control;
-            this.trackBarZoom.LargeChange = 25;
-            this.trackBarZoom.Location = new System.Drawing.Point(3, 122);
-            this.trackBarZoom.Maximum = 200;
-            this.trackBarZoom.Minimum = 50;
-            this.trackBarZoom.Name = "trackBarZoom";
-            this.trackBarZoom.Size = new System.Drawing.Size(148, 30);
-            this.trackBarZoom.SmallChange = 5;
-            this.trackBarZoom.TabIndex = 5;
-            this.trackBarZoom.TickFrequency = 25;
-            this.trackBarZoom.Value = 100;
-            // 
-            // labelZoom
-            // 
-            this.labelZoom.AutoSize = true;
-            this.labelZoom.Location = new System.Drawing.Point(3, 106);
-            this.labelZoom.Margin = new System.Windows.Forms.Padding(3, 12, 3, 0);
-            this.labelZoom.Name = "labelZoom";
-            this.labelZoom.Size = new System.Drawing.Size(34, 13);
-            this.labelZoom.TabIndex = 4;
-            this.labelZoom.Text = "Zoom";
-            // 
-            // zoomUpdateTimer
-            // 
-            this.zoomUpdateTimer.Interval = 250;
-            this.zoomUpdateTimer.Tick += new System.EventHandler(this.zoomUpdateTimer_Tick);
-            // 
-            // labelUI
-            // 
-            this.labelUI.AutoSize = true;
-            this.labelUI.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238)));
-            this.labelUI.Location = new System.Drawing.Point(6, 8);
-            this.labelUI.Margin = new System.Windows.Forms.Padding(0, 2, 0, 0);
-            this.labelUI.Name = "labelUI";
-            this.labelUI.Size = new System.Drawing.Size(111, 20);
-            this.labelUI.TabIndex = 0;
-            this.labelUI.Text = "User Interface";
-            // 
-            // panelUI
-            // 
-            this.panelUI.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
-            | System.Windows.Forms.AnchorStyles.Right)));
-            this.panelUI.Controls.Add(this.checkBestImageQuality);
-            this.panelUI.Controls.Add(this.checkExpandLinks);
-            this.panelUI.Controls.Add(this.checkSwitchAccountSelectors);
-            this.panelUI.Controls.Add(this.checkSpellCheck);
-            this.panelUI.Controls.Add(this.labelZoom);
-            this.panelUI.Controls.Add(this.labelZoomValue);
-            this.panelUI.Controls.Add(this.trackBarZoom);
-            this.panelUI.Location = new System.Drawing.Point(9, 31);
-            this.panelUI.Name = "panelUI";
-            this.panelUI.Size = new System.Drawing.Size(322, 157);
-            this.panelUI.TabIndex = 1;
-            // 
-            // labelTray
-            // 
-            this.labelTray.AutoSize = true;
-            this.labelTray.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238)));
-            this.labelTray.Location = new System.Drawing.Point(6, 212);
-            this.labelTray.Margin = new System.Windows.Forms.Padding(0, 21, 0, 0);
-            this.labelTray.Name = "labelTray";
-            this.labelTray.Size = new System.Drawing.Size(96, 20);
-            this.labelTray.TabIndex = 2;
-            this.labelTray.Text = "System Tray";
-            // 
-            // panelUpdates
-            // 
-            this.panelUpdates.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
-            | System.Windows.Forms.AnchorStyles.Right)));
-            this.panelUpdates.Controls.Add(this.checkUpdateNotifications);
-            this.panelUpdates.Controls.Add(this.btnCheckUpdates);
-            this.panelUpdates.Location = new System.Drawing.Point(9, 358);
-            this.panelUpdates.Name = "panelUpdates";
-            this.panelUpdates.Size = new System.Drawing.Size(322, 55);
-            this.panelUpdates.TabIndex = 5;
-            // 
-            // panelTray
-            // 
-            this.panelTray.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
-            | System.Windows.Forms.AnchorStyles.Right)));
-            this.panelTray.Controls.Add(this.checkTrayHighlight);
-            this.panelTray.Controls.Add(this.comboBoxTrayType);
-            this.panelTray.Controls.Add(this.labelTrayIcon);
-            this.panelTray.Location = new System.Drawing.Point(9, 235);
-            this.panelTray.Name = "panelTray";
-            this.panelTray.Size = new System.Drawing.Size(322, 76);
-            this.panelTray.TabIndex = 3;
-            // 
-            // labelUpdates
-            // 
-            this.labelUpdates.AutoSize = true;
-            this.labelUpdates.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238)));
-            this.labelUpdates.Location = new System.Drawing.Point(6, 335);
-            this.labelUpdates.Margin = new System.Windows.Forms.Padding(0, 21, 0, 0);
-            this.labelUpdates.Name = "labelUpdates";
-            this.labelUpdates.Size = new System.Drawing.Size(70, 20);
-            this.labelUpdates.TabIndex = 4;
-            this.labelUpdates.Text = "Updates";
-            // 
-            // checkBestImageQuality
-            // 
-            this.checkBestImageQuality.AutoSize = true;
-            this.checkBestImageQuality.Location = new System.Drawing.Point(6, 51);
-            this.checkBestImageQuality.Margin = new System.Windows.Forms.Padding(6, 3, 3, 3);
-            this.checkBestImageQuality.Name = "checkBestImageQuality";
-            this.checkBestImageQuality.Size = new System.Drawing.Size(114, 17);
-            this.checkBestImageQuality.TabIndex = 2;
-            this.checkBestImageQuality.Text = "Best Image Quality";
-            this.toolTip.SetToolTip(this.checkBestImageQuality, "When right-clicking a tweet image, the context menu options\r\nwill use links to the original image size (:orig in the URL).");
-            this.checkBestImageQuality.UseVisualStyleBackColor = true;
-            // 
-            // TabSettingsGeneral
-            // 
-            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-            this.Controls.Add(this.labelUpdates);
-            this.Controls.Add(this.panelTray);
-            this.Controls.Add(this.panelUpdates);
-            this.Controls.Add(this.labelTray);
-            this.Controls.Add(this.panelUI);
-            this.Controls.Add(this.labelUI);
-            this.Name = "TabSettingsGeneral";
-            this.Size = new System.Drawing.Size(340, 422);
-            ((System.ComponentModel.ISupportInitialize)(this.trackBarZoom)).EndInit();
-            this.panelUI.ResumeLayout(false);
-            this.panelUI.PerformLayout();
-            this.panelUpdates.ResumeLayout(false);
-            this.panelUpdates.PerformLayout();
-            this.panelTray.ResumeLayout(false);
-            this.panelTray.PerformLayout();
-            this.ResumeLayout(false);
-            this.PerformLayout();
-
-        }
-
-        #endregion
-
-        private System.Windows.Forms.CheckBox checkExpandLinks;
-        private System.Windows.Forms.ComboBox comboBoxTrayType;
-        private System.Windows.Forms.ToolTip toolTip;
-        private System.Windows.Forms.Label labelTrayIcon;
-        private System.Windows.Forms.CheckBox checkTrayHighlight;
-        private System.Windows.Forms.CheckBox checkSpellCheck;
-        private System.Windows.Forms.CheckBox checkUpdateNotifications;
-        private System.Windows.Forms.Button btnCheckUpdates;
-        private System.Windows.Forms.Label labelZoom;
-        private System.Windows.Forms.Label labelZoomValue;
-        private System.Windows.Forms.TrackBar trackBarZoom;
-        private System.Windows.Forms.Timer zoomUpdateTimer;
-        private System.Windows.Forms.CheckBox checkSwitchAccountSelectors;
-        private System.Windows.Forms.Label labelUI;
-        private System.Windows.Forms.Panel panelUI;
-        private System.Windows.Forms.Label labelTray;
-        private System.Windows.Forms.Panel panelUpdates;
-        private System.Windows.Forms.Panel panelTray;
-        private System.Windows.Forms.Label labelUpdates;
-        private System.Windows.Forms.CheckBox checkBestImageQuality;
-    }
-}

Core/Other/Settings/TabSettingsGeneral.cs

@@ -1,122 +0,0 @@
-using System;
-using TweetDuck.Core.Controls;
-using TweetDuck.Updates;
-using TweetDuck.Updates.Events;
-
-namespace TweetDuck.Core.Other.Settings{
-    partial class TabSettingsGeneral : BaseTabSettings{
-        private readonly UpdateHandler updates;
-        private int updateCheckEventId = -1;
-
-        public TabSettingsGeneral(UpdateHandler updates){
-            InitializeComponent();
-
-            this.updates = updates;
-            this.updates.CheckFinished += updates_CheckFinished;
-            Disposed += (sender, args) => this.updates.CheckFinished -= updates_CheckFinished;
-            
-            comboBoxTrayType.Items.Add("Disabled");
-            comboBoxTrayType.Items.Add("Display Icon Only");
-            comboBoxTrayType.Items.Add("Minimize to Tray");
-            comboBoxTrayType.Items.Add("Close to Tray");
-            comboBoxTrayType.Items.Add("Combined");
-            comboBoxTrayType.SelectedIndex = Math.Min(Math.Max((int)Config.TrayBehavior, 0), comboBoxTrayType.Items.Count-1);
-            
-            toolTip.SetToolTip(trackBarZoom, toolTip.GetToolTip(labelZoomValue));
-            trackBarZoom.SetValueSafe(Config.ZoomLevel);
-            labelZoomValue.Text = trackBarZoom.Value+"%";
-
-            checkExpandLinks.Checked = Config.ExpandLinksOnHover;
-            checkSwitchAccountSelectors.Checked = Config.SwitchAccountSelectors;
-            checkBestImageQuality.Checked = Config.BestImageQuality;
-            checkSpellCheck.Checked = Config.EnableSpellCheck;
-            checkTrayHighlight.Checked = Config.EnableTrayHighlight;
-
-            checkUpdateNotifications.Checked = Config.EnableUpdateCheck;
-        }
-
-        public override void OnReady(){
-            checkExpandLinks.CheckedChanged += checkExpandLinks_CheckedChanged;
-            checkSwitchAccountSelectors.CheckedChanged += checkSwitchAccountSelectors_CheckedChanged;
-            checkBestImageQuality.CheckedChanged += checkBestImageQuality_CheckedChanged;
-            checkSpellCheck.CheckedChanged += checkSpellCheck_CheckedChanged;
-            trackBarZoom.ValueChanged += trackBarZoom_ValueChanged;
-
-            comboBoxTrayType.SelectedIndexChanged += comboBoxTrayType_SelectedIndexChanged;
-            checkTrayHighlight.CheckedChanged += checkTrayHighlight_CheckedChanged;
-
-            checkUpdateNotifications.CheckedChanged += checkUpdateNotifications_CheckedChanged;
-            btnCheckUpdates.Click += btnCheckUpdates_Click;
-        }
-
-        public override void OnClosing(){
-            Config.ZoomLevel = trackBarZoom.Value;
-        }
-
-        private void checkExpandLinks_CheckedChanged(object sender, EventArgs e){
-            Config.ExpandLinksOnHover = checkExpandLinks.Checked;
-        }
-
-        private void checkSwitchAccountSelectors_CheckedChanged(object sender, EventArgs e){
-            Config.SwitchAccountSelectors = checkSwitchAccountSelectors.Checked;
-        }
-
-        private void checkBestImageQuality_CheckedChanged(object sender, EventArgs e){
-            Config.BestImageQuality = checkBestImageQuality.Checked;
-        }
-
-        private void checkSpellCheck_CheckedChanged(object sender, EventArgs e){
-            Config.EnableSpellCheck = checkSpellCheck.Checked;
-            PromptRestart();
-        }
-
-        private void trackBarZoom_ValueChanged(object sender, EventArgs e){
-            if (trackBarZoom.AlignValueToTick()){
-                zoomUpdateTimer.Stop();
-                zoomUpdateTimer.Start();
-                labelZoomValue.Text = trackBarZoom.Value+"%";
-            }
-        }
-
-        private void comboBoxTrayType_SelectedIndexChanged(object sender, EventArgs e){
-            Config.TrayBehavior = (TrayIcon.Behavior)comboBoxTrayType.SelectedIndex;
-        }
-
-        private void checkTrayHighlight_CheckedChanged(object sender, EventArgs e){
-            Config.EnableTrayHighlight = checkTrayHighlight.Checked;
-        }
-
-        private void checkUpdateNotifications_CheckedChanged(object sender, EventArgs e){
-            Config.EnableUpdateCheck = checkUpdateNotifications.Checked;
-        }
-
-        private void btnCheckUpdates_Click(object sender, EventArgs e){
-            updateCheckEventId = updates.Check(true);
-
-            if (updateCheckEventId == -1){
-                FormMessage.Warning("Unsupported System", "Sorry, your system is no longer supported.", FormMessage.OK);
-            }
-            else{
-                btnCheckUpdates.Enabled = false;
-                updates.DismissUpdate(string.Empty);
-            }
-        }
-
-        private void updates_CheckFinished(object sender, UpdateCheckEventArgs e){
-            this.InvokeAsyncSafe(() => {
-                if (e.EventId == updateCheckEventId){
-                    btnCheckUpdates.Enabled = true;
-
-                    if (!e.UpdateAvailable){
-                        FormMessage.Information("No Updates Available", "Your version of TweetDuck is up to date.", FormMessage.OK);
-                    }
-                }
-            });
-        }
-
-        private void zoomUpdateTimer_Tick(object sender, EventArgs e){
-            Config.ZoomLevel = trackBarZoom.Value;
-            zoomUpdateTimer.Stop();
-        }
-    }
-}

Core/Other/Settings/TabSettingsSounds.Designer.cs

@@ -1,131 +0,0 @@
-namespace TweetDuck.Core.Other.Settings {
-    partial class TabSettingsSounds {
-        /// <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.components = new System.ComponentModel.Container();
-            this.toolTip = new System.Windows.Forms.ToolTip(this.components);
-            this.btnPlaySound = new System.Windows.Forms.Button();
-            this.btnResetSound = new System.Windows.Forms.Button();
-            this.btnBrowseSound = new System.Windows.Forms.Button();
-            this.tbCustomSound = new System.Windows.Forms.TextBox();
-            this.labelSoundNotification = new System.Windows.Forms.Label();
-            this.panelSoundNotification = new System.Windows.Forms.Panel();
-            this.panelSoundNotification.SuspendLayout();
-            this.SuspendLayout();
-            // 
-            // btnPlaySound
-            // 
-            this.btnPlaySound.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
-            this.btnPlaySound.AutoSize = true;
-            this.btnPlaySound.Location = new System.Drawing.Point(203, 29);
-            this.btnPlaySound.Name = "btnPlaySound";
-            this.btnPlaySound.Padding = new System.Windows.Forms.Padding(3, 0, 3, 0);
-            this.btnPlaySound.Size = new System.Drawing.Size(43, 23);
-            this.btnPlaySound.TabIndex = 2;
-            this.btnPlaySound.Text = "Play";
-            this.btnPlaySound.UseVisualStyleBackColor = true;
-            // 
-            // btnResetSound
-            // 
-            this.btnResetSound.AutoSize = true;
-            this.btnResetSound.Location = new System.Drawing.Point(3, 29);
-            this.btnResetSound.Name = "btnResetSound";
-            this.btnResetSound.Padding = new System.Windows.Forms.Padding(3, 0, 3, 0);
-            this.btnResetSound.Size = new System.Drawing.Size(51, 23);
-            this.btnResetSound.TabIndex = 3;
-            this.btnResetSound.Text = "Reset";
-            this.btnResetSound.UseVisualStyleBackColor = true;
-            // 
-            // btnBrowseSound
-            // 
-            this.btnBrowseSound.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
-            this.btnBrowseSound.AutoSize = true;
-            this.btnBrowseSound.Location = new System.Drawing.Point(252, 29);
-            this.btnBrowseSound.Name = "btnBrowseSound";
-            this.btnBrowseSound.Padding = new System.Windows.Forms.Padding(3, 0, 3, 0);
-            this.btnBrowseSound.Size = new System.Drawing.Size(67, 23);
-            this.btnBrowseSound.TabIndex = 1;
-            this.btnBrowseSound.Text = "Browse...";
-            this.btnBrowseSound.UseVisualStyleBackColor = true;
-            // 
-            // tbCustomSound
-            // 
-            this.tbCustomSound.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
-            | System.Windows.Forms.AnchorStyles.Right)));
-            this.tbCustomSound.Location = new System.Drawing.Point(3, 3);
-            this.tbCustomSound.Name = "tbCustomSound";
-            this.tbCustomSound.Size = new System.Drawing.Size(316, 20);
-            this.tbCustomSound.TabIndex = 0;
-            this.toolTip.SetToolTip(this.tbCustomSound, "When empty, the default TweetDeck sound notification is used.");
-            // 
-            // labelSoundNotification
-            // 
-            this.labelSoundNotification.AutoSize = true;
-            this.labelSoundNotification.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238)));
-            this.labelSoundNotification.Location = new System.Drawing.Point(6, 8);
-            this.labelSoundNotification.Margin = new System.Windows.Forms.Padding(0, 2, 0, 0);
-            this.labelSoundNotification.Name = "labelSoundNotification";
-            this.labelSoundNotification.Size = new System.Drawing.Size(198, 20);
-            this.labelSoundNotification.TabIndex = 1;
-            this.labelSoundNotification.Text = "Custom Sound Notification";
-            // 
-            // panelSoundNotification
-            // 
-            this.panelSoundNotification.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
-            | System.Windows.Forms.AnchorStyles.Right)));
-            this.panelSoundNotification.Controls.Add(this.btnPlaySound);
-            this.panelSoundNotification.Controls.Add(this.tbCustomSound);
-            this.panelSoundNotification.Controls.Add(this.btnResetSound);
-            this.panelSoundNotification.Controls.Add(this.btnBrowseSound);
-            this.panelSoundNotification.Location = new System.Drawing.Point(9, 31);
-            this.panelSoundNotification.Name = "panelSoundNotification";
-            this.panelSoundNotification.Size = new System.Drawing.Size(322, 56);
-            this.panelSoundNotification.TabIndex = 2;
-            // 
-            // TabSettingsSounds
-            // 
-            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-            this.Controls.Add(this.panelSoundNotification);
-            this.Controls.Add(this.labelSoundNotification);
-            this.Name = "TabSettingsSounds";
-            this.Size = new System.Drawing.Size(340, 97);
-            this.panelSoundNotification.ResumeLayout(false);
-            this.panelSoundNotification.PerformLayout();
-            this.ResumeLayout(false);
-            this.PerformLayout();
-
-        }
-
-        #endregion
-
-        private System.Windows.Forms.ToolTip toolTip;
-        private System.Windows.Forms.Button btnResetSound;
-        private System.Windows.Forms.Button btnBrowseSound;
-        private System.Windows.Forms.TextBox tbCustomSound;
-        private System.Windows.Forms.Button btnPlaySound;
-        private System.Windows.Forms.Label labelSoundNotification;
-        private System.Windows.Forms.Panel panelSoundNotification;
-    }
-}

Core/Other/Settings/TabSettingsSounds.cs

@@ -1,67 +0,0 @@
-using System;
-using System.Drawing;
-using System.IO;
-using System.Windows.Forms;
-using TweetDuck.Core.Notification;
-using TweetLib.Audio;
-
-namespace TweetDuck.Core.Other.Settings{
-    partial class TabSettingsSounds : BaseTabSettings{
-        private readonly SoundNotification soundNotification;
-
-        public TabSettingsSounds(){
-            InitializeComponent();
-
-            soundNotification = new SoundNotification();
-            soundNotification.PlaybackError += sound_PlaybackError;
-
-            tbCustomSound.Text = Config.NotificationSoundPath;
-            tbCustomSound_TextChanged(tbCustomSound, new EventArgs());
-
-            Disposed += (sender, args) => soundNotification.Dispose();
-        }
-
-        public override void OnReady(){
-            tbCustomSound.TextChanged += tbCustomSound_TextChanged;
-            btnPlaySound.Click += btnPlaySound_Click;
-            btnBrowseSound.Click += btnBrowseSound_Click;
-            btnResetSound.Click += btnResetSound_Click;
-        }
-
-        public override void OnClosing(){
-            Config.NotificationSoundPath = tbCustomSound.Text;
-        }
-
-        private void tbCustomSound_TextChanged(object sender, EventArgs e){
-            bool isEmpty = string.IsNullOrEmpty(tbCustomSound.Text);
-            tbCustomSound.ForeColor = isEmpty || File.Exists(tbCustomSound.Text) ? SystemColors.WindowText : Color.Maroon;
-            btnPlaySound.Enabled = !isEmpty;
-            btnResetSound.Enabled = !isEmpty;
-        }
-
-        private void btnPlaySound_Click(object sender, EventArgs e){
-            soundNotification.Play(tbCustomSound.Text);
-        }
-
-        private void sound_PlaybackError(object sender, PlaybackErrorEventArgs e){
-            FormMessage.Error("Notification Sound Error", "Could not play custom notification sound.\n"+e.Message, FormMessage.OK);
-        }
-
-        private void btnBrowseSound_Click(object sender, EventArgs e){
-            using(OpenFileDialog dialog = new OpenFileDialog{
-                AutoUpgradeEnabled = true,
-                DereferenceLinks = true,
-                Title = "Custom Notification Sound",
-                Filter = "Sound file ("+soundNotification.SupportedFormats+")|"+soundNotification.SupportedFormats+"|All files (*.*)|*.*"
-            }){
-                if (dialog.ShowDialog() == DialogResult.OK){
-                    tbCustomSound.Text = dialog.FileName;
-                }
-            }
-        }
-
-        private void btnResetSound_Click(object sender, EventArgs e){
-            tbCustomSound.Text = string.Empty;
-        }
-    }
-}

Core/Utils/BrowserCache.cs

@@ -1,50 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Threading.Tasks;
-using System.Linq;
-
-namespace TweetDuck.Core.Utils{
-    static class BrowserCache{
-        private static bool ClearOnExit { get; set; }
-
-        private static readonly string CacheFolder = Path.Combine(Program.StoragePath, "Cache");
-
-        private static IEnumerable<string> CacheFiles{
-            get{
-                return Directory.EnumerateFiles(CacheFolder);
-            }
-        }
-
-        public static void CalculateCacheSize(Action<long> callbackBytes){
-            Task<long> task = new Task<long>(() => {
-                return CacheFiles.Select(file => {
-                    try{
-                        return new FileInfo(file).Length;
-                    }catch{
-                        return 0L;
-                    }
-                }).Sum();
-            });
-            
-            task.ContinueWith(originalTask => callbackBytes(originalTask.Exception == null ? originalTask.Result : -1L), TaskContinuationOptions.ExecuteSynchronously);
-            task.Start();
-        }
-
-        public static void SetClearOnExit(){
-            ClearOnExit = true;
-        }
-
-        public static void Exit(){
-            if (ClearOnExit){
-                foreach(string file in CacheFiles){
-                    try{
-                        File.Delete(file);
-                    }catch{
-                        // welp, too bad
-                    }
-                }
-            }
-        }
-    }
-}

Core/Utils/BrowserProcesses.cs

@@ -1,26 +0,0 @@
-using System.Collections.Generic;
-using System.Diagnostics;
-using CefSharp;
-
-namespace TweetDuck.Core.Utils{
-    static class BrowserProcesses{
-        private static readonly Dictionary<int, int> PIDs = new Dictionary<int, int>();
-
-        public static void Link(int identifier, int pid){
-            PIDs[identifier] = pid;
-        }
-
-        public static void Forget(int identifier){
-            PIDs.Remove(identifier);
-        }
-        
-        public static Process FindProcess(IBrowser browser){
-            if (PIDs.TryGetValue(browser.Identifier, out int pid) && WindowsUtils.IsChildProcess(pid)){ // child process is checked in two places for safety
-                return Process.GetProcessById(pid);
-            }
-            else{
-                return null;
-            }
-        }
-    }
-}

Core/Utils/BrowserUtils.cs

@@ -1,116 +0,0 @@
-using CefSharp;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Net;
-using System.Windows.Forms;
-using TweetDuck.Core.Other;
-
-namespace TweetDuck.Core.Utils{
-    static class BrowserUtils{
-        public static string HeaderAcceptLanguage{
-            get{
-                string culture = Program.Culture.Name;
-
-                if (culture == "en"){
-                    return "en-us,en";
-                }
-                else{
-                    return culture.ToLower()+",en;q=0.9";
-                }
-            }
-        }
-
-        public static string HeaderUserAgent => Program.BrandName+" "+Application.ProductVersion;
-
-        public static void SetupCefArgs(IDictionary<string, string> args){
-            if (!Program.SystemConfig.HardwareAcceleration){
-                args["disable-gpu"] = "1";
-                args["disable-gpu-vsync"] = "1";
-            }
-            
-            args["disable-extensions"] = "1";
-            args["disable-plugins-discovery"] = "1";
-            args["enable-system-flash"] = "0";
-
-            if (args.TryGetValue("js-flags", out string jsFlags)){
-                args["js-flags"] = "--expose-gc "+jsFlags;
-            }
-            else{
-                args["js-flags"] = "--expose-gc";
-            }
-        }
-
-        public static bool IsValidUrl(string url){
-            if (Uri.TryCreate(url, UriKind.Absolute, out Uri uri)){
-                string scheme = uri.Scheme;
-                return scheme == Uri.UriSchemeHttp || scheme == Uri.UriSchemeHttps || scheme == Uri.UriSchemeFtp || scheme == Uri.UriSchemeMailto;
-            }
-
-            return false;
-        }
-
-        public static void OpenExternalBrowser(string url){
-            if (string.IsNullOrWhiteSpace(url))return;
-
-            if (IsValidUrl(url)){
-                OpenExternalBrowserUnsafe(url);
-            }
-            else{
-                FormMessage.Warning("Blocked URL", "A potentially malicious URL was blocked from opening:\n"+url, FormMessage.OK);
-            }
-        }
-
-        public static void OpenExternalBrowserUnsafe(string url){
-            using(Process.Start(url)){}
-        }
-
-        public static string GetFileNameFromUrl(string url){
-            string file = Path.GetFileName(new Uri(url).AbsolutePath);
-            return string.IsNullOrEmpty(file) ? null : file;
-        }
-
-        public static string GetErrorName(CefErrorCode code){
-            return StringUtils.ConvertPascalCaseToScreamingSnakeCase(Enum.GetName(typeof(CefErrorCode), code) ?? string.Empty);
-        }
-
-        public static WebClient DownloadFileAsync(string url, string target, Action onSuccess, Action<Exception> onFailure){
-            WebClient client = new WebClient{ Proxy = null };
-            client.Headers[HttpRequestHeader.UserAgent] = HeaderUserAgent;
-
-            client.DownloadFileCompleted += (sender, args) => {
-                if (args.Cancelled){
-                    try{
-                        File.Delete(target);
-                    }catch{
-                        // didn't want it deleted anyways
-                    }
-                }
-                else if (args.Error != null){
-                    onFailure?.Invoke(args.Error);
-                }
-                else{
-                    onSuccess?.Invoke();
-                }
-            };
-
-            client.DownloadFileAsync(new Uri(url), target);
-            return client;
-        }
-
-        public static int Scale(int baseValue, double scaleFactor){
-            return (int)Math.Round(baseValue*scaleFactor);
-        }
-
-        public static void SetZoomLevel(IBrowser browser, int percentage){
-            browser.GetHost().SetZoomLevel(Math.Log(percentage/100.0, 1.2));
-        }
-
-        #if DEBUG
-        public static void HandleConsoleMessage(object sender, ConsoleMessageEventArgs e){
-            Debug.WriteLine("[Console] {0} ({1}:{2})", e.Message, e.Source, e.Line);
-        }
-        #endif
-    }
-}

Core/Utils/MemoryUsageTracker.cs

@@ -1,91 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Timers;
-using System.Windows.Forms;
-using CefSharp;
-using Timer = System.Timers.Timer;
-
-namespace TweetDuck.Core.Utils{
-    sealed class MemoryUsageTracker : IDisposable{
-        private const int IntervalMemoryCheck = 60000*30; // 30 minutes
-        private const int IntervalCleanupAttempt = 60000*5; // 5 minutes
-
-        private readonly string script;
-        private readonly Timer timer;
-        private Form owner;
-        private IBrowser browser;
-
-        private long threshold;
-        private bool needsCleanup;
-
-        public MemoryUsageTracker(string cleanupFunctionName){
-            this.script = $"window.{cleanupFunctionName} && window.{cleanupFunctionName}()";
-
-            this.timer = new Timer{ Interval = IntervalMemoryCheck };
-            this.timer.Elapsed += timer_Elapsed;
-        }
-
-        public void Start(Form owner, IBrowser browser, int thresholdMB){
-            Stop();
-
-            this.owner = owner;
-            this.browser = browser;
-            this.threshold = thresholdMB*1024L*1024L;
-            this.timer.SynchronizingObject = owner;
-            this.timer.Start();
-        }
-
-        public void Stop(){
-            timer.Stop();
-            timer.SynchronizingObject = null;
-            owner = null;
-            browser = null;
-            SetNeedsCleanup(false);
-        }
-
-        public void Dispose(){
-            timer.SynchronizingObject = null;
-            timer.Dispose();
-            owner = null;
-            browser = null;
-        }
-
-        private void SetNeedsCleanup(bool value){
-            if (needsCleanup != value){
-                needsCleanup = value;
-                timer.Interval = value ? IntervalCleanupAttempt : IntervalMemoryCheck; // restarts timer
-            }
-        }
-
-        private void timer_Elapsed(object sender, ElapsedEventArgs e){
-            if (owner == null || browser == null){
-                return;
-            }
-            
-            if (needsCleanup){
-                if (!owner.ContainsFocus){
-                    using(IFrame frame = browser.MainFrame){
-                        frame.EvaluateScriptAsync(script).ContinueWith(task => {
-                            JavascriptResponse response = task.Result;
-
-                            if (response.Success && (response.Result as bool? ?? false)){
-                                SetNeedsCleanup(false);
-                            }
-                        });
-                    }
-                }
-            }
-            else{
-                try{
-                    using(Process process = BrowserProcesses.FindProcess(browser)){
-                        if (process?.PrivateMemorySize64 > threshold){
-                            SetNeedsCleanup(true);
-                        }
-                    }
-                }catch{
-                    // ignore I guess?
-                }
-            }
-        }
-    }
-}

Core/Utils/StringUtils.cs

@@ -1,22 +0,0 @@
-using System;
-using System.Linq;
-using System.Text.RegularExpressions;
-
-namespace TweetDuck.Core.Utils{
-    static class StringUtils{
-        public static readonly string[] EmptyArray = new string[0];
-
-        public static string ExtractBefore(string str, char search, int startIndex = 0){
-            int index = str.IndexOf(search, startIndex);
-            return index == -1 ? str : str.Substring(0, index);
-        }
-
-        public static int[] ParseInts(string str, char separator){
-            return str.Split(new char[]{ separator }, StringSplitOptions.RemoveEmptyEntries).Select(int.Parse).ToArray();
-        }
-        
-        public static string ConvertPascalCaseToScreamingSnakeCase(string str){
-            return Regex.Replace(str, @"(\p{Ll})(\P{Ll})|(\P{Ll})(\P{Ll}\p{Ll})", "$1$3_$2$4").ToUpper();
-        }
-    }
-}