public RunTask ( Func |
||
backgroundTask | Func |
The background task. |
return | object |
private void m_btnMerge_Click(object sender, EventArgs e) { using (new SIL.FieldWorks.Common.Utils.WaitCursor(this)) { using (ProgressDialogWithTask progressDlg = new ProgressDialogWithTask(this)) { progressDlg.ProgressBarStyle = ProgressBarStyle.Continuous; m_progressDlg = progressDlg as IAdvInd4; try { progressDlg.Title = "Chorus Merge Process"; // 1. export lexicon string outPath = Path.GetTempFileName(); outPath = (string)progressDlg.RunTask(true, new BackgroundTaskInvoker(ExportLexicon), outPath); if (outPath == null) { // TODO: some sort of error report? return; } // 2. merge via chorus string inPath = (string)progressDlg.RunTask(true, new BackgroundTaskInvoker(ChorusMerge), outPath); if (inPath == null) { // TODO: some sort of error report? return; } // 3. re-import lexicon, overwriting current contents. string logFile = (string)progressDlg.RunTask(true, new BackgroundTaskInvoker(ImportLexicon), inPath); if (logFile == null) { // TODO: some sort of error report? return; } else { } } catch { } finally { } } } DialogResult = DialogResult.OK; Close(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Calls the TePublicationsInit.CreateFactoryPublicationInfo method /// </summary> /// <param name="doc">The XML document containing publications and HF sets</param> /// ------------------------------------------------------------------------------------ internal void CallCreatePublicationInfo(XmlDocument doc) { using (ProgressDialogWithTask progressDlg = new ProgressDialogWithTask(Form.ActiveForm)) { progressDlg.RunTask(false, new BackgroundTaskInvoker(CreateFactoryPublicationInfo), doc.SelectSingleNode("PublicationDefaultsForNewProject")); } }
private void m_btnOK_Click(object sender, EventArgs e) { using (var dlg = new ProgressDialogWithTask(this)) { dlg.AllowCancel = false; dlg.Minimum = 0; dlg.Maximum = 500; using (new WaitCursor(this, true)) { var import = new LinguaLinksImport(m_cache, Path.Combine(Path.GetTempPath(), "LanguageExplorer" + Path.DirectorySeparatorChar), Path.Combine(FwDirectoryFinder.CodeDirectory, Path.Combine("Language Explorer", "Import" + Path.DirectorySeparatorChar))); import.NextInput = m_tbFilename.Text; import.Error += import_Error; try { var fSuccess = (bool) dlg.RunTask(true, import.ImportInterlinear, m_tbFilename.Text); if (fSuccess) { DialogResult = DialogResult.OK; // only 'OK' if not exception var firstNewText = import.FirstNewText; if (firstNewText != null && m_mediator != null) { m_mediator.SendMessage("JumpToRecord", firstNewText.Hvo); } } else { DialogResult = DialogResult.Abort; // unsuccessful import string message = ITextStrings.ksInterlinImportFailed + Environment.NewLine + Environment.NewLine; message += m_messages.ToString(); MessageBox.Show(this, message, ITextStrings.ksImportFailed, MessageBoxButtons.OK, MessageBoxIcon.Warning); } Close(); } catch (WorkerThreadException ex) { System.Diagnostics.Debug.WriteLine("Error: " + ex.InnerException.Message); MessageBox.Show(String.Format(import.ErrorMessage, ex.InnerException.Message), ITextStrings.ksUnhandledError, MessageBoxButtons.OK, MessageBoxIcon.Error); DialogResult = DialogResult.Cancel; // only 'OK' if not exception Close(); } } } }
// I made this region to hold methods that perform particular tasks involving wrapping this dialog around // some work. #region static methods to encapsulate usages of the dialog /// <summary> /// I'd like to put all this logic into XmlTranslatedLists, because it is common to most cases of /// calling ImportTranslatedListsForWs, which is the point of this method. Unfortunately FDO /// cannot reference the DLL that has ProgressDialogWithTask. I've made it public static so that /// anything that references FwControls can use it at least. /// </summary> /// <param name="cache"> </param> /// <param name="ws"></param> /// <param name="parentWindow"> </param> public static void ImportTranslatedListsForWs(Form parentWindow, LcmCache cache, string ws) { string path = XmlTranslatedLists.TranslatedListsPathForWs(ws, FwDirectoryFinder.TemplateDirectory); if (!File.Exists(path)) { return; } using (var dlg = new ProgressDialogWithTask(parentWindow)) { dlg.AllowCancel = true; dlg.Maximum = 200; dlg.Message = Path.GetFileName(path); dlg.Title = XmlTranslatedLists.ProgressDialogCaption; dlg.RunTask(true, ImportTranslatedListsForWs, ws, cache); } }
private void m_btnOK_Click(object sender, EventArgs e) { using (ProgressDialogWithTask dlg = new ProgressDialogWithTask(this)) { dlg.CancelButtonVisible = false; dlg.SetRange(0, 500); using (new WaitCursor(this, true)) { LinguaLinksImport import = new LinguaLinksImport(m_cache, Path.Combine(Path.GetTempPath(), "LanguageExplorer\\"), Path.Combine(SIL.FieldWorks.Common.Utils.DirectoryFinder.FWCodeDirectory, "Language Explorer\\Import\\")); import.NextInput = m_tbFilename.Text; import.Error += new LinguaLinksImport.ErrorHandler(import_Error); dlg.Cancel += new CancelHandler(import.On_ProgressDlg_Cancel); try { bool fSuccess = (bool)dlg.RunTask(true, new BackgroundTaskInvoker(import.ImportInterlinear), m_tbFilename.Text); if (fSuccess) this.DialogResult = DialogResult.OK; // only 'OK' if not exception else { this.DialogResult = DialogResult.Abort; // unsuccessful import string message = ITextStrings.ksInterlinImportFailed + "\n\n"; message += m_messages.ToString(); MessageBox.Show(this, message, ITextStrings.ksImportFailed, MessageBoxButtons.OK, MessageBoxIcon.Warning); } Close(); } catch (WorkerThreadException ex) { System.Diagnostics.Debug.WriteLine("Error: " + ex.InnerException.Message); MessageBox.Show(String.Format(import.ErrorMessage, ex.InnerException.Message), ITextStrings.ksUnhandledError, MessageBoxButtons.OK, MessageBoxIcon.Error); this.DialogResult = DialogResult.Cancel; // only 'OK' if not exception Close(); } } } }
/// <summary> /// Create a new Fieldworks project and import a lift file into it. Return the .fwdata path. /// </summary> private static string CreateProjectFromLift(Form parent, IHelpTopicProvider helpTopicProvider, string liftPath) { string projectPath; FdoCache cache; var anthroListFile = CallPickAnthroList(helpTopicProvider); using (var progressDlg = new ProgressDialogWithTask(parent)) { progressDlg.Title = FwControls.ksCreatingLiftProject; var cacheReceiver = new FdoCache[1]; // a clumsy way of handling an out parameter, consistent with RunTask projectPath = (string)progressDlg.RunTask(true, CreateProjectTask, new object[] { liftPath, parent, anthroListFile, cacheReceiver }); cache = cacheReceiver[0]; } CallImportObtainedLexicon(cache, liftPath, parent); ProjectLockingService.UnlockCurrentProject(cache); // finish all saves and completely write the file so we can proceed to open it cache.Dispose(); return(projectPath); }
private void DoImport() { using (new WaitCursor(this)) { using (var progressDlg = new ProgressDialogWithTask(this)) { progressDlg.Minimum = 0; progressDlg.Maximum = 100; progressDlg.AllowCancel = true; progressDlg.Restartable = true; progressDlg.Title = String.Format(LexTextControls.ksImportingFrom0, m_sSfmDataFile); m_sLogFile = (string)progressDlg.RunTask(true, ImportStdFmtFile, m_sSfmDataFile); if (m_chkDisplayImportReport.Checked && !String.IsNullOrEmpty(m_sLogFile)) { using (Process.Start(m_sLogFile)) { } } } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Export all of scripture /// </summary> /// ------------------------------------------------------------------------------------ private void ExportScripture(Form dialogOwner) { int sectionCount = 0; for (int i = 0; i < m_bookFilter.BookCount; i++) sectionCount += m_bookFilter.GetBook(i).SectionsOS.Count; using (var progressDlg = new ProgressDialogWithTask(dialogOwner)) { progressDlg.Minimum = 0; progressDlg.Maximum = sectionCount; progressDlg.Title = DlgResources.ResourceString("kstidExportXmlProgress"); progressDlg.AllowCancel = true; progressDlg.RunTask(true, ExportScripture); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Export all of scripture /// </summary> /// ------------------------------------------------------------------------------------ private void ExportScripture() { int sectionCount = 0; for (int i = 0; i < m_bookFilter.BookCount; i++) sectionCount += m_bookFilter.GetBook(i).SectionsOS.Count; using (ProgressDialogWithTask progressDlg = new ProgressDialogWithTask(Form.ActiveForm)) { progressDlg.SetRange(0, sectionCount); progressDlg.Title = DlgResources.ResourceString("kstidExportXmlProgress"); progressDlg.CancelButtonVisible = true; progressDlg.Cancel += new CancelHandler(OnExportCancel); progressDlg.RunTask(true, new BackgroundTaskInvoker(ExportScripture)); } }
protected override void OnFinishButton() { if (UsesInvalidFileNames(false)) return; base.OnFinishButton(); bool runToCompletion = true; int lastStep = 5; // if the shift key is down, then just build the phaseNoutput files if ((Control.ModifierKeys & Keys.Shift) == Keys.Shift) { runToCompletion = false; lastStep = 4; } SaveSettings(); using (var dlg = new ProgressDialogWithTask(this)) { dlg.AllowCancel = true; dlg.Maximum = 200; using (new WaitCursor(this, true)) { int startPhase = GetDictionaryFileAsPhaseFileNumber(); // see if starting with phase file // XSLT files string sTransformDir = Path.Combine(FwDirectoryFinder.CodeDirectory, String.Format("Language Explorer{0}Import{0}", Path.DirectorySeparatorChar)); LexImport lexImport = new LexImport(m_cache, m_sTempDir, sTransformDir); lexImport.Error += OnImportError; bool fRet = (bool)dlg.RunTask(true, lexImport.Import, runToCompletion, lastStep, startPhase, m_DatabaseFileName.Text, m_cEntries, m_DisplayImportReport.Checked, m_sPhase1HtmlReport, LexImport.s_sPhase1FileName); if (fRet) DialogResult = DialogResult.OK; // only 'OK' if not exception } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Create a new language project showing a dialog progress. /// </summary> /// ------------------------------------------------------------------------------------ protected void CreateNewLangProjWithProgress() { ResourceManager resources = new ResourceManager( "SIL.FieldWorks.FwCoreDlgs.FwCoreDlgs", Assembly.GetExecutingAssembly()); try { using (ProgressDialogWithTask progressDlg = new ProgressDialogWithTask(this)) { progressDlg.Title = string.Format(FwCoreDlgs.kstidCreateLangProjCaption, ProjectName); using (new WaitCursor()) { m_newProjectInfo = (NewLangProjReturnData)progressDlg.RunTask(DisplayUi, new BackgroundTaskInvoker(new FwNewLangProjectCreator().CreateNewLangProj), resources, ProjectName, m_cbAnalWrtSys.SelectedItem, m_cbVernWrtSys.SelectedItem); } } } catch (WorkerThreadException wex) { Exception e = wex.InnerException; if (e is PathTooLongException) { this.Show(); m_fIgnoreClose = true; MessageBox.Show(FwCoreDlgs.kstidErrPathToLong); } else if (e is ApplicationException) { if (resources != null) MessageBox.Show(string.Format(resources.GetString("kstidErrorNewDb"), e.Message)); m_fIgnoreClose = true; this.DialogResult = DialogResult.Cancel; } else { m_fIgnoreClose = true; this.DialogResult = DialogResult.Cancel; throw new Exception(FwCoreDlgs.kstidErrApp, e); } } }
private void ImportTranslatedLists(string filename) { using (var dlg = new ProgressDialogWithTask(this)) { dlg.AllowCancel = true; dlg.Maximum = 200; dlg.Message = filename; dlg.RunTask(true, FdoCache.ImportTranslatedLists, filename, Cache); } }
/// <summary> /// Create a new Fieldworks project and import a lift file into it. Return the .fwdata path. /// </summary> private static string CreateProjectFromLift(Form parent, IHelpTopicProvider helpTopicProvider, string liftPath) { string projectPath; FdoCache cache; var anthroListFile = CallPickAnthroList(helpTopicProvider); using (var progressDlg = new ProgressDialogWithTask(parent)) { progressDlg.Title = FwControls.ksCreatingLiftProject; var cacheReceiver = new FdoCache[1]; // a clumsy way of handling an out parameter, consistent with RunTask projectPath = (string)progressDlg.RunTask(true, CreateProjectTask, new object[] { liftPath, parent, anthroListFile, cacheReceiver }); cache = cacheReceiver[0]; } CallImportObtainedLexicon(cache, liftPath, parent); ProjectLockingService.UnlockCurrentProject(cache); // finish all saves and completely write the file so we can proceed to open it cache.Dispose(); return projectPath; }
protected void DoExport(string outPath, bool fLiftOutput) { string fxtPath = (string)m_exportList.SelectedItems[0].Tag; FxtType ft = m_rgFxtTypes[FxtIndex(fxtPath)]; using (new SIL.FieldWorks.Common.Utils.WaitCursor(this)) { using (ProgressDialogWithTask progressDlg = new ProgressDialogWithTask(this)) { try { progressDlg.Title = String.Format(xWorksStrings.Exporting0, m_exportList.SelectedItems[0].SubItems[0].Text); progressDlg.Message = xWorksStrings.Exporting_; switch (ft.m_ft) { case FxtTypes.kftFxt: using (m_dumper = new XDumper(m_cache)) { m_dumper.UpdateProgress += new XDumper.ProgressHandler(OnDumperUpdateProgress); m_dumper.SetProgressMessage += new EventHandler<XDumper.MessageArgs>(OnDumperSetProgressMessage); progressDlg.SetRange(0, m_dumper.GetProgressMaximum()); progressDlg.CancelButtonVisible = true; progressDlg.Restartable = true; progressDlg.ProgressBarStyle = ProgressBarStyle.Continuous; progressDlg.Cancel += new CancelHandler(Onm_progressDlg_Cancel); progressDlg.RunTask(true, new BackgroundTaskInvoker(ExportFxt), outPath, fxtPath, fLiftOutput); } break; case FxtTypes.kftConfigured: case FxtTypes.kftReversal: progressDlg.SetRange(0, m_seqView.ObjectCount); progressDlg.CancelButtonVisible = true; progressDlg.Cancel += new CancelHandler(ce_Cancel); progressDlg.RunTask(true, new BackgroundTaskInvoker(ExportConfiguredDocView), outPath, fxtPath, ft); break; } } catch (WorkerThreadException e) { if (e.InnerException is CancelException) { MessageBox.Show(this, e.InnerException.Message); m_ce = null; } else { string msg = xWorksStrings.ErrorExporting_ProbablyBug + "\n" + e.InnerException.Message; MessageBox.Show(this, msg); } } finally { m_progressDlg = null; m_dumper = null; this.Close(); } } } }
private void btnImport_Click(object sender, System.EventArgs e) { // if the shift key is down, then just build the phaseNoutput files bool runToCompletion = ((Control.ModifierKeys & Keys.Shift) != Keys.Shift); using (ProgressDialogWithTask dlg = new ProgressDialogWithTask(this)) { dlg.CancelButtonVisible = true; LanguageMapping[] languageMappings = new LanguageMapping[listViewMapping.Items.Count]; for (int i = 0; i < listViewMapping.Items.Count; i++) languageMappings[i] = new LanguageMapping(listViewMapping.Items[i].SubItems); dlg.SetRange(0, 500); using (new WaitCursor(this, true)) { // This needs to be reset when cancel is pressed with out clicking the // browse button. This resolves a noted issue in the code where an exception // is processed when run a second time... m_nextInput = m_LinguaLinksXmlFileName.Text; LinguaLinksImport import = new LinguaLinksImport(m_cache, m_sTempDir, m_sRootDir); import.NextInput = m_nextInput; import.Error += new LinguaLinksImport.ErrorHandler(OnImportError); dlg.Cancel += new CancelHandler(import.On_ProgressDlg_Cancel); Debug.Assert(m_nextInput == m_LinguaLinksXmlFileName.Text); try { bool fSuccess = (bool)dlg.RunTask(true, new BackgroundTaskInvoker(import.Import), runToCompletion, languageMappings, m_startPhase); if (fSuccess) { string sLogFile = m_sTempDir + "LLPhase3Output-Import.log"; MessageBox.Show(this, String.Format(ITextStrings.ksSuccessLoadingLL, Path.GetFileName(m_LinguaLinksXmlFileName.Text), m_cache.DatabaseName, System.Environment.NewLine, sLogFile), ITextStrings.ksLLImportSucceeded, MessageBoxButtons.OK, MessageBoxIcon.Information); this.DialogResult = DialogResult.OK; // only 'OK' if not exception } else { this.DialogResult = DialogResult.Abort; // unsuccessful import } Close(); m_nextInput = import.NextInput; } catch (WorkerThreadException ex) { if (ex.InnerException is InvalidDataException) { // Special handling for this case... ShowFinishLabel(); CheckImportEnabled(); } else { System.Diagnostics.Debug.WriteLine("Error: " + ex.InnerException.Message); MessageBox.Show(String.Format(import.ErrorMessage, ex.InnerException.Message), ITextStrings.ksUnhandledError, MessageBoxButtons.OK, MessageBoxIcon.Error); this.DialogResult = DialogResult.Cancel; // only 'OK' if not exception Close(); } } } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Moves all of the projects in the specified old project folder (including any /// subfolders) to the specified new project folder. /// </summary> /// <param name="oldFolderForProjects">The old folder that held the projects.</param> /// <param name="newFolderForProjects">The new folder that will hold the projects.</param> /// <param name="projectPath">The project path.</param> /// <param name="oldProjectId">The Id of the old project (to use if it has not moved)</param> /// <returns>The ProjectId for the project to load after the move is completed</returns> /// ------------------------------------------------------------------------------------ private static ProjectId MoveProjectFolders(string oldFolderForProjects, string newFolderForProjects, string projectPath, ProjectId oldProjectId) { List<string> rgErrors = new List<string>(); bool fCopy = MustCopyFoldersAndFiles(oldFolderForProjects, newFolderForProjects); using (ProgressDialogWithTask progressDlg = new ProgressDialogWithTask(s_threadHelper)) { string[] subDirs = Directory.GetDirectories(oldFolderForProjects); progressDlg.Maximum = subDirs.Length; progressDlg.AllowCancel = false; progressDlg.Title = string.Format(Properties.Resources.ksMovingProjectsCaption, oldFolderForProjects, newFolderForProjects); // Move all of the files and folders progressDlg.RunTask(true, (progressDialog, dummy) => { foreach (string subdir in subDirs) { try { string sub = Path.GetFileName(subdir); // If the project folder is not known to be ours don't move the folder. // This is some protection against moving vital folders if the user does something silly like // making C:\ the project folder. See FWR-3371. var destDirName = Path.Combine(newFolderForProjects, sub); if (!IsFieldWorksProjectFolder(subdir)) { // It might still be a folder which is the name of a remote server, // and contains local settings for projects on that server. // Check each of its subfolders, and move/copy the ones that appear to be settings, if any. bool movedSomething = false; foreach (string subsubdir in Directory.GetDirectories(subdir)) { if (!IsFieldWorksSettingsFolder(subsubdir)) continue; // We found a project folder one level down. This ought not so to be. // Maybe we are doing some bizarre move into one of our own subfolders, and this // was already moved earlier in the main loop? Anyway don't move it, it's not just a settings folder. if (IsFieldWorksProjectFolder(subsubdir)) continue; movedSomething = true; var leafName = Path.GetFileName(subsubdir); var subDirDest = Path.Combine(destDirName, leafName); Directory.CreateDirectory(destDirName); // may be redundant (will be after first time) but cheap. if (fCopy) { CopyDirectory(subsubdir, subDirDest); Directory.Delete(subsubdir, true); } else { Directory.Move(subsubdir, subDirDest); } } // If we moved something and left nothing behind delete the parent folder. // (We do a fresh GetDirectories just in case bizarrely we are moving INTO one of our own subfolders, // and thus even though we moved everything something is still there). if (movedSomething && Directory.GetDirectories(subdir).Length == 0) Directory.Delete(subdir); continue; // with more top-level directories in the projects folder. } progressDialog.Message = string.Format(Properties.Resources.ksMovingProject, sub); progressDialog.Step(1); if (fCopy) { // Recursively copy each subfolder. CopyDirectory(subdir, destDirName); Directory.Delete(subdir, true); } else { Directory.Move(subdir, destDirName); } } catch (Exception e) { rgErrors.Add(String.Format("{0} - {1}", Path.GetFileNameWithoutExtension(subdir), e.Message)); } } return null; }); } if (rgErrors.Count > 0) { // Show the user any errors that occured while doing the move StringBuilder bldr = new StringBuilder(); bldr.AppendLine(Properties.Resources.ksCannotMoveProjects); foreach (var err in rgErrors) bldr.AppendLine(err); bldr.Append(Properties.Resources.ksYouCanTryToMoveProjects); MessageBox.Show(bldr.ToString(), Properties.Resources.ksProblemsMovingProjects); } if (MiscUtils.IsUnix) { if (projectPath.StartsWith(oldFolderForProjects)) { // This is perhaps a temporary workaround. On Linux, FwDirectoryFinder.ProjectsDirectory // isn't returning the updated value, but rather the original value. This seems to // last for the duration of the program, but if you exit and restart the program, it // gets the correct (updated) value!? // (On the other hand, I somewhat prefer this code which is fairly straightforward and // obvious to depending on calling some static method hidden in the depths of FDO.) string projFileName = Path.GetFileName(projectPath); string projName = Path.GetFileNameWithoutExtension(projectPath); string path = Path.Combine(Path.Combine(newFolderForProjects, projName), projFileName); return new ProjectId(path, null); } } else { if (projectPath.StartsWith(oldFolderForProjects, StringComparison.InvariantCultureIgnoreCase)) { return new ProjectId(ClientServerServices.Current.Local.IdForLocalProject( Path.GetFileNameWithoutExtension(projectPath)), null); } } return oldProjectId; }
/// ------------------------------------------------------------------------------------ /// <summary> /// If all of the books are "new" or auto-merged or caller is asking to auto-accept /// changes, then don't actually show the dialog. /// See TE-7072, TE-2126 and FB-8847. Otherwise, show the dialog and process normally. /// </summary> /// <param name="wnd">The parent form</param> /// <param name="fAutoAcceptChanges">if set to <c>true</c> automatically accept all /// the imported stuff by applying the changes.</param> /// ------------------------------------------------------------------------------------ public void ShowOrSave(IWin32Window wnd, bool fAutoAcceptChanges) { int cNewOrAutoMerged = 0; m_owningForm = wnd as Form; bool fCancelled = false; foreach (ListViewItem item in lstImportedBooks.Items) { BookMerger bookMerger = item.Tag as BookMerger; if (bookMerger == null) { ++cNewOrAutoMerged; continue; } using (ProgressDialogWithTask progressDlg = new ProgressDialogWithTask(m_owningForm)) { bookMerger.AttemptAutoMerge = true; bookMerger.BookVersionAgent = this; bookMerger.UseFilteredDiffList = true; progressDlg.Title = TeResourceHelper.GetResourceString("kstidImportProgressCaption"); Debug.Assert(bookMerger.BookRev != null); progressDlg.Message = string.Format( DlgResources.ResourceString("kstidMergeProgress"), bookMerger.BookRev.BestUIName); progressDlg.CancelButtonText = TeResourceHelper.GetResourceString("kstidStopImporting"); // User should not see undo tasks, so the strings don't need to be localized. UndoableUnitOfWorkHelper.Do("Automerge", "Automerge", m_cache.ServiceLocator.GetInstance<IActionHandler>(), () => { try { progressDlg.RunTask(bookMerger.DetectDifferences); if (bookMerger.AutoMerged) { SetItemStatus(item, ImportedBookStatus.AutoMerged); cNewOrAutoMerged++; } else if (fAutoAcceptChanges) { progressDlg.Message = string.Format( DlgResources.ResourceString("kstidAutoAcceptMergeProgress"), bookMerger.BookRev.BestUIName); progressDlg.RunTask(true, bookMerger.AcceptAllChanges); } } catch (WorkerThreadException e) { if (e.InnerException is CancelException) { // The current version of fCancelled = true; return; } throw; } }); } if (fCancelled) return; } if (cNewOrAutoMerged < lstImportedBooks.Items.Count && !fAutoAcceptChanges) ShowDialog(wnd); else OnClosed(null); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Performs a partial overwrite of the book using the imported portion of the book. /// </summary> /// <param name="bookMerger">The book merger.</param> /// <param name="sectionsToRemove">The sections to remove as the first step (before /// calling the auto-merge code).</param> /// ------------------------------------------------------------------------------------ protected virtual void PartialOverwrite(BookMerger bookMerger, List<IScrSection> sectionsToRemove) { Logger.WriteEvent("Performing partial Overwrite of book: " + bookMerger.BookCurr.BookId); using (ProgressDialogWithTask progress = new ProgressDialogWithTask(this)) { progress.Title = DlgResources.ResourceString("kstidOverwriteCaption"); progress.RunTask(bookMerger.DoPartialOverwrite, sectionsToRemove); } }
/// ------------------------------------------------------------------------------------- /// <summary> /// Perform one-time initialization of a new Scripture project /// </summary> /// <returns>true if data loaded successfully; false, otherwise</returns> /// ------------------------------------------------------------------------------------- protected bool Initialize(IFwSplashScreen splashScreen) { ILangProject lp = m_cache.LangProject; if (m_scr != null) { // Preload all book, section and paragraphs if we already have Scripture PreloadData(m_cache, splashScreen); if (m_scr.BookAnnotationsOS.Count != 0 && m_cache.ScriptureReferenceSystem.BooksOS.Count != 0 && m_scr.PublicationsOC.Count != 0 && lp.KeyTermsList.PossibilitiesOS.Count >= 1 && m_scr.NoteCategoriesOA != null && m_scr.NoteCategoriesOA.PossibilitiesOS.Count > 0) { return true; } } IAdvInd4 existingProgressDlg = null; if (splashScreen != null) existingProgressDlg = splashScreen.ProgressBar as IAdvInd4; using (ProgressDialogWithTask dlg = new ProgressDialogWithTask(Form.ActiveForm)) { try { dlg.RunTask(existingProgressDlg, true, new BackgroundTaskInvoker(InitializeScriptureProject)); } catch (WorkerThreadException e) { UndoResult ures; while (m_cache.Undo(out ures)) ; // Enhance JohnT: make use of ures? MessageBox.Show(Form.ActiveForm, e.InnerException.Message, TeResourceHelper.GetResourceString("kstidApplicationName"), MessageBoxButtons.OK, MessageBoxIcon.Error); return false; } } return true; }
private void DoImport() { using (new WaitCursor(this)) { using (var progressDlg = new ProgressDialogWithTask(this)) { progressDlg.Minimum = 0; progressDlg.Maximum = 100; progressDlg.AllowCancel = true; progressDlg.Restartable = true; progressDlg.Title = String.Format(LexTextControls.ksImportingFrom0, tbPath.Text); try { m_cache.DomainDataByFlid.BeginNonUndoableTask(); m_sLogFile = (string)progressDlg.RunTask(true, ImportLIFT, tbPath.Text); } finally { // This can indirectly try to access Views code in all the PropChanged // handling. This is why the UOW handling has been moved from ImportLIFT // (which executes on a different thread). See FWR-3057. m_cache.DomainDataByFlid.EndNonUndoableTask(); } } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Cleanly exits the FieldWorks process /// </summary> /// ------------------------------------------------------------------------------------ private static void ExitCleanly() { if (s_appServerMode) return; // Continue running even when all apps are shut down if (s_allowFinalShutdown) Logger.WriteEvent("Shutting down"); // To be safe - this method might get called recursively (explicitly and from // Application.Exit() below again). Also could be called when the startup process // did not complete...we picked an app from the command line, but another process // was already handling that project. if (s_cache != null && !s_cache.IsDisposed) { DataUpdateMonitor.ClearSemaphore(); using (var progressDlg = new ProgressDialogWithTask(s_threadHelper)) { progressDlg.Title = string.Format(ResourceHelper.GetResourceString("kstidShutdownCaption"), s_cache.ProjectId.UiName); progressDlg.AllowCancel = false; progressDlg.IsIndeterminate = true; var stackMgr = s_cache.ServiceLocator.GetInstance<IUndoStackManager>(); if (stackMgr.HasUnsavedChanges) progressDlg.RunTask(true, CommitAndDisposeCache); else { // For whatever reasons the progress dialog sometimes got closed while // the worker was still busy which caused a hang. CommitAndDisposeCache(progressDlg, null); } } } // This has to be done to zap anything in it weven during a restart triggered by S/R. SingletonsContainer.Release(); if (s_allowFinalShutdown) { Logger.ShutDown(); Application.Exit(); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// If the current Scripture Note categories list version in the Db doesn't match that of /// the current XML file, update the DB. /// </summary> /// <param name="lp">The language project</param> /// <param name="existingProgressDlg">The existing progress dialog, if any.</param> /// ------------------------------------------------------------------------------------ public static void EnsureCurrentScrNoteCategories(ILangProject lp, IAdvInd4 existingProgressDlg) { XmlNode scrNoteCategories = LoadScrNoteCategoriesDoc(); IScripture scr = lp.TranslatedScriptureOA; Guid newVersion = Guid.Empty; try { XmlNode version = scrNoteCategories.Attributes.GetNamedItem("version"); newVersion = new Guid(version.Value); } catch (Exception e) { ReportInvalidInstallation("List version attribute invalid in TeScrNoteCategories.xml", e); } if (scr.NoteCategoriesOA == null || newVersion != scr.NoteCategoriesOA.ListVersion) { using (ProgressDialogWithTask dlg = new ProgressDialogWithTask(Form.ActiveForm)) { dlg.RunTask(existingProgressDlg, true, new BackgroundTaskInvoker(CreateScrNoteCategories), scrNoteCategories, scr); } } }
protected override void OnFinishButton() { base.OnFinishButton(); SaveSettings(); if (string.IsNullOrEmpty(m_fileListBox.Text)) return; using (var dlg = new ProgressDialogWithTask(this)) { dlg.AllowCancel = false; dlg.Minimum = 0; // Allow 100 units of progress for each file for now. This allows for plenty of resolution for the LL importer dlg.Maximum = InputFiles.Count() * 100; try { dlg.RunTask(true, DoConversion); } catch (WorkerThreadException ex) // any exception on the worker thread is converted to this { // JohnT: I hate to just report and otherwise ignore all exceptions, but have not been able to find any doc of which ones, // if any, EncConverters may throw. System.Diagnostics.Debug.WriteLine("Error: " + ex.InnerException.Message); MessageBox.Show(this, String.Format(ITextStrings.ksSfmImportProblem, ex.InnerException.Message), ITextStrings.ksUnhandledError, MessageBoxButtons.OK, MessageBoxIcon.Error); DialogResult = DialogResult.Cancel; Close(); } } m_mediator.SendMessage("MasterRefresh", ActiveForm); if (m_firstNewText != null) { // try to select it. var clerk = RecordClerk.FindClerk(m_mediator, "interlinearTexts"); if (clerk != null) clerk.JumpToRecord(m_firstNewText.ContentsOA.Hvo); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// If all of the books are "new" or auto-merged, then don't actually show the dialog. /// See TE-7072 and TE-2126. Otherwise, show the dialog and process normally. /// </summary> /// <param name="wnd"></param> /// ------------------------------------------------------------------------------------ public void ShowOrSave(IWin32Window wnd) { int cNewOrAutoMerged = 0; m_owningForm = wnd as Form; foreach (ListViewItem item in lstImportedBooks.Items) { BookMerger bookMerger = item.Tag as BookMerger; if (bookMerger == null) { ++cNewOrAutoMerged; continue; } using (ProgressDialogWithTask progressDlg = new ProgressDialogWithTask(m_owningForm)) { bookMerger.AttemptAutoMerge = true; bookMerger.BookVersionAgent = this; bookMerger.UseFilteredDiffList(); progressDlg.Title = DlgResources.ResourceString("kstidCompareCaption"); Debug.Assert(bookMerger.BookRev != null); progressDlg.Message = string.Format( DlgResources.ResourceString("kstidMergeProgress"), bookMerger.BookRev.BestUIName); #if DEBUG_SINGLE_THREADED progressDlg.RunTask_DebuggingOnly(true, new BackgroundTaskInvoker( bookMerger.DetectDifferences)); #else progressDlg.RunTask(true, new BackgroundTaskInvoker(bookMerger.DetectDifferences)); #endif } if (bookMerger.AutoMerged) { SetItemStatus(item, ImportedBookStatus.AutoMerged); cNewOrAutoMerged++; } } if (cNewOrAutoMerged < lstImportedBooks.Items.Count) ShowDialog(wnd); else OnClosed(null); }
protected override void DoExport(string outPath) { using (var dlg = new ProgressDialogWithTask(this) { IsIndeterminate = true, AllowCancel = false, Message = ITextStrings.ksExporting_ }) { try { var fxtPath = (string)m_exportList.SelectedItems[0].Tag; // read fxtPath here to prevent access to m_exportList on another thread dlg.RunTask(DoExportWithProgress, outPath, fxtPath); } finally { Close(); } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Performs a partial overwrite of the book using the imported portion of the book. /// </summary> /// <param name="bookMerger">The book merger.</param> /// <param name="sectionsToRemove">The sections to remove as the first step (before /// calling the auto-merge code).</param> /// ------------------------------------------------------------------------------------ protected virtual void PartialOverwrite(BookMerger bookMerger, List<IScrSection> sectionsToRemove) { using (ProgressDialogWithTask progress = new ProgressDialogWithTask(this)) { progress.Title = DlgResources.ResourceString("kstidOverwriteCaption"); progress.RunTask(true, new BackgroundTaskInvoker(bookMerger.DoPartialOverwrite), sectionsToRemove); } }
private ScrReference InternalImport(IScrImportSet importSettings, bool fDisplayUi) { ScrReference firstImported = ScrReference.Empty; bool fPartialBtImported = false; try { Logger.WriteEvent("Starting import"); using (var progressDlg = new ProgressDialogWithTask(m_mainWnd)) { progressDlg.CancelButtonText = TeResourceHelper.GetResourceString("kstidStopImporting"); progressDlg.Title = TeResourceHelper.GetResourceString("kstidImportProgressCaption"); progressDlg.Message = TeResourceHelper.GetResourceString("kstidImportInitializing"); using (TeImportUi importUi = CreateTeImportUi(progressDlg)) { firstImported = (ScrReference)progressDlg.RunTask(fDisplayUi, ImportTask, importSettings, m_undoImportManager, importUi); } } } catch (WorkerThreadException e) { if (e.InnerException is ScriptureUtilsException) { var se = (ScriptureUtilsException)e.InnerException; if (m_helpTopicProvider != null) { string sCaption = GetDialogCaption(se.ImportErrorCodeType); // TODO-Linux: Help is not implemented in Mono MessageBox.Show(m_mainWnd, se.Message, sCaption, MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, 0, m_helpTopicProvider.HelpFile, HelpNavigator.Topic, se.HelpTopic); } if (se.ImportErrorCodeType == ErrorCodeType.BackTransErrorCode && !se.InterleavedImport) fPartialBtImported = true; } else if (e.InnerException is ParatextLoadException) { if (!MiscUtils.RunningTests) { Logger.WriteError(e); string sCaption = ScriptureUtilsException.GetResourceString("kstidImportErrorCaption"); Exception innerE = e.InnerException; var sbMsg = new StringBuilder(innerE.Message); while (innerE.InnerException != null) { innerE = innerE.InnerException; sbMsg.AppendLine(); sbMsg.Append(innerE.Message); } MessageBoxUtils.Show(m_mainWnd, sbMsg.ToString(), sCaption, MessageBoxButtons.OK, MessageBoxIcon.Error); } } else if (!(e.InnerException is CancelException)) { // User didn't just cancel import in the middle of a book -- let's die. throw; } } if (m_undoImportManager.ImportedBooks.Count == 0 && !fPartialBtImported) { Logger.WriteEvent("Nothing imported. Undoing Import."); // Either there was nothing in the file, or the user canceled during the first book. // In any case, we didn't get any books, so whatever has been done should be undone. m_undoImportManager.UndoEntireImport(); return null; } return firstImported; }
protected void DoExport(string outPath, bool fLiftOutput) { string fxtPath = (string)m_exportItems[0].Tag; FxtType ft = m_rgFxtTypes[FxtIndex(fxtPath)]; using (new WaitCursor(this)) { using (var progressDlg = new ProgressDialogWithTask(this)) { try { progressDlg.Title = String.Format(xWorksStrings.Exporting0, m_exportItems[0].SubItems[0].Text); progressDlg.Message = xWorksStrings.Exporting_; switch (ft.m_ft) { case FxtTypes.kftFxt: m_dumper = new XDumper(m_cache); m_dumper.UpdateProgress += OnDumperUpdateProgress; m_dumper.SetProgressMessage += OnDumperSetProgressMessage; progressDlg.Minimum = 0; progressDlg.Maximum = m_dumper.GetProgressMaximum(); progressDlg.AllowCancel = true; progressDlg.Restartable = true; progressDlg.RunTask(true, ExportFxt, outPath, fxtPath, fLiftOutput); break; case FxtTypes.kftConfigured: case FxtTypes.kftReversal: case FxtTypes.kftClassifiedDict: progressDlg.Minimum = 0; progressDlg.Maximum = m_seqView.ObjectCount; progressDlg.AllowCancel = true; IVwStylesheet vss = m_seqView.RootBox == null ? null : m_seqView.RootBox.Stylesheet; progressDlg.RunTask(true, ExportConfiguredDocView, outPath, fxtPath, ft, vss); break; case FxtTypes.kftTranslatedLists: progressDlg.Minimum = 0; progressDlg.Maximum = m_translatedLists.Count; progressDlg.AllowCancel = true; progressDlg.RunTask(true, ExportTranslatedLists, outPath); break; case FxtTypes.kftSemanticDomains: // Potentially, we could count semantic domains and try to make the export update for each. // In practice this only takes a second or two on a typical modern computer // an the main export routine is borrowed from kftTranslatedLists and set up to count each // list as one step. For now, claiming this export just has one step seems good enough. progressDlg.Minimum = 0; progressDlg.Maximum = 1; progressDlg.AllowCancel = true; progressDlg.RunTask(true, ExportSemanticDomains, outPath, ft, fxtPath, m_allQuestions); break; case FxtTypes.kftPathway: break; case FxtTypes.kftLift: progressDlg.Minimum = 0; progressDlg.Maximum = 1000; progressDlg.AllowCancel = true; progressDlg.Restartable = true; progressDlg.RunTask(true, ExportLift, outPath, ft.m_filtered); break; case FxtTypes.kftGrammarSketch: progressDlg.Minimum = 0; progressDlg.Maximum = 1000; progressDlg.AllowCancel = true; progressDlg.Restartable = true; progressDlg.RunTask(true, ExportGrammarSketch, outPath, ft.m_sDataType, ft.m_sXsltFiles); break; } } catch (WorkerThreadException e) { if (e.InnerException is CancelException) { MessageBox.Show(this, e.InnerException.Message); m_ce = null; } else if (e.InnerException is LiftFormatException) { // Show the pretty yellow semi-crash dialog box, with instructions for the // user to report the bug. var app = (IApp) m_mediator.PropertyTable.GetValue("App"); ErrorReporter.ReportException(new Exception(xWorksStrings.ksLiftExportBugReport, e.InnerException), app.SettingsKey, m_mediator.FeedbackInfoProvider.SupportEmailAddress, this, false); } else { string msg = xWorksStrings.ErrorExporting_ProbablyBug + Environment.NewLine + e.InnerException.Message; MessageBox.Show(this, msg); } } finally { m_progressDlg = null; m_dumper = null; Close(); } } } }
/// <summary> /// Run the utility on command from the main utility dialog. /// </summary> public void Process() { Debug.Assert(m_dlg != null); using (var dlg = new FixErrorsDlg()) { try { if (dlg.ShowDialog(m_dlg) == DialogResult.OK) { string pathname = Path.Combine( Path.Combine(FwDirectoryFinder.ProjectsDirectory, dlg.SelectedProject), dlg.SelectedProject + FdoFileHelper.ksFwDataXmlFileExtension); if (File.Exists(pathname)) { using (new WaitCursor(m_dlg)) { using (var progressDlg = new ProgressDialogWithTask(m_dlg)) { string fixes = (string)progressDlg.RunTask(true, FixDataFile, pathname); if (fixes.Length > 0) { MessageBox.Show(fixes, Strings.ksErrorsFoundOrFixed); File.WriteAllText(pathname.Replace(FdoFileHelper.ksFwDataXmlFileExtension, "fixes"), fixes); } } } } } } catch { } } }
/// <summary> /// Import the lift file using the given MergeStyle: /// FlexLiftMerger.MergeStyle.MsKeepNew (aka 'merciful', in that all entries from lift file and those in FLEx are retained) /// FlexLiftMerger.MergeStyle.MsKeepOnlyNew (aka 'merciless', /// in that the Flex lexicon ends up with the same entries as in the lift file, even if some need to be deleted in FLEx.) /// </summary> /// <param name="mergeStyle">FlexLiftMerger.MergeStyle.MsKeepNew or FlexLiftMerger.MergeStyle.MsKeepOnlyNew</param> /// <returns>'true' if the import succeeded, otherwise 'false'.</returns> private bool ImportLiftCommon(FlexLiftMerger.MergeStyle mergeStyle) { using (new WaitCursor(_parentForm)) { using (var progressDlg = new ProgressDialogWithTask(_parentForm)) { _progressDlg = progressDlg; try { if(mergeStyle == FlexLiftMerger.MergeStyle.MsKeepBoth) { LiftImportFailureServices.RegisterBasicImportFailure(Path.GetDirectoryName(_liftPathname)); } else { LiftImportFailureServices.RegisterStandardImportFailure(Path.GetDirectoryName(_liftPathname)); } progressDlg.Title = ResourceHelper.GetResourceString("kstidImportLiftlexicon"); var logFile = (string)progressDlg.RunTask(true, ImportLiftLexicon, new object[] { _liftPathname, mergeStyle }); if(logFile != null) { LiftImportFailureServices.ClearImportFailure(Path.GetDirectoryName(_liftPathname)); return true; } LiftImportFailureServices.DisplayLiftFailureNoticeIfNecessary(_parentForm, _liftPathname); return false; } catch (WorkerThreadException error) { // It appears to be an analyst issue to sort out how we should report this. // LT-12340 however says we must report it somehow. var sMsg = String.Format(LexEdStrings.kProblemImportWhileMerging, _liftPathname, error.InnerException.Message); MessageBoxUtils.Show(sMsg, LexEdStrings.kProblemMerging, MessageBoxButtons.OK, MessageBoxIcon.Warning); return false; } finally { _progressDlg = null; } } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Handles paginating the whole document /// </summary> /// <param name="args">ignored</param> /// <returns><c>true</c> because we handled it</returns> /// ------------------------------------------------------------------------------------ public virtual bool OnViewUpdatePageBreak(object args) { CheckDisposed(); IVwRootBox focusedRootBox = FocusedRootBox; using (var dialog = new ProgressDialogWithTask(FindForm())) { dialog.CancelButtonText = ResourceHelper.GetResourceString("kstidUpdatePageBreakButtonText"); dialog.Title = ResourceHelper.GetResourceString("kstidUpdatePageBreakWindowCaption"); dialog.AllowCancel = true; dialog.RunTask(true, UpdatePageBreaks, DpiXPrinter, DpiYPrinter); } // make sure the selection is in view if (focusedRootBox != null && focusedRootBox.Selection != null && focusedRootBox.Selection.IsValid) ScrollSelectionIntoView(focusedRootBox.Selection, VwScrollSelOpts.kssoDefault); return true; }
/// <summary> /// Export the FieldWorks lexicon into the LIFT file. /// The file may, or may not, exist. /// </summary> /// <returns>True, if the import successful, otherwise false.</returns> /// <remarks> /// This method calls an overloaded ExportLiftLexicon, which is run in a thread. /// </remarks> public bool ExportLiftLexicon() { using (new WaitCursor(_parentForm)) { using (var progressDlg = new ProgressDialogWithTask(_parentForm)) { _progressDlg = progressDlg; try { progressDlg.Title = ResourceHelper.GetResourceString("kstidExportLiftLexicon"); var outPath = (string)progressDlg.RunTask(true, ExportLiftLexicon, null); var retval = (!String.IsNullOrEmpty(outPath)); if (!retval && CanUndoLiftExport) { UndoExport(); } return retval; } catch { if (CanUndoLiftExport) { UndoExport(); } return false; } finally { _progressDlg = null; } } } }