/// ------------------------------------------------------------------------------------ /// <summary> /// Executes in two distinct scenarios. /// /// 1. If disposing is true, the method has been called directly /// or indirectly by a user's code via the Dispose method. /// Both managed and unmanaged resources can be disposed. /// /// 2. If disposing is false, the method has been called by the /// runtime from inside the finalizer and you should not reference (access) /// other managed objects, as they already have been garbage collected. /// Only unmanaged resources can be disposed. /// </summary> /// <param name="disposing"></param> /// <remarks> /// If any exceptions are thrown, that is fine. /// If the method is being done in a finalizer, it will be ignored. /// If it is thrown by client code calling Dispose, /// it needs to be handled by fixing the bug. /// /// If subclasses override this method, they should call the base implementation. /// </remarks> /// ------------------------------------------------------------------------------------ protected override void Dispose(bool disposing) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (IsDisposed) { return; } if (disposing) { // Dispose managed resources here. if (m_inMemoryCache != null) { m_inMemoryCache.Dispose(); } } // Dispose unmanaged resources here, whether disposing is true or false. if (m_emptyTsString != null) { Marshal.ReleaseComObject(m_emptyTsString); m_emptyTsString = null; } m_vwenvMock = null; m_inMemoryCache = null; m_book = null; base.Dispose(disposing); }
public void SetUp() { CheckDisposed(); if (m_emptyTsString != null) { Marshal.ReleaseComObject(m_emptyTsString); } // Create an empty TsString ITsStrBldr bldr = TsStrBldrClass.Create(); bldr.Replace(0, 0, string.Empty, null); m_emptyTsString = bldr.GetString(); // Set up the FDO mock and populate it with some values m_inMemoryCache = ScrInMemoryFdoCache.Create(); m_inMemoryCache.InitializeLangProject(); m_inMemoryCache.InitializeScripture(); m_book = m_inMemoryCache.AddBookToMockedScripture(57, "Philemon"); // Set up IVwEnv object m_vwenvMock = new DynamicMock(typeof(IVwEnv)); m_vwenvMock.SetupResult("DataAccess", m_inMemoryCache.CacheAccessor); // save settings m_oldPromptSetting = Options.ShowEmptyParagraphPromptsSetting; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Get the first translator note annotation definition. /// </summary> /// <returns>type of annotation</returns> /// ------------------------------------------------------------------------------------ private static ICmAnnotationDefn StandardNoteType(ScrInMemoryFdoCache scrInMemoryCache) { ICmPossibility possibility = scrInMemoryCache.Cache.LangProject.AnnotationDefsOA.PossibilitiesOS[0]; return(possibility.SubPossibilitiesOS[0] as ICmAnnotationDefn); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Append a new section to the given book, having the specified text as the section /// head. The new section will have an empty content text created also. /// </summary> /// <param name="scrInMemoryCache">in-memory cache to use for testing</param> /// <param name="book">The book to which the section is to be appended</param> /// <param name="sSectionHead">The text of the new section head. Can be a simple string /// or a format string. (See CreateText for the definition of the format string)</param> /// <param name="paraStyleName">paragraph style to apply to the section head</param> /// <returns>The newly created section</returns> /// ------------------------------------------------------------------------------------ internal static ScrSection CreateSection(ScrInMemoryFdoCache scrInMemoryCache, IScrBook book, string sSectionHead, string paraStyleName) { // Create a section ScrSection section = new ScrSection(); book.SectionsOS.Append(section); // Create a section head for this section section.HeadingOA = new StText(); if (sSectionHead.Length == 0 || sSectionHead[0] != '\\') { // create a simple section head with no character style StTxtParaBldr paraBldr = new StTxtParaBldr(scrInMemoryCache.Cache); paraBldr.ParaProps = StyleUtils.ParaStyleTextProps(paraStyleName); paraBldr.AppendRun(sSectionHead, StyleUtils.CharStyleTextProps(null, scrInMemoryCache.Cache.DefaultVernWs)); paraBldr.CreateParagraph(section.HeadingOAHvo); } else { // Create a more complex section head from the given format string // insert a new para in the title StTxtPara para = new StTxtPara(); section.HeadingOA.ParagraphsOS.Append(para); // set the para's fields scrInMemoryCache.AddFormatTextToMockedPara(book, para, sSectionHead, scrInMemoryCache.Cache.DefaultVernWs); para.StyleRules = StyleUtils.ParaStyleTextProps(paraStyleName); } section.ContentOA = new StText(); section.AdjustReferences(); return(section); }
public void Teardown() { m_ctrlOwner.Close(); m_ctrlOwner.Dispose(); m_inMemoryCache.Dispose(); m_inMemoryCache = null; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Create a back translation from a format string, and attach it to the /// given paragraph. /// </summary> /// <param name="scrInMemoryCache">in-memory cache to use for testing</param> /// <param name="book">book to use</param> /// <param name="para">the paragraph that will own this back translation</param> /// <param name="format">(See CreateText for the definition of the format string)</param> /// <param name="ws">writing system of the back translation</param> /// ------------------------------------------------------------------------------------ internal static void AddBackTranslation(ScrInMemoryFdoCache scrInMemoryCache, IScrBook book, StTxtPara para, string format, int ws) { ICmTranslation cmTrans = para.GetOrCreateBT(); // Set the translation string for the given WS cmTrans.Translation.GetAlternative(ws).UnderlyingTsString = ScrInMemoryFdoCache.CreateFormatText(book, null, format, ws); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Append a new section to the given book, having the specified text as the section /// head. The general section head paragraph style is used. /// </summary> /// <param name="scrInMemoryCache">in-memory cache to use for testing</param> /// <param name="book">The book to which the section is to be appended</param> /// <param name="sSectionHead">The text of the new section head</param> /// <returns>The newly created section</returns> /// ------------------------------------------------------------------------------------ internal static ScrSection CreateSection(ScrInMemoryFdoCache scrInMemoryCache, IScrBook book, string sSectionHead) { ScrSection section = CreateSection(scrInMemoryCache, book, sSectionHead, ScrStyleNames.SectionHead); // this should be a scripture section and not an intro section bool isIntro = false; section.VerseRefEnd = book.CanonicalNum * 1000000 + 1000 + ((isIntro) ? 0 : 1); section.AdjustReferences(); return(section); }
public void TearDown() { CheckDisposed(); Options.ShowEmptyParagraphPromptsSetting = m_oldPromptSetting; if (m_emptyTsString != null) { Marshal.ReleaseComObject(m_emptyTsString); } m_inMemoryCache.Dispose(); m_inMemoryCache = null; m_book = null; m_vwenvMock = null; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Create a paragraph from a format string, and append it to the given section's /// heading. /// </summary> /// <param name="scrInMemoryCache">in-memory cache to use for testing</param> /// <param name="book">book to use</param> /// <param name="section">section to append to</param> /// <param name="format">(See CreateText for the definition of the format string)</param> /// <param name="ws">writing system to use</param> /// <param name="paraStyle">paragraph style name</param> /// <returns>the new paragraph</returns> /// ------------------------------------------------------------------------------------ internal static StTxtPara AppendParagraphToSectionHead(ScrInMemoryFdoCache scrInMemoryCache, IScrBook book, IScrSection section, string format, int ws, string paraStyle) { // insert a new para in the section content StTxtPara para = new StTxtPara(); section.HeadingOA.ParagraphsOS.Append(para); // set the para's fields scrInMemoryCache.AddFormatTextToMockedPara(book as ScrBook, para, format, ws); para.StyleRules = StyleUtils.ParaStyleTextProps(paraStyle); return(para); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Add an annotation to a language project. /// </summary> /// <param name="scrInMemoryCache">in-memory cache to use for testing</param> /// <param name="noteText">text to include in discussion</param> /// <param name="startRef"></param> /// <param name="endRef"></param> /// <param name="topPara">Begin StTxtPara to annotate</param> /// <param name="bottomPara">End StTxtPara to annotate</param> /// <returns>a new annotation</returns> /// ------------------------------------------------------------------------------------ internal static IScrScriptureNote AddAnnotation(ScrInMemoryFdoCache scrInMemoryCache, string noteText, ScrReference startRef, ScrReference endRef, ICmObject topPara, ICmObject bottomPara) { ILangProject lp = scrInMemoryCache.Cache.LangProject; ScrBookAnnotations annotations = (ScrBookAnnotations)lp.TranslatedScriptureOA.BookAnnotationsOS[startRef.Book - 1]; IScrScriptureNote note = annotations.InsertNote(startRef, endRef, topPara, bottomPara, StandardNoteType(scrInMemoryCache).Guid); StTxtPara discussionPara = (StTxtPara)note.DiscussionOA.ParagraphsOS[0]; scrInMemoryCache.AddRunToMockedPara(discussionPara, noteText, scrInMemoryCache.Cache.DefaultAnalWs); note.DateCreated = new DateTime(s_Ticks++); return(note); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Create a title paragrpaph for the given book. /// </summary> /// <param name="scrInMemoryCache">in-memory cache to use for testing</param> /// <param name="book">The book</param>param> /// <param name="sTitle">The text of the title. Can be a simple string or a format /// string. (See InMemoryFdoCache.CreateFormatText for the definition of the /// format string)</param> /// ------------------------------------------------------------------------------------ internal static void SetTitle(ScrInMemoryFdoCache scrInMemoryCache, IScrBook book, string sTitle) { book.TitleOA = new StText(); if (sTitle[0] != '\\') { scrInMemoryCache.AddTitleToMockedBook(book.Hvo, sTitle); } else { // Create a more complex title from the given format string // insert a new para in the title StTxtPara para = new StTxtPara(); book.TitleOA.ParagraphsOS.Append(para); // set the para's fields scrInMemoryCache.AddFormatTextToMockedPara(book, para, sTitle, scrInMemoryCache.Cache.DefaultVernWs); para.StyleRules = StyleUtils.ParaStyleTextProps(ScrStyleNames.MainBookTitle); } }
public void Init() { m_inMemoryCache = ScrInMemoryFdoCache.Create(this); m_inMemoryCache.InitializeLangProject(); m_inMemoryCache.InitializeScripture(); m_inMemoryCache.AddBookToMockedScripture(1, "Genesis"); m_inMemoryCache.AddBookToMockedScripture(2, "Exodus"); m_inMemoryCache.AddBookToMockedScripture(5, "Deuteronomy"); m_James = m_inMemoryCache.AddBookToMockedScripture(59, "James"); m_inMemoryCache.AddBookToMockedScripture(66, "Revelation"); m_fdoCache = m_inMemoryCache.Cache; m_scr = (Scripture)m_fdoCache.LangProject.TranslatedScriptureOA; m_ctrlOwner = new Form(); ILgWritingSystemFactory wsf = m_fdoCache.LanguageWritingSystemFactoryAccessor; m_scp = new DummyScrPassageControl(null, m_scr, false); m_dbScp = new DummyScrPassageControl(null, m_scr, true); m_ctrlOwner.Controls.Add(m_scp); m_ctrlOwner.Controls.Add(m_dbScp); m_ctrlOwner.CreateControl(); if (m_scp.DropDownWindow != null) { m_scp.DropDownWindow.Close(); } if (m_dbScp.DropDownWindow != null) { m_dbScp.DropDownWindow.Close(); } // Forcing the reference to this should reset the ScrReference object for us // which, we hope will cause some strange errors to occur when running in // console mode. The tests seem to always work in gui mode but not console mode. m_scp.ScReference = new ScrReference(01001001, m_scr.Versification); m_dbScp.ScReference = new ScrReference(01001001, m_scr.Versification); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Creates the in memory fdo cache. /// </summary> /// <param name="provider">The provider.</param> /// ------------------------------------------------------------------------------------ protected override InMemoryFdoCache CreateInMemoryFdoCache(IWsFactoryProvider provider) { m_scrInMemoryCache = (ScrInMemoryFdoCache)ScrInMemoryFdoCache.Create(provider); return(m_scrInMemoryCache); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Add an annotation to a language project that applies to a single verse reference and /// a single paragraph. /// </summary> /// <param name="scrInMemoryCache">in-memory cache to use for testing</param> /// <param name="noteText">text to include in annotation</param> /// <param name="reference">The reference.</param> /// <param name="para">StTxtPara to annotate</param> /// <returns>a new annotation</returns> /// ------------------------------------------------------------------------------------ internal static IScrScriptureNote AddAnnotation(ScrInMemoryFdoCache scrInMemoryCache, string noteText, ScrReference reference, ICmObject para) { return(AddAnnotation(scrInMemoryCache, noteText, reference, reference, para, para)); }