/// ------------------------------------------------------------------------------------ /// <summary> /// Constructor to use when using an in-memory cache /// </summary> /// <param name="settings">Import settings</param> /// <param name="cache">FDO Cache</param> /// <param name="styleSheet">A stylesheet</param> /// <param name="inMemoryCache"> in-memory cache (use null to test against real DB)</param> /// ------------------------------------------------------------------------------------ public DummyTeImporter(ScrImportSet settings, FdoCache cache, FwStyleSheet styleSheet, ScrInMemoryFdoCache inMemoryCache) : base(settings, cache, styleSheet, new DummyUndoImportManager(inMemoryCache), new TeImportNoUi()) { m_inMemoryCache = inMemoryCache; }
/// ------------------------------------------------------------------------------------ /// <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; }
/// ------------------------------------------------------------------------------------ /// <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() { CheckDisposed(); Debug.Assert(m_inMemoryCache == null, "m_inMemoryCache is not null."); //if (m_inMemoryCache != null) // m_inMemoryCache.Dispose(); m_inMemoryCache = ScrInMemoryFdoCache.Create(); m_inMemoryCache.InitializeLangProject(); m_inMemoryCache.InitializeScripture(); m_scripture = m_inMemoryCache.Cache.LangProject.TranslatedScriptureOA; m_inMemoryCache.InitializeActionHandler(); m_styleSheet = new DynamicMock(typeof(FwStyleSheet)); m_styleSheet.Strict = true; BTInsertVerseAndFootnoteTests.InitializeVwSelection(m_selHelper); Debug.Assert(m_btView == null, "m_btView is not null."); //if (m_btView != null) // m_btView.Dispose(); m_btView = new DummyDraftView(m_inMemoryCache.Cache, true, 0); m_btView.RootBox = SetupRootBox(); m_btView.Graphics = SetupGraphics(); m_btView.MakeRoot(); m_btView.StyleSheet = (FwStyleSheet)m_styleSheet.MockInstance; m_btView.ActivateView(); m_btView.TeEditingHelper.InTestMode = true; m_rootBox.Strict = true; }
/// <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_btView != null) m_btView.Dispose(); if (m_inMemoryCache != null) m_inMemoryCache.Dispose(); } // Dispose unmanaged resources here, whether disposing is true or false. m_btView = null; // mimick back translation view using DummyDraftView m_scripture = null; //m_scripture = null; // Why not set it to null? m_inMemoryCache = null; m_styleSheet = null; // m_styleSheet = null; // Why not set it to null? m_rootBox = null; m_vwGraphics = null; m_selHelper = null; m_sel = null; m_PropInfoArgs = null; m_PropInfoTypes = null; m_TextSelInfoArgs = null; m_TextSelInfoTypes = null; m_LocationArgs = null; m_LocationTypes = null; m_AllSelEndInfoArgs = null; m_AllSelEndInfoTypes = null; base.Dispose(disposing); }
public void Teardown() { m_ctrlOwner.Close(); m_ctrlOwner.Dispose(); m_inMemoryCache.Dispose(); m_inMemoryCache = null; }
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); }
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> /// 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); }
/// ------------------------------------------------------------------------------------ /// <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> /// 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> /// Create a paragraph from a format string, and append it to the given section's /// content. /// </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 AppendParagraph(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.ContentOA.ParagraphsOS.Append(para); // set the para's fields scrInMemoryCache.AddFormatTextToMockedPara(book as ScrBook, para, format, ws); para.StyleRules = StyleUtils.ParaStyleTextProps(paraStyle); section.AdjustReferences(); return para; }
/// ------------------------------------------------------------------------------------ /// <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; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="T:DummyUndoImportManager"/> class. /// </summary> /// <param name="inMemoryCache"></param> /// ------------------------------------------------------------------------------------ public DummyUndoImportManager(ScrInMemoryFdoCache inMemoryCache) : base(inMemoryCache.Cache, null) { m_inMemoryCache = inMemoryCache; }
public void CleanUp() { CheckDisposed(); m_btView.Dispose(); m_btView = null; m_inMemoryCache.Dispose(); m_inMemoryCache = null; m_scripture = null; m_styleSheet = null; m_rootBox = null; m_vwGraphics = null; }
/// ------------------------------------------------------------------------------------ /// <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); }
/// ------------------------------------------------------------------------------------ /// <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; }
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> /// 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; }