/// <summary> /// Clean up any resources being used. /// </summary> 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) { if (components != null) { components.Dispose(); } } if (m_cache != null) { IVwCacheDa cda = m_cache.MainCacheAccessor as IVwCacheDa; cda.CacheVecProp(m_cache.LangProject.Hvo, m_fakeFlid, null, 0); cda = null; m_cache = null; } m_fwTextBoxBottomMsg = null; m_mediator = null; if (m_tsf != null) { System.Runtime.InteropServices.Marshal.ReleaseComObject(m_tsf); } m_tsf = null; base.Dispose(disposing); }
/// <summary> /// Extra cleanup that fieldworks doesn't do correctly. /// </summary> public void Dispose() { // StructureMapService doesn't close this ITsStrFactory tsf = TsStrFactoryClass.Create(); Marshal.FinalReleaseComObject(tsf); }
public void FindNextMissingBtFootnoteMarker_BtSectionHeadToContent() { IScrSection section = m_exodus.SectionsOS[1]; ITsStrFactory strfact = TsStrFactoryClass.Create(); IStTxtPara contentPara = section.ContentOA[0]; ITsStrBldr strBldr = contentPara.Contents.GetBldr(); IStFootnote foot = m_exodus.InsertFootnoteAt(0, strBldr, 7); contentPara.Contents = strBldr.GetString(); IScrTxtPara footPara = Cache.ServiceLocator.GetInstance <IScrTxtParaFactory>().CreateWithStyle( foot, ScrStyleNames.NormalFootnoteParagraph); footPara.Contents = strfact.MakeString("This is footnote text for footnote", Cache.DefaultVernWs); ICmTranslation trans = contentPara.GetOrCreateBT(); m_draftView.SetInsertionPoint(ScrSectionTags.kflidHeading, 0, 1, 0); m_draftView.CallNextMissingBtFootnoteMarker(); SelectionHelper helper = m_draftView.EditingHelper.CurrentSelection; Assert.AreEqual(2, helper.IchAnchor, "IP should be after chapter and verse number."); Assert.AreEqual(0, m_draftView.TeEditingHelper.BookIndex); Assert.AreEqual(1, m_draftView.TeEditingHelper.SectionIndex); Assert.AreEqual(0, m_draftView.ParagraphIndex); Assert.AreEqual(ScrSectionTags.kflidContent, m_draftView.EditingHelper.CurrentSelection.LevelInfo[2].tag); Assert.IsTrue(m_draftView.TeEditingHelper.IsBackTranslation); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Creates a blank dummy footnote. Used when a footnote object is missing. /// Note: This does not insert an ORC into the paragraph. The caller is fixing the ORC /// with a missing object. /// </summary> /// <param name="owner">The owner to which we will add a footnote.</param> /// <param name="iFootnote">The 0-based index where the footnote will be inserted in the /// owner.</param> /// <param name="paraContents">The paragraph string where the ORC is being fixed.</param> /// <param name="iRun">The 0-based index of the run from which we will get the writing /// system used in the footnote.</param> /// <returns>a blank general footnote</returns> /// ------------------------------------------------------------------------------------ protected override StFootnote CreateBlankDummyFootnoteNoRecursion(ICmObject owner, int iFootnote, ITsString paraContents, int iRun) { if (!(owner is IScrBook)) { return(base.CreateBlankDummyFootnoteNoRecursion(owner, iFootnote, paraContents, iRun)); } // get the writing system of the existing ORC run int nDummy; int ws = paraContents.get_Properties(iRun).GetIntPropValues( (int)FwTextPropType.ktptWs, out nDummy); // Make a dummy blank footnote IScripture scr = m_cache.LangProject.TranslatedScriptureOA; string sMarker = scr.GeneralFootnoteMarker; StFootnote newFootnote = ScrFootnote.CreateFootnoteInScrBook((IScrBook)owner, iFootnote, ref sMarker, m_cache, ws); // Create an empty footnote paragraph with properties with default style and writing system. StTxtPara footnotePara = new StTxtPara(); newFootnote.ParagraphsOS.Append(footnotePara); footnotePara.StyleRules = StyleUtils.ParaStyleTextProps(ScrStyleNames.NormalFootnoteParagraph); // Insert an empty run into the footnote paragraph in order to set the // default writing system. ITsStrFactory strFactory = TsStrFactoryClass.Create(); footnotePara.Contents.UnderlyingTsString = strFactory.MakeString(string.Empty, m_cache.DefaultVernWs); return(newFootnote); }
public override void TestSetup() { base.TestSetup(); m_vc = new StVc(); m_vc.Cache = Cache; m_pattern = VwPatternClass.Create(); m_strFactory = TsStrFactoryClass.Create(); m_pattern.Pattern = m_strFactory.MakeString("a", Cache.DefaultVernWs); m_pattern.MatchOldWritingSystem = false; m_pattern.MatchDiacritics = false; m_pattern.MatchWholeWord = false; m_pattern.MatchCase = false; m_pattern.UseRegularExpressions = false; IScrBook genesis = AddBookWithTwoSections(1, "Genesis"); m_section = genesis.SectionsOS[0]; // Add paragraphs (because we use an StVc in the test we add them all to the same section) m_para1 = AddParaToMockedSectionContent(m_section, ScrStyleNames.NormalParagraph); AddRunToMockedPara(m_para1, "This is some text so that we can test the find functionality.", null); m_para2 = AddParaToMockedSectionContent(m_section, ScrStyleNames.NormalParagraph); AddRunToMockedPara(m_para2, "Some more text so that we can test the find and replace functionality.", null); m_para3 = AddParaToMockedSectionContent( m_section, ScrStyleNames.NormalParagraph); AddRunToMockedPara(m_para3, "This purugruph doesn't contuin the first letter of the ulphubet.", null); }
public void LeadingPunctuation() { ITsStrFactory tsf = TsStrFactoryClass.Create(); string test1 = "?This is a question with special punctuation?"; ITsString tss = tsf.MakeString(test1, m_wsEn); m_para.Contents = tss; List <int> results; var segments = m_pp.CollectSegments(tss, out results); VerifyBreaks(new int[] { test1.Length - 1 }, results, "leading QM"); Assert.AreEqual(1, segments.Count); VerifySegment(segments[0], 0, test1.Length, m_para, "leading QM"); // Now try leading punctuation following a verse number. ITsStrBldr bldr = tss.GetBldr(); string verse = "5 "; bldr.Replace(0, 0, verse, null); bldr.SetStrPropValue(0, 1, (int)FwTextPropType.ktptNamedStyle, ScrStyleNames.VerseNumber); ITsString tssMultiV = bldr.GetString(); m_para.Contents = tssMultiV; segments = m_pp.CollectSegments(tssMultiV, out results); VerifyBreaks(new int[] { verse.Length, tssMultiV.Length - 1 }, results, "leading verse and QM"); Assert.AreEqual(2, segments.Count); VerifySegment(segments[0], 0, verse.Length, m_para, "first seg of leading verse and QM"); VerifySegment(segments[1], verse.Length, tssMultiV.Length, m_para, "second seg of leading verse and QM"); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Adds paragraphs to the database /// </summary> /// <param name="ws"></param> /// <param name="firstPara"></param> /// <param name="secondPara"></param> /// ------------------------------------------------------------------------------------ private void AddParagraphs(int ws, string firstPara, string secondPara) { int hvoPara1 = m_hvoPara++; int hvoPara2 = m_hvoPara++; int hvoText1 = m_hvoText++; int hvoText2 = m_hvoText++; ITsStrFactory tsf = TsStrFactoryClass.Create(); ITsString tsString = tsf.MakeString(firstPara, ws); IVwCacheDa cda = Cache.VwCacheDaAccessor; cda.CacheStringProp(hvoPara1, (int)StTxtPara.StTxtParaTags.kflidContents, tsString); tsString = tsf.MakeString(secondPara, ws); cda.CacheStringProp(hvoPara2, (int)StTxtPara.StTxtParaTags.kflidContents, tsString); // Now make each of them the paragraphs of an StText. int[] hvoParas = { hvoPara1 }; cda.CacheVecProp(hvoText1, (int)StText.StTextTags.kflidParagraphs, hvoParas, 1); hvoParas[0] = hvoPara2; cda.CacheVecProp(hvoText2, (int)StText.StTextTags.kflidParagraphs, hvoParas, 1); // And the StTexts to the contents of a dummy property. AddVecProp(new int[] { hvoText1, hvoText2 }); }
public void MySetup() { Setup(); m_tsf = TsStrFactoryClass.Create(); m_wsEng = m_wsf.GetWsFromStr("en"); m_wsFrn = m_wsf.GetWsFromStr("fr"); }
public TitleContentsVc(FdoCache cache) { int wsUser = cache.DefaultUserWs; ITsStrFactory tsf = TsStrFactoryClass.Create(); m_tssTitle = tsf.MakeString(ITextStrings.ksTitle, wsUser); ITsPropsBldr tpb = TsPropsBldrClass.Create(); tpb.SetIntPropValues((int)FwTextPropType.ktptBold, (int)FwTextPropVar.ktpvEnum, (int)FwTextToggleVal.kttvForceOn); m_ttpBold = tpb.GetTextProps(); tpb = TsPropsBldrClass.Create(); // Set some padding all around. tpb.SetIntPropValues((int)FwTextPropType.ktptPadTop, (int)FwTextPropVar.ktpvMilliPoint, 1000); tpb.SetIntPropValues((int)FwTextPropType.ktptPadBottom, (int)FwTextPropVar.ktpvMilliPoint, 1000); tpb.SetIntPropValues((int)FwTextPropType.ktptPadLeading, (int)FwTextPropVar.ktpvMilliPoint, 3000); tpb.SetIntPropValues((int)FwTextPropType.ktptPadTrailing, (int)FwTextPropVar.ktpvMilliPoint, 3000); tpb.SetIntPropValues((int)FwTextPropType.ktptMarginTrailing, (int)FwTextPropVar.ktpvMilliPoint, 11000); // 10000 clips right border. m_ttpDataCellProps = tpb.GetTextProps(); m_vtagStTextTitle = cache.MetaDataCacheAccessor.GetFieldId("StText", "Title", false); // Set up the array of writing systems we will display for title. SetupWritingSystemsForTitle(cache); }
public void FixOrcsWithoutProps_OrphanedFootnoteAndValidPicture() { CheckDisposed(); IScrBook exodus = CreateExodusData(); StTxtPara para = AddPara(exodus.SectionsOS[2]); AddVerse(para, 2, 3, "ORC is here, you see, my friend."); // Update the paragraph contents to include the picture ITsStrBldr tsStrBldr = para.Contents.UnderlyingTsString.GetBldr(); ITsStrFactory factory = TsStrFactoryClass.Create(); CmPicture pict = new CmPicture(Cache, "c:\\junk.jpg", factory.MakeString("Test picture", Cache.DefaultVernWs), StringUtils.LocalPictures); Assert.IsNotNull(pict); pict.InsertOwningORCIntoPara(tsStrBldr, 11, 0); para.Contents.UnderlyingTsString = tsStrBldr.GetString(); // Update the paragraph contents to include the (orphaned) footnote marker CreateFootnote(exodus, 1, 0, 1, 19, ScrStyleNames.CrossRefFootnoteParagraph, true); TeScrInitializer scrInit = new TestTeScrInitializer(Cache); List <string> report = (List <string>)ReflectionHelper.GetResult(scrInit, "FixOrcsWithoutProps"); VerifyNoOrphanedFootnotes(); VerifyResourceForFixedOrphans(); Assert.AreEqual(1, report.Count); Assert.AreEqual("EXO 1:2 - Deleted corrupted footnote marker or picture anchor", report[0]); Assert.AreEqual(0, exodus.FootnotesOS.Count); }
public void FixOrcsWithoutProps_OrcForMissingObject() { CheckDisposed(); IScrBook exodus = CreateExodusData(); StTxtPara para = AddPara(exodus.SectionsOS[2]); AddVerse(para, 2, 3, "ORC is here, you see, my friend."); // Update the paragraph contents to include the picture ITsStrBldr tsStrBldr = para.Contents.UnderlyingTsString.GetBldr(); ITsStrFactory factory = TsStrFactoryClass.Create(); StringUtils.InsertOrcIntoPara(Guid.NewGuid(), FwObjDataTypes.kodtOwnNameGuidHot, tsStrBldr, 11, 11, 0); para.Contents.UnderlyingTsString = tsStrBldr.GetString(); TeScrInitializer scrInit = new TestTeScrInitializer(Cache); List <string> report = (List <string>)ReflectionHelper.GetResult(scrInit, "FixOrcsWithoutProps"); VerifyNoOrphanedFootnotes(); VerifyResourceForFixedOrphans(); Assert.AreEqual(1, report.Count); Assert.AreEqual("EXO 2:3 - Deleted corrupted footnote marker or picture anchor", report[0]); Assert.AreEqual(0, exodus.FootnotesOS.Count); }
int m_wsUr; // Urdu writing system (used for Foreign style) #endregion #region Test setup /// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// ------------------------------------------------------------------------------------ protected override void CreateTestData() { m_inMemoryCache.InitializeWritingSystemEncodings(); // create footnote m_footnote = new StFootnote(); m_book = (ScrBook)m_scrInMemoryCache.AddBookToMockedScripture(1, "Genesis"); m_book.FootnotesOS.Append(m_footnote); m_footnote.FootnoteMarker.Text = "o"; m_footnote.DisplayFootnoteMarker = true; m_footnote.DisplayFootnoteReference = false; // create one empty footnote para StTxtPara para = new StTxtPara(); m_footnote.ParagraphsOS.Append(para); para.StyleRules = StyleUtils.ParaStyleTextProps(ScrStyleNames.NormalFootnoteParagraph); m_strFact = TsStrFactoryClass.Create(); m_vernWs = Cache.LangProject.DefaultVernacularWritingSystem; para.Contents.UnderlyingTsString = m_strFact.MakeString(string.Empty, m_vernWs); m_footnotePara = (StTxtPara)m_footnote.ParagraphsOS[0]; m_wsUr = InMemoryFdoCache.s_wsHvos.Ur; // used with 'foreign' character style m_wsDe = InMemoryFdoCache.s_wsHvos.De; // used for back translations m_wsEs = InMemoryFdoCache.s_wsHvos.Es; }
public void OrcIsLabel() { ITsStrFactory tsf = TsStrFactoryClass.Create(); ParagraphParser pp = new ParagraphParser(m_para); // String with embedded ORC. string test1 = "This is a simple sentence"; string test2 = "\xfffc"; string test3 = " with a footnote."; ITsString tss = tsf.MakeString(test1 + test2 + test3, 1); // To be recognized an ORC must have unique properties. ITsStrBldr bldr = tss.GetBldr(); bldr.SetStrPropValue(test1.Length, test1.Length + test2.Length, (int)FwTextPropType.ktptObjData, "nonsence"); tss = bldr.GetString(); m_para.Contents.UnderlyingTsString = tss; List <int> results; List <int> segments = pp.CollectSegmentAnnotations(tss, out results); VerifyBreaks(new int[] { test1.Length, test1.Length + test2.Length + 1, test1.Length + test2.Length + test3.Length - 1 }, results, "multi-sentence string with ORC"); Assert.AreEqual(3, segments.Count); // The segments break around the ORC. VerifySegment(segments[0], 0, test1.Length, m_para.Hvo, "first seg of multi-sentence w. ORC"); VerifySegment(segments[1], test1.Length, test1.Length + test2.Length + 1, m_para.Hvo, "second seg of multi-sentence w. ORC"); VerifySegment(segments[2], test1.Length + test2.Length + 1, test1.Length + test2.Length + test3.Length, m_para.Hvo, "third seg of multi-sentence w. ORC"); }
public void SetAndAccessMultiStrings() { ITsStrFactory tsf = TsStrFactoryClass.Create(); int kflid = XMLViewsDataCache.ktagEditColumnBase; int hvoRoot = 10578; int wsEng = Cache.WritingSystemFactory.GetWsFromStr("en"); XMLViewsDataCache xmlCache = new XMLViewsDataCache(Cache.MainCacheAccessor as ISilDataAccessManaged, true, new Dictionary <int, int>()); Notifiee recorder = new Notifiee(); xmlCache.AddNotification(recorder); Assert.AreEqual(0, xmlCache.get_MultiStringAlt(hvoRoot, kflid, wsEng).Length); Assert.AreEqual(0, recorder.Changes.Count); ITsString test1 = tsf.MakeString("test1", wsEng); xmlCache.CacheMultiString(hvoRoot, kflid, wsEng, test1); Assert.AreEqual(0, recorder.Changes.Count); Assert.AreEqual(test1, xmlCache.get_MultiStringAlt(hvoRoot, kflid, wsEng)); ITsString test2 = tsf.MakeString("blah", wsEng); xmlCache.SetMultiStringAlt(hvoRoot, kflid, wsEng, test2); Assert.AreEqual(test2, xmlCache.get_MultiStringAlt(hvoRoot, kflid, wsEng)); recorder.CheckChanges(new ChangeInformationTest[] { new ChangeInformationTest(hvoRoot, kflid, wsEng, 0, 0) }, "expected PropChanged from setting string"); xmlCache.RemoveNotification(recorder); // Enhance JohnT: a better test would verify that it doesn't intefere with other multistrings, // and that it can store stuff independently for different HVOs, tags, and WSs. }
/// <summary> /// We understand how to get a multistring for any hvo in the tagEditColumn range. /// We also handle the virtual property LexEntry.ReversalEntriesBulkText in a /// special way. (See FWR-376.) /// </summary> public override ITsString get_MultiStringAlt(int hvo, int tag, int ws) { ITsString result1 = null; if (tag < ktagEditColumnBase || tag > ktagEditColumnLim) { result1 = base.get_MultiStringAlt(hvo, tag, ws); if (tag != m_tagReversalEntriesBulkText) { return(result1); } } ITsString result; if (m_mlStringCache.TryGetValue(new HvoFlidWSKey(hvo, tag, ws), out result)) { return(result); } if (tag == m_tagReversalEntriesBulkText && result1 != null) { return(result1); } ITsStrFactory tsf = TsStrFactoryClass.Create(); return(tsf.MakeString("", ws)); }
public override void Display(IVwEnv vwenv, int hvo, int frag) { switch (frag) { case AudioVisualView.kfragPathname: // Display the filename. ILgWritingSystemFactory wsf = m_cache.WritingSystemFactory; vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvDefault, (int)TptEditable.ktptNotEditable); ITsString tss; ITsStrFactory tsf = m_cache.TsStrFactory; Debug.Assert(hvo != 0); Debug.Assert(m_cache != null); var file = m_cache.ServiceLocator.GetInstance <ICmFileRepository>().GetObject(hvo); Debug.Assert(file != null); string path = file.AbsoluteInternalPath; tss = tsf.MakeString(path, m_cache.WritingSystemFactory.UserWs); vwenv.OpenParagraph(); vwenv.NoteDependency(new [] { m_cache.LangProject.Hvo, file.Hvo }, new [] { LangProjectTags.kflidLinkedFilesRootDir, CmFileTags.kflidInternalPath }, 2); vwenv.AddString(tss); vwenv.CloseParagraph(); break; default: throw new ArgumentException( "Don't know what to do with the given frag.", "frag"); } }
private void SetContentFromNode(FdoCache cache, string sNodeName, bool fFixName, MultiAccessor item) { ILgWritingSystemFactory wsf = cache.LanguageWritingSystemFactoryAccessor; ITsStrFactory tsf = TsStrFactoryClass.Create(); int iWS; XmlNode nd; bool fContentFound = false; // be pessimistic foreach (ILgWritingSystem ws in cache.LangProject.CurAnalysisWssRS) { string sWS = ws.ICULocale; nd = m_node.SelectSingleNode(sNodeName + "[@ws='" + sWS + "']"); if (nd == null || nd.InnerText.Length == 0) { continue; } fContentFound = true; string sNodeContent; if (fFixName) { sNodeContent = NameFixer(nd.InnerText); } else { sNodeContent = nd.InnerText; } iWS = wsf.GetWsFromStr(sWS); item.SetAlternative(tsf.MakeString(sNodeContent, iWS), iWS); } if (!fContentFound) { iWS = cache.LangProject.DefaultAnalysisWritingSystem; item.SetAlternative(tsf.MakeString("", iWS), iWS); } }
public InnerLabeledMultiStringViewVc(int flid, List <IWritingSystem> rgws, int wsUser, bool editable, ITsStrFactory tsf, InnerLabeledMultiStringView view) : base(flid, rgws, wsUser, editable, view.WritingSystemFactory.GetWsFromStr("en"), tsf) { m_view = view; Debug.Assert(m_view != null); }
public void FindNextMissingBtFootnoteMarker_BtSectionHeadToContent() { IScrSection section = m_exodus.SectionsOS[1]; ITsStrFactory strfact = TsStrFactoryClass.Create(); IStTxtPara contentPara = section.ContentOA[0]; ITsStrBldr strBldr = contentPara.Contents.GetBldr(); IStFootnote foot = m_exodus.InsertFootnoteAt(0, strBldr, 7); contentPara.Contents = strBldr.GetString(); IScrTxtPara footPara = Cache.ServiceLocator.GetInstance <IScrTxtParaFactory>().CreateWithStyle( foot, ScrStyleNames.NormalFootnoteParagraph); footPara.Contents = strfact.MakeString("This is footnote text for footnote", Cache.DefaultVernWs); m_draftView.TeEditingHelper.SelectRangeOfChars(0, 0, ScrSectionTags.kflidHeading, 0, 1, 0, 0, true, true, false, VwScrollSelOpts.kssoDefault); m_draftView.CallNextMissingBtFootnoteMarker(); SelectionHelper helper = m_draftView.EditingHelper.CurrentSelection; Assert.IsFalse(helper.IsRange); Assert.AreEqual(1, helper.GetLevelInfo(SelectionHelper.SelLimitType.Anchor)[0].ihvo, "IP should be in first non-label segment."); Assert.AreEqual(0, helper.IchAnchor, "IP should be at start of segment."); Assert.AreEqual(0, m_draftView.TeEditingHelper.BookIndex); Assert.AreEqual(1, m_draftView.TeEditingHelper.SectionIndex); Assert.AreEqual(0, m_draftView.ParagraphIndex); Assert.AreEqual(ScrSectionTags.kflidContent, m_draftView.EditingHelper.CurrentSelection.LevelInfo[2].tag); Assert.IsTrue(m_draftView.TeEditingHelper.IsBackTranslation); }
public RegRuleFormulaVc(FdoCache cache, Mediator mediator) : base(cache, mediator) { ITsPropsBldr tpb = TsPropsBldrClass.Create(); tpb.SetIntPropValues((int)FwTextPropType.ktptBorderBottom, (int)FwTextPropVar.ktpvMilliPoint, 1000); tpb.SetIntPropValues((int)FwTextPropType.ktptBorderColor, (int)FwTextPropVar.ktpvDefault, (int)ColorUtil.ConvertColorToBGR(Color.Gray)); tpb.SetIntPropValues((int)FwTextPropType.ktptAlign, (int)FwTextPropVar.ktpvEnum, (int)FwTextAlign.ktalCenter); m_ctxtProps = tpb.GetTextProps(); tpb = TsPropsBldrClass.Create(); tpb.SetIntPropValues((int)FwTextPropType.ktptFontSize, (int)FwTextPropVar.ktpvMilliPoint, 20000); tpb.SetIntPropValues((int)FwTextPropType.ktptForeColor, (int)FwTextPropVar.ktpvDefault, (int)ColorUtil.ConvertColorToBGR(Color.Gray)); tpb.SetIntPropValues((int)FwTextPropType.ktptAlign, (int)FwTextPropVar.ktpvEnum, (int)FwTextAlign.ktalCenter); tpb.SetIntPropValues((int)FwTextPropType.ktptPadLeading, (int)FwTextPropVar.ktpvMilliPoint, 2000); tpb.SetIntPropValues((int)FwTextPropType.ktptPadTrailing, (int)FwTextPropVar.ktpvMilliPoint, 2000); tpb.SetStrPropValue((int)FwTextPropType.ktptFontFamily, MiscUtils.StandardSansSerif); tpb.SetIntPropValues((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); m_charProps = tpb.GetTextProps(); ITsStrFactory tsf = m_cache.TsStrFactory; int userWs = m_cache.DefaultUserWs; m_arrow = tsf.MakeString("\u2192", userWs); m_slash = tsf.MakeString("/", userWs); m_underscore = tsf.MakeString("__", userWs); }
public void HardLineBreaks() { ITsStrFactory tsf = TsStrFactoryClass.Create(); // String with embedded ORC. string test1 = "This is a simple sentence"; string lineBreak = StringUtils.kChHardLB.ToString(); string test3 = "with a hard break."; ITsString tss = tsf.MakeString(test1 + lineBreak + test3, m_wsEn); m_para.Contents = tss; List <int> results; var segments = m_pp.CollectSegments(tss, out results); VerifyBreaks(new int[] { test1.Length, test1.Length + 1, tss.Length - 1 }, results, "simple string with hard break"); Assert.AreEqual(3, segments.Count); // The segments break around the ORC. VerifySegment(segments[0], 0, test1.Length, m_para, "simple string with hard break"); VerifySegment(segments[1], test1.Length, test1.Length + 1, m_para, "simple string with hard break"); VerifySegment(segments[2], test1.Length + 1, tss.Length, m_para, "simple string with hard break"); // Now try with an EOS before the hard break. string test1a = "This is a proper sentence?!"; tss = tsf.MakeString(test1a + lineBreak + test3, m_wsEn); m_para.Contents = tss; segments = m_pp.CollectSegments(tss, out results); VerifyBreaks(new int[] { test1a.Length - 2, test1a.Length + 1, tss.Length - 1 }, results, "EOS before hard break"); Assert.AreEqual(3, segments.Count); // The segments break around the ORC. VerifySegment(segments[0], 0, test1a.Length, m_para, "EOS before hard break"); VerifySegment(segments[1], test1a.Length, test1a.Length + 1, m_para, "EOS before hard break"); VerifySegment(segments[2], test1a.Length + 1, tss.Length, m_para, "EOS before hard break"); }
/// <summary> /// /// </summary> /// <param name="hvo"></param> /// <param name="tag"></param> /// <param name="ws"></param> /// <param name="cda"></param> public override void Load(int hvo, int tag, int ws, IVwCacheDa cda) { IMoMorphSynAnalysis msa = MoMorphSynAnalysis.CreateFromDBObject(m_cache, hvo); ITsStrFactory tsf = TsStrFactoryClass.Create(); cda.CacheStringProp(hvo, tag, tsf.MakeString(msa.InterlinearName, m_cache.DefaultAnalWs)); }
public override void MakeRoot() { m_rootb = (IVwRootBox) new FwViews.VwRootBoxClass(); m_rootb.SetSite(this); int hvoRoot = 1; m_sda = (ISilDataAccess) new FwViews.VwCacheDaClass(); // Usually not here, but in some application global passed to each view. m_wsf = (ILgWritingSystemFactory) new FwLanguage.LgWritingSystemFactoryClass(); m_sda.set_WritingSystemFactory(m_wsf); m_rootb.set_DataAccess(m_sda); ITsStrFactory tsf = (ITsStrFactory) new FwKernelLib.TsStrFactoryClass(); ITsString tss = tsf.MakeString("Hello World! This is a view", m_wsf.get_UserWs()); IVwCacheDa cda = (IVwCacheDa)m_sda; cda.CacheStringProp(hvoRoot, ktagProp, tss); m_vVc = new HvVc(); m_rootb.SetRootObject(hvoRoot, m_vVc, kfrText, null); m_fRootboxMade = true; m_dxdLayoutWidth = -50000; // Don't try to draw until we get OnSize and do layout. }
public void GoToNextPara_NextFlid() { // Add a title to the root object int hvoTitle = m_cache.MakeNewObject(SimpleRootsiteTestsConstants.kclsidStText, m_hvoRoot, SimpleRootsiteTestsConstants.kflidDocTitle, -2); int hvoTitlePara = m_cache.MakeNewObject(SimpleRootsiteTestsConstants.kclsidStTxtPara, hvoTitle, SimpleRootsiteTestsConstants.kflidTextParas, 0); ITsStrFactory tsStrFactory = TsStrFactoryClass.Create(); m_cache.CacheStringProp(hvoTitlePara, SimpleRootsiteTestsConstants.kflidParaContents, tsStrFactory.MakeString("The First Book of the Law given by Moses", m_wsFrn)); ShowForm(Lng.English, SimpleViewVc.DisplayType.kNormal | SimpleViewVc.DisplayType.kTitle); m_basicView.Show(); m_basicView.RefreshDisplay(); // Set the IP at the beginning of the only (0th) instance of the only (0th) paragraph // of the only (0th) instance of the second (1th) footnote of the book we're displaying. m_SelectionHelper = new DummySelectionHelper(null, m_basicView); SetSelection(0, 1, 0, 0, 2, 0, 0, true); IVwSelection vwsel = m_SelectionHelper.SetSelection(true); Assert.IsNotNull(vwsel, "No selection made"); Assert.IsTrue(m_basicView.IsSelectionVisible(null), "Selection is not visible"); m_basicView.EditingHelper.GoToNextPara(); // We expect that the selection will be at the start of the book title. SelectionHelper selectionHelper = SelectionHelper.GetSelectionInfo(null, m_basicView); Assert.IsFalse(selectionHelper.IsRange); CheckSelectionHelperValues(SelectionHelper.SelLimitType.Anchor, selectionHelper, 0, 0, 0, 0, false, 2, SimpleRootsiteTestsConstants.kflidDocTitle, 0, 0, SimpleRootsiteTestsConstants.kflidTextParas, 0, 0); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the RelatedWordsVc class. /// </summary> /// <param name="wsUser">The ws user.</param> /// <param name="headword">Headword of the target lexical entry.</param> /// ------------------------------------------------------------------------------------ public RelatedWordsVc(int wsUser, ITsString headword) { m_wsDefault = wsUser; ITsStrFactory tsf = TsStrFactoryClass.Create(); m_tssColon = tsf.MakeString(": ", wsUser); m_tssComma = tsf.MakeString(", ", wsUser); m_tssSdRelation = tsf.MakeString(FdoUiStrings.ksWordsRelatedBySemanticDomain, wsUser); m_tssLexRelation = tsf.MakeString(FdoUiStrings.ksLexicallyRelatedWords, wsUser); var semanticDomainStrBuilder = m_tssSdRelation.GetBldr(); var index = semanticDomainStrBuilder.Text.IndexOf("{0}"); if (index > 0) { semanticDomainStrBuilder.ReplaceTsString(index, index + "{0}".Length, headword); } m_tssSdRelation = semanticDomainStrBuilder.GetString(); var lexStrBuilder = m_tssLexRelation.GetBldr(); index = lexStrBuilder.Text.IndexOf("{0}"); if (index > 0) { lexStrBuilder.ReplaceTsString(index, index + "{0}".Length, headword); } m_tssLexRelation = lexStrBuilder.GetString(); }
public void FindNextMissingBtFootnoteMarker_BtSectionHeadToNowhere() { IScrSection section = m_exodus.SectionsOS[1]; ITsStrFactory strfact = TsStrFactoryClass.Create(); IStTxtPara contentPara = section.ContentOA[0]; ITsStrBldr strBldr = contentPara.Contents.GetBldr(); IStFootnote foot = m_exodus.InsertFootnoteAt(0, strBldr, 7); contentPara.Contents = strBldr.GetString(); IScrTxtPara footPara = Cache.ServiceLocator.GetInstance <IScrTxtParaFactory>().CreateWithStyle( foot, ScrStyleNames.NormalFootnoteParagraph); footPara.Contents = strfact.MakeString("This is footnote text for footnote", Cache.DefaultVernWs); ICmTranslation trans = contentPara.GetOrCreateBT(); ITsStrBldr bldr = trans.Translation.get_String(Cache.DefaultAnalWs).GetBldr(); TsStringUtils.InsertOrcIntoPara(foot.Guid, FwObjDataTypes.kodtNameGuidHot, bldr, 2, 2, Cache.DefaultAnalWs); trans.Translation.set_String(Cache.DefaultAnalWs, bldr.GetString()); m_draftView.SetInsertionPoint(ScrSectionTags.kflidHeading, 0, 1, 0); m_draftView.CallNextMissingBtFootnoteMarker(); SelectionHelper helper = m_draftView.EditingHelper.CurrentSelection; Assert.AreEqual(0, helper.IchAnchor); Assert.AreEqual(0, m_draftView.TeEditingHelper.BookIndex); Assert.AreEqual(1, m_draftView.TeEditingHelper.SectionIndex); Assert.AreEqual(0, m_draftView.ParagraphIndex); Assert.AreEqual(ScrSectionTags.kflidHeading, m_draftView.EditingHelper.CurrentSelection.LevelInfo[2].tag); Assert.IsTrue(m_draftView.TeEditingHelper.IsBackTranslation); }
/// <summary> /// Clean up any resources being used. /// </summary> 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) { Controls.Remove(m_fwTextBoxBottomMsg); m_fwTextBoxBottomMsg.Dispose(); if (components != null) { components.Dispose(); } } m_fwTextBoxBottomMsg = null; m_mediator = null; if (m_tsf != null) { System.Runtime.InteropServices.Marshal.ReleaseComObject(m_tsf); } m_tsf = null; m_cache = null; base.Dispose(disposing); }
/// <summary> /// Set up the dlg in preparation to showing it. /// </summary> /// <param name="cache">FDO cache.</param> /// <param name="wp">Strings used for various items in this dialog.</param> public void SetDlgInfo(FdoCache cache, Mediator mediator, WindowParams wp, DummyCmObject mainObj, List <DummyCmObject> mergeCandidates, string guiControl, string helpTopic) { CheckDisposed(); Debug.Assert(cache != null); m_mediator = mediator; m_cache = cache; m_mainObj = mainObj; m_tsf = cache.TsStrFactory; m_fwTextBoxBottomMsg.WritingSystemFactory = m_cache.WritingSystemFactory; m_fwTextBoxBottomMsg.WritingSystemCode = m_cache.WritingSystemFactory.UserWs; InitBrowseView(guiControl, mergeCandidates); Text = wp.m_title; label2.Text = wp.m_label; m_helpTopic = helpTopic; if (m_helpTopic != null && m_helpTopicProvider != null) // m_helpTopicProvider could be null for testing { helpProvider = new HelpProvider(); helpProvider.HelpNamespace = m_helpTopicProvider.HelpFile; helpProvider.SetHelpKeyword(this, m_helpTopicProvider.GetHelpString(m_helpTopic)); helpProvider.SetHelpNavigator(this, HelpNavigator.Topic); } MoveWindowToPreviousPosition(); }
public DiscourseTestHelper(FdoCache cache) { m_cache = cache; #region Load Factories and Repositories m_servLoc = m_cache.ServiceLocator; m_tsf = cache.TsStrFactory; m_wAnalysisFact = m_servLoc.GetInstance <IWfiAnalysisFactory>(); m_wGlossFact = m_servLoc.GetInstance <IWfiGlossFactory>(); m_rowFact = m_servLoc.GetInstance <IConstChartRowFactory>(); m_wordGrpFact = m_servLoc.GetInstance <IConstChartWordGroupFactory>(); m_ccTagFact = m_servLoc.GetInstance <IConstChartTagFactory>(); m_mtmFact = m_servLoc.GetInstance <IConstChartMovedTextMarkerFactory>(); m_clauseMrkrFact = m_servLoc.GetInstance <IConstChartClauseMarkerFactory>(); m_partRepo = m_servLoc.GetInstance <IConstituentChartCellPartRepository>(); m_rowRepo = m_servLoc.GetInstance <IConstChartRowRepository>(); #endregion m_text = m_servLoc.GetInstance <ITextFactory>().Create(); //Cache.LangProject.TextsOC.Add(m_text); m_stText = m_servLoc.GetInstance <IStTextFactory>().Create(); m_text.ContentsOA = m_stText; m_allOccurrences = new Dictionary <IStTxtPara, AnalysisOccurrence[]>(); m_firstPara = MakeParagraph(); }
/// <summary> /// Reconstitute data. /// </summary> protected virtual void FromXml(XElement reader, ILgWritingSystemFactory wsf, ITsStrFactory tsf) { foreach (var aStrNode in reader.Elements("AStr")) { // Throwing out a string without a ws is probably better than crashing // and preventing a db from being opened. // This code currently accepts this data, only storing en, fr, and es strings. // <Description> // <AStr ws="en"><Run ws="en">***</Run></AStr> // <AStr><Run ws="fr">***</Run></AStr> // <AStr ws="du"/> // <AStr ws="zh"></AStr> // <AStr ws="ko"><Run/></AStr> // <AStr ws="in"><Run>bad</Run></AStr> // <AStr/> // <AStr ws="es"><Run ws="es">help</Run></AStr> // </Description> ITsString tss; int wsHvo = ReadAstrElementOfMultiString(aStrNode, wsf, out tss); if (tss != null && wsHvo > 0 && tss.Length > 0) { Add(wsHvo, tss); } } }
private void SetContentFromNode(FdoCache cache, string sNodeName, bool fFixName, ITsMultiString item) { ILgWritingSystemFactory wsf = cache.WritingSystemFactory; ITsStrFactory tsf = cache.TsStrFactory; int iWS; XmlNode nd; bool fContentFound = false; // be pessimistic foreach (IWritingSystem ws in cache.ServiceLocator.WritingSystems.CurrentAnalysisWritingSystems) { string sWS = ws.Id; nd = m_node.SelectSingleNode(sNodeName + "[@ws='" + sWS + "']"); if (nd == null || nd.InnerText.Length == 0) { continue; } fContentFound = true; string sNodeContent; if (fFixName) { sNodeContent = NameFixer(nd.InnerText); } else { sNodeContent = nd.InnerText; } iWS = wsf.GetWsFromStr(sWS); item.set_String(iWS, (tsf.MakeString(sNodeContent, iWS))); } if (!fContentFound) { iWS = cache.ServiceLocator.WritingSystems.DefaultAnalysisWritingSystem.Handle; item.set_String(iWS, tsf.MakeString("", iWS)); } }
public void Dispose() { m_stText = null; m_tsf = null; m_text = null; m_firstPara = null; m_cache = null; }
public DiscourseTestHelper(FdoCache cache) { m_cache = cache; m_tsf = TsStrFactoryClass.Create(); m_text = (Text)Cache.LangProject.TextsOC.Add(new Text()); m_stText = new StText(); m_text.ContentsOA = m_stText; m_firstPara = MakeParagraph(); }
public void Setup() { tsf = TsStrFactoryClass.Create(); wsf = new MockWsf(); wsEn = wsf.GetWsFromStr("en"); wsFrn = wsf.GetWsFromStr("fr"); ITsPropsBldr propBldr = TsPropsBldrClass.Create(); propBldr.SetIntPropValues((int)FwTextPropType.ktptWs, (int)FwTextPropVar.ktpvDefault, wsFrn); ttpFrn = propBldr.GetTextProps(); }
public override void FixtureSetup() { base.FixtureSetup(); SetupTestModel(Resources.TextCacheModel_xml); m_sda = new RealDataCache(); m_sda.MetaDataCache = MetaDataCache.CreateMetaDataCache("TestModel.xml"); //m_cache.ParaContentsFlid = kflidParaContents; //m_cache.ParaPropertiesFlid = kflidParaProperties; //m_cache.TextParagraphsFlid = kflidTextParas; Debug.Assert(m_wsManager == null); m_wsManager = Cache.ServiceLocator.GetInstance<IWritingSystemManager>(); m_sda.WritingSystemFactory = m_wsManager; m_wsAnal = Cache.DefaultAnalWs; m_wsVern = Cache.DefaultVernWs; //IWritingSystem deWs; //m_wsManager.GetOrSet("de", out deWs); //m_wsDeu = deWs.Handle; //m_wsManager.UserWs = m_wsEng; //m_wsUser = m_wsManager.UserWs; m_tsf = TsStrFactoryClass.Create(); m_hvoLexDb = m_sda.MakeNewObject(kclsidLexDb, 0, -1, -1); kflidLexDb_Entries = m_sda.MetaDataCache.GetFieldId("LexDb", "Entries", false); kflidEntry_Form = m_sda.MetaDataCache.GetFieldId("Entry", "Form", false); kflidEntry_Summary = m_sda.MetaDataCache.GetFieldId("Entry", "Summary", false); m_hvoKick = m_sda.MakeNewObject(kclsidEntry, m_hvoLexDb, kflidLexDb_Entries, 0); m_sda.SetMultiStringAlt(m_hvoKick, kflidEntry_Form, m_wsVern, m_tsf.MakeString("kick", m_wsVern)); m_sda.SetString(m_hvoKick, kflidEntry_Summary, m_tsf.MakeString("strike with foot", m_wsAnal)); var keyAttrs = new Dictionary<string, string[]>(); keyAttrs["layout"] = new[] { "class", "type", "name", "choiceGuid" }; keyAttrs["group"] = new[] { "label" }; keyAttrs["part"] = new[] { "ref" }; var layoutInventory = new Inventory("*.fwlayout", "/LayoutInventory/*", keyAttrs, "test", "nowhere"); layoutInventory.LoadElements(Resources.Layouts_xml, 1); keyAttrs = new Dictionary<string, string[]>(); keyAttrs["part"] = new[] { "id" }; var partInventory = new Inventory("*Parts.xml", "/PartInventory/bin/*", keyAttrs, "test", "nowhere"); partInventory.LoadElements(Resources.Parts_xml, 1); m_layouts = new LayoutCache(m_sda.MetaDataCache, layoutInventory, partInventory); }
public void FixtureSetup() { m_wsManager = new PalasoWritingSystemManager(); IWritingSystem enWs; m_wsManager.GetOrSet("en", out enWs); m_enWs = enWs.Handle; IWritingSystem frWs; m_wsManager.GetOrSet("fr", out frWs); m_frWs = frWs.Handle; m_tsf = TsStrFactoryClass.Create(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Create test data for tests. /// </summary> /// ------------------------------------------------------------------------------------ protected override void CreateTestData() { m_servloc = Cache.ServiceLocator; m_text = AddInterlinearTextToLangProj("My Interlinear Text"); m_stTextPara = AddParaToInterlinearTextContents(m_text, "Here is a sentence I can chart."); m_stText = m_text.ContentsOA; m_tssFact = Cache.TsStrFactory; m_rowFact = m_servloc.GetInstance<IConstChartRowFactory>(); m_wordGrpFact = m_servloc.GetInstance<IConstChartWordGroupFactory>(); m_possFact = m_servloc.GetInstance<ICmPossibilityFactory>(); m_wfiFact = m_servloc.GetInstance<IWfiWordformFactory>(); m_mtMrkrFact = m_servloc.GetInstance<IConstChartMovedTextMarkerFactory>(); m_clsMrkrFact = m_servloc.GetInstance<IConstChartClauseMarkerFactory>(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes for replace all: creates a view constructor to be used with replace all /// as well as initial settings for the pattern. /// </summary> /// ------------------------------------------------------------------------------------ private void InitializeForReplaceAll() { // REVIEW: do we need to create m_vc? We don't seem to use it anywhere. m_vc = new TeStVc(TeStVc.LayoutViewTarget.targetDraft, 0); m_vc.Cache = Cache; m_pattern = VwPatternClass.Create(); m_strFactory = TsStrFactoryClass.Create(); m_pattern.MatchOldWritingSystem = false; m_pattern.MatchDiacritics = false; m_pattern.MatchWholeWord = false; m_pattern.MatchCase = false; m_pattern.UseRegularExpressions = false; }
private void FixtureSetupInternal() { //IWritingSystem wsEn = Cache.WritingSystemFactory.get_Engine("en"); // Setup default analysis ws //m_wsEn = Cache.ServiceLocator.GetInstance<ILgWritingSystemRepository>().GetObject(wsEn.WritingSystem); m_wsVern = Cache.DefaultVernWs; m_wsTrans = Cache.DefaultAnalWs; m_text = Cache.ServiceLocator.GetInstance<ITextFactory>().Create(); //Cache.LangProject.TextsOC.Add(m_text); var stText = Cache.ServiceLocator.GetInstance<IStTextFactory>().Create(); m_text.ContentsOA = stText; m_para = Cache.ServiceLocator.GetInstance<IScrTxtParaFactory>().CreateWithStyle(stText, ScrStyleNames.NormalParagraph); m_trans = m_para.GetOrCreateBT(); Cache.LangProject.TranslatedScriptureOA.UseScriptDigits = false; m_tsf = Cache.TsStrFactory; }
/// <summary> /// Constructor. Called by service locator factory (by reflection). /// </summary> /// <remarks> /// The hvo values are true 'handles' in that they are valid for one session, /// but may not be the same integer for another session for the 'same' object. /// Therefore, one should not use them for multi-session identity. /// CmObject identity can only be guaranteed by using their Guids (or using '==' in code). /// </remarks> internal DomainDataByFlid(ICmObjectRepository cmObjectRepository, IStTextRepository stTxtRepository, IFwMetaDataCacheManaged mdc, ISilDataAccessHelperInternal uowService, ITsStrFactory tsf, ILgWritingSystemFactory wsf) { if (cmObjectRepository == null) throw new ArgumentNullException("cmObjectRepository"); if (stTxtRepository == null) throw new ArgumentNullException("stTxtRepository"); if (mdc == null) throw new ArgumentNullException("mdc"); if (uowService == null) throw new ArgumentNullException("uowService"); if (tsf == null) throw new ArgumentNullException("tsf"); if (wsf == null) throw new ArgumentNullException("wsf"); m_cmObjectRepository = cmObjectRepository; m_stTxtRepository = stTxtRepository; m_mdc = mdc; m_uowService = uowService; m_tsf = tsf; m_wsf = wsf; }
/// <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 (m_isDisposed) return; if (disposing) { // Dispose managed resources here. } // Dispose unmanaged resources here, whether disposing is true or false. if (m_cpe != null && Marshal.IsComObject(m_cpe)) Marshal.ReleaseComObject(m_cpe); m_cpe = null; m_settings = null; m_SOWrapper = null; m_sSegmentText = null; m_sMarker = null; m_styleProxy = null; m_vernParaStyleProxy = null; m_vernTextProps = null; m_analTextProps = null; m_styleProxies = null; m_notesStyleProxies = null; m_lastPara = null; m_BookTitleParaProxy = null; m_DefaultFootnoteParaProxy = null; m_TsStringFactory = null; m_BTFootnoteStrBldr = null; m_CurrParaPictures = null; m_CurrParaFootnotes = null; m_BTPendingPictures = null; m_CurrBTFootnote = null; m_sBtFootnoteParaStyle = null; m_BtFootnoteStrBldrs = null; m_PendingAnnotations = null; m_BTfootnoteIndex = null; m_sCharStyleEndMarker = null; m_sFootnoteEndMarker = null; m_sCharStyleBeginMarker = null; m_sFootnoteBeginMarker = null; m_scrTranslatorAnnotationDef = null; base.Dispose(disposing); }
public TsStringfactory(ITsStrFactory tsf, Dictionary<string, int> wsCache) { m_tsf = tsf; m_wsCache = wsCache; }
/// <summary> /// Clean up any resources being used. /// </summary> protected override void Dispose(bool disposing) { System.Diagnostics.Debug.WriteLineIf(!disposing, "****** Missing Dispose() call for " + GetType().Name + ". ****** "); // Must not be run more than once. if (IsDisposed) return; if (disposing) { Controls.Remove(m_fwTextBoxBottomMsg); m_fwTextBoxBottomMsg.Dispose(); if(components != null) { components.Dispose(); } } m_fwTextBoxBottomMsg = null; m_mediator = null; if (m_tsf != null) System.Runtime.InteropServices.Marshal.ReleaseComObject(m_tsf); m_tsf = null; m_cache = null; base.Dispose( disposing ); }
/// <summary> /// Set up the dlg in preparation to showing it. /// </summary> /// <param name="cache">FDO cache.</param> /// <param name="mediator"></param> /// <param name="entry">LexEntry</param> public void SetDlgInfo(FdoCache cache, Mediator mediator, ILexEntry entry) { CheckDisposed(); Debug.Assert(cache != null); m_mediator = mediator; m_cache = cache; m_entry = entry; m_tsf = m_cache.TsStrFactory; m_fwTextBoxBottomMsg.WritingSystemFactory = m_cache.WritingSystemFactory; //m_fwTextBoxBottomMsg.WritingSystemCode = 1; // What!? Why? No longer makes ANY sense! IVwStylesheet stylesheet = FontHeightAdjuster.StyleSheetFromMediator(mediator); // We want to do this BEFORE the text gets set, to avoid overriding its height properties. // However, because of putting multiple lines in the box, we also need to do it AFTER we set the text // (in SetBottomMessage) so it adjusts to the resulting even greater height. m_fwTextBoxBottomMsg.AdjustForStyleSheet(this, null, stylesheet); Font f = FontHeightAdjuster.GetFontForNormalStyle( m_cache.ServiceLocator.WritingSystems.DefaultVernacularWritingSystem.Handle, stylesheet, m_cache.LanguageWritingSystemFactoryAccessor); foreach (IMoForm allo in entry.AlternateFormsOS) { ListViewItem lvi = m_lvAlloOptions.Items.Add(allo.Form.VernacularDefaultWritingSystem.Text); lvi.Tag = allo; lvi.UseItemStyleForSubItems = true; lvi.Font = f; } m_lvAlloOptions.Font = f; // Get location to the stored values, if any. object locWnd = m_mediator.PropertyTable.GetValue("swapDlgLocation"); // And when I do this, it works the first time, but later times the window is // too small and doesn't show all the controls. Give up on smart location for now. //object szWnd = this.Size; object szWnd = null; // suppresses the smart location stuff. //if (locWnd != null && szWnd != null) //{ // Rectangle rect = new Rectangle((Point)locWnd, (Size)szWnd); // ScreenUtils.EnsureVisibleRect(ref rect); // DesktopBounds = rect; // StartPosition = FormStartPosition.Manual; //} m_lvAlloOptions.Items[0].Selected = true; Text = LexEdStrings.ksSwapLexWithAllo; label2.Text = LexEdStrings.ksAlternateForms; // Determine the help file to use, if any m_helpTopic = "khtpSwapLexemeWithAllomorph"; if(m_mediator.HelpTopicProvider != null) { helpProvider = new HelpProvider(); helpProvider.HelpNamespace = m_mediator.HelpTopicProvider.HelpFile; helpProvider.SetHelpKeyword(this, m_mediator.HelpTopicProvider.GetHelpString(m_helpTopic)); helpProvider.SetHelpNavigator(this, HelpNavigator.Topic); } }
private ITsString NameOfWs(ITsStrFactory tsf, int i) { // Don't use this, it uses the analysis default writing system which is not wanted per LT-4610. //tsf.MakeString(m_rgws[i].Abbreviation, m_wsUI); ILgWritingSystem ws = m_rgws[i]; // Display in English if possible for now (August 2008). See LT-8631 and LT-8574. ITsString result = ws.Cache.MainCacheAccessor.get_MultiStringAlt(ws.Hvo, (int)LgWritingSystem.LgWritingSystemTags.kflidAbbr, m_wsEn/*m_wsUI*/); if (result == null || result.Length == 0) return tsf.MakeString(m_rgws[i].Abbreviation, m_wsEn/*m_wsUI*/); return result; }
/// <summary> /// Initialize the control. /// </summary> /// <param name="cache"></param> /// <param name="mediator"></param> /// <param name="parentForm"></param> public void Initialize(FdoCache cache, Mediator mediator, Form parentForm, SandboxGenericMSA sandboxMSA) { CheckDisposed(); m_parentForm = parentForm; m_mediator = mediator; m_tsf = cache.TsStrFactory; m_cache = cache; IVwStylesheet stylesheet = FontHeightAdjuster.StyleSheetFromMediator(mediator); int defUserWs = m_cache.ServiceLocator.WritingSystemManager.UserWs; IWritingSystem defAnalWs = m_cache.ServiceLocator.WritingSystems.DefaultAnalysisWritingSystem; string defAnalWsFont = defAnalWs.DefaultFontName; m_fwcbAffixTypes.WritingSystemFactory = m_cache.WritingSystemFactory; m_fwcbAffixTypes.WritingSystemCode = defAnalWs.Handle; m_fwcbAffixTypes.Items.Add(m_tsf.MakeString(LexTextControls.ksNotSure, defUserWs)); m_fwcbAffixTypes.Items.Add(m_tsf.MakeString(LexTextControls.ksInflectional, defUserWs)); m_fwcbAffixTypes.Items.Add(m_tsf.MakeString(LexTextControls.ksDerivational, defUserWs)); m_fwcbAffixTypes.StyleSheet = stylesheet; m_fwcbAffixTypes.AdjustStringHeight = false; m_fwcbSlots.Font = new Font(defAnalWsFont, 10); m_fwcbSlots.WritingSystemFactory = m_cache.WritingSystemFactory; m_fwcbSlots.WritingSystemCode = defAnalWs.Handle; m_fwcbSlots.StyleSheet = stylesheet; m_fwcbSlots.AdjustStringHeight = false; m_tcMainPOS.Font = new Font(defAnalWsFont, 10); m_tcMainPOS.WritingSystemFactory = m_cache.WritingSystemFactory; m_tcMainPOS.WritingSystemCode = defAnalWs.Handle; m_tcMainPOS.StyleSheet = stylesheet; m_tcMainPOS.AdjustStringHeight = false; m_tcSecondaryPOS.Font = new Font(defAnalWsFont, 10); m_tcSecondaryPOS.WritingSystemFactory = m_cache.WritingSystemFactory; m_tcSecondaryPOS.WritingSystemCode = defAnalWs.Handle; m_tcSecondaryPOS.StyleSheet = stylesheet; m_tcSecondaryPOS.AdjustStringHeight = false; m_selectedMainPOS = sandboxMSA.MainPOS; m_fwcbAffixTypes.SelectedIndex = 0; m_fwcbAffixTypes.SelectedIndexChanged += HandleComboMSATypesChange; m_mainPOSPopupTreeManager = new POSPopupTreeManager(m_tcMainPOS, m_cache, m_cache.LanguageProject.PartsOfSpeechOA, defAnalWs.Handle, false, m_mediator, m_parentForm); m_mainPOSPopupTreeManager.NotSureIsAny = true; m_mainPOSPopupTreeManager.LoadPopupTree(m_selectedMainPOS != null ? m_selectedMainPOS.Hvo : 0); m_mainPOSPopupTreeManager.AfterSelect += m_mainPOSPopupTreeManager_AfterSelect; m_fwcbSlots.SelectedIndexChanged += HandleComboSlotChange; m_secPOSPopupTreeManager = new POSPopupTreeManager(m_tcSecondaryPOS, m_cache, m_cache.LanguageProject.PartsOfSpeechOA, defAnalWs.Handle, false, m_mediator, m_parentForm); m_secPOSPopupTreeManager.NotSureIsAny = true; // only used for affixes. m_selectedSecondaryPOS = sandboxMSA.SecondaryPOS; m_secPOSPopupTreeManager.LoadPopupTree(m_selectedSecondaryPOS != null ? m_selectedSecondaryPOS.Hvo : 0); m_secPOSPopupTreeManager.AfterSelect += m_secPOSPopupTreeManager_AfterSelect; // Relocate the m_tcSecondaryPOS control to overlay the m_fwcbSlots. // In the designer, they are offset to see them, and edit them. // In running code they are in the same spot, but only one is visible at a time. m_tcSecondaryPOS.Location = m_fwcbSlots.Location; if (m_selectedMainPOS != null && sandboxMSA.MsaType == MsaType.kInfl) { // This fixes LT-4677, LT-6048, and LT-6201. ResetSlotCombo(); } MSAType = sandboxMSA.MsaType; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Create an ITsString in the given writing system. /// </summary> /// ------------------------------------------------------------------------------------ public static ITsString MakeTss(ITsStrFactory tsf, int wsHvo, string text) { return tsf.MakeString(text, wsHvo); }
/// <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> private void Dispose(bool disposing) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (m_isDisposed) return; if (disposing) { if (m_wsCache != null) m_wsCache.Clear(); if (m_delayedAtomicReferences != null) m_delayedAtomicReferences.Clear(); if (m_delayedVecterReferences != null) m_delayedVecterReferences.Clear(); if (m_cachedFlids != null) m_cachedFlids.Clear(); if (m_tsf != null) m_tsf.Dispose(); } // Dispose unmanaged resources here, whether disposing is true or false. if (m_itsf != null) { if (Marshal.IsComObject(m_itsf)) Marshal.ReleaseComObject(m_itsf); m_itsf = null; } m_tsf = null; m_metaDataCache = null; m_realDataCache = null; m_wsCache = null; m_delayedAtomicReferences = null; m_delayedVecterReferences = null; m_cachedFlids = null; m_isDisposed = true; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes for replace all: creates a view constructor to be used with replace all /// as well as initial settings for the pattern. /// </summary> /// ------------------------------------------------------------------------------------ private void InitializeForReplaceAll() { m_vc = new TeStVc(TeStVc.LayoutViewTarget.targetDraft, 0); m_vc.Cache = Cache; m_pattern = VwPatternClass.Create(); m_strFactory = TsStrFactoryClass.Create(); m_pattern.MatchOldWritingSystem = false; m_pattern.MatchDiacritics = false; m_pattern.MatchWholeWord = false; m_pattern.MatchCase = false; m_pattern.UseRegularExpressions = false; }
/// <summary> /// Clean up any resources being used. /// </summary> 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 ) { if(components != null) { components.Dispose(); } } m_cache = null; m_tsf = null; base.Dispose( disposing ); }
protected virtual void SetDlgInfo(FdoCache cache, WindowParams wp, Mediator mediator, int wsVern) { CheckDisposed(); Debug.Assert(cache != null); m_cache = cache; m_mediator = mediator; if (m_mediator != null) { ReplaceMatchingItemsControl(); // Reset window location. // Get location to the stored values, if any. object locWnd = m_mediator.PropertyTable.GetValue(PersistenceLabel + "DlgLocation"); object szWnd = m_mediator.PropertyTable.GetValue(PersistenceLabel + "DlgSize"); if (locWnd != null && szWnd != null) { Rectangle rect = new Rectangle((Point)locWnd, (Size)szWnd); //grow it if it's too small. This will happen when we add new controls to the dialog box. if(rect.Width < btnHelp.Left + btnHelp.Width + 30) rect.Width = btnHelp.Left + btnHelp.Width + 30; if(rect.Height < btnHelp.Top + btnHelp.Height + 50) rect.Height = btnHelp.Top + btnHelp.Height + 50; //rect.Height = 600; ScreenUtils.EnsureVisibleRect(ref rect); DesktopBounds = rect; StartPosition = FormStartPosition.Manual; } } SetupBasicTextProperties(wp); IVwStylesheet stylesheet = FontHeightAdjuster.StyleSheetFromMediator(mediator); InitializeMatchingEntries(cache, mediator); int hvoWs = wsVern; // Set font, writing system factory, and writing system code for the Lexical Form // edit box. Also set an empty string with the proper writing system. m_tbForm.Font = new Font(cache.LanguageWritingSystemFactoryAccessor.get_EngineOrNull(wsVern).DefaultSerif, 10); m_tbForm.WritingSystemFactory = cache.LanguageWritingSystemFactoryAccessor; m_tbForm.WritingSystemCode = hvoWs; m_tsf = TsStrFactoryClass.Create(); m_tbForm.AdjustStringHeight = false; m_tbForm.Tss = m_tsf.MakeString("", hvoWs); m_tbForm.StyleSheet = stylesheet; // Setup the fancy message text box. // Note: at 120DPI (only), it seems to be essential to set at least the WSF of the // bottom message even if not using it. SetupBottomMsg(); SetBottomMessage(); m_fwTextBoxBottomMsg.BorderStyle = BorderStyle.None; m_analHvos.AddRange(cache.LangProject.CurAnalysisWssRS.HvoArray); List<int> vernList = new List<int>(cache.LangProject.CurVernWssRS.HvoArray); m_vernHvos.AddRange(vernList); LoadWritingSystemCombo(); int iWs = vernList.IndexOf(hvoWs); ILgWritingSystem lgwsCurrent; if (iWs < 0) { List<int> analList = new List<int>(cache.LangProject.CurAnalysisWssRS.HvoArray); iWs = analList.IndexOf(hvoWs); if (iWs < 0) { lgwsCurrent = LgWritingSystem.CreateFromDBObject(cache, hvoWs); m_cbWritingSystems.Items.Add(lgwsCurrent); } else { lgwsCurrent = cache.LangProject.CurAnalysisWssRS[iWs]; } } else { lgwsCurrent = cache.LangProject.CurVernWssRS[iWs]; } Debug.Assert(lgwsCurrent != null && lgwsCurrent.Hvo == hvoWs); m_skipCheck = true; m_cbWritingSystems.SelectedItem = lgwsCurrent; m_skipCheck = false; // Don't hook this up until AFTER we've initialized it; otherwise, it can // modify the contents of the form as a side effect of initialization. // Also, doing that triggers laying out the dialog prematurely, before // we've set WSF on all the controls. m_cbWritingSystems.SelectedIndexChanged += new System.EventHandler(this.m_cbWritingSystems_SelectedIndexChanged); // Adjust things if the form box needs to grow to accommodate its style. int oldHeight = m_tbForm.Height; int newHeight = Math.Max(oldHeight, m_tbForm.PreferredHeight); int delta = newHeight - oldHeight; if (delta != 0) { m_tbForm.Height = newHeight; panel1.Height += delta; GrowDialogAndAdjustControls(delta, panel1); } }
/// <summary> /// Clean up any resources being used. /// </summary> protected override void Dispose(bool disposing) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (IsDisposed) return; base.Dispose(disposing); if (disposing) { if (m_vc != null) m_vc.Dispose(); if (m_usedIndices != null) m_usedIndices.Clear(); } m_sense = null; m_vc = null; if (m_tsf != null) System.Runtime.InteropServices.Marshal.ReleaseComObject(m_tsf); m_tsf = null; m_silCache = null; if (m_vwCache != null) { m_vwCache.ClearAllData(); System.Runtime.InteropServices.Marshal.ReleaseComObject(m_vwCache); m_vwCache = null; } m_usedIndices = null; }
public ReversalIndexEntryVc(List<IReversalIndex> usedIndices, FdoCache cache) { m_cache = cache; m_usedIndices = usedIndices; m_ttpLabel = LgWritingSystem.AbbreviationTextProperties; m_tsf = TsStrFactoryClass.Create(); }
/// <summary> /// Clean up any resources being used. /// </summary> protected override void Dispose(bool disposing) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (IsDisposed) return; base.Dispose(disposing); if (disposing) { if (components != null) { components.Dispose(); } if (m_PhoneEnvReferenceVc != null) m_PhoneEnvReferenceVc.Dispose(); } m_validator = null; // TODO: Make m_validator disposable? m_realEnvs.Clear(); m_realEnvs = null; m_rootObj = null; if (m_tsf != null) System.Runtime.InteropServices.Marshal.ReleaseComObject(m_tsf); m_tsf = null; m_silCache = null; if (m_vwCache != null) System.Runtime.InteropServices.Marshal.ReleaseComObject(m_vwCache); m_vwCache = null; m_PhoneEnvReferenceVc = 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_usedIndices != null) m_usedIndices.Clear(); } // Dispose unmanaged resources here, whether disposing is true or false. m_cache = null; m_usedIndices = null; m_ttpLabel = null; m_tsf = null; base.Dispose(disposing); }
/// <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. } // Dispose unmanaged resources here, whether disposing is true or false. m_footnote = null;; m_book = null; if (m_strFact != null) Marshal.ReleaseComObject(m_strFact); m_strFact = null;; base.Dispose(disposing); }
public void SetUp() { m_tsf = TsStrFactoryClass.Create(); }
private HvoTreeNode AddTreeNodeForMsa(PopupTree popupTree, ITsStrFactory tsf, IMoMorphSynAnalysis msa) { // JohnT: as described in LT-4633, a stem can be given an allomorph that // is an affix. So we need some sort of way to handle this. //Debug.Assert(msa is MoStemMsa); ITsString tssLabel = msa.InterlinearNameTSS; if (msa is IMoStemMsa && (msa as IMoStemMsa).PartOfSpeechRA == null) tssLabel = tsf.MakeString( m_sUnknown, Cache.ServiceLocator.WritingSystemManager.UserWs); var node = new HvoTreeNode(tssLabel, msa.Hvo); popupTree.Nodes.Add(node); return node; }
public void FixtureSetup() { m_wsManager = new PalasoWritingSystemManager(); m_comparer = new TsStringComparer(m_wsManager.Create("en")); m_tssFact = TsStrFactoryClass.Create(); }