/// ------------------------------------------------------------------------------------- /// <summary> /// Calls the TePublicationsInit.CreateHfSets method to create a HeaderFooterSet for each /// HeaderFooterSet node in the given xml node list. /// </summary> /// <param name="hfSetNodes">the xml nodes to read</param> /// ------------------------------------------------------------------------------------- internal void CallCreateHfSets(XmlNodeList hfSetNodes) { using (ProgressDialogWithTask progressDlg = new ProgressDialogWithTask(Form.ActiveForm)) { base.CreateHfSets(progressDlg, hfSetNodes); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Exposes the <see cref="TeScrInitializer.CreateScrBookRefs"/> method /// </summary> /// <param name="cache"></param> /// ------------------------------------------------------------------------------------ public void CallCreateScrBookRefs(FdoCache cache) { using (ProgressDialogWithTask progressDlg = new ProgressDialogWithTask(Form.ActiveForm)) { CreateScrBookRefs(progressDlg); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the ChooseScriptureDialog class. /// WARNING: this constructor is called by reflection, at least in the Interlinear /// Text DLL. If you change its parameters be SURE to find and fix those callers also. /// </summary> /// <param name="cache">The cache.</param> /// <param name="objList">A list of texts and books to check as an array of hvos</param> /// <param name="helpTopicProvider">The help topic provider.</param> /// <param name="importer">The Paratext book importer.</param> /// ------------------------------------------------------------------------------------ public FilterTextsDialogTE(FdoCache cache, IStText[] objList, IHelpTopicProvider helpTopicProvider, IBookImporter importer) : base(cache, objList, helpTopicProvider) { m_bookImporter = importer; using (var progressDlg = new ProgressDialogWithTask(this)) { // This somewhat duplicates some logic in FieldWorks.GetHelpTopicProvider, but it feels // wrong to reference the main exe even though I can't find an actual circular dependency. // As far as I can discover, the help topic provider is only used if the user has modified // TE styles and TE needs to display a dialog about it (possibly because it has loaded a // new version of the standard ones?). Anyway, I don't think it will be used at all if TE // is not installed, so it should be safe to use the regular FLEx one. IHelpTopicProvider helpProvider; if (FwUtils.FwUtils.IsTEInstalled) { helpProvider = (IHelpTopicProvider)DynamicLoader.CreateObject(FwDirectoryFinder.TeDll, "SIL.FieldWorks.TE.TeHelpTopicProvider"); } else { helpProvider = (IHelpTopicProvider)DynamicLoader.CreateObject(FwDirectoryFinder.FlexDll, "SIL.FieldWorks.XWorks.LexText.FlexHelpTopicProvider"); } NonUndoableUnitOfWorkHelper.Do(cache.ActionHandlerAccessor, () => TeScrInitializer.EnsureMinimalScriptureInitialization(cache, progressDlg, helpProvider)); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the ChooseScriptureDialog class. /// WARNING: this constructor is called by reflection, at least in the Interlinear /// Text DLL. If you change its parameters be SURE to find and fix those callers also. /// </summary> /// <param name="cache">The cache.</param> /// <param name="objList">A list of texts and books to check as an array of hvos</param> /// <param name="helpTopicProvider">The help topic provider.</param> /// <param name="importer">The Paratext book importer.</param> /// ------------------------------------------------------------------------------------ public FilterTextsDialogTE(FdoCache cache, IStText[] objList, IHelpTopicProvider helpTopicProvider, IBookImporter importer) : base(cache, objList, helpTopicProvider) { m_bookImporter = importer; using (var progressDlg = new ProgressDialogWithTask(this)) { // This somewhat duplicates some logic in FieldWorks.GetHelpTopicProvider, but it feels // wrong to reference the main exe even though I can't find an actual circular dependency. // As far as I can discover, the help topic provider is only used if the user has modified // TE styles and TE needs to display a dialog about it (possibly because it has loaded a // new version of the standard ones?). Anyway, I don't think it will be used at all if TE // is not installed, so it should be safe to use the regular FLEx one. IHelpTopicProvider helpProvider; if (FwUtils.FwUtils.IsTEInstalled) { helpProvider = (IHelpTopicProvider) DynamicLoader.CreateObject(FwDirectoryFinder.TeDll, "SIL.FieldWorks.TE.TeHelpTopicProvider"); } else { helpProvider = (IHelpTopicProvider)DynamicLoader.CreateObject(FwDirectoryFinder.FlexDll, "SIL.FieldWorks.XWorks.LexText.FlexHelpTopicProvider"); } NonUndoableUnitOfWorkHelper.Do(cache.ActionHandlerAccessor, () => TeScrInitializer.EnsureMinimalScriptureInitialization(cache, progressDlg, helpProvider)); } }
/// ------------------------------------------------------------------------------------ /// <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")); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="T:TeImportUi"/> class. /// </summary> /// <param name="progressDialog">The progress dialog.</param> /// ------------------------------------------------------------------------------------ public TeImportUi(ProgressDialogWithTask progressDialog) { m_progressDialog = progressDialog; if (m_progressDialog != null) // might be null for tests m_progressDialog.Cancel += new CancelHandler(OnCancelPressed); m_ctrl = new Control(); m_ctrl.CreateControl(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Exposes the CreateScrStyles method /// </summary> /// ------------------------------------------------------------------------------------ static public void CallCreateScrStyles(IScripture scr, XmlNode teStyles) { using (ProgressDialogWithTask progressDlg = new ProgressDialogWithTask(Form.ActiveForm)) { DummyTeStylesXmlAccessor acc = new DummyTeStylesXmlAccessor(scr, teStyles); acc.InitLoading(progressDlg, scr, teStyles); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="TeImportUi"/> class. /// </summary> /// <param name="progressDialog">The progress dialog.</param> /// <param name="helpTopicProvider">The help topic provider.</param> /// ------------------------------------------------------------------------------------ public TeImportUi(ProgressDialogWithTask progressDialog, IHelpTopicProvider helpTopicProvider) { m_progressDialog = progressDialog; if (m_progressDialog != null) m_progressDialog.Canceling += OnCancelPressed; m_helpTopicProvider = helpTopicProvider; m_ctrl = new Control(); m_ctrl.CreateControl(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the ChooseScriptureDialog class. /// WARNING: this constructor is called by reflection, at least in the Interlinear /// Text DLL. If you change its parameters be SURE to find and fix those callers also. /// </summary> /// <param name="cache">The cache.</param> /// <param name="objList">A list of texts and books to check as an array of hvos</param> /// <param name="helpTopicProvider">The help topic provider.</param> /// <param name="importer">The Paratext book importer.</param> /// ------------------------------------------------------------------------------------ public FilterTextsDialogTE(FdoCache cache, IStText[] objList, IHelpTopicProvider helpTopicProvider, IBookImporter importer) : base(cache, objList, helpTopicProvider) { m_bookImporter = importer; using (var progressDlg = new ProgressDialogWithTask(null, cache.ThreadHelper)) { NonUndoableUnitOfWorkHelper.Do(cache.ActionHandlerAccessor, () => TeScrInitializer.EnsureMinimalScriptureInitialization(cache, progressDlg, (IHelpTopicProvider)DynamicLoader.CreateObject(DirectoryFinder.TeDll, "SIL.FieldWorks.TE.TeHelpTopicProvider"))); } }
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(); } } } }
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(); }
// 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 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; }
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> /// Creates a TeImportUi object. /// </summary> /// <param name="progressDialog">The progress dialog.</param> /// <returns>A TeImportUi object</returns> /// <remarks>Can be overriden in tests</remarks> /// ------------------------------------------------------------------------------------ protected virtual TeImportUi CreateTeImportUi(ProgressDialogWithTask progressDialog) { return new TeImportUi(progressDialog, m_helpTopicProvider); }
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(); } } } }
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(); } } }
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)) { } } } } }
private void m_backUp_Click(object sender, EventArgs e) { if (!Path.IsPathRooted(DestinationFolder)) { MessageBox.Show(this, FwCoreDlgs.ksBackupErrorRelativePath, FwCoreDlgs.ksErrorCreatingBackupDirCaption, MessageBoxButtons.OK, MessageBoxIcon.Warning); m_destinationFolder.Select(); DialogResult = DialogResult.None; return; } if (!Directory.Exists(DestinationFolder)) { try { Directory.CreateDirectory(DestinationFolder); } catch (Exception e1) { MessageBox.Show(this, e1.Message, FwCoreDlgs.ksErrorCreatingBackupDirCaption, MessageBoxButtons.OK, MessageBoxIcon.Warning); m_destinationFolder.Select(); DialogResult = DialogResult.None; return; } } if (!DestinationFolder.Equals(FwDirectoryFinder.DefaultBackupDirectory)) { using (var dlgChangeDefaultBackupLocation = new ChangeDefaultBackupDir(m_helpTopicProvider)) { if (dlgChangeDefaultBackupLocation.ShowDialog(this) == DialogResult.Yes) FwDirectoryFinder.DefaultBackupDirectory = DestinationFolder; } } if (m_presenter.FileNameProblems(this)) return; try { using (new WaitCursor(this)) using (var progressDlg = new ProgressDialogWithTask(this)) { BackupFilePath = m_presenter.BackupProject(progressDlg); } } catch (FwBackupException be) { MessageBox.Show(this, string.Format(FwCoreDlgs.ksBackupErrorCreatingZipfile, be.ProjectName, be.Message), FwCoreDlgs.ksBackupErrorCaption, MessageBoxButtons.OK, MessageBoxIcon.Warning); DialogResult = DialogResult.None; } }
static void Main(string[] arguments) { // <summary> // any filters that we want, for example, to only output items which satisfy their constraint. // </summary> IFilterStrategy[] filters=null; if (arguments.Length < 3) { Console.WriteLine("usage: fxt dbName fxtTemplatePath xmlOutputPath (-guids)"); Console.WriteLine(""); Console.WriteLine("example using current directory: fxt TestLangProj WebPageSample.xhtml LangProj.xhtml"); Console.WriteLine("example with environment variables: fxt ZPU \"%fwroot%/distfiles/fxtTest.fxt\" \"%temp%/fxtTest.xml\""); return; } string fxtPath = System.Environment.ExpandEnvironmentVariables(arguments[1]); if(!File.Exists(fxtPath)) { Console.WriteLine("could not find the file "+fxtPath); return; } string outputPath = System.Environment.ExpandEnvironmentVariables(arguments[2]); FdoCache cache = null; try { Console.WriteLine("Initializing cache..."); var bepType = GetBEPTypeFromFileExtension(fxtPath); var isMemoryBEP = bepType == FDOBackendProviderType.kMemoryOnly; var threadHelper = new ThreadHelper(); var consoleProj = new ConsoleProgress(); if (isMemoryBEP) cache = FdoCache.CreateCacheWithNewBlankLangProj(new BrowserProjectId(bepType, null), "en", "en", "en", threadHelper); else { using (var progressDlg = new ProgressDialogWithTask(consoleProj)) { cache = FdoCache.CreateCacheFromExistingData(new BrowserProjectId(bepType, fxtPath), "en", progressDlg); } } } catch (Exception error) { Console.WriteLine(error.Message); return; } //try //{ // Console.WriteLine("Initializing cache..."); // Dictionary<string, string> cacheOptions = new Dictionary<string, string>(); // cacheOptions.Add("db", arguments[0]); // cache = FdoCache.Create(cacheOptions); //} //catch (Exception error) //{ // Console.WriteLine(error.Message); // return; //} Console.WriteLine("Beginning output..."); DateTime dtstart = DateTime.Now; XDumper d = new XDumper(cache); if (arguments.Length == 4) { if(arguments[3] == "-parserDump") { filters = new IFilterStrategy[]{new ConstraintFilterStrategy()}; } else //boy do we have a brain-dead argument parser in this app! System.Diagnostics.Debug.Assert(arguments[3] == "-guids"); d.OutputGuids = true; } try { d.Go(cache.LangProject as ICmObject, fxtPath, File.CreateText(outputPath), filters); //clean up, add the <?xml tag, etc. Won't be necessary if/when we make the dumper use an xmlwriter instead of a textwriter //was introducing changes such as single quote to double quote XmlDocument doc=new XmlDocument(); // doc.Load(outputPath); // doc.Save(outputPath); } catch (Exception error) { if (cache != null) cache.Dispose(); Console.WriteLine(error.Message); return; } TimeSpan tsTimeSpan = new TimeSpan(DateTime.Now.Ticks - dtstart.Ticks); Console.WriteLine("Finished: " + tsTimeSpan.TotalSeconds.ToString() + " Seconds"); if(outputPath.ToLower().IndexOf("fxttestout") > -1) System.Diagnostics.Debug.WriteLine(File.OpenText(outputPath).ReadToEnd()); if (cache != null) cache.Dispose(); System.Diagnostics.Debug.WriteLine("Finished: " + tsTimeSpan.TotalSeconds.ToString() + " Seconds"); }
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> /// 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)); } }
/// <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; } } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// <param name="disposing"></param> /// ------------------------------------------------------------------------------------ protected virtual void Dispose(bool disposing) { System.Diagnostics.Debug.WriteLineIf(!disposing, "****** Missing Dispose() call for " + GetType().Name + ". ****** "); if (disposing) { if (m_ctrl != null) m_ctrl.Dispose(); } m_ctrl = null; m_progressDialog = null; m_importer = null; m_fDisposed = true; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="T:DummyTeImportUi"/> class. /// </summary> /// <param name="progressDlg">The progress DLG.</param> /// ------------------------------------------------------------------------------------ public DummyTeImportUi(ProgressDialogWithTask progressDlg) : base() { }
/// ------------------------------------------------------------------------------------ /// <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); } }
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> /// 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> ///// Sets a value indicating whether to simulate deleting all books. ///// </summary> ///// ------------------------------------------------------------------------------------ //internal bool SimulateDeleteAllBooks //{ // set // { // if (value && m_fSimulateAcceptAllBooks) // throw new Exception("SimulateAcceptAllBooks and SimulateDeleteAllBooks cannot both be set to true."); // m_fSimulateDeleteAllBooks = value; // } //} #endregion #region Overridden methods /// ------------------------------------------------------------------------------------ /// <summary> /// Creates a TeImportUi object. /// </summary> /// <param name="progressDialog">The progress dialog.</param> /// <returns>A TeImportUi object</returns> /// <remarks>Can be overriden in tests</remarks> /// ------------------------------------------------------------------------------------ protected override TeImportUi CreateTeImportUi(ProgressDialogWithTask progressDialog) { return new DummyTeImportUi(progressDialog); }
/// ------------------------------------------------------------------------------------ /// <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> /// 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; }