/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="T:KeyTermsControl"/> class. /// </summary> /// <param name="sCaption">The caption to use when this control is displayed as a /// floating window</param> /// <param name="sProject">The name of the current project</param> /// ------------------------------------------------------------------------------------ internal KeyTermsControl(string sCaption, string sProject) : base(sCaption, sProject) { InitializeComponent(); m_sepShowOnlyAtTop = new ToolStripSeparator(); m_ToolStrip.Items.Insert(0, m_sepShowOnlyAtTop); AddToolStripButton(0, TeResourceHelper.KeyTermFilterImage, TeResourceHelper.GetTmResourceString("kstidApplyFilterToKeyTermsToolTip")); m_tbbApplyFilter = m_ToolStrip.Items[0] as ToolStripButton; m_ToolStrip.Items.Insert(0, new ToolStripSeparator()); AddToolStripButton(0, TeResourceHelper.KeyTermNotRenderedImage, TeResourceHelper.GetTmResourceString("kstidVernEqNotAssignedToolTip")); m_tbbNotRendered = m_ToolStrip.Items[0] as ToolStripButton; AddToolStripButton(0, TeResourceHelper.KeyTermIgnoreRenderingImage, TeResourceHelper.GetTmResourceString("kstidNotRenderedToolTip")); m_tbbVernNotAssigned = m_ToolStrip.Items[0] as ToolStripButton; AddToolStripButton(0, TeResourceHelper.KeyTermRenderedImage, TeResourceHelper.GetTmResourceString("kstidUseAsVernEqToolTip")); m_tbbUseAsVern = m_ToolStrip.Items[0] as ToolStripButton; m_ToolStrip.Items.Insert(0, new ToolStripSeparator()); AddToolStripButton(0, TeResourceHelper.UpdateKeyTermEquivalentsImage, TeResourceHelper.GetTmResourceString("kstidUpdateKeyTermEquivalentsToolTip")); m_tbbUpdateKeyTermEquivalents = m_ToolStrip.Items[0] as ToolStripButton; m_ToolStrip.ItemClicked += new ToolStripItemClickedEventHandler(OnItemClicked); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Shows the category chooser dialog to let the user set the category for the /// specified annotation. /// </summary> /// ------------------------------------------------------------------------------------ private void SetAnnotationCategory(IScrScriptureNote ann) { if (ann == null) { return; // Not much we can do } m_rootb.DestroySelection(); string sUndo, sRedo; TeResourceHelper.MakeUndoRedoLabels("kstidSetAnnotationCategory", out sUndo, out sRedo); using (new WaitCursor(this)) using (CategoryChooserDlg dlg = new CategoryChooserDlg(m_scr.NoteCategoriesOA, ann.CategoriesRS.ToHvoArray(), m_helpTopicProvider, TheMainWnd.App)) { if (dlg.ShowDialog(ParentForm) == DialogResult.OK) { using (UndoTaskHelper undoHelper = new UndoTaskHelper(this, sUndo, sRedo)) { dlg.GetPossibilities(ann.CategoriesRS); ann.DateModified = DateTime.Now; undoHelper.RollBack = false; } } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Load the Paratext project and enumerator, preparing us to read the data files. /// </summary> /// <param name="paratextProjectId">3-letter Paratext project ID</param> /// <returns>true if the project was loaded, else false</returns> /// ------------------------------------------------------------------------------------ protected virtual void LoadParatextProject(string paratextProjectId) { try { m_ptProjectText = ScriptureProvider.MakeScrText(paratextProjectId); } catch (Exception e) { // Can't load Paratext project if Paratext is not installed. throw new ParatextLoadException( TeResourceHelper.GetResourceString("kstidCheckParatextInstallation"), e); } try { // create ref objs of the Paratext lib Logger.WriteEvent("Loading Paratext project " + paratextProjectId + " to import from " + m_settings.StartRef.AsString + " to " + m_settings.EndRef.AsString); // Now initialize the TextEnum with the range of Scripture text we want m_ptParser = m_ptProjectText.Parser; m_ptCurrBook = ScriptureProvider.MakeVerseRef(m_settings.StartRef.Book, 0, 0); ResetParatextState(); } catch (Exception e) { string msg = string.Format( TeResourceHelper.GetResourceString("kstidParatextProjectLoadFailure"), paratextProjectId); throw new ParatextLoadException(msg, e); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="BookPropertiesDialog"/> class. /// </summary> /// <param name="book">the current book</param> /// <param name="stylesheet">The stylesheet.</param> /// <param name="helpTopicProvider">The help topic provider.</param> /// ------------------------------------------------------------------------------------ public BookPropertiesDialog(IScrBook book, IVwStylesheet stylesheet, IHelpTopicProvider helpTopicProvider) { m_currentBook = book; m_helpTopicProvider = helpTopicProvider; // TE-5663: make sure the book's name and abbreviation are updated if some were added IScrRefSystem scrRefSystem = book.Cache.ServiceLocator.GetInstance <IScrRefSystemRepository>().AllInstances().FirstOrDefault(); book.Name.MergeAlternatives(scrRefSystem.BooksOS[book.CanonicalNum - 1].BookName); book.Abbrev.MergeAlternatives(scrRefSystem.BooksOS[book.CanonicalNum - 1].BookAbbrev); // // Required for Windows Form Designer support // InitializeComponent(); // Put the book name in the dialog caption Text = string.Format(Text, book.Name.UserDefaultWritingSystem.Text); m_listBookInfo.Cache = book.Cache; m_listBookInfo.FieldsToDisplay.Add(new FwMultilingualPropView.ColumnInfo( ScrBookTags.kflidName, TeResourceHelper.GetResourceString("kstidBookNameColHeader"), 60)); m_listBookInfo.FieldsToDisplay.Add(new FwMultilingualPropView.ColumnInfo( ScrBookTags.kflidAbbrev, TeResourceHelper.GetResourceString("kstidBookAbbrevColHeader"), 40)); m_listBookInfo.RootObject = book.Hvo; foreach (IWritingSystem ws in book.Cache.ServiceLocator.WritingSystems.AllWritingSystems) { m_listBookInfo.WritingSystemsToDisplay.Add(ws.Handle); } // Initialize the ID textbox. m_txtScrBookIdText.Text = m_currentBook.IdText; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Throws an exception. Release mode overrides the message. /// </summary> /// <param name="message">The message to display (in debug mode)</param> /// <param name="e">Optional inner exception</param> /// ------------------------------------------------------------------------------------ static protected void ReportInvalidInstallation(string message, Exception e) { #if !DEBUG message = TeResourceHelper.GetResourceString("kstidInvalidInstallation"); #endif throw new Exception(message, e); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="ExportUsfmDialog"/> class. /// </summary> /// <param name="cache">database cache</param> /// <param name="filter">book filter to display which books we will export</param> /// <param name="appKey">location of registry</param> /// <param name="markup">type of markup format for export: /// Paratext (one domain, non-interleaved) OR Toolbox (optionally interleaved)</param> /// ------------------------------------------------------------------------------------ public ExportUsfmDialog(FdoCache cache, FilteredScrBooks filter, RegistryKey appKey, MarkupType markup) : this() { m_cache = cache; m_markupType = markup; // let dialog know if this is for Paratext or Toolbox if (appKey != null) // might be null in tests - in this case derived class has to provide a m_regGroup { m_regGroup = new RegistryGroup(appKey, "ExportUsfmSettings"); } // Display books and markup labels string filtered = (filter.AllBooks ? TeResourceHelper.GetResourceString("kstidExportDlgUnfiltered") : TeResourceHelper.GetResourceString("kstidExportDlgFiltered")); string booksToExport = GetExportedBooksStr(filter); if (filter.BookCount == 1) { lblBooks.Text = string.Format(TeResourceHelper.GetResourceString("kstidBooksToExportSingularForm"), filtered, booksToExport); } else { lblBooks.Text = string.Format(lblBooks.Text, filter.BookCount, filtered, booksToExport); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="T:FilesOverwriteDialog"/> class. /// </summary> /// <param name="filename">name of the file that may be overwritten</param> /// ------------------------------------------------------------------------------------ public FilesOverwriteDialog(string filename) { InitializeComponent(); this.Text = TeResourceHelper.GetResourceString("kstidApplicationName"); lblFilename.Text = filename; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Get a string that describes the Scripture passage based on the selection. /// </summary> /// <param name="tag">The flid of the selected element</param> /// <param name="hvoSel">The hvo of the selected element, either a ScrSection (usually) /// or ScrBook (if in a title)</param> /// <param name="fSimpleFormat">Gets a simple, standardized reference (uses SIL 3-letter /// codes and no verse bridges)</param> /// <returns> /// String that describes the Scripture passage or null if the selection /// can't be interpreted as a book and/or section reference. /// </returns> /// ------------------------------------------------------------------------------------ public override string GetPassageAsString(int tag, int hvoSel, bool fSimpleFormat) { CheckDisposed(); if (m_cache == null) { return(null); } string sEditRef = null; // Title/reference/etc of text being edited in the draft pane switch (tag) { case (int)ScrBook.ScrBookTags.kflidFootnotes: { ScrBook book = new ScrBook(m_cache, hvoSel, false, false); sEditRef = (fSimpleFormat ? (book.BookId + " 0:0") : book.BestUIName); break; } default: return(base.GetPassageAsString(tag, hvoSel, fSimpleFormat)); } // Add the back translation writing system info to the output string, if needed if (IsBackTranslation) { LgWritingSystem ws = new LgWritingSystem(m_cache, ViewConstructorWS); sEditRef = string.Format( TeResourceHelper.GetResourceString("kstidCaptionInBackTrans"), sEditRef, ws.Name.UserDefaultWritingSystem); } return(string.IsNullOrEmpty(sEditRef) ? null : sEditRef); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Deletes a footnote /// </summary> /// <param name="args"></param> /// <returns><c>true</c> if we handle this</returns> /// ------------------------------------------------------------------------------------ protected bool OnDeleteFootnote(object args) { if (DataUpdateMonitor.IsUpdateInProgress() || !ValidFootnoteSelection) { return(true); //discard this event } string undo; string redo; TeResourceHelper.MakeUndoRedoLabels("kstidUndoDelFootnote", out undo, out redo); using (UndoTaskHelper undoTaskHelper = new UndoTaskHelper(this, undo, redo)) using (new DataUpdateMonitor(this, "DeleteFootnote")) { // Put code to do work in separate method for testing DeleteFootnoteAux(); undoTaskHelper.RollBack = false; } // If there are no more footnotes, then give focus back to the main draft view if (RootBox.Height <= 0 && DraftView != null) { DraftView.Focus(); } return(true); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Called when the user pressed the cancel button on the progress dialog. /// </summary> /// ------------------------------------------------------------------------------------ private void OnCancelPressed(object sender, CancelEventArgs e) { CheckDisposed(); Debug.Assert(!m_ctrl.InvokeRequired); try { // pause the import thread, while we ask if they really want to cancel m_importer.Pause(); if (m_importer.PrevBook != null) { string sMsg = string.Format(TeResourceHelper.GetResourceString("kstidConfirmStopImport"), m_importer.PrevBook); if (MessageBox.Show(sMsg, FwUtils.ksTeAppName, MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No) { // the user does not wish to cancel the import, so cancel the event e.Cancel = true; return; } } //Display "stopping" message in progress bar m_progressDialog.Message = TeResourceHelper.GetResourceString("kstidStoppingImport"); m_progressDialog.Position = m_progressDialog.Maximum; } finally { // resume the import thread m_importer.Resume(); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Handles the Click event of the m_btnImport control. /// </summary> /// ------------------------------------------------------------------------------------ private void m_btnImport_Click(object sender, EventArgs e) { if (!File.Exists(m_tbFilename.Text)) { // "{0} does not exist!" string sFmt = TeResourceHelper.GetResourceString("kstidImportXmlNotAFile"); string sMsg = String.Format(sFmt, m_tbFilename.Text); // "Warning" string sCaption = TeResourceHelper.GetResourceString("kstidImportXmlWarning"); MessageBox.Show(sMsg, sCaption, MessageBoxButtons.OK, MessageBoxIcon.Warning); return; } if (VerifyLanguageInOxesFile() && EnsureProperOxesFile()) { string validationErrors = Validator.GetAnyValidationErrors(m_tbFilename.Text); if (validationErrors == null) { this.DialogResult = DialogResult.OK; this.Close(); } else { DisplayImportError(SUE_ErrorCode.OxesValidationFailed, null, null, validationErrors); } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Get a string that describes the Scripture passage based on the selection. /// </summary> /// <param name="tag">The flid of the selected element</param> /// <param name="hvoSel">The hvo of the selected element, either a ScrSection (usually) /// or ScrBook (if in a title)</param> /// <param name="fSimpleFormat">Gets a simple, standardized reference (uses SIL 3-letter /// codes and no verse bridges)</param> /// <returns> /// String that describes the Scripture passage or null if the selection /// can't be interpreted as a book and/or section reference. /// </returns> /// ------------------------------------------------------------------------------------ public override string GetPassageAsString(int tag, int hvoSel, bool fSimpleFormat) { CheckDisposed(); if (m_cache == null) { return(null); } string sEditRef = null; // Title/reference/etc of text being edited in the draft pane switch (tag) { case ScrBookTags.kflidFootnotes: IScrBook book = m_cache.ServiceLocator.GetInstance <IScrBookRepository>().GetObject(hvoSel); sEditRef = (fSimpleFormat ? (book.BookId + " 0:0") : book.BestUIName); break; default: return(base.GetPassageAsString(tag, hvoSel, fSimpleFormat)); } // Add the back translation writing system info to the output string, if needed if (IsBackTranslation) { IWritingSystem ws = m_cache.ServiceLocator.WritingSystemManager.Get(ViewConstructorWS); sEditRef = string.Format( TeResourceHelper.GetResourceString("kstidCaptionInBackTrans"), sEditRef, ws.DisplayLabel); } return(string.IsNullOrEmpty(sEditRef) ? null : sEditRef); }
/// ------------------------------------------------------------------------------------ /// <summary> /// When really, truly done with all merging etc, collapse all the things we can Undo /// for the import into a single Undo Item. /// </summary> /// <returns>True if some actions were collapsed, false otherwise</returns> /// ------------------------------------------------------------------------------------ public bool CollapseAllUndoActions() { string undo; string redo; TeResourceHelper.MakeUndoRedoLabels("kstidImport", out undo, out redo); return(m_cache.DomainDataByFlid.GetActionHandler().CollapseToMark(m_hMark, undo, redo)); }
/// ------------------------------------------------------------------------------------ /// <summary> /// When really, truly done with all merging etc, collapse all the things we can Undo /// for the import into a single Undo Item. /// </summary> /// ------------------------------------------------------------------------------------ public void CollapseAllUndoActions() { string undo; string redo; TeResourceHelper.MakeUndoRedoLabels("kstidImport", out undo, out redo); m_cache.ActionHandlerAccessor.CollapseToMark(m_hMark, undo, redo); }
/// <summary> /// Shut down the TEResourceHelper Form. /// </summary> public static void ShutDownTEResourceHelper() { if (s_form != null) { s_form.Dispose(); s_form = null; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Complain if the context is not valid for the tool that is loading the styles. /// TE currently allows all but Flex's private context /// </summary> /// <returns></returns> /// ------------------------------------------------------------------------------------ protected override void ValidateContext(ContextValues context, string styleName) { if (context == ContextValues.InternalConfigureView) { ReportInvalidInstallation(String.Format(TeResourceHelper.GetResourceString("ksInvalidStyleContext"), styleName, context.ToString(), ResourceFileName)); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Throw an exception if the specified context is not valid for the specified paragraph /// style. TE overrides to forbid 'general' paragraph styles. /// </summary> /// <param name="context"></param> /// <param name="styleName"></param> /// ------------------------------------------------------------------------------------ protected override void ValidateParagraphContext(ContextValues context, string styleName) { if (context == ContextValues.General) { ReportInvalidInstallation(String.Format(TeResourceHelper.GetResourceString("ksInvalidParagraphStyleContext"), styleName, context.ToString())); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="SaveVersionDialog"/> class. /// </summary> /// ------------------------------------------------------------------------------------ public SaveVersionDialog(FdoCache cache, IHelpTopicProvider helpTopicProvider) { m_cache = cache; m_scr = m_cache.LangProject.TranslatedScriptureOA; m_helpTopicProvider = helpTopicProvider; // // Required for Windows Form Designer support // InitializeComponent(); if (m_cache == null) { return; } m_BooksToSave = new List <IScrBook>(); m_treeView.BeginUpdate(); List <TreeNode> otBooks = new List <TreeNode>(); List <TreeNode> ntBooks = new List <TreeNode>(); foreach (IScrBook book in m_scr.ScriptureBooksOS) { TreeNode node = new TreeNode(book.BestUIName); node.Tag = book; if (book.CanonicalNum < ScriptureTags.kiNtMin) { otBooks.Add(node); // OT book } else { ntBooks.Add(node); // NT book } } TreeNode bibleNode = new TreeNode(TeResourceHelper.GetResourceString("kstidBibleNode")); if (otBooks.Count > 0) { bibleNode.Nodes.Add(new TreeNode(TeResourceHelper.GetResourceString("kstidOtNode"), otBooks.ToArray())); } if (ntBooks.Count > 0) { bibleNode.Nodes.Add(new TreeNode(TeResourceHelper.GetResourceString("kstidNtNode"), ntBooks.ToArray())); } m_treeView.Nodes.Add(bibleNode); // REVIEW: once we have sections we probably don't want to expand below book level m_treeView.ExpandAll(); m_treeView.EndUpdate(); // update the ok button enabled state m_treeView_NodeCheckChanged(null, EventArgs.Empty); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Update the interleaved labels to reflect the current state of the check boxes. /// </summary> /// ------------------------------------------------------------------------------------ private void UpdateInterleavedLabels() { // If Scripture is checked, then mark back translation as interleaved chkBackTranslation.Text = m_defaultBtLabel; if (ExportScriptureDomain) { chkBackTranslation.Text += " " + TeResourceHelper.GetResourceString("kstidExportUSFMInterleavedLabel"); } }
/// ------------------------------------------------------------------------------------- /// <summary> /// Create publications and header/footer sets (in the DB) from the given XML document. /// </summary> /// <remarks>tests are able to call this method</remarks> /// <param name="progressDlg">Progress dialog</param> /// <param name="rootNode">The XmlNode from which to read the publication info</param> /// ------------------------------------------------------------------------------------- protected void SetNamesAndAbbreviations(IProgress progressDlg, XmlNode rootNode) { IScrRefSystem srs = m_cache.ServiceLocator.GetInstance <IScrRefSystemRepository>().Singleton; Debug.Assert(srs != null && srs.BooksOS.Count == BCVRef.LastBook); XmlNodeList tagList = rootNode.SelectNodes("/ScrBookRef/writingsystem"); progressDlg.Minimum = 0; progressDlg.Maximum = tagList.Count * BCVRef.LastBook; progressDlg.Position = 0; progressDlg.Title = TeResourceHelper.GetResourceString("kstidCreatingBookNames"); ITsStrFactory tsf = m_cache.TsStrFactory; IWritingSystem ws; foreach (XmlNode writingSystem in tagList) { XmlAttributeCollection attributes = writingSystem.Attributes; string sWsTag = attributes.GetNamedItem("xml:lang").Value; m_cache.ServiceLocator.WritingSystemManager.GetOrSet(sWsTag, out ws); XmlNodeList WSBooks = writingSystem.SelectNodes("book"); foreach (XmlNode book in WSBooks) { XmlAttributeCollection bookAttributes = book.Attributes; string sSilBookId = bookAttributes.GetNamedItem("SILBookId").Value; Debug.Assert(sSilBookId != null); int nCanonicalBookNum = BCVRef.BookToNumber(sSilBookId); string sName = bookAttributes.GetNamedItem("Name").Value; string sAbbrev = bookAttributes.GetNamedItem("Abbreviation").Value; string sAltName = bookAttributes.GetNamedItem("AlternateName").Value; progressDlg.Message = string.Format( TeResourceHelper.GetResourceString("kstidCreatingBookNamesStatusMsg"), sName); progressDlg.Step(0); // check for the book id IScrBookRef bookRef = srs.BooksOS[nCanonicalBookNum - 1]; int wsHandle = ws.Handle; if (sName != null) { bookRef.BookName.set_String(wsHandle, tsf.MakeString(sName, wsHandle)); } if (sAbbrev != null) { bookRef.BookAbbrev.set_String(wsHandle, tsf.MakeString(sAbbrev, wsHandle)); } if (sAltName != null) { bookRef.BookNameAlt.set_String(wsHandle, tsf.MakeString(sAltName, wsHandle)); } } } // Finally, update resource version in database. SetNewResourceVersion(GetVersion(rootNode)); }
/// <summary> /// This must be called before starting import. /// </summary> public void StartImportingFiles() { Debug.Assert(m_cache.DomainDataByFlid.GetActionHandler() != null); Debug.Assert(m_cache.DomainDataByFlid.GetActionHandler().CurrentDepth == 0); m_hMark = m_cache.DomainDataByFlid.GetActionHandler().Mark(); IActionHandler actionHandler = m_cache.ActionHandlerAccessor; actionHandler.BeginUndoTask("Create saved version", "Create saved version"); m_backupVersion = GetOrCreateVersion(TeResourceHelper.GetResourceString("kstidSavedVersionDescriptionOriginal")); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Deletes a footnote /// </summary> /// <param name="args"></param> /// <returns><c>true</c> if we handle this</returns> /// ------------------------------------------------------------------------------------ protected bool OnDeleteFootnote(object args) { if (DataUpdateMonitor.IsUpdateInProgress(DataAccess)) { return(true); //discard this event } if (!ValidFootnoteSelection) { return(true); } string undo; string redo; TeResourceHelper.MakeUndoRedoLabels("kstidUndoDelFootnote", out undo, out redo); using (new UndoTaskHelper(this, undo, redo, false)) using (new DataUpdateMonitor(this, RootBox.DataAccess, this, "DeleteFootnote")) { SelectionHelper helper = SelectionHelper.Create(this); int fnLevel = helper.GetLevelForTag((int)ScrBook.ScrBookTags.kflidFootnotes); if (helper.Selection.IsRange) { DeleteFootnoteRange(helper); } else { // There's no range selection, so delete only one footnote ScrFootnote footnote = new ScrFootnote(m_fdoCache, helper.LevelInfo[fnLevel].hvo); ScrFootnote.DeleteFootnoteAndMarker(footnote); } if (RootBox.Height <= 0) { DraftView.Focus(); } else { int iBook = helper.LevelInfo[fnLevel + 1].ihvo; ScrBook book = m_bookFilter.GetBook(iBook); int iFootnote = helper.LevelInfo[fnLevel].ihvo; // If the last footnote in the book was deleted find a footnote to move to if (iFootnote >= book.FootnotesOS.Count) { FindNearestFootnote(ref iBook, ref iFootnote); } FootnoteEditingHelper.ScrollToFootnote(iBook, iFootnote, 0); } } return(true); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Returns the help urls for each tab on the styles dialog (currently 5 tabs) /// </summary> /// <returns></returns> /// ------------------------------------------------------------------------------------ public override string[] GetStyleDlgHelpUrls() { CheckDisposed(); return(new string[] { TeResourceHelper.GetHelpString("khtpTeStylesGeneral"), TeResourceHelper.GetHelpString("khtpTeStylesFont"), TeResourceHelper.GetHelpString("khtpTeStylesParagraph"), TeResourceHelper.GetHelpString("khtpTeStylesBullets"), TeResourceHelper.GetHelpString("khtpTeStylesBorder") }); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Fills in the versification system combo box /// </summary> /// ------------------------------------------------------------------------------------ private void FillVersificationSchemes() { for (int iVers = 1; iVers <= 6; iVers++) { ScrVers vers = (ScrVers)iVers; m_cboVersification.Items.Add(TeResourceHelper.GetResourceString( "kstid" + vers.ToString() + "Versification")); if (m_scr.Versification == vers) { m_cboVersification.SelectedIndex = iVers - 1; } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Update the existing categories and terms with new localized strings. /// </summary> /// <param name="dlg">The progress dialog.</param> /// <param name="parameters">The parameters: 1) the BiblicalTermsLocalization object /// representing the contents of the XML file with the localized strings; 2) The ICU /// locale (string).</param> /// <returns>always null</returns> /// ------------------------------------------------------------------------------------ protected object UpdateLocalization(IThreadedProgress dlg, params object[] parameters) { BiblicalTermsLocalization loc = (BiblicalTermsLocalization)parameters[0]; string locale = (string)parameters[1]; const int kcStepsToBuildLookupTable = 4; dlg.Position = 0; dlg.Minimum = 0; dlg.Maximum = loc.Categories.Count + loc.Terms.Count + kcStepsToBuildLookupTable; dlg.Title = TeResourceHelper.GetResourceString("kstidLoadKeyTermsInDBCaption"); dlg.Message = TeResourceHelper.FormatResourceString("kstidLoadKeyTermsLocalizations", m_wsf.get_Engine(locale).LanguageName); m_wsDefault = m_servLoc.WritingSystemManager.GetWsFromStr("en"); int hvoLocWs = loc.WritingSystemHvo = m_wsf.GetWsFromStr(locale); IEnumerable <ICmPossibility> categories = ((ILangProject)m_scr.Owner).KeyTermsList.PossibilitiesOS; foreach (CategoryLocalization localizedCategory in loc.Categories) { ICmPossibility category = categories.FirstOrDefault( p => p.Abbreviation.get_String(m_wsDefault).Text == localizedCategory.Id); if (category != null) { category.Name.set_String(hvoLocWs, localizedCategory.Gloss); } dlg.Step(1); } Dictionary <int, IChkTerm> termLookupTable = m_servLoc.GetInstance <IChkTermRepository>().AllInstances().ToDictionary(t => t.TermId); dlg.Step(kcStepsToBuildLookupTable); IChkTerm term; string message = TeResourceHelper.GetResourceString("kstidLoadKeyTermsInDBStatus"); foreach (TermLocalization localizedTerm in loc.Terms) { dlg.Message = string.Format(message, localizedTerm.Gloss); if (termLookupTable.TryGetValue(localizedTerm.Id, out term)) { SetLocalizedGlossAndDescription(term, localizedTerm, loc.WritingSystemHvo); } dlg.Step(1); } return(null); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Save results when closed. /// </summary> /// <param name="e">The <see cref="T:System.EventArgs"/> that contains the event data.</param> /// ------------------------------------------------------------------------------------ protected override void OnClosed(EventArgs e) { if (DialogResult == DialogResult.OK) { using (new UndoRedoTaskHelper(m_draft.Cache, TeResourceHelper.GetResourceString("ksUndoDraftProperties"), TeResourceHelper.GetResourceString("ksRedoDraftProperties"))) { m_draft.Protected = m_cbProtected.Checked; m_draft.Description = m_tbDescription.Text; } } base.OnClosed(e); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Handle the Folder browse button to locate a folder to write to. /// </summary> /// ------------------------------------------------------------------------------------ protected virtual void btnFolderBrowse_Click(object sender, System.EventArgs e) { using (FolderBrowserDialog dlg = new FolderBrowserDialog()) { dlg.SelectedPath = BaseOutputFolder; dlg.Description = TeResourceHelper.GetResourceString(StidExportDlgFolderBrowserPrompt); dlg.ShowNewFolderButton = true; if (dlg.ShowDialog() == DialogResult.OK) { BaseOutputFolder = dlg.SelectedPath; m_fUserModifiedFolder = true; } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Handles the NodeMouseClick event of the m_treeArchives control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="T:System.Windows.Forms.TreeNodeMouseClickEventArgs"/> /// instance containing the event data.</param> /// ------------------------------------------------------------------------------------ private void m_treeArchives_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e) { if (e.Button == System.Windows.Forms.MouseButtons.Right) { TreeNode node = e.Node; if (node == null || !(node.Tag is IScrDraft)) { return; } m_treeArchives.SelectedNode = node; ContextMenuStrip menu = new ContextMenuStrip(); menu.Items.Add(new ToolStripMenuItem(TeResourceHelper.GetResourceString("kstidProperties"), null, new EventHandler(propertiesClick))); menu.Show(m_treeArchives, e.Location); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Save results when closed. /// </summary> /// <param name="e">The <see cref="T:System.EventArgs"/> that contains the event data.</param> /// ------------------------------------------------------------------------------------ protected override void OnClosed(EventArgs e) { if (DialogResult == DialogResult.OK) { using (UndoableUnitOfWorkHelper undoHelper = new UndoableUnitOfWorkHelper( m_draft.Cache.ServiceLocator.GetInstance <IActionHandler>(), TeResourceHelper.GetResourceString("ksUndoDraftProperties"), TeResourceHelper.GetResourceString("ksRedoDraftProperties"))) { m_draft.Protected = m_cbProtected.Checked; m_draft.Description = m_tbDescription.Text; undoHelper.RollBack = false; } } base.OnClosed(e); }
/// ------------------------------------------------------------------------------------- /// <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); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Adds the Scripture/Print layout View /// </summary> /// <param name="viewName">Name of the resource string for the view.</param> /// <param name="viewType">Type of the view.</param> /// <param name="pubName">Name of the publication.</param> /// <param name="sideBarIndex">Index of the side bar.</param> /// <param name="sideBarItemName">Name of the side bar item.</param> /// ------------------------------------------------------------------------------------ protected override void AddPrintLayoutView(string viewName, TeViewType viewType, string pubName, TeResourceHelper.SideBarIndices sideBarIndex, string sideBarItemName) { // We don't want to add anything but Scripture/Draft View. }
/// ------------------------------------------------------------------------------------ /// <summary> /// Adds the Scripture/Print layout View /// </summary> /// <param name="viewName">Name of the resource string for the view.</param> /// <param name="viewType">Type of the view.</param> /// <param name="pubName">Name of the publication.</param> /// <param name="sideBarIndex">Index of the icon for the view in the side bar.</param> /// <param name="sideBarItemName">Name of the side bar item.</param> /// ------------------------------------------------------------------------------------ protected virtual void AddPrintLayoutView(string viewName, TeViewType viewType, string pubName, TeResourceHelper.SideBarIndices sideBarIndex, string sideBarItemName) { // Add this user view to the Scripture sidebar tab. SBTabItemProperties itemProps = new SBTabItemProperties(this); itemProps.Name = sideBarItemName; itemProps.Text = viewName; itemProps.ImageIndex = (int)sideBarIndex; itemProps.Tag = viewType; itemProps.Message = "SwitchActiveView"; AddSideBarTabItem(kScrSBTabName, itemProps); m_uncreatedViews.Add(viewType, new TePrintLayoutViewFactory(viewName, viewType, pubName, CreatePrintLayoutView)); }