/// ------------------------------------------------------------------------------------ /// <summary> /// This is the main interesting method of displaying objects and fragments of them. Most /// subclasses should override. /// </summary> /// <param name="vwenv"></param> /// <param name="hvo"></param> /// <param name="frag"></param> /// ------------------------------------------------------------------------------------ public override void Display(IVwEnv vwenv, int hvo, int frag) { switch (frag) { case kfragRoot: // assume the root object has been loaded. base.Display(vwenv, hvo, frag); vwenv.AddObj(khvoNewItem, this, kfragEditRow); break; case kfragEditRow: AddEditRow(vwenv, hvo); break; case kfragListItem: if (hvo != khvoNewItem) { base.Display(vwenv, hvo, frag); } break; default: base.Display(vwenv, hvo, frag); break; } }
/// <summary> /// Calling vwenv.AddObjVec() in Display() and implementing DisplayVec() seems to /// work better than calling vwenv.AddObjVecItems() in Display(). Theoretically /// this should not be case, but experience trumps theory every time. :-) :-( /// </summary> public override void DisplayVec(IVwEnv vwenv, int hvo, int tag, int frag) { if (hvo == 0) { return; } ISilDataAccess da = vwenv.DataAccess; int count = da.get_VecSize(hvo, tag); for (int i = 0; i < count; ++i) { vwenv.AddObj(da.get_VecItem(hvo, tag, i), this, VectorReferenceView.kfragTargetObj); vwenv.AddSeparatorBar(); } vwenv.AddObj(PossibilityVectorReferenceView.khvoFake, this, VectorReferenceView.kfragTargetObj); }
/// <summary> /// Calling vwenv.AddObjVec() in Display() and implementing DisplayVec() seems to /// work better than calling vwenv.AddObjVecItems() in Display(). Theoretically /// this should not be case, but experience trumps theory every time. :-) :-( /// </summary> public override void DisplayVec(IVwEnv vwenv, int hvo, int tag, int frag) { ISilDataAccess da = vwenv.DataAccess; int count = da.get_VecSize(hvo, tag); // Show everything in the sequence including current element from the main display. for (int i = 0; i < count; ++i) { int hvoItem = da.get_VecItem(hvo, tag, i); vwenv.AddObj(hvoItem, this, VectorReferenceView.kfragTargetObj); vwenv.AddSeparatorBar(); } }
/// <summary> /// Calling vwenv.AddObjVec() in Display() and implementing DisplayVec() seems to /// work better than calling vwenv.AddObjVecItems() in Display(). Theoretically /// this should not be case, but experience trumps theory every time. :-) :-( /// </summary> public override void DisplayVec(IVwEnv vwenv, int hvo, int tag, int frag) { ISilDataAccess da = vwenv.DataAccess; int count = da.get_VecSize(hvo, tag); // Tree Branches consist of everything FOLLOWING the first element which is the Tree root. for (int i = 1; i < count; ++i) { vwenv.AddObj(da.get_VecItem(hvo, tag, i), this, VectorReferenceView.kfragTargetObj); vwenv.AddSeparatorBar(); } }
/// <summary> /// Calling vwenv.AddObjVec() in Display() and implementing DisplayVec() seems to /// work better than calling vwenv.AddObjVecItems() in Display(). Theoretically /// this should not be case, but experience trumps theory every time. :-) :-( /// </summary> public override void DisplayVec(IVwEnv vwenv, int hvo, int tag, int frag) { CheckDisposed(); ISilDataAccess da = vwenv.DataAccess; int count = da.get_VecSize(hvo, tag); for (int i = 0; i < count; ++i) { vwenv.AddObj(da.get_VecItem(hvo, tag, i), this, VectorReferenceView.kfragTargetObj); vwenv.AddSeparatorBar(); } }
/// <summary> /// Calling vwenv.AddObjVec() in Display() and implementing DisplayVec() seems to /// work better than calling vwenv.AddObjVecItems() in Display(). Theoretically /// this should not be case, but experience trumps theory every time. :-) :-( /// </summary> public override void DisplayVec(IVwEnv vwenv, int hvo, int tag, int frag) { CheckDisposed(); ISilDataAccess da = vwenv.DataAccess; int count = da.get_VecSize(hvo, tag); // Tree Branches consist of everything FOLLOWING the first element which is the Tree root. for (int i = 1; i < count; ++i) { vwenv.AddObj(da.get_VecItem(hvo, tag, i), this, VectorReferenceView.kfragTargetObj); vwenv.AddSeparatorBar(); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Override of DisplayVec /// </summary> /// ------------------------------------------------------------------------------------ public override void DisplayVec(IVwEnv vwenv, int paraHvo, int tag, int frag) { CheckDisposed(); if (tag == StTxtParaTags.kflidTranslations && frag == (int)ScrFrags.kfrBtTranslationStatus) { IStTxtPara para = Cache.ServiceLocator.GetInstance <IStTxtParaRepository>().GetObject(paraHvo); vwenv.AddObj(GetTranslationForPara(paraHvo), this, frag); } else { base.DisplayVec(vwenv, paraHvo, tag, frag); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Override of DisplayVec /// </summary> /// ------------------------------------------------------------------------------------ public override void DisplayVec(IVwEnv vwenv, int hvo, int tag, int frag) { CheckDisposed(); if (tag == (int)StTxtPara.StTxtParaTags.kflidTranslations && frag == (int)ScrFrags.kfrBtTranslationStatus) { vwenv.AddObj(GetTranslationForPara(hvo), this, frag); } else { base.DisplayVec(vwenv, hvo, tag, frag); } }
/// ----------------------------------------------------------------------------------- /// <summary> /// Handles displaying the vector of words with commas except after the last /// </summary> /// <param name="vwenv"></param> /// <param name="hvo"></param> /// <param name="tag"></param> /// <param name="frag"></param> /// ----------------------------------------------------------------------------------- public override void DisplayVec(IVwEnv vwenv, int hvo, int tag, int frag) { Debug.Assert(frag == kfragWords); ISilDataAccess sda = vwenv.DataAccess; int cwords = sda.get_VecSize(hvo, ktagWords); for (int i = 0; i < cwords; i++) { vwenv.AddObj(sda.get_VecItem(hvo, ktagWords, i), this, kfragName); if (i != cwords - 1) { vwenv.AddString(m_tssComma); } } }
public override void DisplayVec(IVwEnv vwenv, int hvo, int tag, int frag) { CheckDisposed(); ISilDataAccess da = vwenv.DataAccess; int count = da.get_VecSize(hvo, tag); for (int i = 0; i < count; ++i) { if (i != 0) { vwenv.AddSeparatorBar(); } vwenv.AddObj(da.get_VecItem(hvo, tag, i), this, PhoneEnvReferenceView.kFragEnvironmentObj); } }
public override void DisplayVec(IVwEnv vwenv, int hvo, int tag, int frag) { CheckDisposed(); switch (frag) { case kfragMorph: // The bundle of 4 lines representing a morpheme. ISilDataAccess sda = vwenv.DataAccess; int cmorph = sda.get_VecSize(hvo, tag); for (int i = 0; i < cmorph; ++i) { int hvoMorph = sda.get_VecItem(hvo, tag, i); vwenv.AddObj(hvoMorph, this, i == 0 ? kfragFirstMorph : kfragMorph); } break; } }
/// <summary> /// Calling vwenv.AddObjVec() in Display() and implementing DisplayVec() seems to /// work better than calling vwenv.AddObjVecItems() in Display(). Theoretically /// this should not be case, but experience trumps theory every time. :-) :-( /// </summary> public override void DisplayVec(IVwEnv vwenv, int hvo, int tag, int frag) { ISilDataAccess da = vwenv.DataAccess; int count = da.get_VecSize(hvo, tag); // Show everything in the collection except the current element from the main display. for (int i = 0; i < count; ++i) { int hvoItem = da.get_VecItem(hvo, tag, i); if (m_displayParent != null && hvoItem == m_displayParent.Hvo) { continue; } vwenv.AddObj(hvoItem, this, VectorReferenceView.kfragTargetObj); vwenv.AddSeparatorBar(); } }
public override void DisplayVec(IVwEnv vwenv, int hvo, int tag, int frag) { switch (frag) { case kfragInput: // input context cell foreach (var ctxt in m_rule.InputOS) { vwenv.Props = m_ctxtProps; vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); vwenv.AddObj(ctxt.Hvo, this, kfragContext); vwenv.CloseParagraph(); vwenv.CloseTableCell(); } break; default: base.DisplayVec(vwenv, hvo, tag, frag); break; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Creates the notes paragraph. /// </summary> /// <param name="vwenv">The vwenv.</param> /// <param name="notes">The notes.</param> /// <param name="styleProps">The style props.</param> /// ------------------------------------------------------------------------------------ private void CreateNotesParagraph(IVwEnv vwenv, List <int> notes, ITsTextProps styleProps) { // Don't create a completely empty paragraph. The way the Views system handles such paragraphs // doesn't work for a MappedTaggedPara. Also, we want the footnote to take up no height at all // if there are none. if (notes.Count == 0) { return; } vwenv.set_IntProperty((int)FwTextPropType.ktptBaseWs, (int)FwTextPropVar.ktpvDefault, DefaultWs); vwenv.set_IntProperty((int)FwTextPropType.ktptRightToLeft, (int)FwTextPropVar.ktpvEnum, (RightToLeft ? -1 : 0)); vwenv.set_IntProperty((int)FwTextPropType.ktptAlign, (int)FwTextPropVar.ktpvEnum, RightToLeft ? (int)FwTextAlign.ktalRight : (int)FwTextAlign.ktalLeft); vwenv.Props = styleProps; // The body of the paragraph is either editable or not. vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, Editable ? (int)TptEditable.ktptIsEditable : (int)TptEditable.ktptNotEditable); vwenv.OpenMappedTaggedPara(); for (int ihvo = 0; ihvo < notes.Count; ihvo++) { // Optimize JohnT: could make this string once and save it in a member variable. if (ihvo != 0) { vwenv.AddString(m_cache.TsStrFactory.MakeString(" ", m_cache.DefaultVernWs)); } vwenv.AddObj(notes[ihvo], this, (int)FootnoteFrags.kfrFootnoteWithinPagePara); } vwenv.CloseParagraph(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Insert the body of a paragraph. This is normally (with fApplyProps true) the body /// of case kfrPara and kfrFootnotePara in the Display method, but some subclasses /// need to separate this from applying the properties. /// </summary> /// <param name="vwenv"></param> /// <param name="paraHvo"></param> /// <param name="frag"></param> /// <param name="fApplyProps"></param> /// <param name="contentType"></param> /// <param name="vc">The view constructor used to create the paragraphs</param> /// ------------------------------------------------------------------------------------ protected void InsertParagraphBody(IVwEnv vwenv, int paraHvo, int frag, bool fApplyProps, ContentTypes contentType, StVc vc) { vc.SetupWsAndDirectionForPara(vwenv, paraHvo); if (fApplyProps) { ApplyParagraphStyleProps(vwenv, paraHvo, vc); } // This was causing assertions in the layoutmgr // TODO (TE-5777): Should be able to do this with an in-memory stylesheet. // if (DisplayTranslation) // { // // display the back translation text as double spaced // vwenv.set_IntProperty((int)FwTextPropType.ktptLineHeight, // (int)FwTextPropVar.ktpvRelative, 20000); // } // The body of the paragraph is either editable or not. vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, vc.Editable ? (int)TptEditable.ktptIsEditable : (int)TptEditable.ktptNotEditable); // Make the paragraph containing the paragraph contents. OpenPara(vwenv, paraHvo); // Cause a regenerate when the style changes...this is mainly used for Undo. vwenv.NoteDependency(new[] { paraHvo }, new[] { StParaTags.kflidStyleRules }, 1); // Insert the label if it is the first paragraph. if (vc.Label != null) { int lev = vwenv.EmbeddingLevel; int hvoOuter; int ihvoItem; int tagOuter; vwenv.GetOuterObject(lev - 1, out hvoOuter, out tagOuter, out ihvoItem); if (ihvoItem == 0) { vwenv.AddObj(paraHvo, vc, (int)StTextFrags.kfrLabel); } } if (frag == (int)StTextFrags.kfrFootnotePara) { int lev = vwenv.EmbeddingLevel; int hvoOuter; int ihvoItem; int tagOuter; vwenv.GetOuterObject(lev - 1, out hvoOuter, out tagOuter, out ihvoItem); // Note a dependency on the footnote options so that the footnote will // be refreshed when these are changed. // If this is the 1st paragraph in the footnote... if (ihvoItem == 0) { vwenv.AddObj(hvoOuter, vc, (int)StTextFrags.kfrFootnoteMarker); vwenv.AddObj(hvoOuter, vc, (int)StTextFrags.kfrFootnoteReference); } } if (contentType == ContentTypes.kctSimpleBT) { // If a translation is being shown instead of the paragraph, then show it instead // of the text of the paragraph. vwenv.AddObj(GetTranslationForPara(paraHvo), vc, (int)StTextFrags.kfrTranslation); if (!PrintLayout) { // This dependency is here so that the "Missing" prompt will be added to the // view when the first character is typed in the contents. But to solve the // problem with losing the IP when typing (FWR-1415), the dependency is not // added in print layout views. The missing prompt seems less of a problem // than the problem with typing. vwenv.NoteDependency(new[] { paraHvo }, new[] { StTxtParaTags.kflidContents }, 1); } } else if (contentType == ContentTypes.kctSegmentBT) { vwenv.AddObjVecItems(StTxtParaTags.kflidSegments, vc, (int)StTextFrags.kfrSegmentFreeTranslations); } else if (!InsertParaContentsUserPrompt(vwenv, paraHvo)) { // Display the text paragraph contents, or its user prompt. vwenv.AddStringProp(StTxtParaTags.kflidContents, null); } // Display an "end-of-paragraph" marker if needed InsertEndOfParaMarks(vwenv, paraHvo); vwenv.CloseParagraph(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Display a view of the LexEntry (or fragment thereof). /// </summary> /// <param name="vwenv"></param> /// <param name="hvo"></param> /// <param name="frag"></param> /// ------------------------------------------------------------------------------------ public override void Display(IVwEnv vwenv, int hvo, int frag) { switch (frag) { case (int)VcFrags.kfragHeadWord: // This case should stay in sync with // LexEntry.LexemeFormMorphTypeAndHomographStatic vwenv.OpenParagraph(); AddHeadwordWithHomograph(vwenv, hvo); vwenv.CloseParagraph(); break; case kfragEntryAndVariant: var wfb = m_cache.ServiceLocator.GetInstance <IWfiMorphBundleRepository>().GetObject(hvo); //int hvoMf = wfb.MorphRA.Hvo; //int hvoLexEntry = m_cache.GetOwnerOfObject(hvoMf); // if morphbundle morph (entry) is in a variant relationship to the morph bundle sense // display its entry headword and variant type information (LT-4053) ILexEntryRef ler; var variant = wfb.MorphRA.Owner as ILexEntry; if (variant.IsVariantOfSenseOrOwnerEntry(wfb.SenseRA, out ler)) { // build Headword from sense's entry vwenv.OpenParagraph(); vwenv.OpenInnerPile(); vwenv.AddObj(wfb.SenseRA.EntryID, this, (int)VcFrags.kfragHeadWord); vwenv.CloseInnerPile(); vwenv.OpenInnerPile(); // now add variant type info vwenv.AddObj(ler.Hvo, this, kfragVariantTypes); vwenv.CloseInnerPile(); vwenv.CloseParagraph(); break; } // build Headword even though we aren't in a variant relationship. vwenv.AddObj(variant.Hvo, this, (int)VcFrags.kfragHeadWord); break; case kfragVariantTypes: ler = m_cache.ServiceLocator.GetInstance <ILexEntryRefRepository>().GetObject(hvo); bool fNeedInitialPlus = true; vwenv.OpenParagraph(); foreach (var let in ler.VariantEntryTypesRS.Where(let => let.ClassID == LexEntryTypeTags.kClassId)) { // just concatenate them together separated by comma. ITsString tssVariantTypeRevAbbr = let.ReverseAbbr.BestAnalysisAlternative; if (tssVariantTypeRevAbbr != null && tssVariantTypeRevAbbr.Length > 0) { if (fNeedInitialPlus) { vwenv.AddString(TsStringUtils.MakeString("+", m_cache.DefaultUserWs)); } else { vwenv.AddString(TsStringUtils.MakeString(",", m_cache.DefaultUserWs)); } vwenv.AddString(tssVariantTypeRevAbbr); fNeedInitialPlus = false; } } vwenv.CloseParagraph(); break; case kfragFormForm: // form of MoForm vwenv.AddStringAltMember(MoFormTags.kflidForm, m_wsActual, this); break; default: base.Display(vwenv, hvo, frag); break; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// This is the main interesting method of displaying objects and fragments of them. /// Scripture Footnotes are displayed by displaying each footnote's reference and text. /// The text is displayed using the standard view constructor for StText. /// </summary> /// <param name="vwenv"></param> /// <param name="hvo"></param> /// <param name="frag"></param> /// ------------------------------------------------------------------------------------ public override void Display(IVwEnv vwenv, int hvo, int frag) { CheckDisposed(); switch (frag) { case (int)FootnoteFrags.kfrScripture: { vwenv.NoteDependency(new int[] { m_cache.LangProject.TranslatedScriptureOAHvo }, new int[] { (int)Scripture.ScriptureTags.kflidScriptureBooks }, 1); vwenv.AddLazyVecItems(BooksTag, this, (int)FootnoteFrags.kfrBook); break; } case (int)FootnoteFrags.kfrRootInPageSeq: { int tag = DummyVirtualHandler.InstallDummyHandler(m_cache.VwCacheDaAccessor, "Scripture", "FootnotesOnPage", (int)CellarModuleDefns.kcptReferenceSequence).Tag; // Get the list of footnotes to display int[] hvos = m_cache.GetVectorProperty(hvo, tag, true); if (hvos.Length > 0) { int ownerHvo = m_cache.GetOwnerOfObject(hvos[0]); // The ownerHvo should be the HVO of the book vwenv.NoteDependency(new int[] { ownerHvo }, new int[] { (int)ScrBook.ScrBookTags.kflidFootnotes }, 1); } vwenv.AddObjVec(tag, this, (int)FootnoteFrags.kfrAllFootnotesWithinPagePara); break; } case (int)FootnoteFrags.kfrFootnoteWithinPagePara: { // Note a dependency on the footnote options so that the footnote will // be refreshed when these are changed. int[] depHvos = { hvo }; int[] depTags = { StFootnote.ktagFootnoteOptions }; vwenv.NoteDependency(depHvos, depTags, 1); // Insert the marker and reference vwenv.AddObj(hvo, this, (int)StTextFrags.kfrFootnoteMarker); vwenv.AddObj(hvo, this,(int)StTextFrags.kfrFootnoteReference); // Insert (we hope only one) paragraph contents. vwenv.AddObjVecItems((int)StText.StTextTags.kflidParagraphs, this, (int)FootnoteFrags.kfrFootnoteParaWithinPagePara); break; } case (int) FootnoteFrags.kfrFootnoteParaWithinPagePara: { if (!InsertParaContentsUserPrompt(vwenv, hvo)) { // Display the text paragraph contents, or its user prompt. vwenv.AddStringProp((int)StTxtPara.StTxtParaTags.kflidContents, null); } break; } case (int)FootnoteFrags.kfrBook: { vwenv.OpenDiv(); vwenv.AddObjVecItems((int)ScrBook.ScrBookTags.kflidFootnotes, this, (int)StTextFrags.kfrFootnote); vwenv.CloseDiv(); break; } case (int)StTextFrags.kfrFootnoteMarker: { ScrFootnote footnote = new ScrFootnote(Cache, hvo); if (footnote.DisplayFootnoteMarker) DisplayFootnoteMarker(vwenv, footnote); break; } case (int)StTextFrags.kfrFootnoteReference: { ITsStrFactory tsStrFactory = TsStrFactoryClass.Create(); ITsPropsFactory tpf = TsPropsFactoryClass.Create(); ITsTextProps ttp = tpf.MakeProps(ScrStyleNames.FootnoteTargetRef, m_wsDefault, 0); ScrFootnote footnote = new ScrFootnote(m_cache, hvo); string footnoteRef = footnote.GetReference(m_wsDefault); ITsString tssRef = tsStrFactory.MakeStringWithPropsRgch(footnoteRef, footnoteRef.Length, ttp); vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); vwenv.AddString(tssRef); break; } default: base.Display(vwenv, hvo, frag); break; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Override of DisplayVec /// </summary> /// ------------------------------------------------------------------------------------ public override void DisplayVec(IVwEnv vwenv, int hvo, int tag, int frag) { CheckDisposed(); if (tag == (int)StTxtPara.StTxtParaTags.kflidTranslations && frag == (int)ScrFrags.kfrBtTranslationStatus) { vwenv.AddObj(GetTranslationForPara(hvo), this, frag); } else base.DisplayVec(vwenv, hvo, tag, frag); }
/// <summary> /// Add a display of the category of hvoAnalysis. /// If choiceOffset is -1, display the current analysis writing systems, otherwise, /// display the one indicated (choiceIndex is an index into line choices). /// When choice index is not -1, hvoAnalysis may not be the current object. /// In that case, we invoke AddObj with a special flid which results in a recursive /// call to this, but with the correct current object. /// </summary> /// <param name="vwenv"></param> /// <param name="hvoAnalysis"></param> protected void AddAnalysisPos(IVwEnv vwenv, int hvoAnalysis, int hvoCurrent, int choiceIndex) { IWfiAnalysis wa = m_coRepository.GetObject(hvoAnalysis) as IWfiAnalysis; int hvoPos = wa.CategoryRA != null ? wa.CategoryRA.Hvo : 0; SetColor(vwenv, LabelRGBFor(choiceIndex)); if (hvoPos == 0) { vwenv.OpenParagraph(); vwenv.NoteDependency(new int[] {hvoAnalysis}, new int[] {WfiAnalysisTags.kflidCategory}, 1); vwenv.AddString(m_tssMissingAnalysisPos); vwenv.CloseParagraph(); } else if (choiceIndex < 0) { vwenv.AddObjProp(WfiAnalysisTags.kflidCategory, this, kfragCategory); } else { if (hvoCurrent == hvoAnalysis) vwenv.AddObjProp(WfiAnalysisTags.kflidCategory, this, kfragLineChoices + choiceIndex); else vwenv.AddObj(hvoAnalysis, this, kfragAnalysisCategoryChoices + choiceIndex); // causes recursive call with right hvoCurrent } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Display a view of the LexEntry (or fragment thereof). /// </summary> /// <param name="vwenv"></param> /// <param name="hvo"></param> /// <param name="frag"></param> /// ------------------------------------------------------------------------------------ public override void Display(IVwEnv vwenv, int hvo, int frag) { switch (frag) { case (int)VcFrags.kfragHeadWord: // This case should stay in sync with // LexEntry.LexemeFormMorphTypeAndHomographStatic vwenv.OpenParagraph(); AddHeadwordWithHomograph(vwenv, hvo); vwenv.CloseParagraph(); break; case kfragEntryAndVariant: var wfb = m_cache.ServiceLocator.GetInstance<IWfiMorphBundleRepository>().GetObject(hvo); //int hvoMf = wfb.MorphRA.Hvo; //int hvoLexEntry = m_cache.GetOwnerOfObject(hvoMf); // if morphbundle morph (entry) is in a variant relationship to the morph bundle sense // display its entry headword and variant type information (LT-4053) ILexEntryRef ler; var variant = wfb.MorphRA.Owner as ILexEntry; if (variant.IsVariantOfSenseOrOwnerEntry(wfb.SenseRA, out ler)) { // build Headword from sense's entry vwenv.OpenParagraph(); vwenv.OpenInnerPile(); vwenv.AddObj(wfb.SenseRA.EntryID, this, (int)VcFrags.kfragHeadWord); vwenv.CloseInnerPile(); vwenv.OpenInnerPile(); // now add variant type info vwenv.AddObj(ler.Hvo, this, kfragVariantTypes); vwenv.CloseInnerPile(); vwenv.CloseParagraph(); break; } // build Headword even though we aren't in a variant relationship. vwenv.AddObj(variant.Hvo, this, (int)VcFrags.kfragHeadWord); break; case kfragVariantTypes: ler = m_cache.ServiceLocator.GetInstance<ILexEntryRefRepository>().GetObject(hvo); bool fNeedInitialPlus = true; vwenv.OpenParagraph(); foreach (var let in ler.VariantEntryTypesRS.Where(let => let.ClassID == LexEntryTypeTags.kClassId)) { // just concatenate them together separated by comma. ITsString tssVariantTypeRevAbbr = let.ReverseAbbr.BestAnalysisAlternative; if (tssVariantTypeRevAbbr != null && tssVariantTypeRevAbbr.Length > 0) { if (fNeedInitialPlus) vwenv.AddString(TsStringUtils.MakeTss("+", m_cache.DefaultUserWs)); else vwenv.AddString(TsStringUtils.MakeTss(",", m_cache.DefaultUserWs)); vwenv.AddString(tssVariantTypeRevAbbr); fNeedInitialPlus = false; } } vwenv.CloseParagraph(); break; case kfragFormForm: // form of MoForm vwenv.AddStringAltMember(MoFormTags.kflidForm, m_wsActual, this); break; default: base.Display(vwenv, hvo, frag); break; } }
/// <summary> /// NOTE: this routine is ignorant of calling context, so caller must provide NoteDependency to the possibleVariant and the sense /// (e.g. vwenv.NoteDependency(new[] { wfiMorphBundle.Hvo }, new[] { WfiMorphBundleTags.kflidSense }, 1); /// vwenv.NoteDependency(new[] { wfiMorphBundle.Hvo }, new[] { WfiMorphBundleTags.kflidInflType }, 1); /// </summary> /// <param name="vwenv"></param> /// <param name="possibleVariant"></param> /// <param name="sense"></param> /// <param name="spec"></param> /// <param name="inflType"></param> /// <returns>true if there was anything to display </returns> internal bool DisplayLexGlossWithInflType(IVwEnv vwenv, ILexEntry possibleVariant, ILexSense sense, InterlinLineSpec spec, ILexEntryInflType inflType) { int iLineChoice = m_lineChoices.IndexOf(spec); ILexEntryRef ler; if (possibleVariant.IsVariantOfSenseOrOwnerEntry(sense, out ler)) { var wsPreferred = GetRealWsOrBestWsForContext(sense.Hvo, spec); var wsGloss = Cache.ServiceLocator.WritingSystemManager.Get(wsPreferred); var wsUser = Cache.ServiceLocator.WritingSystemManager.UserWritingSystem; var testGloss = sense.Gloss.get_String(wsPreferred); // don't bother adding anything for an empty gloss. if (testGloss.Text != null && testGloss.Text.Length >= 0) { vwenv.OpenParagraph(); // see if we have an irregularly inflected form type reference var leitFirst = ler.VariantEntryTypesRS.Where( let => let.ClassID == LexEntryInflTypeTags.kClassId).FirstOrDefault(); // add any GlossPrepend info if (leitFirst != null) { vwenv.OpenInnerPile(); // TODO: add dependency to VariantType GlossPrepend/Append names vwenv.NoteDependency(new[] { ler.Hvo }, new[] { LexEntryRefTags.kflidVariantEntryTypes }, 1); vwenv.OpenParagraph(); ITsString tssPrepend = null; if (inflType != null) { tssPrepend = MorphServices.AddTssGlossAffix(null, inflType.GlossPrepend, wsGloss, wsUser); } else { ITsIncStrBldr sbPrepend; ITsIncStrBldr sbAppend; JoinGlossAffixesOfInflVariantTypes(ler, wsPreferred, out sbPrepend, out sbAppend); if (sbPrepend.Text != null) tssPrepend = sbPrepend.GetString(); } if (tssPrepend != null) vwenv.AddString(tssPrepend); vwenv.CloseParagraph(); vwenv.CloseInnerPile(); } // add gloss of main entry or sense { vwenv.OpenInnerPile(); // NOTE: remember to NoteDependency from OuterObject vwenv.AddObj(sense.Hvo, this, kfragLineChoices + iLineChoice); vwenv.CloseInnerPile(); } // now add variant type info if (leitFirst != null) { vwenv.OpenInnerPile(); // TODO: add dependency to VariantType GlossPrepend/Append names vwenv.NoteDependency(new[] { ler.Hvo }, new[] { LexEntryRefTags.kflidVariantEntryTypes }, 1); vwenv.OpenParagraph(); ITsString tssAppend = null; if (inflType != null) { tssAppend = MorphServices.AddTssGlossAffix(null, inflType.GlossAppend, wsGloss, wsUser); } else { ITsIncStrBldr sbPrepend; ITsIncStrBldr sbAppend; JoinGlossAffixesOfInflVariantTypes(ler, wsPreferred, out sbPrepend, out sbAppend); if (sbAppend.Text != null) tssAppend = sbAppend.GetString(); } { // Use AddProp/DisplayVariant to store GlossAppend with m_tssPendingGlossAffix // this allows InterlinearExporter to know to export a glsAppend item try { if (tssAppend != null) m_tssPendingGlossAffix = tssAppend; else m_tssPendingGlossAffix = m_tssMissingGlossAppend; vwenv.AddProp(ktagGlossAppend, this, 0); } finally { m_tssPendingGlossAffix = null; } } vwenv.CloseParagraph(); vwenv.CloseInnerPile(); } vwenv.CloseParagraph(); return true; } } return false; }
public override void DisplayVec(IVwEnv vwenv, int hvo, int tag, int frag) { switch (frag) { case kfragBundleVec: int[] ccas = m_cache.GetVectorProperty(hvo, tag, false); for (int i = 0; i < ccas.Length; i++) { if (i < ccas.Length - 1) { // Give whatever box we make 5 points of separation from whatever follows. vwenv.set_IntProperty((int)FwTextPropType.ktptMarginTrailing, (int)FwTextPropVar.ktpvMilliPoint, 5000); } vwenv.AddObj(ccas[i], this, kfragBundle); } break; case kfragClauseLabels: // hvo is cmIndirectAnnotation pointing at a group of rows (at least one). // Enhance JohnT: this assumes it is always a contiguous list. ISilDataAccess sda = vwenv.DataAccess; int chvo = sda.get_VecSize(hvo, kflidAppliesTo); int hvoFirst = sda.get_VecItem(hvo, kflidAppliesTo, 0); vwenv.AddObj(hvoFirst, this, kfragComment); if (chvo == 1) break; vwenv.AddString(m_cache.MakeAnalysisTss("-")); int hvoLast = sda.get_VecItem(hvo, kflidAppliesTo, chvo - 1); vwenv.AddObj(hvoLast, this, kfragComment); break; default: base.DisplayVec(vwenv, hvo, tag, frag); break; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// This is the main interesting method of displaying objects and fragments of them. /// Scripture Footnotes are displayed by displaying each footnote's reference and text. /// The text is displayed using the standard view constructor for StText. /// </summary> /// <param name="vwenv"></param> /// <param name="hvo"></param> /// <param name="frag"></param> /// ------------------------------------------------------------------------------------ public override void Display(IVwEnv vwenv, int hvo, int frag) { switch (frag) { case (int)StTextFrags.kfrFootnote: { // FWR-1640: Make the sequence of footnote paragraphs non-editable // since we only allow one para per footnote. This will cause // pasting multiple paragraphs to work correctly. vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); base.Display(vwenv, hvo, frag); break; } case (int)FootnoteFrags.kfrScripture: { vwenv.NoteDependency(new int[] { m_cache.LanguageProject.TranslatedScriptureOA.Hvo }, new int[] { (int)ScriptureTags.kflidScriptureBooks }, 1); vwenv.AddLazyVecItems(BooksTag, this, (int)FootnoteFrags.kfrBook); break; } case (int)FootnoteFrags.kfrRootInPageSeq: { vwenv.AddObjVec(ScrBookTags.kflidFootnotes, this, (int)FootnoteFrags.kfrAllFootnotesWithinPagePara); break; } case (int)FootnoteFrags.kfrFootnoteWithinPagePara: { // Insert the marker and reference vwenv.AddObj(hvo, this, (int)StTextFrags.kfrFootnoteMarker); vwenv.AddObj(hvo, this,(int)StTextFrags.kfrFootnoteReference); // Insert (we hope only one) paragraph contents. vwenv.AddObjVecItems(StTextTags.kflidParagraphs, this, (int)FootnoteFrags.kfrFootnoteParaWithinPagePara); break; } case (int) FootnoteFrags.kfrFootnoteParaWithinPagePara: { if (!InsertParaContentsUserPrompt(vwenv, hvo)) { // Display the text paragraph contents, or its user prompt. vwenv.AddStringProp(StTxtParaTags.kflidContents, null); } break; } case (int)FootnoteFrags.kfrBook: { vwenv.OpenDiv(); vwenv.AddObjVecItems(ScrBookTags.kflidFootnotes, this, (int)StTextFrags.kfrFootnote); vwenv.CloseDiv(); break; } case (int)StTextFrags.kfrFootnoteReference: { DisplayFootnoteReference(vwenv, hvo); break; } default: base.Display(vwenv, hvo, frag); break; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// This is the main interesting method of displaying objects and fragments of them. Most /// subclasses should override. /// </summary> /// <param name="vwenv"></param> /// <param name="hvo"></param> /// <param name="frag"></param> /// ------------------------------------------------------------------------------------ public override void Display(IVwEnv vwenv, int hvo, int frag) { switch (frag) { case kfragRoot: // assume the root object has been loaded. base.Display(vwenv, hvo, frag); vwenv.AddObj(khvoNewItem, this, kfragEditRow); break; case kfragEditRow: AddEditRow(vwenv, hvo); break; case kfragListItem: if (hvo != khvoNewItem) base.Display(vwenv, hvo, frag); break; default: base.Display(vwenv, hvo, frag); break; } }
public override void DisplayVec(IVwEnv vwenv, int hvo, int tag, int frag) { switch (frag) { case kfragInput: // input context cell int[] ctxtHvos = m_cache.GetVectorProperty(hvo, tag, false); foreach (int ctxtHvo in ctxtHvos) { vwenv.Props = m_ctxtProps; vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); vwenv.AddObj(ctxtHvo, this, kfragContext); vwenv.CloseParagraph(); vwenv.CloseTableCell(); } break; default: base.DisplayVec(vwenv, hvo, tag, frag); break; } }
/// <summary> /// Calling vwenv.AddObjVec() in Display() and implementing DisplayVec() seems to /// work better than calling vwenv.AddObjVecItems() in Display(). Theoretically /// this should not be case, but experience trumps theory every time. :-) :-( /// </summary> public override void DisplayVec(IVwEnv vwenv, int hvo, int tag, int frag) { ISilDataAccess da = vwenv.DataAccess; int count = da.get_VecSize(hvo, tag); for (int i = 0; i < count; ++i) { vwenv.AddObj(da.get_VecItem(hvo, tag, i), this, VectorReferenceView.kfragTargetObj); vwenv.AddSeparatorBar(); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Insert the body of a paragraph. This is normally (with fApplyProps true) the body /// of case kfrPara and kfrFootnotePara in the Display method, but some subclasses /// need to separate this from applying the properties. /// </summary> /// <param name="vwenv"></param> /// <param name="hvo"></param> /// <param name="frag"></param> /// <param name="fApplyProps"></param> /// <param name="contentType"></param> /// <param name="vc">The view constructor used to create the paragraphs</param> /// ------------------------------------------------------------------------------------ protected void InsertParagraphBody(IVwEnv vwenv, int hvo, int frag, bool fApplyProps, ContentTypes contentType, StVc vc) { vc.SetupWsAndDirectionForPara(vwenv, hvo); if (fApplyProps) ApplyParagraphStyleProps(vwenv, hvo, vc); // This was causing assertions in the layoutmgr // TODO (TE-5777): Should be able to do this with an in-memory stylesheet. // if (DisplayTranslation) // { // // display the back translation text as double spaced // vwenv.set_IntProperty((int)FwTextPropType.ktptLineHeight, // (int)FwTextPropVar.ktpvRelative, 20000); // } // The body of the paragraph is either editable or not. vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, vc.Editable ? (int)TptEditable.ktptIsEditable : (int)TptEditable.ktptNotEditable); // Make the paragraph containing the paragraph contents. OpenPara(vwenv, hvo); // Cause a regenerate when the style changes...this is mainly used for Undo. vwenv.NoteDependency(new int[] {hvo}, new int[] {(int)StPara.StParaTags.kflidStyleRules}, 1); // Insert the label if it is the first paragraph. if (vc.Label != null) { int lev = vwenv.EmbeddingLevel; int hvoOuter; int ihvoItem; int tagOuter; vwenv.GetOuterObject(lev - 1, out hvoOuter, out tagOuter, out ihvoItem); if (ihvoItem == 0) vwenv.AddObj(hvo, vc, (int)StTextFrags.kfrLabel); } if (frag == (int)StTextFrags.kfrFootnotePara) { int lev = vwenv.EmbeddingLevel; int hvoOuter; int ihvoItem; int tagOuter; vwenv.GetOuterObject(lev - 1, out hvoOuter, out tagOuter, out ihvoItem); // Note a dependency on the footnote options so that the footnote will // be refreshed when these are changed. int[] depHvos = { hvoOuter }; int[] depTags = { StFootnote.ktagFootnoteOptions }; vwenv.NoteDependency(depHvos, depTags, 1); // If this is the 0th paragraph in the footnote... if (ihvoItem == 0) { vwenv.AddObj(hvoOuter, vc, (int)StTextFrags.kfrFootnoteMarker); vwenv.AddObj(hvoOuter, /*vc.Parent != null ? vc.Parent :*/ vc, (int)StTextFrags.kfrFootnoteReference); } } if (contentType == ContentTypes.kctSimpleBT) { // If a translation is being shown instead of the paragraph, then show it instead // of the text of the paragraph. int transHvo = GetTranslationForPara(hvo); vwenv.AddObj(transHvo, vc, (int)StTextFrags.kfrTranslation); vwenv.NoteDependency(new int[] {hvo}, new int[] {(int)StTxtPara.StTxtParaTags.kflidContents}, 1); } else if (contentType == ContentTypes.kctSegmentBT) { InsertBtSegments(vc, vwenv, hvo); } else if (!InsertParaContentsUserPrompt(vwenv, hvo)) { // Display the text paragraph contents, or its user prompt. vwenv.AddStringProp((int)StTxtPara.StTxtParaTags.kflidContents, null); } // Display an "end-of-paragraph" marker if needed InsertEndOfParaMarks(vwenv, hvo); vwenv.CloseParagraph(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Displays the annotation fragment. /// </summary> /// ------------------------------------------------------------------------------------ private void DisplayAnnotationFragment(IVwEnv vwenv, int hvo) { IScrScriptureNote ann = m_cache.ServiceLocator.GetInstance<IScrScriptureNoteRepository>().GetObject(hvo); bool isExpanded = (m_expandTable.ContainsKey(hvo) && m_expandTable[hvo]); int hvoFirstResponse = ann.ResponsesOS.Count > 0 ? ann.ResponsesOS[0].Hvo : 0; bool responseExpanded = m_expandTable.ContainsKey(hvoFirstResponse) && m_expandTable[hvoFirstResponse]; // put the separator at the top of the note InsertNoteSeparator(vwenv); // Open a table to display the first line of the annotation. VwLength vlTable; // we use this to specify that the table takes 100% of the width. vlTable.nVal = 10000; vlTable.unit = VwUnit.kunPercent100; int borderThickness = 2000; int columnCount = 9; VwFramePosition framePos = VwFramePosition.kvfpVoid; if (ann.Hvo == SelectedNoteHvo) { columnCount = 7; framePos = (ann.ResponsesOS.Count == 0 || !isExpanded || !responseExpanded) ? VwFramePosition.kvfpBox : (VwFramePosition.kvfpAbove | VwFramePosition.kvfpVsides); } vwenv.OpenTable(columnCount, vlTable, // Table uses 100% of available width. borderThickness, VwAlignment.kvaLeft, // Default alignment. framePos, //VwFramePosition.kvfpBox, //VwRule.kvrlAll, // rule lines between cells VwRule.kvrlNone, 0, //No space between cells. 0, //No padding inside cells. false); vwenv.NoteDependency(new int[] { hvo, hvo }, new int[]{m_expansionTag, ScrScriptureNoteTags.kflidResponses}, 2); // Specify column widths. The first argument is the number of columns, // not a column index. VwLength vlColumn; if (ann.Hvo != SelectedNoteHvo) { vlColumn.nVal = borderThickness; vlColumn.unit = VwUnit.kunPoint1000; vwenv.MakeColumns(1, vlColumn); } vlColumn.nVal = 13000; vlColumn.unit = VwUnit.kunPoint1000; vwenv.MakeColumns(2, vlColumn); vlColumn.nVal = 60000; vlColumn.unit = VwUnit.kunPoint1000; vwenv.MakeColumns(1, vlColumn); vlColumn.nVal = 2; vlColumn.unit = VwUnit.kunRelative; vwenv.MakeColumns(1, vlColumn); // Column for the CONNOT categories vlColumn.nVal = 12000; vlColumn.unit = VwUnit.kunPoint1000; vwenv.MakeColumns(1, vlColumn); // Column for the chooser button when showing quote vlColumn.nVal = 3; vlColumn.unit = VwUnit.kunRelative; vwenv.MakeColumns(1, vlColumn); // Column for the quote when collapsed vlColumn.nVal = 12000; vlColumn.unit = VwUnit.kunPoint1000; vwenv.MakeColumns(1, vlColumn); // Column for the chooser button when not showing quote if (ann.Hvo != SelectedNoteHvo) { vlColumn.nVal = borderThickness; vlColumn.unit = VwUnit.kunPoint1000; vwenv.MakeColumns(1, vlColumn); } vwenv.OpenTableBody(); DisplayAnnotation(vwenv, ann, isExpanded); // Only display the responses if this note is expanded and has responses. if (!isExpanded || ann.ResponsesOS.Count == 0) { // Close table vwenv.CloseTableBody(); vwenv.CloseTable(); return; } vwenv.NoteDependency(new int[] { ann.ResponsesOS.ToHvoArray()[0] }, new int[] { m_expansionTag }, 1); OpenTableRow(vwenv, ann); // Display empty first cell vwenv.OpenTableCell(1, 1); vwenv.CloseTableCell(); // Display expand box (+/-) in the second cell vwenv.OpenTableCell(1, 1); vwenv.AddObj(ann.ResponsesOS.ToHvoArray()[0], this, (int)NotesFrags.kfrExpansion); vwenv.CloseTableCell(); // Display response label in the remaining cells vwenv.OpenTableCell(1, 5); vwenv.OpenConcPara(0, 0, 0, 0); vwenv.AddString(m_responseLabel); vwenv.CloseParagraph(); vwenv.CloseTableCell(); CloseTableRow(vwenv, ann); // Close table vwenv.CloseTableBody(); vwenv.CloseTable(); if (responseExpanded) { vwenv.AddObjVecItems((int)ScrScriptureNoteTags.kflidResponses, this, (int)NotesFrags.kfrResponse); } }
/// <summary> /// Displays a MorphBundle, setting the colors of its parts. /// </summary> /// <param name="vwenv"></param> /// <param name="hvo">WfiMorphBundle</param> private void DisplayMorphBundle(IVwEnv vwenv, int hvo) { IWfiMorphBundle wmb = null; if (hvo != 0) wmb = m_wmbRepository.GetObject(hvo); vwenv.set_IntProperty((int)FwTextPropType.ktptMarginTrailing, (int)FwTextPropVar.ktpvMilliPoint, 10000); vwenv.OpenInnerPile(); int first = m_lineChoices.FirstMorphemeIndex; int last = m_lineChoices.LastMorphemeIndex; IMoForm mf = null; if (wmb != null) mf = wmb.MorphRA; if (vwenv is CollectorEnv && mf != null) { // Collectors are given an extra initial chance to 'collect' the morph type, if any. vwenv.AddObjProp(WfiMorphBundleTags.kflidMorph, this, kfragMorphType); } for (int i = first; i <= last; i++) { InterlinLineSpec spec = m_lineChoices[i]; SetColor(vwenv, LabelRGBFor(spec)); switch (spec.Flid) { case InterlinLineChoices.kflidMorphemes: if (wmb == null) { vwenv.AddString(m_tssMissingMorph); } else if (mf == null) { // displaying morphemes should be int ws = 0; if (wmb.MorphRA != null) { Debug.Assert(spec.StringFlid == MoFormTags.kflidForm); ws = GetRealWsOrBestWsForContext(wmb.MorphRA.Hvo, spec); } // If no morph, use the form of the morph bundle (and the entry is of // course missing) if (ws == 0) { ws = WritingSystemServices.ActualWs(m_cache, spec.WritingSystem, wmb.Hvo, WfiMorphBundleTags.kflidForm); } vwenv.AddStringAltMember( WfiMorphBundleTags.kflidForm, ws, this); } else { // Got a morph, show it. vwenv.AddObjProp(WfiMorphBundleTags.kflidMorph, this, kfragMorphFormChoices + i); // And the LexEntry line. } break; case InterlinLineChoices.kflidLexEntries: if (mf == null) { if (hvo != 0) vwenv.NoteDependency(new int[] { hvo }, new int[] { WfiMorphBundleTags.kflidMorph }, 1); vwenv.AddString(m_tssMissingEntry); } else { int ws = GetRealWsOrBestWsForContext(mf.Hvo, spec); if (ws == 0) ws = spec.WritingSystem; LexEntryVc vcEntry = new LexEntryVc(m_cache); vcEntry.WritingSystemCode = ws; vwenv.AddObj(hvo, vcEntry, LexEntryVc.kfragEntryAndVariant); } break; case InterlinLineChoices.kflidLexGloss: int flid = 0; if (wmb != null) { vwenv.NoteDependency(new[] { wmb.Hvo }, new[] { WfiMorphBundleTags.kflidMorph }, 1); vwenv.NoteDependency(new[] { wmb.Hvo }, new[] { WfiMorphBundleTags.kflidInflType }, 1); vwenv.NoteDependency(new[] { hvo }, new[] { WfiMorphBundleTags.kflidSense }, 1); if (wmb.SenseRA == null) { if (ShowDefaultSense && wmb.DefaultSense != null && UsingGuess) { flid = wmb.Cache.MetaDataCacheAccessor.GetFieldId2(WfiMorphBundleTags.kClassId, "DefaultSense", false); } } else { flid = WfiMorphBundleTags.kflidSense; if (wmb.MorphRA != null && DisplayLexGlossWithInflType(vwenv, wmb.MorphRA.Owner as ILexEntry, wmb.SenseRA, spec, wmb.InflTypeRA)) { break; } } } if (flid == 0) vwenv.AddString(m_tssMissingSense); else vwenv.AddObjProp(flid, this, kfragLineChoices + i); break; case InterlinLineChoices.kflidLexPos: // LexPOS line: int hvoMsa = 0; if (wmb != null && wmb.MsaRA != null) hvoMsa = wmb.MsaRA.Hvo; if (hvoMsa == 0) { if (hvo != 0) vwenv.NoteDependency(new int[] { hvo }, new int[] { WfiMorphBundleTags.kflidMsa }, 1); vwenv.AddString(m_tssMissingMsa); } else { // Use a special view constructor that knows how to display the // interlinear view of whatever kind of MSA it is. // Enhance JohnT: ideally we would have one of these VCs for each writing system, // perhaps stored in the InterlinLineSpec. Currently displaying multiple Wss of LexPos // is not useful, though it is possible. // Enhancement RickM: we set the m_msaVc.DefaultWs to the selected writing system // of each LexPos line in interlinear. This is used extract the LexPos abbreviation // for the specific writing system. m_msaVc.DefaultWs = spec.WritingSystem; vwenv.AddObjProp(WfiMorphBundleTags.kflidMsa, m_msaVc, (int)VcFrags.kfragInterlinearAbbr); } break; } } vwenv.CloseInnerPile(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Displays an annotation expanded or contracted /// </summary> /// <param name="vwenv"></param> /// <param name="ann"></param> /// <param name="expanded"></param> /// ------------------------------------------------------------------------------------ private void DisplayAnnotation(IVwEnv vwenv, IScrScriptureNote ann, bool expanded) { #region First row has status, ref, category, & quote SetBackgroundColorForNote(ann, vwenv); OpenTableRow(vwenv, ann); // Display expand box (+/-) in the first cell //InsertNoteSeparator(vwenv); vwenv.OpenTableCell(1, 1); vwenv.AddObj(ann.Hvo, this, (int)NotesFrags.kfrExpansion); vwenv.CloseTableCell(); // Display status in the second cell vwenv.OpenTableCell(1, 1); vwenv.set_IntProperty((int)FwTextPropType.ktptPadTop, (int)FwTextPropVar.ktpvMilliPoint, 1000); if (ann.AnnotationType == NoteType.CheckingError) { // When the annotation is a checking error, we don't want clicking on the status // to change the status. Therefore, make the min and max the same. vwenv.AddIntPropPic((int)ScrScriptureNoteTags.kflidResolutionStatus, this, (int)NotesFrags.kfrStatus, 0, 0); } else { vwenv.AddIntPropPic((int)ScrScriptureNoteTags.kflidResolutionStatus, this, (int)NotesFrags.kfrStatus, (int)NoteStatus.Open, (int)NoteStatus.Closed); } vwenv.CloseTableCell(); // Display reference in the third cell and make it readonly. vwenv.OpenTableCell(1, 1); vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvDefault, 0); vwenv.OpenParagraph(); vwenv.AddProp((int)CmBaseAnnotationTags.kflidBeginRef, this, (int)NotesFrags.kfrScrRef); vwenv.CloseParagraph(); vwenv.CloseTableCell(); // Display CONNOT category in the fourth (and possibly fifth and sixth) cell(s) vwenv.OpenTableCell(1, expanded ? 3 : 1); IStTxtPara quotePara = ann.QuoteOA[0]; bool fQuoteParaRtoL = IsParaRightToLeft(quotePara); // Conc paragraphs don't work well for R-to-L: If the text doesn't fit, it will // show the trailing text rather than the leading text. if (fQuoteParaRtoL || expanded) vwenv.OpenParagraph(); else vwenv.OpenConcPara(0, 0, 0, 0); vwenv.AddObjVec((int)ScrScriptureNoteTags.kflidCategories, this, (int)NotesFrags.kfrConnotCategory); vwenv.CloseParagraph(); vwenv.CloseTableCell(); // Display CONNOT category chooser button in the penultimate or last cell vwenv.OpenTableCell(1, 1); vwenv.set_IntProperty((int)FwTextPropType.ktptPadTop, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptPadLeading, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.AddPicture(m_picChooser, -(int)NotesFrags.kfrConnotCategory, 0, 0); vwenv.CloseTableCell(); // If not expanded, display the quote in the last cell if (!expanded) { vwenv.OpenTableCell(1, 1); SetupWsAndDirectionForPara(vwenv, quotePara.Hvo); if (fQuoteParaRtoL) vwenv.OpenParagraph(); // Conc paragraphs don't work well for R-to-L else vwenv.OpenConcPara(0, 0, 0, 0); vwenv.AddString(quotePara.Contents); vwenv.CloseParagraph(); vwenv.CloseTableCell(); } CloseTableRow(vwenv, ann); #endregion if (!expanded) return; #region Second through fifth rows bool fRegularAnnotation = ann.AnnotationType != NoteType.CheckingError; //Second row has quote DisplayExpandableAnnotation(vwenv, ann, (int)ScrScriptureNoteTags.kflidQuote, ann.QuoteOA.Hvo, ann.QuoteOA, fRegularAnnotation ? m_quoteLabel : m_detailsLabel, !fRegularAnnotation); // Third row has discussion DisplayExpandableAnnotation(vwenv, ann, ScrScriptureNoteTags.kflidDiscussion, ann.DiscussionOA.Hvo, ann.DiscussionOA, fRegularAnnotation ? m_discussionLabel : m_messageLabel, !fRegularAnnotation); // Fourth row has recommendation (i.e. suggestion) DisplayExpandableAnnotation(vwenv, ann, ScrScriptureNoteTags.kflidRecommendation, ann.RecommendationOA.Hvo, ann.RecommendationOA, m_suggestionLabel); // Fifth row has resolution DisplayExpandableAnnotation(vwenv, ann, ScrScriptureNoteTags.kflidResolution, ann.ResolutionOA.Hvo, ann.ResolutionOA, m_resolutionLabel); #endregion #region Sixth row has author SetBackgroundColorForNote(ann, vwenv); OpenTableRow(vwenv, ann); // Display empty first and second cell vwenv.OpenTableCell(1, 2); vwenv.CloseTableCell(); // Display author in third cell vwenv.OpenTableCell(1, 3); vwenv.OpenParagraph(); SetDisabledColorForNote(vwenv); vwenv.AddString(m_authorLabel); vwenv.CloseParagraph(); vwenv.CloseTableCell(); CloseTableRow(vwenv, ann); #endregion #region Seventh row has dates SetBackgroundColorForNote(ann, vwenv); OpenTableRow(vwenv, ann); // Display empty first and second cell vwenv.OpenTableCell(1, 2); vwenv.CloseTableCell(); // Display date created in third cell vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); vwenv.AddString(m_createdLabel); vwenv.AddTimeProp(CmAnnotationTags.kflidDateCreated, 0); vwenv.CloseParagraph(); vwenv.CloseTableCell(); // Display date modified in fourth/fifth cells vwenv.OpenTableCell(1, 2); vwenv.OpenParagraph(); vwenv.AddString(m_modifiedLabel); vwenv.AddTimeProp(CmAnnotationTags.kflidDateModified, 0); vwenv.CloseParagraph(); vwenv.CloseTableCell(); // Display date resolved in last two cells vwenv.OpenTableCell(1, 2); vwenv.OpenParagraph(); if (ann.ResolutionStatus == NoteStatus.Closed) { SetDisabledColorForNote(vwenv); vwenv.AddString(m_resolvedLabel); // TODO (TE-4039) This date is incorrect //vwenv.AddTimeProp(ScrScriptureNote.ScrScriptureNoteTags.kflidDateResolved, 0); } vwenv.CloseParagraph(); vwenv.CloseTableCell(); CloseTableRow(vwenv, ann); #endregion }
public override void DisplayVec(IVwEnv vwenv, int hvo, int tag, int frag) { CheckDisposed(); switch (frag) { case kfragSegFf: // freeform annotations. (Cf override in InterlinPrintVc) { // Note that changes here may need to be refleced in FreeformAdder's code // for selecting a newly created annotation. AddFreeformAnnotations(vwenv, hvo); break; } default: if (frag >= kfragWordGlossWs && frag < kfragWordGlossWs + m_WsList.AnalysisWsIds.Length) { // Displaying one ws of all the glosses of an analysis, separated by commas. vwenv.OpenParagraph(); IWfiAnalysis wa = m_coRepository.GetObject(hvo) as IWfiAnalysis; int i = 0; foreach (IWfiGloss gloss in wa.MeaningsOC) { if (i != 0) vwenv.AddString(CommaSpaceString); vwenv.AddObj(gloss.Hvo, this, frag); i++; } vwenv.CloseParagraph(); } else { base.DisplayVec (vwenv, hvo, tag, frag); } break; } }
protected override void DisplayObjectProperty(IVwEnv vwenv, int hvo) { vwenv.NoteDependency(new int[] { m_hvoOwner }, new int[] { m_flid }, 1); vwenv.AddObj(hvo, this, AtomicReferenceView.kFragObjName); }
public override void Display(IVwEnv vwenv, int hvo, int frag) { #if __MonoCS__ // TODO-Linux: Randomly m_tsf seem to have been Release. // eg Marshal.ReleaseComObject(m_tsf); // However the Dispose method isn't called (which calls the Release) // Currently unsure what is doing this need to find out - very concerning // Hack - just recreate a new TsStrFactory each time... for now // seems to stop the problem. m_tsf = TsStrFactoryClass.Create(); #endif CheckDisposed(); if (hvo == 0) return; // Can't do anything without an hvo (except crash -- see LT-9348). #if DEBUG //TimeRecorder.Begin("Display"); #endif switch (frag) { case kfragStText: // new root object for InterlinDocChild. SetupRealVernWsForDisplay(WritingSystemServices.ActualWs(m_cache, WritingSystemServices.kwsVernInParagraph, hvo, StTextTags.kflidParagraphs)); vwenv.AddLazyVecItems(StTextTags.kflidParagraphs, this, kfragInterlinPara); break; case kfragInterlinPara: // Whole StTxtPara. This can be the root fragment in DE view. if (vwenv.DataAccess.get_VecSize(hvo, StTxtParaTags.kflidSegments) == 0) { vwenv.NoteDependency(new int[] { hvo }, new int[] { StTxtParaTags.kflidSegments }, 1); vwenv.AddString(m_tssEmptyPara); } else { PreferredVernWs = WritingSystemServices.ActualWs(m_cache, WritingSystemServices.kwsVernInParagraph, hvo, StTxtParaTags.kflidSegments); // Include the plain text version of the paragraph? vwenv.AddLazyVecItems(StTxtParaTags.kflidSegments, this, kfragParaSegment); } break; case kfragParaSegment: // Don't put anything in this segment if it is a 'label' segment (typically containing a verse // number for TE). var seg = m_segRepository.GetObject(hvo); if (seg.IsLabel) break; // This puts ten points between segments. There's always 5 points below each line of interlinear; // if there are no freeform annotations another 5 points makes 10 between segments. // If there are freeforms, we need the full 10 points after the last of them. var haveFreeform = seg.FreeTranslation != null || seg.LiteralTranslation != null || seg.NotesOS.Count > 0; vwenv.set_IntProperty((int)FwTextPropType.ktptMarginBottom, (int)FwTextPropVar.ktpvMilliPoint, !haveFreeform ? 5000 : 10000); vwenv.OpenDiv(); // Enhance JohnT: determine what the overall direction of the paragraph should // be and set it. if (m_mpBundleHeight == 0) { // First time...figure it out. int dmpx, dmpyAnal, dmpyVern; vwenv.get_StringWidth(m_tssEmptyAnalysis, null, out dmpx, out dmpyAnal); vwenv.get_StringWidth(m_tssEmptyVern, null, out dmpx, out dmpyVern); m_mpBundleHeight = dmpyAnal * 4 + dmpyVern * 3; } // The interlinear bundles are not editable. vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); if (m_fRtl) { vwenv.set_IntProperty((int)FwTextPropType.ktptRightToLeft, (int)FwTextPropVar.ktpvEnum, (int)FwTextToggleVal.kttvForceOn); vwenv.set_IntProperty((int)FwTextPropType.ktptAlign, (int)FwTextPropVar.ktpvEnum, (int) FwTextAlign.ktalRight); } vwenv.set_IntProperty((int)FwTextPropType.ktptSpellCheck, (int)FwTextPropVar.ktpvEnum, (int)SpellingModes.ksmDoNotCheck); vwenv.OpenParagraph(); AddSegmentReference(vwenv, hvo); // Calculate and display the segment reference. AddLabelPile(vwenv, m_tsf, m_cache, true, m_fShowMorphBundles); vwenv.AddObjVecItems(SegmentTags.kflidAnalyses, this, kfragBundle); // JohnT, 1 Feb 2008. Took this out as I can see no reason for it; AddObjVecItems handles // the dependency already. Adding it just means that any change to the forms list // regenerates a higher level than needed, which contributes to a great deal of scrolling // and flashing (LT-7470). // Originally added by Eric in revision 72 on the trunk as part of handling phrases. // Eric can't see any reason we need it now, either. If you find a need to re-insert it, // please document carefully the reasons it is needed and what bad consequences follow // from removing it. //vwenv.NoteDependency(new int[] { hvo }, new int[] { ktagSegmentForms }, 1); vwenv.CloseParagraph(); // We'd get the same visual effect from just calling AddFreeformAnnotations here. But then a regenerate // such as happens when hiding or showing a prompt has to redisplay the whole segment. This initially // makes it lazy, then the lazy stuff gets expanded. In the process we may get undesired scrolling (LT-12248). // So we insert another layer of object, allowing just the freeforms to be regenerated. var flidSelf = Cache.MetaDataCacheAccessor.GetFieldId2(CmObjectTags.kClassId, "Self", false); vwenv.AddObjProp(flidSelf, this, kfragFreeformBundle); vwenv.CloseDiv(); break; case kfragFreeformBundle: AddFreeformAnnotations(vwenv, hvo); break; case kfragBundle: // One annotated word bundle; hvo is the IAnalysis object. // checking AllowLayout (especially in context of Undo/Redo make/break phrase) // helps prevent us from rebuilding the display until we've finished // reconstructing the data and cache. Otherwise we can crash. if (m_rootsite != null && !m_rootsite.AllowLayout) return; AddWordBundleInternal(hvo, vwenv); break; case kfragIsolatedAnalysis: // This one is used for an isolated HVO that is surely an analysis. { var wa = m_analRepository.GetObject(hvo); vwenv.AddObj(wa.Owner.Hvo, this, kfragWordformForm); if (m_fShowMorphBundles) vwenv.AddObj(hvo, this, kfragAnalysisMorphs); int chvoGlosses = wa.MeaningsOC.Count; for (int i = 0; i < m_WsList.AnalysisWsIds.Length; ++i) { SetColor(vwenv, LabelRGBFor(m_lineChoices.IndexOf(InterlinLineChoices.kflidWordGloss, m_WsList.AnalysisWsIds[i]))); if (chvoGlosses == 0) { // There are no glosses, display something indicating it is missing. vwenv.AddProp(ktagAnalysisMissingGloss, this, kfragAnalysisMissingGloss); } else { vwenv.AddObjVec(WfiAnalysisTags.kflidMeanings, this, kfragWordGlossWs + i); } } AddAnalysisPos(vwenv, hvo, hvo, -1); } break; case kfragAnalysisMorphs: int cmorphs = 0; ICmObject co = m_coRepository.GetObject(hvo); if (co is IWfiAnalysis) cmorphs = (co as IWfiAnalysis).MorphBundlesOS.Count; // We really want a variable for this...there have been pathological cases where // m_fHaveOpenedParagraph changed during the construction of the paragraph, and we want to be // sure to close the paragraph if we opened it. var openedParagraph = !m_fHaveOpenedParagraph; if (openedParagraph) vwenv.OpenParagraph(); if (cmorphs == 0) { DisplayMorphBundle(vwenv, 0); } else { vwenv.AddObjVecItems(WfiAnalysisTags.kflidMorphBundles, this, kfragMorphBundle); } if (openedParagraph) vwenv.CloseParagraph(); break; case kfragMorphType: // for export only at present, display the vwenv.AddObjProp(MoFormTags.kflidMorphType, this, kfragPossibiltyAnalysisName); break; case kfragPossibiltyAnalysisName: vwenv.AddStringAltMember(CmPossibilityTags.kflidName, m_cache.DefaultAnalWs, this); break; case kfragMorphBundle: // the lines of morpheme information (hvo is a WfiMorphBundle) // Make an 'inner pile' to contain the bundle of morph information. // Give it 10 points of separation from whatever follows. DisplayMorphBundle(vwenv, hvo); break; case kfragSingleInterlinearAnalysisWithLabels: /* // This puts ten points between segments. There's always 5 points below each line of interlinear; // if there are no freeform annotations another 5 points makes 10 between segments. // If there are freeforms, we need the full 10 points after the last of them. int cfreeform = vwenv.get_DataAccess().get_VecSize(hvo, ktagSegFF); vwenv.set_IntProperty((int)FwTextPropType.ktptMarginBottom, (int)FwTextPropVar.ktpvMilliPoint, cfreeform == 0 ? 5000 : 10000); */ vwenv.OpenDiv(); DisplaySingleInterlinearAnalysisWithLabels(vwenv, hvo); vwenv.CloseDiv(); break; // This frag is used to display a single interlin analysis that is always left-aligned, even for RTL languages case kfragSingleInterlinearAnalysisWithLabelsLeftAlign: vwenv.OpenDiv(); vwenv.set_IntProperty((int)FwTextPropType.ktptPadLeading, (int)FwTextPropVar.ktpvMilliPoint, m_leftPadding); vwenv.OpenParagraph(); vwenv.OpenInnerPile(); DisplaySingleInterlinearAnalysisWithLabels(vwenv, hvo); vwenv.CloseInnerPile(); vwenv.CloseParagraph(); vwenv.CloseDiv(); break; //case kfragDefaultSense: // Some default sense // // NB: If the hvo is zero, then we need to go back to the normal missing sense display, after all. // // (hvo isn't zero, even for cases where there isn't even a default value.) // if (hvo > 0) // { // // Show default sense, in some other 'guess' color. // SetGuessing(vwenv, false); // foreach (int wsId in m_WsList.AnalysisWsIds) // vwenv.AddStringAltMember(LexSenseTags.kflidGloss, // wsId, this); // } // else // { // // Give up and show the missing sense row. // vwenv.AddString(m_tssMissingSense); // } // break; case kfragWordformForm: // The form of a WviWordform. vwenv.AddStringAltMember(WfiWordformTags.kflidForm, m_wsVernForDisplay, this); break; case kfragPrefix: vwenv.AddUnicodeProp(MoMorphTypeTags.kflidPrefix, m_wsVernForDisplay, this); break; case kfragPostfix: vwenv.AddUnicodeProp(MoMorphTypeTags.kflidPostfix, m_wsVernForDisplay, this); break; case kfragSenseName: // The name (gloss) of a LexSense. foreach (int wsId in m_WsList.AnalysisWsIds) vwenv.AddStringAltMember(LexSenseTags.kflidGloss, wsId, this); break; case kfragCategory: // the category of a WfiAnalysis, a part of speech; // display the Abbreviation property inherited from CmPossibility. foreach(var wsId in m_WsList.AnalysisWsIds) { vwenv.AddStringAltMember(CmPossibilityTags.kflidAbbreviation, wsId, this); } break; default: if (frag >= kfragWordGlossWs && frag < kfragWordGlossWs + m_WsList.AnalysisWsIds.Length) { // Displaying one ws of the form of a WfiGloss. int ws = m_WsList.AnalysisWsIds[frag - kfragWordGlossWs]; vwenv.AddStringAltMember(WfiGlossTags.kflidForm, ws, this); } else if (frag >= kfragLineChoices && frag < kfragLineChoices + m_lineChoices.Count) { var spec = m_lineChoices[frag - kfragLineChoices]; var ws = GetRealWsOrBestWsForContext(hvo, spec); vwenv.AddStringAltMember(spec.StringFlid, ws, this); } else if (frag >= kfragAnalysisCategoryChoices && frag < kfragAnalysisCategoryChoices + m_lineChoices.Count) { AddAnalysisPos(vwenv, hvo, hvo, frag - kfragAnalysisCategoryChoices); } else if (frag >= kfragMorphFormChoices && frag < kfragMorphFormChoices + m_lineChoices.Count) { InterlinLineSpec spec = m_lineChoices[frag - kfragMorphFormChoices]; int wsActual = GetRealWsOrBestWsForContext(hvo, spec); DisplayMorphForm(vwenv, hvo, wsActual); } else if (frag >= kfragSegFfChoices && frag < kfragSegFfChoices + m_lineChoices.Count) { AddFreeformComment(vwenv, hvo, frag - kfragSegFfChoices); } else { throw new Exception("Bad fragment ID in InterlinVc.Display"); } break; } #if DEBUG //TimeRecorder.End("Display"); #endif }
/// ------------------------------------------------------------------------------------ /// <summary> /// This is the main interesting method of displaying objects and fragments of them. /// Scripture Footnotes are displayed by displaying each footnote's reference and text. /// The text is displayed using the standard view constructor for StText. /// </summary> /// <param name="vwenv"></param> /// <param name="hvo"></param> /// <param name="frag"></param> /// ------------------------------------------------------------------------------------ public override void Display(IVwEnv vwenv, int hvo, int frag) { switch (frag) { case (int)StTextFrags.kfrFootnote: { // FWR-1640: Make the sequence of footnote paragraphs non-editable // since we only allow one para per footnote. This will cause // pasting multiple paragraphs to work correctly. vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); base.Display(vwenv, hvo, frag); break; } case (int)FootnoteFrags.kfrScripture: { vwenv.NoteDependency(new int[] { m_cache.LanguageProject.TranslatedScriptureOA.Hvo }, new int[] { (int)ScriptureTags.kflidScriptureBooks }, 1); vwenv.AddLazyVecItems(BooksTag, this, (int)FootnoteFrags.kfrBook); break; } case (int)FootnoteFrags.kfrRootInPageSeq: { vwenv.AddObjVec(ScrBookTags.kflidFootnotes, this, (int)FootnoteFrags.kfrAllFootnotesWithinPagePara); break; } case (int)FootnoteFrags.kfrFootnoteWithinPagePara: { // Insert the marker and reference vwenv.AddObj(hvo, this, (int)StTextFrags.kfrFootnoteMarker); vwenv.AddObj(hvo, this, (int)StTextFrags.kfrFootnoteReference); // Insert (we hope only one) paragraph contents. vwenv.AddObjVecItems(StTextTags.kflidParagraphs, this, (int)FootnoteFrags.kfrFootnoteParaWithinPagePara); break; } case (int)FootnoteFrags.kfrFootnoteParaWithinPagePara: { if (!InsertParaContentsUserPrompt(vwenv, hvo)) { // Display the text paragraph contents, or its user prompt. vwenv.AddStringProp(StTxtParaTags.kflidContents, null); } break; } case (int)FootnoteFrags.kfrBook: { vwenv.OpenDiv(); vwenv.AddObjVecItems(ScrBookTags.kflidFootnotes, this, (int)StTextFrags.kfrFootnote); vwenv.CloseDiv(); break; } case (int)StTextFrags.kfrFootnoteReference: { DisplayFootnoteReference(vwenv, hvo); break; } default: base.Display(vwenv, hvo, frag); break; } }
private void CreateNotesParagraph(IVwEnv vwenv, List<int> notes, ITsTextProps styleProps) { // Don't create a completely empty paragraph. The way the Views system handles such paragraphs // doesn't work for a MappedTaggedPara. Also, we want the footnote to take up no height at all // if there are none. if (notes.Count == 0) return; vwenv.set_IntProperty((int)FwTextPropType.ktptBaseWs, (int)FwTextPropVar.ktpvDefault, DefaultWs); vwenv.set_IntProperty((int)FwTextPropType.ktptRightToLeft, (int)FwTextPropVar.ktpvEnum, (RightToLeft ? -1 : 0)); vwenv.set_IntProperty((int)FwTextPropType.ktptAlign, (int)FwTextPropVar.ktpvEnum, RightToLeft ? (int)FwTextAlign.ktalRight : (int)FwTextAlign.ktalLeft); vwenv.Props = styleProps; // The body of the paragraph is either editable or not. vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, Editable ? (int)TptEditable.ktptIsEditable : (int)TptEditable.ktptNotEditable); vwenv.OpenMappedTaggedPara(); for (int ihvo = 0; ihvo < notes.Count; ihvo++) { // Optimize JohnT: could make this string once and save it in a member variable. if (ihvo != 0) vwenv.AddString(m_cache.MakeVernTss(" ")); vwenv.AddObj(notes[ihvo], this, (int)FootnoteFrags.kfrFootnoteWithinPagePara); } vwenv.CloseParagraph(); }
public override void Display(IVwEnv vwenv, int hvo, int frag) { switch (frag) { case kfragRule: m_rule = m_cache.ServiceLocator.GetInstance <IPhMetathesisRuleRepository>().GetObject(hvo); if (m_rule.Disabled) { vwenv.set_StringProperty((int)FwTextPropType.ktptNamedStyle, "Disabled Text"); } int maxNumLines = GetMaxNumLines(); VwLength tableLen; tableLen.nVal = 10000; tableLen.unit = VwUnit.kunPercent100; vwenv.OpenTable(5, tableLen, 0, VwAlignment.kvaCenter, VwFramePosition.kvfpVoid, VwRule.kvrlNone, 0, 4000, false); VwLength ctxtLen; ctxtLen.nVal = 1; ctxtLen.unit = VwUnit.kunRelative; int resultx, inputx, dmpy; vwenv.get_StringWidth(m_resultStr, m_colHeaderProps, out resultx, out dmpy); vwenv.get_StringWidth(m_inputStr, m_colHeaderProps, out inputx, out dmpy); VwLength headerLen; headerLen.nVal = Math.Max(resultx, inputx) + 8000; headerLen.unit = VwUnit.kunPoint1000; vwenv.MakeColumns(1, headerLen); vwenv.MakeColumns(4, ctxtLen); vwenv.OpenTableBody(); vwenv.OpenTableRow(); vwenv.OpenTableCell(1, 1); vwenv.CloseTableCell(); // left context header cell vwenv.Props = m_colHeaderProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTop, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderLeading, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.OpenTableCell(1, 1); vwenv.AddString(m_leftEnvStr); vwenv.CloseTableCell(); // switch header cell vwenv.Props = m_colHeaderProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTop, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderLeading, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTrailing, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.OpenTableCell(1, 2); vwenv.AddString(m_switchStr); vwenv.CloseTableCell(); // right context header cell vwenv.Props = m_colHeaderProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTop, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTrailing, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.OpenTableCell(1, 1); vwenv.AddString(m_rightEnvStr); vwenv.CloseTableCell(); vwenv.CloseTableRow(); vwenv.OpenTableRow(); // input header cell vwenv.Props = m_rowHeaderProps; vwenv.OpenTableCell(1, 1); vwenv.AddString(m_inputStr); vwenv.CloseTableCell(); // input left context cell vwenv.Props = m_inputCtxtProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTop, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderLeading, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); if (m_rule.LeftEnvIndex == -1) { OpenSingleLinePile(vwenv, maxNumLines, false); vwenv.Props = m_bracketProps; vwenv.AddProp(ktagLeftEnv, this, kfragEmpty); CloseSingleLinePile(vwenv, false); } else { for (int i = 0; i < m_rule.LeftEnvLimit; i++) { vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } } vwenv.CloseParagraph(); vwenv.CloseTableCell(); // input left switch cell vwenv.Props = m_inputCtxtProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTop, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderLeading, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTrailing, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); if (m_rule.LeftSwitchIndex == -1) { OpenSingleLinePile(vwenv, maxNumLines, false); vwenv.Props = m_bracketProps; vwenv.AddProp(ktagLeftSwitch, this, kfragEmpty); CloseSingleLinePile(vwenv, false); } else { for (int i = m_rule.LeftSwitchIndex; i < m_rule.LeftSwitchLimit; i++) { vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } if (m_rule.MiddleIndex != -1 && m_rule.IsMiddleWithLeftSwitch) { for (int i = m_rule.MiddleIndex; i < m_rule.MiddleLimit; i++) { vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } } } vwenv.CloseParagraph(); vwenv.CloseTableCell(); // input right switch cell vwenv.Props = m_inputCtxtProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTop, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTrailing, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); if (m_rule.RightSwitchIndex == -1) { OpenSingleLinePile(vwenv, maxNumLines, false); vwenv.Props = m_bracketProps; vwenv.AddProp(ktagRightSwitch, this, kfragEmpty); CloseSingleLinePile(vwenv, false); } else { if (m_rule.MiddleIndex != -1 && !m_rule.IsMiddleWithLeftSwitch) { for (int i = m_rule.MiddleIndex; i < m_rule.MiddleLimit; i++) { vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } } for (int i = m_rule.RightSwitchIndex; i < m_rule.RightSwitchLimit; i++) { vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } } vwenv.CloseParagraph(); vwenv.CloseTableCell(); // input right context cell vwenv.Props = m_inputCtxtProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTop, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTrailing, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); if (m_rule.RightEnvIndex == -1) { OpenSingleLinePile(vwenv, maxNumLines, false); vwenv.Props = m_bracketProps; vwenv.AddProp(ktagRightEnv, this, kfragEmpty); CloseSingleLinePile(vwenv, false); } else { for (int i = m_rule.RightEnvIndex; i < m_rule.RightEnvLimit; i++) { vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } } vwenv.CloseParagraph(); vwenv.CloseTableCell(); vwenv.CloseTableRow(); vwenv.OpenTableRow(); // input result header cell vwenv.Props = m_rowHeaderProps; vwenv.OpenTableCell(1, 1); vwenv.AddString(m_resultStr); vwenv.CloseTableCell(); // result left context cell vwenv.Props = m_resultCtxtProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderLeading, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); if (m_rule.LeftEnvIndex != -1) { for (int i = 0; i < m_rule.LeftEnvLimit; i++) { vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } } vwenv.CloseParagraph(); vwenv.CloseTableCell(); // result right switch cell vwenv.Props = m_resultCtxtProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderLeading, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTrailing, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); if (m_rule.RightSwitchIndex != -1) { for (int i = m_rule.RightSwitchIndex; i < m_rule.RightSwitchLimit; i++) { vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } } if (m_rule.MiddleIndex != -1 && m_rule.IsMiddleWithLeftSwitch) { for (int i = m_rule.MiddleIndex; i < m_rule.MiddleLimit; i++) { vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } } vwenv.CloseParagraph(); vwenv.CloseTableCell(); // result left switch cell vwenv.Props = m_resultCtxtProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTrailing, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); if (m_rule.MiddleIndex != -1 && !m_rule.IsMiddleWithLeftSwitch) { for (int i = m_rule.MiddleIndex; i < m_rule.MiddleLimit; i++) { vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } } if (m_rule.LeftSwitchIndex != -1) { for (int i = m_rule.LeftSwitchIndex; i < m_rule.LeftSwitchLimit; i++) { vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } } vwenv.CloseParagraph(); vwenv.CloseTableCell(); // result right context cell vwenv.Props = m_resultCtxtProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTrailing, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); if (m_rule.RightEnvIndex != -1) { for (int i = m_rule.RightEnvIndex; i < m_rule.RightEnvLimit; i++) { vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } } vwenv.CloseParagraph(); vwenv.CloseTableCell(); vwenv.CloseTableRow(); vwenv.CloseTableBody(); vwenv.CloseTable(); break; default: base.Display(vwenv, hvo, frag); break; } }
private void RegurgitateIVwEnvCall(StoredMethod storedMethod) { int tag; int frag; IVwViewConstructor vc; switch (storedMethod.MethodType) { case DecoratorMethodTypes.AddObj: var hvo = (int)storedMethod.ParamArray[0]; vc = (IVwViewConstructor)storedMethod.ParamArray[1]; frag = (int)storedMethod.ParamArray[2]; m_vwEnv.AddObj(hvo, vc, frag); break; case DecoratorMethodTypes.AddObjProp: tag = (int)storedMethod.ParamArray[0]; vc = (IVwViewConstructor)storedMethod.ParamArray[1]; frag = (int)storedMethod.ParamArray[2]; m_vwEnv.AddObjProp(tag, vc, frag); break; case DecoratorMethodTypes.AddObjVec: tag = (int)storedMethod.ParamArray[0]; vc = (IVwViewConstructor)storedMethod.ParamArray[1]; frag = (int)storedMethod.ParamArray[2]; m_vwEnv.AddObjVec(tag, vc, frag); break; case DecoratorMethodTypes.AddObjVecItems: tag = (int)storedMethod.ParamArray[0]; vc = (IVwViewConstructor)storedMethod.ParamArray[1]; frag = (int)storedMethod.ParamArray[2]; m_vwEnv.AddObjVecItems(tag, vc, frag); break; case DecoratorMethodTypes.AddString: var tsStr = (ITsString)storedMethod.ParamArray[0]; m_vwEnv.AddString(tsStr); break; case DecoratorMethodTypes.AddStringProp: tag = (int)storedMethod.ParamArray[0]; vc = (IVwViewConstructor)storedMethod.ParamArray[1]; m_vwEnv.AddStringProp(tag, vc); break; case DecoratorMethodTypes.CloseParagraph: m_vwEnv.CloseParagraph(); break; case DecoratorMethodTypes.CloseTableCell: m_vwEnv.CloseTableCell(); break; case DecoratorMethodTypes.NoteDependency: var _rghvo = (int[])storedMethod.ParamArray[0]; var _rgtag = (int[])storedMethod.ParamArray[1]; var chvo = (int)storedMethod.ParamArray[2]; m_vwEnv.NoteDependency(_rghvo, _rgtag, chvo); break; case DecoratorMethodTypes.OpenParagraph: m_vwEnv.OpenParagraph(); break; case DecoratorMethodTypes.OpenTableCell: var nRows = (int)storedMethod.ParamArray[0]; var nCols = (int)storedMethod.ParamArray[1]; m_vwEnv.OpenTableCell(nRows, nCols); break; case DecoratorMethodTypes.SetIntProperty: var tpt = (int)storedMethod.ParamArray[0]; var tpv = (int)storedMethod.ParamArray[1]; var nValue = (int)storedMethod.ParamArray[2]; m_vwEnv.set_IntProperty(tpt, tpv, nValue); break; case DecoratorMethodTypes.PropsSetter: var value = (ITsTextProps)storedMethod.ParamArray[0]; m_vwEnv.Props = value; break; default: Debug.Assert(false, "Unknown DecoratorMethodType!"); break; } }
public override void DisplayVec(IVwEnv vwenv, int hvo, int tag, int frag) { CheckDisposed(); ISilDataAccess da = vwenv.DataAccess; switch (frag) { default: { Debug.Assert(false, "Unrecognized fragment."); break; } case ReversalIndexEntrySliceView.kFragIndices: { // hvo here is the sense. int countRows = da.get_VecSize(hvo, tag); Debug.Assert(countRows == m_usedIndices.Count, "Mismatched number of indices."); for (int i = 0; i < countRows; ++i) { vwenv.OpenTableRow(); int idxHvo = da.get_VecItem(hvo, tag, i); vwenv.AddObj(idxHvo, this, ReversalIndexEntrySliceView.kFragIndexMain); vwenv.CloseTableRow(); } break; } case ReversalIndexEntrySliceView.kFragEntries: { int wsHvo = 0; foreach (IReversalIndex idx in m_usedIndices) { if (idx.Hvo == hvo) { wsHvo = idx.WritingSystemRAHvo; break; } } Debug.Assert(wsHvo > 0, "Could not find writing system."); int wsOldDefault = this.DefaultWs; this.DefaultWs = wsHvo; // hvo here is a reversal index. int countEntries = da.get_VecSize(hvo, ReversalIndexEntrySliceView.kFlidEntries); for (int j = 0; j < countEntries; ++j) { if (j != 0) vwenv.AddSeparatorBar(); int entryHvo = da.get_VecItem(hvo, ReversalIndexEntrySliceView.kFlidEntries, j); vwenv.AddObj(entryHvo, this, ReversalIndexEntrySliceView.kFragEntryForm); } this.DefaultWs = wsOldDefault; break; } } }
protected override void DisplayObjectProperty(IVwEnv vwenv, int hvo) { vwenv.AddObj(hvo, this, AtomicReferenceView.kFragObjName); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Insert the body of a paragraph. This is normally (with fApplyProps true) the body /// of case kfrPara and kfrFootnotePara in the Display method, but some subclasses /// need to separate this from applying the properties. /// </summary> /// <param name="vwenv"></param> /// <param name="hvo"></param> /// <param name="frag"></param> /// <param name="fApplyProps"></param> /// <param name="contentType"></param> /// <param name="vc">The view constructor used to create the paragraphs</param> /// ------------------------------------------------------------------------------------ protected void InsertParagraphBody(IVwEnv vwenv, int hvo, int frag, bool fApplyProps, ContentTypes contentType, StVc vc) { vc.SetupWsAndDirectionForPara(vwenv, hvo); if (fApplyProps) { ApplyParagraphStyleProps(vwenv, hvo, vc); } // This was causing assertions in the layoutmgr // TODO (TE-5777): Should be able to do this with an in-memory stylesheet. // if (DisplayTranslation) // { // // display the back translation text as double spaced // vwenv.set_IntProperty((int)FwTextPropType.ktptLineHeight, // (int)FwTextPropVar.ktpvRelative, 20000); // } // The body of the paragraph is either editable or not. vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, vc.Editable ? (int)TptEditable.ktptIsEditable : (int)TptEditable.ktptNotEditable); // Make the paragraph containing the paragraph contents. OpenPara(vwenv, hvo); // Cause a regenerate when the style changes...this is mainly used for Undo. vwenv.NoteDependency(new int[] { hvo }, new int[] { (int)StPara.StParaTags.kflidStyleRules }, 1); // Insert the label if it is the first paragraph. if (vc.Label != null) { int lev = vwenv.EmbeddingLevel; int hvoOuter; int ihvoItem; int tagOuter; vwenv.GetOuterObject(lev - 1, out hvoOuter, out tagOuter, out ihvoItem); if (ihvoItem == 0) { vwenv.AddObj(hvo, vc, (int)StTextFrags.kfrLabel); } } if (frag == (int)StTextFrags.kfrFootnotePara) { int lev = vwenv.EmbeddingLevel; int hvoOuter; int ihvoItem; int tagOuter; vwenv.GetOuterObject(lev - 1, out hvoOuter, out tagOuter, out ihvoItem); // Note a dependency on the footnote options so that the footnote will // be refreshed when these are changed. int[] depHvos = { hvoOuter }; int[] depTags = { StFootnote.ktagFootnoteOptions }; vwenv.NoteDependency(depHvos, depTags, 1); // If this is the 0th paragraph in the footnote... if (ihvoItem == 0) { vwenv.AddObj(hvoOuter, vc, (int)StTextFrags.kfrFootnoteMarker); vwenv.AddObj(hvoOuter, /*vc.Parent != null ? vc.Parent :*/ vc, (int)StTextFrags.kfrFootnoteReference); } } if (contentType == ContentTypes.kctSimpleBT) { // If a translation is being shown instead of the paragraph, then show it instead // of the text of the paragraph. int transHvo = GetTranslationForPara(hvo); vwenv.AddObj(transHvo, vc, (int)StTextFrags.kfrTranslation); vwenv.NoteDependency(new int[] { hvo }, new int[] { (int)StTxtPara.StTxtParaTags.kflidContents }, 1); } else if (contentType == ContentTypes.kctSegmentBT) { InsertBtSegments(vc, vwenv, hvo); } else if (!InsertParaContentsUserPrompt(vwenv, hvo)) { // Display the text paragraph contents, or its user prompt. vwenv.AddStringProp((int)StTxtPara.StTxtParaTags.kflidContents, null); } // Display an "end-of-paragraph" marker if needed InsertEndOfParaMarks(vwenv, hvo); vwenv.CloseParagraph(); }
public override void DisplayVec(IVwEnv vwenv, int hvo, int tag, int frag) { CheckDisposed(); ISilDataAccess da = vwenv.DataAccess; int count = da.get_VecSize(hvo, tag); for (int i = 0; i < count; ++i) { if (i != 0) vwenv.AddSeparatorBar(); vwenv.AddObj(da.get_VecItem(hvo, tag, i), this, PhoneEnvReferenceView.kFragEnvironmentObj); } }
/// <summary> /// Calling vwenv.AddObjVec() in Display() and implementing DisplayVec() seems to /// work better than calling vwenv.AddObjVecItems() in Display(). Theoretically /// this should not be case, but experience trumps theory every time. :-) :-( /// </summary> public override void DisplayVec(IVwEnv vwenv, int hvo, int tag, int frag) { ISilDataAccess da = vwenv.DataAccess; int count = da.get_VecSize(hvo, tag); // Show everything in the collection except the current element from the main display. for (int i = 0; i < count; ++i) { int hvoItem = da.get_VecItem(hvo, tag, i); if (m_displayParent != null && hvoItem == m_displayParent.Hvo) continue; vwenv.AddObj(hvoItem, this, VectorReferenceView.kfragTargetObj); vwenv.AddSeparatorBar(); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// This is the main interesting method of displaying objects and fragments of them. /// Scripture Footnotes are displayed by displaying each footnote's reference and text. /// The text is displayed using the standard view constructor for StText. /// </summary> /// <param name="vwenv"></param> /// <param name="hvo"></param> /// <param name="frag"></param> /// ------------------------------------------------------------------------------------ public override void Display(IVwEnv vwenv, int hvo, int frag) { CheckDisposed(); switch (frag) { case (int)FootnoteFrags.kfrScripture: { vwenv.NoteDependency(new int[] { m_cache.LangProject.TranslatedScriptureOAHvo }, new int[] { (int)Scripture.ScriptureTags.kflidScriptureBooks }, 1); vwenv.AddLazyVecItems(BooksTag, this, (int)FootnoteFrags.kfrBook); break; } case (int)FootnoteFrags.kfrRootInPageSeq: { int tag = DummyVirtualHandler.InstallDummyHandler(m_cache.VwCacheDaAccessor, "Scripture", "FootnotesOnPage", (int)CellarModuleDefns.kcptReferenceSequence).Tag; // Get the list of footnotes to display int[] hvos = m_cache.GetVectorProperty(hvo, tag, true); if (hvos.Length > 0) { int ownerHvo = m_cache.GetOwnerOfObject(hvos[0]); // The ownerHvo should be the HVO of the book vwenv.NoteDependency(new int[] { ownerHvo }, new int[] { (int)ScrBook.ScrBookTags.kflidFootnotes }, 1); } vwenv.AddObjVec(tag, this, (int)FootnoteFrags.kfrAllFootnotesWithinPagePara); break; } case (int)FootnoteFrags.kfrFootnoteWithinPagePara: { // Note a dependency on the footnote options so that the footnote will // be refreshed when these are changed. int[] depHvos = { hvo }; int[] depTags = { StFootnote.ktagFootnoteOptions }; vwenv.NoteDependency(depHvos, depTags, 1); // Insert the marker and reference vwenv.AddObj(hvo, this, (int)StTextFrags.kfrFootnoteMarker); vwenv.AddObj(hvo, this, (int)StTextFrags.kfrFootnoteReference); // Insert (we hope only one) paragraph contents. vwenv.AddObjVecItems((int)StText.StTextTags.kflidParagraphs, this, (int)FootnoteFrags.kfrFootnoteParaWithinPagePara); break; } case (int)FootnoteFrags.kfrFootnoteParaWithinPagePara: { if (!InsertParaContentsUserPrompt(vwenv, hvo)) { // Display the text paragraph contents, or its user prompt. vwenv.AddStringProp((int)StTxtPara.StTxtParaTags.kflidContents, null); } break; } case (int)FootnoteFrags.kfrBook: { vwenv.OpenDiv(); vwenv.AddObjVecItems((int)ScrBook.ScrBookTags.kflidFootnotes, this, (int)StTextFrags.kfrFootnote); vwenv.CloseDiv(); break; } case (int)StTextFrags.kfrFootnoteMarker: { ScrFootnote footnote = new ScrFootnote(Cache, hvo); if (footnote.DisplayFootnoteMarker) { DisplayFootnoteMarker(vwenv, footnote); } break; } case (int)StTextFrags.kfrFootnoteReference: { ITsStrFactory tsStrFactory = TsStrFactoryClass.Create(); ITsPropsFactory tpf = TsPropsFactoryClass.Create(); ITsTextProps ttp = tpf.MakeProps(ScrStyleNames.FootnoteTargetRef, m_wsDefault, 0); ScrFootnote footnote = new ScrFootnote(m_cache, hvo); string footnoteRef = footnote.GetReference(m_wsDefault); ITsString tssRef = tsStrFactory.MakeStringWithPropsRgch(footnoteRef, footnoteRef.Length, ttp); vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); vwenv.AddString(tssRef); break; } default: base.Display(vwenv, hvo, frag); break; } }
public override void Display(IVwEnv vwenv, int hvo, int frag) { switch (frag) { case kfragRule: m_rule = m_cache.ServiceLocator.GetInstance<IPhMetathesisRuleRepository>().GetObject(hvo); if (m_rule.Disabled) { vwenv.set_StringProperty((int)FwTextPropType.ktptNamedStyle, "Disabled Text"); } int maxNumLines = GetMaxNumLines(); VwLength tableLen; tableLen.nVal = 10000; tableLen.unit = VwUnit.kunPercent100; vwenv.OpenTable(5, tableLen, 0, VwAlignment.kvaCenter, VwFramePosition.kvfpVoid, VwRule.kvrlNone, 0, 4000, false); VwLength ctxtLen; ctxtLen.nVal = 1; ctxtLen.unit = VwUnit.kunRelative; int resultx, inputx, dmpy; vwenv.get_StringWidth(m_resultStr, m_colHeaderProps, out resultx, out dmpy); vwenv.get_StringWidth(m_inputStr, m_colHeaderProps, out inputx, out dmpy); VwLength headerLen; headerLen.nVal = Math.Max(resultx, inputx) + 8000; headerLen.unit = VwUnit.kunPoint1000; vwenv.MakeColumns(1, headerLen); vwenv.MakeColumns(4, ctxtLen); vwenv.OpenTableBody(); vwenv.OpenTableRow(); vwenv.OpenTableCell(1, 1); vwenv.CloseTableCell(); // left context header cell vwenv.Props = m_colHeaderProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTop, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderLeading, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.OpenTableCell(1, 1); vwenv.AddString(m_leftEnvStr); vwenv.CloseTableCell(); // switch header cell vwenv.Props = m_colHeaderProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTop, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderLeading, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTrailing, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.OpenTableCell(1, 2); vwenv.AddString(m_switchStr); vwenv.CloseTableCell(); // right context header cell vwenv.Props = m_colHeaderProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTop, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTrailing, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.OpenTableCell(1, 1); vwenv.AddString(m_rightEnvStr); vwenv.CloseTableCell(); vwenv.CloseTableRow(); vwenv.OpenTableRow(); // input header cell vwenv.Props = m_rowHeaderProps; vwenv.OpenTableCell(1, 1); vwenv.AddString(m_inputStr); vwenv.CloseTableCell(); // input left context cell vwenv.Props = m_inputCtxtProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTop, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderLeading, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); if (m_rule.LeftEnvIndex == -1) { OpenSingleLinePile(vwenv, maxNumLines, false); vwenv.Props = m_bracketProps; vwenv.AddProp(ktagLeftEnv, this, kfragEmpty); CloseSingleLinePile(vwenv, false); } else { for (int i = 0; i < m_rule.LeftEnvLimit; i++) vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } vwenv.CloseParagraph(); vwenv.CloseTableCell(); // input left switch cell vwenv.Props = m_inputCtxtProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTop, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderLeading, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTrailing, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); if (m_rule.LeftSwitchIndex == -1) { OpenSingleLinePile(vwenv, maxNumLines, false); vwenv.Props = m_bracketProps; vwenv.AddProp(ktagLeftSwitch, this, kfragEmpty); CloseSingleLinePile(vwenv, false); } else { for (int i = m_rule.LeftSwitchIndex; i < m_rule.LeftSwitchLimit; i++) vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); if (m_rule.MiddleIndex != -1 && m_rule.IsMiddleWithLeftSwitch) { for (int i = m_rule.MiddleIndex; i < m_rule.MiddleLimit; i++) vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } } vwenv.CloseParagraph(); vwenv.CloseTableCell(); // input right switch cell vwenv.Props = m_inputCtxtProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTop, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTrailing, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); if (m_rule.RightSwitchIndex == -1) { OpenSingleLinePile(vwenv, maxNumLines, false); vwenv.Props = m_bracketProps; vwenv.AddProp(ktagRightSwitch, this, kfragEmpty); CloseSingleLinePile(vwenv, false); } else { if (m_rule.MiddleIndex != -1 && !m_rule.IsMiddleWithLeftSwitch) { for (int i = m_rule.MiddleIndex; i < m_rule.MiddleLimit; i++) vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } for (int i = m_rule.RightSwitchIndex; i < m_rule.RightSwitchLimit; i++) vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } vwenv.CloseParagraph(); vwenv.CloseTableCell(); // input right context cell vwenv.Props = m_inputCtxtProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTop, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTrailing, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); if (m_rule.RightEnvIndex == -1) { OpenSingleLinePile(vwenv, maxNumLines, false); vwenv.Props = m_bracketProps; vwenv.AddProp(ktagRightEnv, this, kfragEmpty); CloseSingleLinePile(vwenv, false); } else { for (int i = m_rule.RightEnvIndex; i < m_rule.RightEnvLimit; i++) vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } vwenv.CloseParagraph(); vwenv.CloseTableCell(); vwenv.CloseTableRow(); vwenv.OpenTableRow(); // input result header cell vwenv.Props = m_rowHeaderProps; vwenv.OpenTableCell(1, 1); vwenv.AddString(m_resultStr); vwenv.CloseTableCell(); // result left context cell vwenv.Props = m_resultCtxtProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderLeading, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); if (m_rule.LeftEnvIndex != -1) { for (int i = 0; i < m_rule.LeftEnvLimit; i++) vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } vwenv.CloseParagraph(); vwenv.CloseTableCell(); // result right switch cell vwenv.Props = m_resultCtxtProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderLeading, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTrailing, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); if (m_rule.RightSwitchIndex != -1) { for (int i = m_rule.RightSwitchIndex; i < m_rule.RightSwitchLimit; i++) vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } if (m_rule.MiddleIndex != -1 && m_rule.IsMiddleWithLeftSwitch) { for (int i = m_rule.MiddleIndex; i < m_rule.MiddleLimit; i++) vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } vwenv.CloseParagraph(); vwenv.CloseTableCell(); // result left switch cell vwenv.Props = m_resultCtxtProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTrailing, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); if (m_rule.MiddleIndex != -1 && !m_rule.IsMiddleWithLeftSwitch) { for (int i = m_rule.MiddleIndex; i < m_rule.MiddleLimit; i++) vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } if (m_rule.LeftSwitchIndex != -1) { for (int i = m_rule.LeftSwitchIndex; i < m_rule.LeftSwitchLimit; i++) vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } vwenv.CloseParagraph(); vwenv.CloseTableCell(); // result right context cell vwenv.Props = m_resultCtxtProps; vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTrailing, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); if (m_rule.RightEnvIndex != -1) { for (int i = m_rule.RightEnvIndex; i < m_rule.RightEnvLimit; i++) vwenv.AddObj(m_rule.StrucDescOS[i].Hvo, this, kfragContext); } vwenv.CloseParagraph(); vwenv.CloseTableCell(); vwenv.CloseTableRow(); vwenv.CloseTableBody(); vwenv.CloseTable(); break; default: base.Display(vwenv, hvo, frag); break; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Override of DisplayVec /// </summary> /// ------------------------------------------------------------------------------------ public override void DisplayVec(IVwEnv vwenv, int paraHvo, int tag, int frag) { CheckDisposed(); if (tag == StTxtParaTags.kflidTranslations && frag == (int)ScrFrags.kfrBtTranslationStatus) { IStTxtPara para = Cache.ServiceLocator.GetInstance<IStTxtParaRepository>().GetObject(paraHvo); vwenv.AddObj(GetTranslationForPara(paraHvo), this, frag); } else base.DisplayVec(vwenv, paraHvo, tag, frag); }
public override void Display(IVwEnv vwenv, int hvo, int frag) { CheckDisposed(); ISilDataAccess da = vwenv.DataAccess; switch (frag) { default: { Debug.Assert(false, "Unrecognized fragment."); break; } case ReversalIndexEntrySliceView.kFragMainObject: { // The hvo here is for the sense. // We use a table to display // encodings in column one and the strings in column two. // The table uses 100% of the available width. VwLength vlTable; vlTable.nVal = 10000; vlTable.unit = VwUnit.kunPercent100; // The width of the writing system column is determined from the width of the // longest one which will be displayed. int dxs; // Width of displayed string. int dys; // Height of displayed string (not used here). int dxsMax = 0; // Max width required. ISilDataAccess silDaCache = vwenv.DataAccess; IVwCacheDa vwCache = silDaCache as IVwCacheDa; foreach (IReversalIndex idx in m_usedIndices) { vwenv.get_StringWidth(silDaCache.get_StringProp(idx.WritingSystemRAHvo, (int)LgWritingSystem.LgWritingSystemTags.kflidAbbr), m_ttpLabel, out dxs, out dys); dxsMax = Math.Max(dxsMax, dxs); } VwLength vlColWs; // 5-pt space plus max label width. vlColWs.nVal = dxsMax + 5000; vlColWs.unit = VwUnit.kunPoint1000; // Enhance JohnT: possibly allow for right-to-left UI by reversing columns? // The Main column is relative and uses the rest of the space. VwLength vlColMain; vlColMain.nVal = 1; vlColMain.unit = VwUnit.kunRelative; vwenv.OpenTable(2, // Two columns. vlTable, // Table uses 100% of available width. 0, // Border thickness. VwAlignment.kvaLeft, // Default alignment. VwFramePosition.kvfpVoid, // No border. VwRule.kvrlNone, // No rules between cells. 0, // No forced space between cells. 0, // No padding inside cells. false); // Specify column widths. The first argument is the number of columns, // not a column index. The writing system column only occurs at all if its // width is non-zero. vwenv.MakeColumns(1, vlColWs); vwenv.MakeColumns(1, vlColMain); vwenv.OpenTableBody(); // Do vector of rows. Each row essentially is a reversal index, but shows other information. vwenv.AddObjVec(ReversalIndexEntrySliceView.kFlidIndices, this, ReversalIndexEntrySliceView.kFragIndices); vwenv.CloseTableBody(); vwenv.CloseTable(); break; } case ReversalIndexEntrySliceView.kFragIndexMain: { // First cell has writing system abbreviation displayed using m_ttpLabel. int wsHvo = 0; foreach (ReversalIndex idx in m_usedIndices) { if (idx.Hvo == hvo) { wsHvo = idx.WritingSystemRAHvo; break; } } Debug.Assert(wsHvo > 0, "Could not find writing system."); int wsOldDefault = this.DefaultWs; this.DefaultWs = wsHvo; // Cell 1 shows the ws abbreviation. vwenv.OpenTableCell(1,1); vwenv.Props = m_ttpLabel; vwenv.AddObj(wsHvo, this, ReversalIndexEntrySliceView.kFragWsAbbr); vwenv.CloseTableCell(); // Second cell has the contents for the reversal entries. vwenv.OpenTableCell(1,1); // This displays the field flush right for RTL data, but gets arrow keys to // behave reasonably. See comments on LT-5287. IWritingSystem lgws = m_cache.LanguageWritingSystemFactoryAccessor.get_EngineOrNull(this.DefaultWs); if (lgws != null && lgws.RightToLeft) { vwenv.set_IntProperty((int)FwTextPropType.ktptRightToLeft, (int)FwTextPropVar.ktpvEnum, (int)FwTextToggleVal.kttvForceOn); } vwenv.OpenParagraph(); // Do vector of entries in the second column. vwenv.AddObjVec(ReversalIndexEntrySliceView.kFlidEntries, this, ReversalIndexEntrySliceView.kFragEntries); vwenv.CloseParagraph(); vwenv.CloseTableCell(); this.DefaultWs = wsOldDefault; break; } case ReversalIndexEntrySliceView.kFragEntryForm: { vwenv.AddStringAltMember((int)ReversalIndexEntry.ReversalIndexEntryTags.kflidReversalForm, this.DefaultWs, this); int hvoCurrent = vwenv.CurrentObject(); if (hvoCurrent > 0) { IReversalIndexEntry rie = ReversalIndexEntry.CreateFromDBObject(m_cache, hvoCurrent); Debug.Assert(rie != null); int[] rgWs = m_cache.LangProject.GetReversalIndexWritingSystems(rie.Hvo, false); int wsAnal = m_cache.DefaultAnalWs; ITsIncStrBldr tisb = TsIncStrBldrClass.Create(); tisb.SetIntPropValues((int)FwTextPropType.ktptWs, (int)FwTextPropVar.ktpvDefault, wsAnal); tisb.SetIntPropValues((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); tisb.Append(" ["); int cstr = 0; ITsTextProps ttpBase = null; for (int i = 0; i < rgWs.Length; ++i) { int ws = rgWs[i]; if (ws == this.DefaultWs) continue; string sForm = rie.ReversalForm.GetAlternative(ws); if (sForm != null && sForm.Length != 0) { if (cstr > 0) tisb.Append(", "); ++cstr; string sWs = m_cache.GetMultiUnicodeAlt(ws, (int)LgWritingSystem.LgWritingSystemTags.kflidAbbr, wsAnal, "LgWritingSystem_Abbr"); if (sWs != null && sWs.Length != 0) { ITsString tssWs = m_tsf.MakeStringWithPropsRgch(sWs, sWs.Length, m_ttpLabel); tisb.AppendTsString(tssWs); // We have to totally replace the properties set by m_ttpLabel. The // simplest way is to create another ITsString with the simple base // property of only the default analysis writing system. if (ttpBase == null) { ITsPropsBldr tpbBase = TsPropsBldrClass.Create(); tpbBase.SetIntPropValues((int)FwTextPropType.ktptWs, (int)FwTextPropVar.ktpvDefault, wsAnal); ttpBase = tpbBase.GetTextProps(); } ITsString tssSpace = m_tsf.MakeStringWithPropsRgch(" ", 1, ttpBase); tisb.AppendTsString(tssSpace); } tisb.SetIntPropValues((int)FwTextPropType.ktptWs, (int)FwTextPropVar.ktpvDefault, ws); tisb.Append(sForm); tisb.SetIntPropValues((int)FwTextPropType.ktptWs, (int)FwTextPropVar.ktpvDefault, wsAnal); } } if (cstr > 0) { tisb.Append("]"); ITsString tss = tisb.GetString(); vwenv.AddString(tss); } } break; } case ReversalIndexEntrySliceView.kFragWsAbbr: { vwenv.AddString(da.get_StringProp(hvo, (int)LgWritingSystem.LgWritingSystemTags.kflidAbbr)); break; } } }
protected override void DisplayObjectProperty(IVwEnv vwenv, int hvo) { vwenv.NoteDependency(new int[] {m_hvoOwner}, new int[] {m_flid}, 1); vwenv.AddObj(hvo, this, AtomicReferenceView.kFragObjName); }
/// ----------------------------------------------------------------------------------- /// <summary> /// Handles displaying the vector of words with commas except after the last /// </summary> /// <param name="vwenv"></param> /// <param name="hvo"></param> /// <param name="tag"></param> /// <param name="frag"></param> /// ----------------------------------------------------------------------------------- public override void DisplayVec(IVwEnv vwenv, int hvo, int tag, int frag) { CheckDisposed(); Debug.Assert(frag == kfragWords); ISilDataAccess sda = vwenv.DataAccess; int cwords = sda.get_VecSize(hvo, ktagWords); for (int i = 0; i < cwords; i++) { vwenv.AddObj(sda.get_VecItem(hvo, ktagWords, i), this, kfragName); if (i != cwords - 1) vwenv.AddString(m_tssComma); } }
/// <summary> /// The main entry point to do the work of the original method. /// </summary> internal void Display(ref ITsString tssDelayedNumber) { MainCallerDisplayCommand dispInfo; if (!m_viewConstructor.CanGetMainCallerDisplayCommand(m_frag, out dispInfo)) { // Shouldn't be possible, but just in case... Debug.Assert(true, "No MainCallerDisplayCommand!"); return; } XmlNode listDelimitNode; // has the list seps attrs like 'sep' XmlNode specialAttrsNode; // has the more exotic ones like 'excludeHvo' listDelimitNode = specialAttrsNode = dispInfo.MainNode; // 'inheritSeps' attr means to use the 'caller' (the part ref node) // to get the separator information. if (XmlUtils.GetOptionalBooleanAttributeValue(listDelimitNode, "inheritSeps", false)) { listDelimitNode = dispInfo.Caller; } // // 1. get number of items in vector // var chvo = m_sda.get_VecSize(m_hvo, m_flid); if (chvo == 0) { // We may want to do something special for empty vectors. See LT-9687. ProcessEmptyVector(m_vwEnv, m_hvo, m_flid); return; } // // 2. for each item in the vector, // a) print leading number if desired. // b) call AddObj // c) print separator if desired and needed // int[] rghvo = GetVector(m_sda, m_hvo, m_flid); Debug.Assert(chvo == rghvo.Length); // // Define some special boolean flags. // // Note that we deliberately don't use the listDelimitNode here. // These three props are not currently configurable, and they belong on the 'seq' element, // not the part ref. var fCheckForEmptyItems = XmlUtils.GetOptionalBooleanAttributeValue(specialAttrsNode, "checkForEmptyItems", false); string exclude = XmlUtils.GetOptionalAttributeValue(specialAttrsNode, "excludeHvo", null); var fFirstOnly = XmlUtils.GetOptionalBooleanAttributeValue(specialAttrsNode, "firstOnly", false); XmlAttribute xaNum; var fNumber = SetNumberFlagIncludingSingleOption(listDelimitNode, chvo, out xaNum); ApplySortingIfSpecified(rghvo, specialAttrsNode); // Determine if sequence should be filtered by a stored list of Guids. // Note that if we filter, we replace rghvo with the filtered list. if (m_viewConstructor.ShouldFilterByGuid) { // order by vector item type guids // Don't reorder LexEntry VisibleComplexFormBackRefs vector if the user overrode it manually. var obj = m_cache.ServiceLocator.GetObject(m_hvo); if (obj is ILexEntry) { var lexEntry = obj as ILexEntry; if (m_flid == m_cache.MetaDataCacheAccessor.GetFieldId("LexEntry", "VisibleComplexFormBackRefs", false)) { if (!VirtualOrderingServices.HasVirtualOrdering(lexEntry, "VisibleComplexFormBackRefs")) { chvo = ApplyFilterToSequence(ref rghvo); } } else { chvo = ApplyFilterToSequence(ref rghvo); } } else { chvo = ApplyFilterToSequence(ref rghvo); } } // Check whether the user wants the grammatical information to appear only once, preceding any // sense numbers, if there is only one set of grammatical information, and all senses refer to // it. See LT-9663. var childFrag = m_frag; var fSingleGramInfoFirst = false; if (m_flid == LexEntryTags.kflidSenses) { fSingleGramInfoFirst = XmlUtils.GetOptionalBooleanAttributeValue(listDelimitNode, "singlegraminfofirst", false); } // This groups senses by placing graminfo before the number, and omitting it if the same as the // previous sense in the entry. This isn't yet supported by the UI, but may well be requested in // the future. (See LT-9663.) //bool fGramInfoBeforeNumber = XmlUtils.GetOptionalBooleanAttributeValue(listDelimitNode, "graminfobeforenumber", false); // Setup text properties for any numbering int wsEng = m_cache.WritingSystemFactory.GetWsFromStr(strEng); ITsTextProps ttpNum = null; var fDelayNumber = false; if (fNumber) { ttpNum = SetNumberTextProperties(wsEng, listDelimitNode); fDelayNumber = XmlUtils.GetOptionalBooleanAttributeValue(specialAttrsNode, "numdelay", false); } // A vector may be conditionally configured to display its objects as separate paragraphs // in dictionary (document) configuration. See LT-9667. var fShowAsParagraphsInInnerPile = XmlUtils.GetOptionalBooleanAttributeValue(listDelimitNode, "showasindentedpara", false); // We have (this is probably bad) two ways to do this. The better one is setting the flowType to divInPara. // When we do this for a vector, and configure properties that require us to insert numbering and so forth, // we currently force a paragraph for each item. It's too hard otherwise to get the numbers etc. into the paragraph. // This means that the X_AsPara layout which the configure dialog causes to be invoked when setting up sense-as-para // has to be configured NOT to make a paragraph. It also means we can't readily configure a view that has more than one // paragraph, except when doing another layer of inserting paragraphs into what is usually a single one. I don't like // this much but it does what we need for now and making it better looks very messy. var fShowAsParagraphsInDivInPara = XmlUtils.GetOptionalAttributeValue(listDelimitNode, "flowType", null) == "divInPara"; ITsString tssBefore = null; string sParaStyle = null; if (fShowAsParagraphsInInnerPile && chvo > 0) { sParaStyle = XmlUtils.GetOptionalAttributeValue(listDelimitNode, "style"); tssBefore = SetBeforeString(specialAttrsNode, listDelimitNode); // We need a line break here to force the inner pile of paragraphs to begin at // the margin, rather than somewhere in the middle of the line. m_vwEnv.AddString(m_cache.TsStrFactory.MakeString(StringUtils.kChHardLB.ToString(), m_cache.ServiceLocator.WritingSystems.DefaultAnalysisWritingSystem.Handle)); m_vwEnv.OpenInnerPile(); } else if (fShowAsParagraphsInDivInPara) { sParaStyle = XmlUtils.GetOptionalAttributeValue(listDelimitNode, "parastyle", ""); } // Setup and run actual internal vector loop var tsf = m_cache.TsStrFactory; var xattrSeparator = listDelimitNode.Attributes["sep"]; var fFirst = true; // May actually mean first non-empty. for (var ihvo = 0; ihvo < chvo; ++ihvo) { if (IsExcluded(exclude, ihvo, rghvo)) { continue; } if (fCheckForEmptyItems && IsItemEmpty(rghvo[ihvo], childFrag)) { continue; } if (fShowAsParagraphsInInnerPile || fShowAsParagraphsInDivInPara) { SetupParagraph(sParaStyle, (fFirst ? tssBefore : null), listDelimitNode); } // This needs to happen AFTER we wet up the paragraph that we want it to be part of // and any 'before' stuff that goes ahead of the whole sequence, but BEFORE we add any other stuff to the para. if (fFirst && fNumber && fSingleGramInfoFirst) { var fAllMsaSame = SetAllMsaSameFlag(chvo, rghvo); if (fAllMsaSame) { DisplayFirstChildPOS(rghvo[0], childFrag); } // Exactly if we put out the grammatical info at the start, we need to NOT put it out // as part of each item. Note that we must not set this flag before we put out the one-and-only // gram info, or that will be suppressed too! m_viewConstructor.ShouldIgnoreGramInfo = fAllMsaSame; } if (!fShowAsParagraphsInInnerPile && !fShowAsParagraphsInDivInPara) { AddSeparatorIfNeeded(fFirst, xattrSeparator, listDelimitNode, wsEng); } // add the numbering if needed. if (fNumber) { var sTag = CalculateAndFormatSenseLabel(rghvo, ihvo, xaNum); ITsStrBldr tsb = tsf.GetBldr(); tsb.Replace(0, 0, sTag, ttpNum); ITsString tss = tsb.GetString(); m_numberPartRef = listDelimitNode; AddNumberingNowOrDelayed(fDelayNumber, tss, out tssDelayedNumber); } // add the object. Debug.Assert(ihvo < rghvo.Length); m_vwEnv.AddObj(rghvo[ihvo], m_viewConstructor, childFrag); // Close Paragraph if displaying paragraphs if (fShowAsParagraphsInInnerPile || fShowAsParagraphsInDivInPara) { m_vwEnv.CloseParagraph(); } fFirst = false; if (fFirstOnly) { break; } } // end of sequence 'for' loop // Close Inner Pile if displaying paragraphs if (fShowAsParagraphsInInnerPile && chvo > 0) { m_vwEnv.CloseInnerPile(); } // Reset the flag for ignoring grammatical information after the first if it was set // earlier in this method. if (fSingleGramInfoFirst) { m_viewConstructor.ShouldIgnoreGramInfo = false; } // Reset the flag for delaying displaying a number. if (m_viewConstructor.DelayNumFlag && m_hvo == m_hvoDelayedNumber) { m_viewConstructor.DelayNumFlag = false; tssDelayedNumber = null; } // end of Display method }