public override void BwApp_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            WorkerTask task = (WorkerTask)e.Result;

            PostWorkerTasks();
            if (task == null)
            {
                return;
            }

            this.Text  = Engine.GetProductName();
            niTray.Tag = task;

            if (task.UploadResults.Count > 0)
            {
                UploadManager.UploadResultLast = task.UploadResults[task.UploadResults.Count - 1];
                UploadManager.ResetCumulativePercentage();
            }

            try
            {
                if (task.IsError && task.Errors[0].Contains(ExceptionMessage.ProxyAuthenticationRequired))
                {
                    ProxyUI ui = new ProxyUI();
                    if (ui.ShowDialog() == DialogResult.OK)
                    {
                        Engine.ConfigUI.ConfigProxy.ProxyList.Add(ui.Proxy);
                        Engine.ConfigUI.ConfigProxy.ProxyConfigType = EProxyConfigType.ManualProxy;
                        Uploader.ProxySettings = Adapter.CheckProxySettings();
                    }
                    RetryTask(task);
                }

                WorkerTask checkTask = RetryUpload(task);

                if (checkTask.States.Contains(WorkerTask.TaskState.RetryPending))
                {
                    string message = string.Format("{0}\r\n\r\nAutomatically retrying upload for {1}.", string.Join("\r\n", task.Errors.ToArray()), checkTask.WorkflowConfig.DestConfig.ToStringImageUploaders());
                    niTray.ShowBalloonTip(5000, Application.ProductName, message, ToolTipIcon.Warning);
                }
                else
                {
                    task.States.Add(WorkerTask.TaskState.Finished);

                    if (task.WorkflowConfig.DestConfig.TaskClipboardContent.Contains(ClipboardContentEnum.Local) && Engine.ConfigUI.ShowSaveFileDialogImages)
                    {
                        string fp = task.WriteImageAs();
                        if (!string.IsNullOrEmpty(fp))
                        {
                            task.UpdateLocalFilePath(fp);
                        }
                    }

                    switch (task.Job1)
                    {
                    case EDataType.Text:
                        if (task.Job2 == WorkerTask.JobLevel2.Translate)
                        {
                            UpdateGoogleTranslateGUI(task.TranslationInfo);

                            Loader.MyGTGUI.btnTranslate.Enabled   = true;
                            Loader.MyGTGUI.btnTranslateTo.Enabled = true;
                        }
                        break;

                    case EDataType.Image:
                        if (!task.WorkflowConfig.DestConfig.TaskClipboardContent.Contains(ClipboardContentEnum.Local) && Engine.ConfigOptions.DeleteLocal && File.Exists(task.Info.LocalFilePath))
                        {
                            try
                            {
                                File.Delete(task.Info.LocalFilePath);
                            }
                            catch (Exception ex)     // TODO: sometimes file is still locked... delete those files sometime
                            {
                                DebugHelper.WriteException(ex, "Error while finalizing job");
                            }
                        }
                        break;
                    }

                    if (Engine.ConfigOptions.TwitterEnabled)
                    {
                        Adapter.TwitterMsg(task);
                    }

                    bool bLastSourceButtonsEnabled = task.UploadResults.Count > 0 && !string.IsNullOrEmpty(task.UploadResults[task.UploadResults.Count - 1].Source);
                    this.btnOpenSourceText.Enabled    = bLastSourceButtonsEnabled;
                    this.btnOpenSourceBrowser.Enabled = bLastSourceButtonsEnabled;
                    this.btnOpenSourceString.Enabled  = bLastSourceButtonsEnabled;

                    if (task.UploadResults.Count > 0 || File.Exists(task.Info.LocalFilePath) || task.Job2 == WorkerTask.JobLevel2.Translate)
                    {
                        if (Engine.ConfigOptions.CompleteSound)
                        {
                            if (Engine.ConfigWorkflow.EnableSoundTaskCompleted && !string.IsNullOrEmpty(Engine.ConfigWorkflow.SoundPath) && File.Exists(Engine.ConfigWorkflow.SoundPath))
                            {
                                new SoundPlayer(Engine.ConfigWorkflow.SoundPath).Play();
                            }
                            else
                            {
                                SystemSounds.Exclamation.Play();
                            }
                        }

                        if (Engine.ConfigOptions.ShowBalloonTip)
                        {
                            ShowBalloonTip(task);
                        }
                    }

                    if (task.IsError)
                    {
                        foreach (string error in task.Errors)
                        {
                            DebugHelper.WriteLine(error);
                        }
                        niTray.ShowBalloonTip(5000, Application.ProductName, niTray.BalloonTipText + Environment.NewLine + task.Errors[task.Errors.Count - 1], ToolTipIcon.Error);
                    }
                }

                if (!task.IsError)
                {
                    AddHistoryItem(task);
                }

                // do this last
                UploadManager.ShowUploadResults(task, false);
            }
            catch (Exception ex)
            {
                DebugHelper.WriteException(ex, "Job Completed with errors: ");
            }
            finally
            {
                UploadManager.Commit(task.Id);

                if (TaskbarManager.IsPlatformSupported)
                {
                    Adapter.TaskbarSetProgressState(this, TaskbarProgressBarState.NoProgress);
                }
            }

            DebugHelper.WriteLine(string.Format("Job completed: {0}", task.Job2));
            DebugHelper.WriteLine(string.Format("Task duration: {0} ms", task.UploadDuration));
            PostWorkerTasks();
        }