private void bwConfig_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            LoggerTimer timer = Engine.EngineLogger.StartTimer(new StackFrame().GetMethod().Name + " started");

            Text        = Engine.GetProductName();
            niTray.Text = Text;

            Uploader.ProxySettings = Adapter.CheckProxySettings();

            if (Engine.ConfigUploaders.PasswordsSecureUsingEncryption)
            {
                Engine.ConfigUploaders.CryptPasswords(bEncrypt: false);
            }

            ZScreen_ConfigGUI();

            if (Engine.ConfigUI.CheckUpdates)
            {
                FormsMgr.OptionsUI.CheckUpdates();
            }

            PerformOnlineTasks();

            CleanCache();

            if (Engine.ConfigUI.ConfigProxy.ProxyConfigType != EProxyConfigType.NoProxy && Uploader.ProxySettings.ProxyActive != null)
            {
                DebugHelper.WriteLine("Proxy Settings: " + Uploader.ProxySettings.ProxyActive);
            }

            if (Engine.ConfigUI.BackupApplicationSettings)
            {
                FileSystem.BackupSettings();
            }

            if (Engine.ConfigUI.FirstRun)
            {
                if (Engine.HasVista)
                {
                    cboCaptureEngine.SelectedIndex = (int)CaptureEngineType.DWM;
                }

                ShowWindow();

                Engine.ConfigUI.FirstRun = false;
            }

            timer.WriteLineTime(new StackFrame().GetMethod().Name + " finished");
            DebugHelper.WriteLine("ZScreen startup time: {0} ms", Engine.StartTimer.ElapsedMilliseconds);

            UseCommandLineArg(Loader.CommandLineArg);

            IsReady = true;

            Engine.IsClipboardUploading = false;
            tmrClipboardMonitor.Tick   += tmrClipboardMonitor_Tick;
        }
        private void ZScreen_Load(object sender, EventArgs e)
        {
            Engine.zHandle = Handle;

            #region Window Size/Location

            if (Engine.ConfigApp.WindowLocation.IsEmpty)
            {
                Engine.ConfigApp.WindowLocation = Location;
            }

            if (Engine.ConfigApp.WindowSize.IsEmpty)
            {
                Engine.ConfigApp.WindowSize = Size;
            }

            if (Engine.ConfigApp.SaveFormSizePosition)
            {
                Rectangle screenRect = CaptureHelpers.GetScreenBounds();
                screenRect.Inflate(-100, -100);

                if (
                    screenRect.IntersectsWith(new Rectangle(Engine.ConfigApp.WindowLocation, Engine.ConfigApp.WindowSize)))
                {
                    Size     = Engine.ConfigApp.WindowSize;
                    Location = Engine.ConfigApp.WindowLocation;
                }
            }

            #endregion Window Size/Location

            #region Window Show/Hide

            bool bHideWindow = false;
            if (Engine.ConfigApp.ShowMainWindow)
            {
                if (Engine.ConfigApp.WindowState == FormWindowState.Maximized)
                {
                    WindowState = FormWindowState.Maximized;
                }
                else
                {
                    WindowState = FormWindowState.Normal;
                }
                ShowInTaskbar = Engine.ConfigApp.ShowInTaskbar;
            }
            else if (Engine.ConfigApp.ShowInTaskbar &&
                     Engine.ConfigApp.WindowButtonActionClose == WindowButtonAction.MinimizeToTaskbar)
            {
                WindowState = FormWindowState.Minimized;
            }
            else
            {
                bHideWindow = true;
            }

            if (Engine.ConfigApp.Windows7TaskbarIntegration && Engine.HasWindows7)
            {
                ZScreen_Windows7onlyTasks();
            }

            if (bHideWindow)
            {
                Hide(); // this should happen after windows 7 taskbar integration
            }

            #endregion Window Show/Hide

            LoggerTimer timer = Engine.EngineLogger.StartTimer(new StackFrame().GetMethod().Name + " started");

            ZScreen_Preconfig();

            mDebug = new ZScreenDebugHelper();
            mDebug.GetDebugInfo += debug_GetDebugInfo;

            SetToolTip(nudScreenshotDelay);

            new RichTextBoxMenu(rtbDebugLog, true);
            new RichTextBoxMenu(rtbStats, true);

            if (Engine.IsMultiInstance)
            {
                niTray.ShowBalloonTip(2000, Engine.GetProductName(),
                                      string.Format("Another instance of {0} is already running...",
                                                    Application.ProductName), ToolTipIcon.Warning);
                niTray.BalloonTipClicked += niTray2_BalloonTipClicked;
            }

            timer.WriteLineTime(new StackFrame().GetMethod().Name + " finished");

            Application.Idle += Application_Idle;
        }
        public static void LoadSettings(string fp = null)
        {
            LoggerTimer timer = EngineLogger.StartTimer("LoadSettings started");

            Thread threadOptions = new Thread(() =>
            {
                Engine.ConfigOptions = ZScreenOptions.Read(OptionsFilePath);
            });

            Thread threadMainFormSettings = new Thread(() =>
            {
                if (string.IsNullOrEmpty(fp))
                {
                    Engine.ConfigUI = XMLSettings.Read();
                }
                else
                {
                    Engine.ConfigUI = XMLSettings.Read(fp);
                }
            });

            Thread threadWorkflow = new Thread(() =>
            {
                Engine.ConfigWorkflow = Workflow.Read(WorkflowConfigPath);
            });

            Thread threadUploadersConfig = new Thread(() =>
            {
                Engine.ConfigUploaders = UploadersConfig.Load(UploadersConfigPath);
            });

            Thread threadGt = new Thread(() =>
            {
                Engine.ConfigGT = GoogleTranslatorConfig.Read(GoogleTranslateConfigPath);
            });

            threadOptions.Start();
            threadMainFormSettings.Start();
            threadGt.Start();
            threadWorkflow.Start();
            threadUploadersConfig.Start();

            threadMainFormSettings.Join();
            threadWorkflow.Join();
            threadUploadersConfig.Join();

            timer.WriteLineTime("LoadSettings finished");

            Engine.InitializeFiles();

            // Use Configuration Wizard Settings if applied
            if (RunConfig)
            {
                Engine.ConfigUI.ConfOutputs          = Engine.ConfigApp.AppOutputs;
                Engine.ConfigUI.ConfClipboardContent = Engine.ConfigApp.ClipboardContent;
                Engine.ConfigUI.MyImageUploaders     = Engine.ConfigApp.ImageUploaders;
                Engine.ConfigUI.MyTextUploaders      = Engine.ConfigApp.TextUploaders;
                Engine.ConfigUI.MyFileUploaders      = Engine.ConfigApp.FileUploaders;
                Engine.ConfigUI.MyURLShorteners      = Engine.ConfigApp.LinkUploaders;
            }

            // Portable then we don't need PreferSystemFolders to be true
            if (IsPortable)
            {
                Engine.ConfigApp.PreferSystemFolders = false;
            }
        }