/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// <param name="vwenv"></param> /// <param name="hvo"></param> /// <param name="frag"></param> /// ------------------------------------------------------------------------------------ public override void Display(IVwEnv vwenv, int hvo, int frag) { CheckDisposed(); int hvoOuter, tag, ihvo; ITsString tss; switch (frag) { case 1: // A ScrBook; display the title. vwenv.AddObjProp((int)ScrBook.ScrBookTags.kflidTitle, this, 2); break; case 2: // An StText; display the paragraphs. vwenv.GetOuterObject(vwenv.EmbeddingLevel - 1, out hvoOuter, out tag, out ihvo); tss = TsStringHelper.MakeTSS( "Hvo = " + hvoOuter + "; Tag = " + tag + "; Ihvo = " + ihvo, InMemoryFdoCache.s_wsHvos.Fr); vwenv.AddString(tss); vwenv.AddObjVecItems((int)StText.StTextTags.kflidParagraphs, this, 3); break; case 3: // StTxtPara, display details of our outer object vwenv.GetOuterObject(vwenv.EmbeddingLevel - 1, out hvoOuter, out tag, out ihvo); tss = TsStringHelper.MakeTSS( "Hvo = " + hvoOuter + "; Tag = " + tag + "; Ihvo = " + ihvo, InMemoryFdoCache.s_wsHvos.Fr); vwenv.AddString(tss); break; default: throw new ApplicationException("Unexpected frag in DummyCollectorEnvVc"); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// <param name="vwenv"></param> /// <param name="hvo"></param> /// <param name="frag"></param> /// ------------------------------------------------------------------------------------ public override void Display(IVwEnv vwenv, int hvo, int frag) { int frWs = vwenv.DataAccess.WritingSystemFactory.GetWsFromStr("fr"); int hvoOuter, tag, ihvo; ITsString tss; switch (frag) { case 1: // A ScrBook; display the title. vwenv.AddObjProp(ScrBookTags.kflidTitle, this, 2); break; case 2: // An StText; display the paragraphs. vwenv.GetOuterObject(vwenv.EmbeddingLevel - 1, out hvoOuter, out tag, out ihvo); tss = TsStringUtils.MakeString( "Hvo = " + hvoOuter + "; Tag = " + tag + "; Ihvo = " + ihvo, frWs); vwenv.AddString(tss); vwenv.AddObjVecItems(StTextTags.kflidParagraphs, this, 3); break; case 3: // StTxtPara, display details of our outer object vwenv.GetOuterObject(vwenv.EmbeddingLevel - 1, out hvoOuter, out tag, out ihvo); tss = TsStringUtils.MakeString( "Hvo = " + hvoOuter + "; Tag = " + tag + "; Ihvo = " + ihvo, frWs); vwenv.AddString(tss); break; default: throw new ApplicationException("Unexpected frag in DummyCollectorEnvVc"); } }
/// ----------------------------------------------------------------------------------- /// <summary> /// We need to show something, since the current view code can't handle a property /// containing no boxes. Check to see if the StText is missing or if there are /// no paragraphs. If so, then put in an empty string placeholder. /// TODO (FWR-1688): If we prevent the occurrence of texts with no paragraphs in FDO, /// this code can be removed. /// </summary> /// <param name="vwenv">view environment</param> /// <param name="hvo">id of object to be displayed</param> /// <returns>true if an empty string was substituted for missing/empty StText</returns> /// ----------------------------------------------------------------------------------- protected bool HandleEmptyText(IVwEnv vwenv, int hvo) { if (hvo == 0 || vwenv.DataAccess.get_VecSize(hvo, StTextTags.kflidParagraphs) > 0) { return(false); } // Either we have no ST object at all, or it is empty of paragraphs. The // current view code can't handle either, so stick something in. // ENHANCE JohnT: come up with a real solution. This makes it look right, // but we should (a) be able to edit and have the first paragraph and // if necessary the text itself be created; and (b) if someone adds a real // paragraph and/or text in some other view, have them show up. int ws = vwenv.DataAccess.WritingSystemFactory.UserWs; ITsString tssMissing = TsStringUtils.EmptyString(ws); vwenv.set_IntProperty((int)FwTextPropType.ktptParaColor, (int)FwTextPropVar.ktpvDefault, m_BackColor.ToArgb()); vwenv.set_StringProperty((int)FwTextPropType.ktptNamedStyle, m_sDefaultParaStyle); vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); // This sets the current default writing system from the relevant field spec. vwenv.set_IntProperty((int)FwTextPropType.ktptBaseWs, (int)FwTextPropVar.ktpvDefault, m_wsDefault); vwenv.AddString(tssMissing); return(true); }
public override void Display(IVwEnv vwenv, int hvo, int frag) { switch (frag) { case AudioVisualView.kfragPathname: // Display the filename. ILgWritingSystemFactory wsf = m_cache.WritingSystemFactory; vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvDefault, (int)TptEditable.ktptNotEditable); Debug.Assert(hvo != 0); Debug.Assert(m_cache != null); var file = m_cache.ServiceLocator.GetInstance <ICmFileRepository>().GetObject(hvo); Debug.Assert(file != null); string path = file.AbsoluteInternalPath; ITsString tss = TsStringUtils.MakeString(path, m_cache.WritingSystemFactory.UserWs); vwenv.OpenParagraph(); vwenv.NoteDependency(new [] { m_cache.LangProject.Hvo, file.Hvo }, new [] { LangProjectTags.kflidLinkedFilesRootDir, CmFileTags.kflidInternalPath }, 2); vwenv.AddString(tss); vwenv.CloseParagraph(); break; default: throw new ArgumentException( "Don't know what to do with the given frag.", "frag"); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// <param name="vwenv"></param> /// <param name="hvo"></param> /// <param name="frag"></param> /// ------------------------------------------------------------------------------------ public override void Display(IVwEnv vwenv, int hvo, int frag) { if (m_displayOptions.LiteralStringLabels) { ITsStrFactory factory = TsStrFactoryClass.Create(); vwenv.AddString(factory.MakeString("Label" + m_counter++, m_wsDefault)); } switch (frag) { case kfragRoot: // the root; Display the paragraph AddParagraphBoxContents(vwenv, () => { if (m_displayOptions.ReadOnlyView) { vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); } }); break; default: throw new ApplicationException("Unexpected frag in SimpleRootSiteDataProviderVc"); } }
/// <summary> /// Add to the current display (a paragraph should be open) a label followed by colon, in the standard style, /// that identifies a particular writing system from the current list. /// </summary> /// <param name="vwenv"></param> /// <param name="iws"></param> public void AddWsLabel(IVwEnv vwenv, int iws) { CheckDisposed(); if (m_tssColon == null) { m_tssColon = TsStringUtils.MakeString(": ", m_lp.Cache.DefaultUserWs); } if (m_ttpLabelStyle == null) { m_ttpLabelStyle = LanguageCodeStyle; } vwenv.Props = m_ttpLabelStyle; vwenv.OpenSpan(); vwenv.AddString(AnalysisWsLabels[iws]); vwenv.AddString(m_tssColon); vwenv.CloseSpan(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Displays the footnote reference. /// </summary> /// <param name="vwenv">The view environment.</param> /// <param name="hvoFootnote">The HVO of the footnote.</param> /// ------------------------------------------------------------------------------------ internal void DisplayFootnoteReference(IVwEnv vwenv, int hvoFootnote) { IScrFootnote footnote = m_cache.ServiceLocator.GetInstance <IScrFootnoteRepository>().GetObject(hvoFootnote); ITsString tssRef = TsStringUtils.MakeTss(footnote.GetReference(m_wsDefault), m_wsDefault, ScrStyleNames.FootnoteTargetRef); vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); vwenv.AddString(tssRef); }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </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: // the root; Display the paragraph using (new VwConstructorServices.ParagraphBoxHelper(vwenv, () => { if (m_displayOptions.ReadOnlyView) { vwenv.set_IntProperty( (int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); } })) { if (m_displayOptions.LiteralStringLabels) { using (new VwConstructorServices.InnerPileHelper(vwenv)) { ITsStrFactory factory = TsStrFactoryClass.Create(); foreach (var ws in WsOrder) { using (new VwConstructorServices.ParagraphBoxHelper(vwenv)) { if (m_displayOptions.LiteralStringLabels) { vwenv.AddString(factory.MakeString("Label" + ws, ws)); } } } } } using (new VwConstructorServices.InnerPileHelper(vwenv)) { ITsStrFactory factory = TsStrFactoryClass.Create(); foreach (var ws in WsOrder) { using (new VwConstructorServices.ParagraphBoxHelper(vwenv)) { //if (m_displayOptions.LiteralStringLabels) // vwenv.AddString(factory.MakeString("Label" + ws, ws)); vwenv.AddStringAltMember(kflidMultiString, ws, null); } } } } break; default: throw new ApplicationException("Unexpected frag in SimpleRootSiteDataProviderVc"); } }
private void OutputItemNumber(IVwEnv vwenv, ITsString tssNumber) { if (vwenv is ConfiguredExport) { (vwenv as ConfiguredExport).OutputItemNumber(tssNumber, m_numberPartRef); } else { vwenv.AddString(tssNumber); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// The main method just displays the deletion text with the appropriate properties. /// </summary> /// <param name="vwenv"></param> /// <param name="hvo"></param> /// <param name="frag"></param> /// ------------------------------------------------------------------------------------ public override void Display(IVwEnv vwenv, int hvo, int frag) { CheckDisposed(); vwenv.OpenParagraph(); if (m_textbox.Tss != null) { vwenv.AddString(m_textbox.Tss); } vwenv.CloseParagraph(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Display the footnote marker. /// </summary> /// <param name="vwenv">View environment</param> /// <param name="footnote">The footnote.</param> /// ------------------------------------------------------------------------------------ protected override void DisplayFootnoteMarker(IVwEnv vwenv, IStFootnote footnote) { // The footnote marker is not editable. vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); ITsStrBldr strBldr = ((IScrFootnote)footnote).MakeFootnoteMarker(DefaultWs); strBldr.ReplaceTsString(strBldr.Length, strBldr.Length, OneSpaceString); vwenv.AddString(strBldr.GetString()); }
public override void Display(IVwEnv vwenv, int hvo, int frag) { CheckDisposed(); vwenv.set_StringProperty((int)FwTextPropType.ktptFontFamily, StStyle.DefaultHeadingFont); vwenv.set_IntProperty((int)FwTextPropType.ktptForeColor, (int)FwTextPropVar.ktpvDefault, (int)ColorUtil.ConvertColorToBGR(Color.FromKnownColor(KnownColor.ControlDarkDark))); vwenv.set_IntProperty((int)FwTextPropType.ktptBold, (int)FwTextPropVar.ktpvEnum, (int)FwTextToggleVal.kttvForceOn); vwenv.AddString(m_text); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Display the footnote marker /// </summary> /// <param name="vwenv">View environment</param> /// <param name="footnote">The footnote.</param> /// ------------------------------------------------------------------------------------ protected virtual void DisplayFootnoteMarker(IVwEnv vwenv, IStFootnote footnote) { // The footnote marker is not editable. vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); vwenv.AddStringProp(StFootnoteTags.kflidFootnoteMarker, null); // add a read-only space after the footnote marker vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); vwenv.AddString(OneSpaceString); }
/// <summary> /// Add to the vwenv the label(s) for a gloss line. /// If multiple glosses are wanted, it generates a set of labels /// </summary> public void AddGlossLabels(IVwEnv vwenv, ITsStrFactory tsf, int color, string baseLabel, FdoCache cache, WsListManager wsList) { if (wsList != null && wsList.AnalysisWsLabels.Length > 1) { ITsString tssBase = MakeUiElementString(baseLabel, cache.DefaultUserWs, null); ITsString space = tsf.MakeString(" ", cache.DefaultUserWs); foreach (ITsString tssLabel in wsList.AnalysisWsLabels) { SetColor(vwenv, color); vwenv.OpenParagraph(); vwenv.AddString(tssBase); vwenv.AddString(space); vwenv.AddString(tssLabel); vwenv.CloseParagraph(); } } else { AddColoredString(vwenv, color, tsf, cache.DefaultAnalWs, baseLabel); } }
/// <summary> /// Add to the current display (a paragraph should be open) a label followed by colon, in the standard style, /// that identifies a particular writing system from the current list. /// </summary> /// <param name="vwenv"></param> /// <param name="iws"></param> public void AddWsLabel(IVwEnv vwenv, int iws) { CheckDisposed(); if (m_tssColon == null) { ITsStrFactory tsf = TsStrFactoryClass.Create(); m_tssColon = tsf.MakeString(": ", m_lp.Cache.DefaultUserWs); } if (m_ttpLabelStyle == null) { ITsPropsFactory tpf = TsPropsFactoryClass.Create(); // Get a ttp invoking the style "Language Code" style for the writing system // which corresponds to the user's environment. m_ttpLabelStyle = tpf.MakeProps("Language Code", m_lp.Cache.DefaultUserWs, 0); } vwenv.Props = m_ttpLabelStyle; vwenv.OpenSpan(); vwenv.AddString(AnalysisWsLabels[iws]); vwenv.AddString(m_tssColon); vwenv.CloseSpan(); }
private void DisplayMorphBundles(IVwEnv vwenv, int hvo) { if (m_fShowMorphBundles) { // Don't allow direct editing of the morph bundle lines. MakeNextFlowObjectReadOnly(vwenv); if (vwenv.DataAccess.get_VecSize(hvo, ktagSbWordMorphs) == 0) { SetColor(vwenv, m_choices.LabelRGBFor(m_choices.IndexOf(InterlinLineChoices.kflidMorphemes))); vwenv.AddProp(ktagMissingMorphs, this, kfragMissingMorphs); // Blank lines to fill up the gap; LexEntry line vwenv.AddString(m_tssEmptyVern); vwenv.AddString(m_tssEmptyAnalysis); // LexGloss line vwenv.AddString(m_tssEmptyAnalysis); // LexPos line } else { vwenv.OpenParagraph(); vwenv.AddObjVec(ktagSbWordMorphs, this, kfragMorph); vwenv.CloseParagraph(); } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Display the footnote marker. /// </summary> /// <param name="vwenv">View environment</param> /// <param name="footnote">The footnote.</param> /// ------------------------------------------------------------------------------------ private void DisplayFootnoteMarker(IVwEnv vwenv, ScrFootnote footnote) { vwenv.NoteDependency(new int[] { footnote.Hvo }, new int[] { (int)StFootnote.StFootnoteTags.kflidFootnoteMarker }, 1); // The footnote marker is not editable. vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); ITsStrBldr strBldr = footnote.MakeFootnoteMarker(DefaultWs); strBldr.Replace(strBldr.Length, strBldr.Length, " ", null); vwenv.AddString(strBldr.GetString()); }
public override void Display(IVwEnv vwenv, int hvo, int frag) { // Enhance JohnT: change background if this is the selected slice. vwenv.OpenParagraph(); if (m_info.Hvo == 0 || m_info.ContentStringFlid == 0) { vwenv.AddString(m_info.ContentString); } else { Debug.Assert(hvo == m_info.Hvo); vwenv.AddStringProp(m_info.ContentStringFlid, this); } vwenv.CloseParagraph(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Inserts the missing content paragraph. /// </summary> /// <param name="vwenv">The view environment.</param> /// ------------------------------------------------------------------------------------ private void InsertMissingContentPara(IVwEnv vwenv) { vwenv.OpenParagraph(); vwenv.set_IntProperty((int)FwTextPropType.ktptBackColor, (int)FwTextPropVar.ktpvDefault, (int)kHighlightColor); vwenv.set_IntProperty((int)FwTextPropType.ktptBold, (int)FwTextPropVar.ktpvEnum, (int)FwTextToggleVal.kttvForceOn); vwenv.set_IntProperty((int)FwTextPropType.ktptMarginTop, (int)FwTextPropVar.ktpvMilliPoint, 10000); vwenv.set_IntProperty((int)FwTextPropType.ktptMarginBottom, (int)FwTextPropVar.ktpvMilliPoint, 10000); vwenv.AddString(TsStringUtils.MakeTss( TeDiffViewResources.kstidContentMissing, Cache.DefaultUserWs)); vwenv.CloseParagraph(); }
/// <summary> /// This is for an IAnalysis object at a particular index of a Segment. /// </summary> internal override void AddExtraBundleRows(IVwEnv vwenv, AnalysisOccurrence analysis) { ITsString tss; var key = GetDictKey(analysis); if (m_tagStrings.TryGetValue(key, out tss)) { var stText = analysis.Segment.Owner.Owner; // If either the Segment's analyses sequence or the tags on the text change, we want to redraw this vwenv.NoteDependency(new [] { analysis.Segment.Hvo, stText.Hvo }, new [] { SegmentTags.kflidAnalyses, StTextTags.kflidTags }, 2); SetTrailingAlignmentIfNeeded(vwenv, tss); vwenv.AddString(tss); } }
/// ----------------------------------------------------------------------------------- /// <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); } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Display the footnote marker /// </summary> /// <param name="vwenv">View environment</param> /// ------------------------------------------------------------------------------------ private void DisplayFootnoteMarker(IVwEnv vwenv) { // The footnote marker is not editable. vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); vwenv.AddStringProp((int)StFootnote.StFootnoteTags.kflidFootnoteMarker, null); // add a read-only space after the footnote marker vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); ITsIncStrBldr strBldr = TsIncStrBldrClass.Create(); strBldr.Append(" "); vwenv.AddString(strBldr.GetString()); }
public override void Display(IVwEnv vwenv, int hvo, int frag) { vwenv.set_IntProperty((int)FwTextPropType.ktptForeColor, (int)FwTextPropVar.ktpvDefault, (int)ColorUtil.ConvertColorToBGR(Color.FromKnownColor(KnownColor.ControlDarkDark))); // By default, the paragraph that is created automatically by AddString will automatically inherit // the background color of the whole view (typically white). A paragraph with a background color // of white rather than transparent is automatically as wide as it is allowed to be (so as to display // the background color over the whole area the user things of as being that paragraph). // However, we want LiteralLabelView to adjust its size so it is just big enough to show the label, // so we can use the rest of the space for the command menu items. So we need to make the paragraph // transparent background, which allows it to be just as wide as the text content. vwenv.set_IntProperty((int)FwTextPropType.ktptBackColor, (int)FwTextPropVar.ktpvDefault, (int)FwTextColor.kclrTransparent); vwenv.set_IntProperty((int)FwTextPropType.ktptBold, (int)FwTextPropVar.ktpvEnum, (int)FwTextToggleVal.kttvForceOn); vwenv.AddString(m_text); }
public override void Display(IVwEnv vwenv, int hvo, int frag) { // Enhance JohnT: make the alignment position a function of window width. // Enhance JohnT: change background if this is the selected context line. vwenv.OpenConcPara(m_info.ContextStringStartOffset, m_info.ContextStringStartOffset + m_info.ContextStringLength, VwConcParaOpts.kcpoDefault, 72 * 2 * 1000); // 72 pts per inch * 2 inches * 1000 -> 2" in millipoints. if (m_info.Hvo == 0 || m_info.ContentStringFlid == 0) { vwenv.AddString(m_info.ContentString); } else { Debug.Assert(hvo == m_info.Hvo); vwenv.AddStringProp(m_info.ContentStringFlid, this); } vwenv.CloseParagraph(); }
public override void Display(IVwEnv vwenv, int hvo, int frag) { CheckDisposed(); switch (frag) { case AudioVisualView.kfragPathname: // Display the filename. ILgWritingSystemFactory wsf = m_cache.LanguageWritingSystemFactoryAccessor; vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvDefault, (int)TptEditable.ktptNotEditable); ITsString tss; Debug.Assert(hvo != 0); Debug.Assert(m_cache != null); ICmFile file = CmFile.CreateFromDBObject(m_cache, hvo); Debug.Assert(file != null); string path; if (Path.IsPathRooted(file.InternalPath)) { path = file.InternalPath; } else { path = Path.Combine(m_cache.LangProject.ExternalLinkRootDir, file.InternalPath); } tss = m_cache.MakeUserTss(path); vwenv.OpenParagraph(); vwenv.AddString(tss); vwenv.CloseParagraph(); break; default: throw new ArgumentException( "Don't know what to do with the given frag.", "frag"); } }
/// ------------------------------------------------------------------------------------ /// <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> /// Method to insert the homograph number with settings into the Text /// </summary> private void InsertHomographNumber(IVwEnv vwenv, HomographConfiguration hc, int nHomograph, int defUserWs) { if (nHomograph <= 0) { return; } // Use a string builder to embed the properties in with the TsString. // this allows our TsStringCollectorEnv to properly encode the superscript. // ideally, TsStringCollectorEnv could be made smarter to handle SetIntPropValues // since AppendTss treats the given Tss as atomic. ITsIncStrBldr tsBldr = TsStringUtils.MakeIncStrBldr(); tsBldr.SetIntPropValues((int)FwTextPropType.ktptSuperscript, (int)FwTextPropVar.ktpvEnum, (int)FwSuperscriptVal.kssvSub); tsBldr.SetIntPropValues((int)FwTextPropType.ktptBold, (int)FwTextPropVar.ktpvEnum, (int)FwTextToggleVal.kttvForceOn); tsBldr.SetIntPropValues((int)FwTextPropType.ktptWs, (int)FwTextPropVar.ktpvDefault, defUserWs); StringServices.InsertHomographNumber(tsBldr, nHomograph, hc, HomographConfiguration.HeadwordVariant.Main, m_cache); vwenv.AddString(tsBldr.GetString()); }
protected virtual void AddFreeformComment(IVwEnv vwenv, int hvoSeg, int lineChoiceIndex) { int[] wssAnalysis = m_lineChoices.AdjacentWssAtIndex(lineChoiceIndex); if (wssAnalysis.Length == 0) return; vwenv.OpenDiv(); SetParaDirectionAndAlignment(vwenv, wssAnalysis[0]); vwenv.OpenMappedPara(); string label; int flid; InterlinearExporter exporter = vwenv as InterlinearExporter; int dummyFlid = m_lineChoices[lineChoiceIndex].Flid; switch (dummyFlid) { case InterlinLineChoices.kflidFreeTrans: label = ITextStrings.ksFree_; flid = SegmentTags.kflidFreeTranslation; if (exporter != null) exporter.FreeAnnotationType = "gls"; break; case InterlinLineChoices.kflidLitTrans: label = ITextStrings.ksLit_; flid = SegmentTags.kflidLiteralTranslation; if (exporter != null) exporter.FreeAnnotationType = "lit"; break; case InterlinLineChoices.kflidNote: label = ITextStrings.ksNote_; flid = NoteTags.kflidContent; if (exporter != null) exporter.FreeAnnotationType = "note"; break; default: throw new Exception("Unexpected FF annotation type"); } SetNoteLabelProps(vwenv); // REVIEW: Should we set the label to a special color as well? ITsString tssLabel = MakeUiElementString(label, m_cache.DefaultUserWs, propsBldr => propsBldr.SetIntPropValues((int)FwTextPropType.ktptBold, (int)FwTextPropVar.ktpvEnum, (int)FwTextToggleVal.kttvForceOn)); ITsStrBldr labelBldr = tssLabel.GetBldr(); AddLineIndexProperty(labelBldr, lineChoiceIndex); tssLabel = labelBldr.GetString(); int labelWidth = 0; int labelHeight; // unused if (wssAnalysis.Length > 1) vwenv.get_StringWidth(tssLabel, null, out labelWidth, out labelHeight); if (IsWsRtl(wssAnalysis[0]) != m_fRtl) { ITsStrBldr bldr = tssLabel.GetBldr(); bldr.Replace(bldr.Length - 1, bldr.Length, null, null); ITsString tssLabelNoSpace = bldr.GetString(); // (First) analysis language is upstream; insert label at end. vwenv.AddString(GetTssDirForWs(wssAnalysis[0])); AddFreeformComment(vwenv, hvoSeg, wssAnalysis[0], flid); vwenv.AddString(GetTssDirForWs(wssAnalysis[0])); if (wssAnalysis.Length != 1) { // Insert WS label for first line vwenv.AddString(m_tssDir); vwenv.AddString(m_tssSpace); vwenv.AddString(m_tssDir); SetNoteLabelProps(vwenv); vwenv.AddString(WsListManager.WsLabel(m_cache, wssAnalysis[0])); } vwenv.AddString(m_tssDir); vwenv.AddString(m_tssSpace); vwenv.AddString(m_tssDir); vwenv.AddString(tssLabelNoSpace); vwenv.AddString(m_tssDir); } else { vwenv.AddString(m_tssDir); vwenv.AddString(tssLabel); vwenv.AddString(m_tssDir); if (wssAnalysis.Length == 1) { vwenv.AddString(GetTssDirForWs(wssAnalysis[0])); AddFreeformComment(vwenv, hvoSeg, wssAnalysis[0], flid); } else { SetNoteLabelProps(vwenv); vwenv.AddString(WsListManager.WsLabel(m_cache, wssAnalysis[0])); vwenv.AddString(m_tssDir); vwenv.AddString(m_tssSpace); // label width unfortunately does not include trailing space. vwenv.AddString(m_tssDir); vwenv.AddString(GetTssDirForWs(wssAnalysis[0])); AddFreeformComment(vwenv, hvoSeg, wssAnalysis[0], flid); } } // Add any other lines, each in its appropriate direction. for (int i = 1; i < wssAnalysis.Length; i++) { vwenv.CloseParagraph(); // Indent subsequent paragraphs by the width of the main label. if (IsWsRtl(wssAnalysis[i]) != m_fRtl) { vwenv.set_IntProperty((int)FwTextPropType.ktptTrailingIndent, (int)FwTextPropVar.ktpvMilliPoint, labelWidth); } else { vwenv.set_IntProperty((int) FwTextPropType.ktptLeadingIndent, (int) FwTextPropVar.ktpvMilliPoint, labelWidth); } SetParaDirectionAndAlignment(vwenv, wssAnalysis[i]); vwenv.OpenParagraph(); if (IsWsRtl(wssAnalysis[i]) != m_fRtl) { // upstream...reverse everything. vwenv.AddString(GetTssDirForWs(wssAnalysis[i])); AddFreeformComment(vwenv, hvoSeg, wssAnalysis[i], flid); vwenv.AddString(GetTssDirForWs(wssAnalysis[i])); vwenv.AddString(m_tssDir); vwenv.AddString(m_tssSpace); vwenv.AddString(m_tssDir); vwenv.AddString(m_tssDir); SetNoteLabelProps(vwenv); vwenv.AddString(WsListManager.WsLabel(m_cache, wssAnalysis[i])); vwenv.AddString(m_tssDir); vwenv.AddString(m_tssSpace); vwenv.AddString(m_tssDir); } else { vwenv.AddString(m_tssDir); vwenv.AddString(m_tssSpace); vwenv.AddString(m_tssDir); SetNoteLabelProps(vwenv); vwenv.AddString(WsListManager.WsLabel(m_cache, wssAnalysis[i])); vwenv.AddString(m_tssDir); vwenv.AddString(m_tssSpace); vwenv.AddString(m_tssDir); vwenv.AddString(GetTssDirForWs(wssAnalysis[i])); AddFreeformComment(vwenv, hvoSeg, wssAnalysis[i], flid); } } vwenv.CloseParagraph(); vwenv.CloseDiv(); }
public override void Display(IVwEnv vwenv, int hvo, int frag) { // Ignore 0 hvo's. RootObject may have not been set. FWNX-613. if (hvo == 0) return; switch(frag) { case kfragRoot: if (m_dxLabWidth == 0) { int dmpx1, dmpy; //, dmpx2; vwenv.get_StringWidth(m_tssTitle, m_ttpBold, out dmpx1, out dmpy); //vwenv.get_StringWidth(m_tssComments, m_ttpBold, out dmpx2, out dmpy); //m_dxLabWidth = Math.Max(dmpx1, dmpx2) + 13000; // add 3 pt spacing to box, 10 to margin. m_dxLabWidth = dmpx1 + 13000; // add 3 pt spacing to box, 10 to margin. m_dxWsLabWidth = 0; foreach (ITsString tssLabel in m_WsLabels) { vwenv.get_StringWidth(tssLabel, m_ttpWsLabel, out dmpx1, out dmpy); m_dxWsLabWidth = Math.Max(m_dxWsLabWidth, dmpx1); } m_dxWsLabWidth += 18000; // 3 pts white space each side, 11 margin, 1 border, plus 1 for safety. } VwLength vlTable; vlTable.nVal = 10000; vlTable.unit = VwUnit.kunPercent100; VwLength vlColLabels; // 5-pt space plus max label width. vlColLabels.nVal = m_dxLabWidth; vlColLabels.unit = VwUnit.kunPoint1000; VwLength vlColWsLabels; // 5-pt space plus max ws label width. vlColWsLabels.nVal = m_dxWsLabWidth; vlColWsLabels.unit = VwUnit.kunPoint1000; // The Main column is relative and uses the rest of the space. VwLength vlColMain; vlColMain.nVal = 1; vlColMain.unit = VwUnit.kunRelative; // The Padding column allows for the the trailing margin and border. VwLength vlColPadding; vlColPadding.nVal = 10000; vlColPadding.unit = VwUnit.kunPoint1000; vwenv.set_IntProperty((int)FwTextPropType.ktptMarginTop, (int) FwTextPropVar.ktpvMilliPoint, 5000); vwenv.OpenTable(4, // Four 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); vwenv.MakeColumns(1, vlColLabels); vwenv.MakeColumns(1, vlColWsLabels); vwenv.MakeColumns(1, vlColMain); vwenv.MakeColumns(1, vlColPadding); vwenv.OpenTableBody(); for (int i = 0; i < m_writingSystems.Length; i++) { vwenv.OpenTableRow(); // First cell has 'Title' label in bold. vwenv.Props = m_ttpBold; vwenv.OpenTableCell(1,1); vwenv.set_IntProperty((int)FwTextPropType.ktptMarginLeading, (int) FwTextPropVar.ktpvMilliPoint, 10000); if (i == 0) // only on the first row { // We want this fixed at 10 point, since it's considered a UI component, not data. // See LT-4816 vwenv.set_IntProperty((int)FwTextPropType.ktptFontSize, (int)FwTextPropVar.ktpvMilliPoint, 10000); vwenv.AddString(m_tssTitle); } vwenv.CloseTableCell(); // Second cell has ws labels. vwenv.set_IntProperty((int)FwTextPropType.ktptBackColor, (int) FwTextPropVar.ktpvDefault, m_editBackColor); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderLeading, (int)FwTextPropVar.ktpvMilliPoint, 1000); if (i == 0) vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTop, (int)FwTextPropVar.ktpvMilliPoint, 1000); if (i == m_writingSystems.Length - 1) vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.OpenTableCell(1,1); vwenv.Props = m_ttpDataCellProps; vwenv.Props = m_ttpWsLabel; vwenv.AddString(m_WsLabels[i]); vwenv.CloseTableCell(); // Third cell has the Title property, in a box. vwenv.set_IntProperty((int)FwTextPropType.ktptBackColor, (int) FwTextPropVar.ktpvDefault, m_editBackColor); // Set the underlying directionality so that arrow keys work properly. bool fRTL = m_writingSystems[i].RightToLeftScript; vwenv.set_IntProperty((int)FwTextPropType.ktptRightToLeft, (int)FwTextPropVar.ktpvEnum, fRTL ? -1 : 0); vwenv.set_IntProperty((int)FwTextPropType.ktptAlign, (int)FwTextPropVar.ktpvEnum, fRTL ? (int)FwTextAlign.ktalRight : (int)FwTextAlign.ktalLeft); if (i == 0) vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTop, (int)FwTextPropVar.ktpvMilliPoint, 1000); if (i == m_writingSystems.Length - 1) vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.OpenTableCell(1,1); vwenv.OpenParagraph(); vwenv.Props = m_ttpDataCellProps; vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, this.Editable ? (int)TptEditable.ktptIsEditable : (int)TptEditable.ktptNotEditable); if (IsScripture) { vwenv.AddStringAltMember(m_vtagStTextTitle, m_writingSystems[i].Handle, this); } else { vwenv.AddStringAltMember(CmMajorObjectTags.kflidName, m_writingSystems[i].Handle, this); } vwenv.CloseParagraph(); vwenv.CloseTableCell(); vwenv.set_IntProperty((int)FwTextPropType.ktptMarginTrailing, (int)FwTextPropVar.ktpvMilliPoint, 10000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTrailing, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.OpenTableCell(1, 1); vwenv.CloseTableCell(); vwenv.CloseTableRow(); } //// Second row. //vwenv.OpenTableRow(); // //// First cell has 'Comments' label in bold. //vwenv.Props = m_ttpBold; //vwenv.OpenTableCell(1,1); //vwenv.set_IntProperty((int)FwTextPropType.ktptMarginLeading, // (int)FwTextPropVar.ktpvMilliPoint, 10000); //vwenv.AddString(m_tssComments); //vwenv.CloseTableCell(); // //// Second cell has the Description property, in a box. //vwenv.set_IntProperty((int)FwTextPropType.ktptMarginTrailing, // (int)FwTextPropVar.ktpvMilliPoint, 10000); //vwenv.OpenTableCell(1,1); //vwenv.Props = m_ttpDataCellProps; //vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, // (int)FwTextPropVar.ktpvMilliPoint, 1000); //vwenv.AddStringAltMember( // (int)CmMajorObject.CmMajorObjectTags.kflidDescription, m_wsAnalysis, this); //vwenv.CloseTableCell(); // //vwenv.CloseTableRow(); vwenv.CloseTableBody(); vwenv.CloseTable(); break; default: throw new Exception("Bad frag id in TitleContentsVc"); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Displays the footnote reference. /// </summary> /// <param name="vwenv">The view environment.</param> /// <param name="hvoFootnote">The HVO of the footnote.</param> /// ------------------------------------------------------------------------------------ internal void DisplayFootnoteReference(IVwEnv vwenv, int hvoFootnote) { IScrFootnote footnote = m_cache.ServiceLocator.GetInstance<IScrFootnoteRepository>().GetObject(hvoFootnote); ITsString tssRef = TsStringUtils.MakeTss(footnote.GetReference(m_wsDefault), m_wsDefault, ScrStyleNames.FootnoteTargetRef); vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); vwenv.AddString(tssRef); }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </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: // the root; Display the paragraph using (new VwConstructorServices.ParagraphBoxHelper(vwenv, () => { if (m_displayOptions.ReadOnlyView) { vwenv.set_IntProperty( (int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); } })) { if (m_displayOptions.LiteralStringLabels) { using (new VwConstructorServices.InnerPileHelper(vwenv)) { ITsStrFactory factory = TsStrFactoryClass.Create(); foreach (var ws in WsOrder) { using (new VwConstructorServices.ParagraphBoxHelper(vwenv)) { if (m_displayOptions.LiteralStringLabels) vwenv.AddString(factory.MakeString("Label" + ws, ws)); } } } } using (new VwConstructorServices.InnerPileHelper(vwenv)) { ITsStrFactory factory = TsStrFactoryClass.Create(); foreach (var ws in WsOrder) { using (new VwConstructorServices.ParagraphBoxHelper(vwenv)) { //if (m_displayOptions.LiteralStringLabels) // vwenv.AddString(factory.MakeString("Label" + ws, ws)); vwenv.AddStringAltMember(kflidMultiString, ws, null); } } } } break; default: throw new ApplicationException("Unexpected frag in SimpleRootSiteDataProviderVc"); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// The main method just displays the text with the appropriate properties. /// </summary> /// <param name="vwenv">The view environment</param> /// <param name="hvo">The HVo of the object to display</param> /// <param name="frag">The fragment to lay out</param> /// ------------------------------------------------------------------------------------ public override void Display(IVwEnv vwenv, int hvo, int frag) { CheckDisposed(); switch (frag) { case InnerFwListBox.kfragRoot: Font f = m_listbox.Font; if (m_listbox.StyleSheet == null) { // Try to get items a reasonable size based on whatever font has been set for the // combo as a whole. We don't want to do this if a stylesheet has been set, because // it will override the sizes specified in the stylesheet. // Enhance JohnT: there are several more properties we could readily copy over // from the font, but this is a good start. vwenv.set_IntProperty((int)FwTextPropType.ktptFontSize, (int)FwTextPropVar.ktpvMilliPoint, (int)(f.SizeInPoints * 1000)); } // Setting the font family here appears to override the fonts associated with the // TsString data. This causes trouble for non-Microsoft Sans Serif writing systems. // See LT-551 for the bug report that revealed this problem. // vwenv.set_StringProperty((int) FwTextPropType.ktptFontFamily, // f.FontFamily.Name); vwenv.set_IntProperty((int)FwTextPropType.ktptForeColor, (int)FwTextPropVar.ktpvDefault, (int)ColorUtil.ConvertColorToBGR(m_listbox.ForeColor)); DisplayList(vwenv); break; case InnerFwListBox.kfragItems: int index, hvoDummy, tagDummy; int clev = vwenv.EmbeddingLevel; vwenv.GetOuterObject(clev - 1, out hvoDummy, out tagDummy, out index); bool fHighlighted = m_listbox.Owner.IsHighlighted(index); if (fHighlighted && m_listbox.ShowHighlight) { vwenv.set_IntProperty((int)FwTextPropType.ktptForeColor, (int)FwTextPropVar.ktpvDefault, (int)ColorUtil.ConvertColorToBGR(Color.FromKnownColor(KnownColor.HighlightText))); vwenv.set_IntProperty((int)FwTextPropType.ktptBackColor, (int)FwTextPropVar.ktpvDefault, (int)ColorUtil.ConvertColorToBGR(Color.FromKnownColor(KnownColor.Highlight))); } vwenv.OpenParagraph(); if (fHighlighted && m_listbox.ShowHighlight) { // Insert a string that has the foreground color not set, so the foreground color set above can take effect. ITsStrBldr bldr = vwenv.DataAccess.get_StringProp(hvo, InnerFwListBox.ktagText).GetBldr(); bldr.SetIntPropValues(0, bldr.Length, (int) FwTextPropType.ktptForeColor, -1, -1); vwenv.AddString(bldr.GetString()); } else { vwenv.AddStringProp(InnerFwListBox.ktagText, this); } vwenv.AddString(m_tssBlanks); vwenv.CloseParagraph(); break; } }
/// <summary> /// Add the specified string in the specified color to the display, using the UI Writing system. /// </summary> /// <param name="vwenv"></param> /// <param name="color"></param> /// <param name="str"></param> protected void AddColoredString(IVwEnv vwenv, int color, string str) { SetColor(vwenv, color); vwenv.AddString(m_tsf.MakeString(str, m_wsUi)); }
/// ----------------------------------------------------------------------------------- /// <summary> /// This is the main interesting method of displaying objects and fragments of them. /// </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 kfragRoot: ITsString tssWord = vwenv.DataAccess.get_StringProp(hvo, ktagCf); ITsStrBldr tsbSdRelation = m_tssSdRelation.GetBldr(); ITsStrBldr tsbLexRel = m_tssLexRelation.GetBldr(); if (tssWord != null && tssWord.Length > 0) { int ich = tsbSdRelation.Text.IndexOf("{0}"); if (ich >= 0) tsbSdRelation.ReplaceTsString(ich, ich + 3, tssWord); ich = tsbLexRel.Text.IndexOf("{0}"); if (ich >= 0) tsbLexRel.ReplaceTsString(ich, ich + 3, tssWord); } int cDomains = vwenv.DataAccess.get_VecSize(hvo, ktagDomains); int cLexRels = vwenv.DataAccess.get_VecSize(hvo, ktagLexRels); Debug.Assert(cDomains > 0 || cLexRels > 0); if (cDomains > 0) { vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); vwenv.set_IntProperty((int)FwTextPropType.ktptMarginBottom, (int)FwTextPropVar.ktpvMilliPoint, 6000); vwenv.OpenParagraph(); vwenv.AddString(tsbSdRelation.GetString()); vwenv.CloseParagraph(); vwenv.AddLazyVecItems(ktagDomains, this, kfragEntryList); } if (cLexRels > 0) { vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); vwenv.set_IntProperty((int)FwTextPropType.ktptMarginTop, (int)FwTextPropVar.ktpvMilliPoint, 6000); vwenv.set_IntProperty((int)FwTextPropType.ktptMarginBottom, (int)FwTextPropVar.ktpvMilliPoint, 6000); vwenv.OpenParagraph(); vwenv.AddString(tsbLexRel.GetString()); vwenv.CloseParagraph(); vwenv.AddLazyVecItems(ktagLexRels, this, kfragEntryList); } break; case kfragEntryList: vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); vwenv.OpenParagraph(); vwenv.set_IntProperty((int)FwTextPropType.ktptBold, (int)FwTextPropVar.ktpvEnum, (int)FwTextToggleVal.kttvForceOn); vwenv.AddStringProp(ktagName, this); vwenv.AddString (m_tssColon); vwenv.AddObjVec(ktagWords, this, kfragWords); vwenv.CloseParagraph(); break; case kfragName: vwenv.AddStringProp(ktagName, this); break; default: throw new Exception("bad case in RelatedWordsVc.Display"); } }
public override void Display(IVwEnv vwenv, int hvo, int frag) { // Ignore 0 hvo's. RootObject may have not been set. FWNX-613. if (hvo == 0) { return; } switch (frag) { case kfragRoot: if (m_dxLabWidth == 0) { int dmpx1, dmpy; //, dmpx2; vwenv.get_StringWidth(m_tssTitle, m_ttpBold, out dmpx1, out dmpy); //vwenv.get_StringWidth(m_tssComments, m_ttpBold, out dmpx2, out dmpy); //m_dxLabWidth = Math.Max(dmpx1, dmpx2) + 13000; // add 3 pt spacing to box, 10 to margin. m_dxLabWidth = dmpx1 + 13000; // add 3 pt spacing to box, 10 to margin. m_dxWsLabWidth = 0; foreach (ITsString tssLabel in m_WsLabels) { vwenv.get_StringWidth(tssLabel, m_ttpWsLabel, out dmpx1, out dmpy); m_dxWsLabWidth = Math.Max(m_dxWsLabWidth, dmpx1); } m_dxWsLabWidth += 18000; // 3 pts white space each side, 11 margin, 1 border, plus 1 for safety. } VwLength vlTable; vlTable.nVal = 10000; vlTable.unit = VwUnit.kunPercent100; VwLength vlColLabels; // 5-pt space plus max label width. vlColLabels.nVal = m_dxLabWidth; vlColLabels.unit = VwUnit.kunPoint1000; VwLength vlColWsLabels; // 5-pt space plus max ws label width. vlColWsLabels.nVal = m_dxWsLabWidth; vlColWsLabels.unit = VwUnit.kunPoint1000; // The Main column is relative and uses the rest of the space. VwLength vlColMain; vlColMain.nVal = 1; vlColMain.unit = VwUnit.kunRelative; // The Padding column allows for the the trailing margin and border. VwLength vlColPadding; vlColPadding.nVal = 10000; vlColPadding.unit = VwUnit.kunPoint1000; vwenv.set_IntProperty((int)FwTextPropType.ktptMarginTop, (int)FwTextPropVar.ktpvMilliPoint, 5000); vwenv.OpenTable(4, // Four 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); vwenv.MakeColumns(1, vlColLabels); vwenv.MakeColumns(1, vlColWsLabels); vwenv.MakeColumns(1, vlColMain); vwenv.MakeColumns(1, vlColPadding); vwenv.OpenTableBody(); for (int i = 0; i < m_writingSystems.Length; i++) { vwenv.OpenTableRow(); // First cell has 'Title' label in bold. vwenv.Props = m_ttpBold; vwenv.OpenTableCell(1, 1); vwenv.set_IntProperty((int)FwTextPropType.ktptMarginLeading, (int)FwTextPropVar.ktpvMilliPoint, 10000); if (i == 0) // only on the first row { // We want this fixed at 10 point, since it's considered a UI component, not data. // See LT-4816 vwenv.set_IntProperty((int)FwTextPropType.ktptFontSize, (int)FwTextPropVar.ktpvMilliPoint, 10000); vwenv.AddString(m_tssTitle); } vwenv.CloseTableCell(); // Second cell has ws labels. vwenv.set_IntProperty((int)FwTextPropType.ktptBackColor, (int)FwTextPropVar.ktpvDefault, m_editBackColor); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderLeading, (int)FwTextPropVar.ktpvMilliPoint, 1000); if (i == 0) { vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTop, (int)FwTextPropVar.ktpvMilliPoint, 1000); } if (i == m_writingSystems.Length - 1) { vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, (int)FwTextPropVar.ktpvMilliPoint, 1000); } vwenv.OpenTableCell(1, 1); vwenv.Props = m_ttpDataCellProps; vwenv.Props = m_ttpWsLabel; vwenv.AddString(m_WsLabels[i]); vwenv.CloseTableCell(); // Third cell has the Title property, in a box. vwenv.set_IntProperty((int)FwTextPropType.ktptBackColor, (int)FwTextPropVar.ktpvDefault, m_editBackColor); // Set the underlying directionality so that arrow keys work properly. bool fRTL = m_writingSystems[i].RightToLeftScript; vwenv.set_IntProperty((int)FwTextPropType.ktptRightToLeft, (int)FwTextPropVar.ktpvEnum, fRTL ? -1 : 0); vwenv.set_IntProperty((int)FwTextPropType.ktptAlign, (int)FwTextPropVar.ktpvEnum, fRTL ? (int)FwTextAlign.ktalRight : (int)FwTextAlign.ktalLeft); if (i == 0) { vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTop, (int)FwTextPropVar.ktpvMilliPoint, 1000); } if (i == m_writingSystems.Length - 1) { vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, (int)FwTextPropVar.ktpvMilliPoint, 1000); } vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); vwenv.Props = m_ttpDataCellProps; vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, this.Editable ? (int)TptEditable.ktptIsEditable : (int)TptEditable.ktptNotEditable); if (IsScripture) { vwenv.AddStringAltMember(m_vtagStTextTitle, m_writingSystems[i].Handle, this); } else { vwenv.AddStringAltMember(CmMajorObjectTags.kflidName, m_writingSystems[i].Handle, this); } vwenv.CloseParagraph(); vwenv.CloseTableCell(); vwenv.set_IntProperty((int)FwTextPropType.ktptMarginTrailing, (int)FwTextPropVar.ktpvMilliPoint, 10000); vwenv.set_IntProperty((int)FwTextPropType.ktptBorderTrailing, (int)FwTextPropVar.ktpvMilliPoint, 1000); vwenv.OpenTableCell(1, 1); vwenv.CloseTableCell(); vwenv.CloseTableRow(); } //// Second row. //vwenv.OpenTableRow(); // //// First cell has 'Comments' label in bold. //vwenv.Props = m_ttpBold; //vwenv.OpenTableCell(1,1); //vwenv.set_IntProperty((int)FwTextPropType.ktptMarginLeading, // (int)FwTextPropVar.ktpvMilliPoint, 10000); //vwenv.AddString(m_tssComments); //vwenv.CloseTableCell(); // //// Second cell has the Description property, in a box. //vwenv.set_IntProperty((int)FwTextPropType.ktptMarginTrailing, // (int)FwTextPropVar.ktpvMilliPoint, 10000); //vwenv.OpenTableCell(1,1); //vwenv.Props = m_ttpDataCellProps; //vwenv.set_IntProperty((int)FwTextPropType.ktptBorderBottom, // (int)FwTextPropVar.ktpvMilliPoint, 1000); //vwenv.AddStringAltMember( // (int)CmMajorObject.CmMajorObjectTags.kflidDescription, m_wsAnalysis, this); //vwenv.CloseTableCell(); // //vwenv.CloseTableRow(); vwenv.CloseTableBody(); vwenv.CloseTable(); break; default: throw new Exception("Bad frag id in TitleContentsVc"); } }
public override void Display(IVwEnv vwenv, int hvo, int frag) { switch (frag) { case kfragRHS: m_rhs = m_cache.ServiceLocator.GetInstance <IPhSegRuleRHSRepository>().GetObject(hvo); var rule = m_rhs.OwningRule; if (rule.Disabled) { vwenv.set_StringProperty((int)FwTextPropType.ktptNamedStyle, "Disabled Text"); } int arrowWidth, slashWidth, underscoreWidth, charHeight; vwenv.get_StringWidth(m_arrow, m_charProps, out arrowWidth, out charHeight); int maxCharHeight = charHeight; vwenv.get_StringWidth(m_slash, m_charProps, out slashWidth, out charHeight); maxCharHeight = Math.Max(charHeight, maxCharHeight); vwenv.get_StringWidth(m_underscore, m_charProps, out underscoreWidth, out charHeight); maxCharHeight = Math.Max(charHeight, maxCharHeight); int dmpx, spaceHeight; vwenv.get_StringWidth(m_zwSpace, m_bracketProps, out dmpx, out spaceHeight); int maxNumLines = GetMaxNumLines(); int maxCtxtHeight = maxNumLines * spaceHeight; int maxHeight = Math.Max(maxCharHeight, maxCtxtHeight); int charOffset = maxHeight; int ctxtPadding = maxHeight - maxCtxtHeight; VwLength tableLen; tableLen.nVal = 10000; tableLen.unit = VwUnit.kunPercent100; vwenv.OpenTable(7, tableLen, 0, VwAlignment.kvaCenter, VwFramePosition.kvfpVoid, VwRule.kvrlNone, 0, 0, false); VwLength ctxtLen; ctxtLen.nVal = 1; ctxtLen.unit = VwUnit.kunRelative; VwLength charLen; charLen.unit = VwUnit.kunPoint1000; vwenv.MakeColumns(1, ctxtLen); charLen.nVal = arrowWidth + 4000; vwenv.MakeColumns(1, charLen); vwenv.MakeColumns(1, ctxtLen); charLen.nVal = slashWidth + 4000; vwenv.MakeColumns(1, charLen); vwenv.MakeColumns(1, ctxtLen); charLen.nVal = underscoreWidth + 4000; vwenv.MakeColumns(1, charLen); vwenv.MakeColumns(1, ctxtLen); vwenv.OpenTableBody(); vwenv.OpenTableRow(); // LHS cell vwenv.Props = m_ctxtProps; vwenv.set_IntProperty((int)FwTextPropType.ktptPadTop, (int)FwTextPropVar.ktpvMilliPoint, ctxtPadding); vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); vwenv.AddObjProp(m_cache.MetaDataCacheAccessor.GetFieldId2(PhSegRuleRHSTags.kClassId, "OwningRule", false), this, kfragRule); vwenv.CloseParagraph(); vwenv.CloseTableCell(); // arrow cell vwenv.Props = m_charProps; vwenv.set_IntProperty((int)FwTextPropType.ktptOffset, (int)FwTextPropVar.ktpvMilliPoint, -charOffset); vwenv.OpenTableCell(1, 1); vwenv.AddString(m_arrow); vwenv.CloseTableCell(); // RHS cell vwenv.Props = m_ctxtProps; vwenv.set_IntProperty((int)FwTextPropType.ktptPadTop, (int)FwTextPropVar.ktpvMilliPoint, ctxtPadding); vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); if (m_rhs.StrucChangeOS.Count > 0) { vwenv.AddObjVecItems(PhSegRuleRHSTags.kflidStrucChange, this, kfragContext); } else { vwenv.NoteDependency(new[] { hvo }, new[] { PhSegRuleRHSTags.kflidStrucChange }, 1); OpenSingleLinePile(vwenv, maxNumLines, false); vwenv.Props = m_bracketProps; vwenv.AddProp(PhSegRuleRHSTags.kflidStrucChange, this, kfragEmpty); CloseSingleLinePile(vwenv, false); } vwenv.CloseParagraph(); vwenv.CloseTableCell(); // slash cell vwenv.Props = m_charProps; vwenv.set_IntProperty((int)FwTextPropType.ktptOffset, (int)FwTextPropVar.ktpvMilliPoint, -charOffset); vwenv.OpenTableCell(1, 1); vwenv.AddString(m_slash); vwenv.CloseTableCell(); // left context cell vwenv.Props = m_ctxtProps; vwenv.set_IntProperty((int)FwTextPropType.ktptPadTop, (int)FwTextPropVar.ktpvMilliPoint, ctxtPadding); vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); if (m_rhs.LeftContextOA != null) { vwenv.AddObjProp(PhSegRuleRHSTags.kflidLeftContext, this, kfragContext); } else { vwenv.NoteDependency(new[] { hvo }, new[] { PhSegRuleRHSTags.kflidLeftContext }, 1); OpenSingleLinePile(vwenv, maxNumLines, false); vwenv.Props = m_bracketProps; vwenv.AddProp(PhSegRuleRHSTags.kflidLeftContext, this, kfragEmpty); CloseSingleLinePile(vwenv, false); } vwenv.CloseParagraph(); vwenv.CloseTableCell(); // underscore cell vwenv.Props = m_charProps; vwenv.set_IntProperty((int)FwTextPropType.ktptOffset, (int)FwTextPropVar.ktpvMilliPoint, -charOffset); vwenv.OpenTableCell(1, 1); vwenv.AddString(m_underscore); vwenv.CloseTableCell(); // right context cell vwenv.Props = m_ctxtProps; vwenv.set_IntProperty((int)FwTextPropType.ktptPadTop, (int)FwTextPropVar.ktpvMilliPoint, ctxtPadding); vwenv.OpenTableCell(1, 1); vwenv.OpenParagraph(); if (m_rhs.RightContextOA != null) { vwenv.AddObjProp(PhSegRuleRHSTags.kflidRightContext, this, kfragContext); } else { vwenv.NoteDependency(new[] { hvo }, new[] { PhSegRuleRHSTags.kflidRightContext }, 1); OpenSingleLinePile(vwenv, maxNumLines, false); vwenv.Props = m_bracketProps; vwenv.AddProp(PhSegRuleRHSTags.kflidRightContext, this, kfragEmpty); CloseSingleLinePile(vwenv, false); } vwenv.CloseParagraph(); vwenv.CloseTableCell(); vwenv.CloseTableRow(); vwenv.CloseTableBody(); vwenv.CloseTable(); break; case kfragRule: if (m_rhs.OwningRule.StrucDescOS.Count > 0) { vwenv.AddObjVecItems(PhSegmentRuleTags.kflidStrucDesc, this, kfragContext); } else { OpenSingleLinePile(vwenv, GetMaxNumLines(), false); vwenv.Props = m_bracketProps; vwenv.AddProp(PhSegmentRuleTags.kflidStrucDesc, this, kfragEmpty); CloseSingleLinePile(vwenv, false); } break; default: base.Display(vwenv, hvo, frag); break; } }
/// <summary> /// Add a segment number appropriate to the current segment being displayed. /// (See LT-1236.) /// </summary> /// <param name="vwenv"></param> /// <param name="hvo"></param> private void AddSegmentReference(IVwEnv vwenv, int hvo) { ITsString tssSegNum; StringBuilder sbSegNum = new StringBuilder(); int flid = 0; var seg = m_segRepository.GetObject(hvo); var para = seg.Paragraph; if (para != null) { ISilDataAccess sda = vwenv.DataAccess; int cseg = para.SegmentsOS.Count; int idxSeg = para.SegmentsOS.IndexOf(seg); // sda.GetObjIndex(hvoStPara, ktagParaSegments, hvo); IStText stText = para.Owner as IStText; if (stText != null) flid = stText.OwningFlid; if (flid == ScrSectionTags.kflidContent) { var scrPara = para as IScrTxtPara; // With null book name and trimmed it should have just chapter:v{a,b}. // The {a,b} above would not be the segment identifiers we add for multiple segments in // a verse, but the letters indicating that the verse label is for only part of the verse. // There is therefore a pathological case where, say, verse 4a as labeled in the main text // gets another letter because 4a has multiple segments 4aa, 4ab, etc. string chapRef = ScriptureServices.FullScrRef(scrPara, seg.BeginOffset, "").Trim(); sbSegNum.Append(chapRef + ScriptureServices.VerseSegLabel(scrPara, idxSeg)); } else { int idxPara = para.OwnOrd; if (idxPara >= 0) { sbSegNum.AppendFormat("{0}", idxPara + 1); if (idxSeg >= 0 && cseg > 1) sbSegNum.AppendFormat(".{0}", idxSeg + 1); } } } ITsStrBldr tsbSegNum = m_tsf.GetBldr(); tsbSegNum.ReplaceTsString(0, tsbSegNum.Length, TsStringUtils.MakeTss(sbSegNum.ToString(), m_cache.DefaultUserWs)); tsbSegNum.SetIntPropValues(0, tsbSegNum.Length, (int)FwTextPropType.ktptBold, (int)FwTextPropVar.ktpvEnum, (int)FwTextToggleVal.kttvForceOn); tssSegNum = tsbSegNum.GetString(); vwenv.set_IntProperty((int)FwTextPropType.ktptMarginTrailing, (int)FwTextPropVar.ktpvMilliPoint, 10000); vwenv.set_IntProperty((int)FwTextPropType.ktptForeColor, (int)FwTextPropVar.ktpvDefault, (int)CmObjectUi.RGB(SystemColors.ControlText)); try { m_fIsAddingSegmentReference = true; vwenv.OpenInnerPile(); vwenv.AddString(tssSegNum); vwenv.CloseInnerPile(); } finally { m_fIsAddingSegmentReference = false; } }
/// <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 } }
public override void Display(IVwEnv vwenv, int hvo, int frag) { CheckDisposed(); ITsStrFactory tsf = null; switch (frag) { case kfragStText: // The whole text, root object for the InterlinDocChild. if (hvo == 0) return; // What if the user deleted all the texts? See LT-6727. vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvDefault, (int)TptEditable.ktptNotEditable); vwenv.OpenDiv(); StText stText = new StText(m_cache, hvo); vwenv.set_IntProperty((int)FwTextPropType.ktptMarginBottom, (int)FwTextPropVar.ktpvMilliPoint, 6000); vwenv.set_IntProperty((int)FwTextPropType.ktptFontSize, (int)FwTextPropVar.ktpvMilliPoint, 24000); // Add both vernacular and analysis if we have them (LT-5561). bool fAddedVernacular = false; int wsVernTitle = 0; // if (stText.Title.TryWs(LangProject.kwsFirstVern, out wsVernTitle)) { vwenv.OpenParagraph(); vwenv.AddStringAltMember(vtagStTextTitle, wsVernTitle, this); vwenv.CloseParagraph(); fAddedVernacular = true; } int wsAnalysisTitle = 0; vwenv.set_IntProperty((int)FwTextPropType.ktptMarginBottom, (int)FwTextPropVar.ktpvMilliPoint, 10000); vwenv.OpenParagraph(); ITsString tssAnal; if (stText.Title.TryWs(LangProject.kwsFirstAnal, out wsAnalysisTitle, out tssAnal) && !tssAnal.Equals(stText.Title.BestVernacularAlternative)) { if (fAddedVernacular) { // display analysis title at smaller font size. vwenv.set_IntProperty((int)FwTextPropType.ktptFontSize, (int)FwTextPropVar.ktpvMilliPoint, 12000); } vwenv.AddStringAltMember(vtagStTextTitle, wsAnalysisTitle, this); } else { // just add a blank title. tsf = TsStrFactoryClass.Create(); ITsString blankTitle = tsf.MakeString("", m_wsAnalysis); vwenv.AddString(blankTitle); } vwenv.CloseParagraph(); int wsSource = 0; ITsString tssSource = stText.SourceOfTextForWs(m_wsVernForDisplay); if (tssSource == null || tssSource.Length == 0) { tssSource = stText.SourceOfTextForWs(m_wsAnalysis); if (tssSource != null && tssSource.Length > 0) wsSource = m_wsAnalysis; } else { wsSource = m_wsVernForDisplay; } vwenv.set_IntProperty((int)FwTextPropType.ktptMarginBottom, (int)FwTextPropVar.ktpvMilliPoint, 10000); if (tssSource != null && tssSource.Length > 0) { vwenv.OpenParagraph(); vwenv.set_IntProperty((int)FwTextPropType.ktptFontSize, (int)FwTextPropVar.ktpvMilliPoint, 12000); vwenv.AddStringAltMember(vtagStTextSource, wsSource, this); vwenv.CloseParagraph(); } else { // just add a blank source. tsf = TsStrFactoryClass.Create(); ITsString tssBlank = tsf.MakeString("", m_wsAnalysis); vwenv.AddString(tssBlank); } vwenv.set_IntProperty((int)FwTextPropType.ktptMarginBottom, (int)FwTextPropVar.ktpvMilliPoint, 10000); vwenv.OpenParagraph(); if (stText.OwningFlid == (int)Text.TextTags.kflidContents) { vwenv.AddObjProp((int)CmObjectFields.kflidCmObject_Owner, this, kfragTextDescription); } vwenv.CloseParagraph(); base.Display(vwenv, hvo, frag); vwenv.CloseDiv(); break; case kfragTextDescription: vwenv.AddStringAltMember((int)CmMajorObject.CmMajorObjectTags.kflidDescription, m_wsAnalysis, this); break; case kfragSegFf: // One freeform annotation. int[] wssAnalysis = m_WsList.AnalysisWsIds; if (wssAnalysis.Length == 0) break; // This is bizarre, but for the sake of paranoia... tsf = TsStrFactoryClass.Create(); int hvoType = m_cache.MainCacheAccessor.get_ObjectProp(hvo, (int)CmAnnotation.CmAnnotationTags.kflidAnnotationType); string label = ""; if (hvoType == NoteSegmentDefn) label = ITextStrings.ksNt; else if (hvoType == FtSegmentDefn) label = ITextStrings.ksFT; else if (hvoType == LtSegmentDefn) label = ITextStrings.ksLT; else throw new Exception("Unexpected FF annotation type"); ITsString tssLabel = tsf.MakeString(label, m_cache.DefaultUserWs); ISilDataAccess sda = vwenv.DataAccess; if (wssAnalysis.Length == 1) { ITsString tss = sda.get_MultiStringAlt(hvo, (int)CmAnnotation.CmAnnotationTags.kflidComment, m_cache.DefaultAnalWs); if (tss.Length == 0) break; vwenv.OpenParagraph(); vwenv.AddString(tssLabel); vwenv.AddStringAltMember((int)CmAnnotation.CmAnnotationTags.kflidComment, m_cache.DefaultAnalWs, this); vwenv.CloseParagraph(); } else { int labelWidth, labelHeight; vwenv.get_StringWidth(tssLabel, null, out labelWidth, out labelHeight); // This roughly corresponds to the width of the space at the end of FT. // The nice way to do it (here and in the base class) would be a table or 'interlinear' paragraph. labelWidth += 3000; int cNonBlank = 0; for (int i = 0; i < wssAnalysis.Length; i++) { ITsString tss = sda.get_MultiStringAlt(hvo, (int)CmAnnotation.CmAnnotationTags.kflidComment, wssAnalysis[i]); if (tss.Length == 0) continue; if (cNonBlank != 0) { // Indent subsequent paragraphs by the width of the main label. vwenv.set_IntProperty((int)FwTextPropType.ktptLeadingIndent, (int) FwTextPropVar.ktpvMilliPoint, labelWidth); } vwenv.OpenParagraph(); if (cNonBlank == 0) vwenv.AddString(tssLabel); cNonBlank++; // after tests above! m_WsList.AddWsLabel(vwenv, i); vwenv.AddStringAltMember((int)CmAnnotation.CmAnnotationTags.kflidComment, wssAnalysis[i], this); vwenv.CloseParagraph(); } } break; default: base.Display(vwenv, hvo, frag); break; } }
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; } }
public override void Display(IVwEnv vwenv, int hvo, int frag) { ITsStrFactory tsf = null; switch (frag) { case kfragStText: // The whole text, root object for the InterlinDocChild. if (hvo == 0) return; // What if the user deleted all the texts? See LT-6727. IStText stText = m_coRepository.GetObject(hvo) as IStText; vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvDefault, (int)TptEditable.ktptNotEditable); vwenv.OpenDiv(); vwenv.set_IntProperty((int)FwTextPropType.ktptMarginBottom, (int)FwTextPropVar.ktpvMilliPoint, 6000); vwenv.set_IntProperty((int)FwTextPropType.ktptFontSize, (int)FwTextPropVar.ktpvMilliPoint, 24000); // Add both vernacular and analysis if we have them (LT-5561). bool fAddedVernacular = false; int wsVernTitle = 0; // if (stText.Title.TryWs(WritingSystemServices.kwsFirstVern, out wsVernTitle)) { vwenv.OpenParagraph(); vwenv.AddStringAltMember(vtagStTextTitle, wsVernTitle, this); vwenv.CloseParagraph(); fAddedVernacular = true; } int wsAnalysisTitle = 0; vwenv.set_IntProperty((int)FwTextPropType.ktptMarginBottom, (int)FwTextPropVar.ktpvMilliPoint, 10000); vwenv.OpenParagraph(); ITsString tssAnal; if (stText.Title.TryWs(WritingSystemServices.kwsFirstAnal, out wsAnalysisTitle, out tssAnal) && !tssAnal.Equals(stText.Title.BestVernacularAlternative)) { if (fAddedVernacular) { // display analysis title at smaller font size. vwenv.set_IntProperty((int)FwTextPropType.ktptFontSize, (int)FwTextPropVar.ktpvMilliPoint, 12000); } vwenv.AddStringAltMember(vtagStTextTitle, wsAnalysisTitle, this); } else { // just add a blank title. tsf = TsStrFactoryClass.Create(); ITsString blankTitle = tsf.MakeString("", m_wsAnalysis); vwenv.AddString(blankTitle); } vwenv.CloseParagraph(); vwenv.set_IntProperty((int)FwTextPropType.ktptMarginBottom, (int)FwTextPropVar.ktpvMilliPoint, 10000); int wsSource = 0; if (stText.Source.TryWs(WritingSystemServices.kwsFirstVernOrAnal, out wsSource)) { vwenv.OpenParagraph(); vwenv.set_IntProperty((int)FwTextPropType.ktptFontSize, (int)FwTextPropVar.ktpvMilliPoint, 12000); vwenv.AddStringAltMember(vtagStTextSource, wsSource, this); vwenv.CloseParagraph(); } else { // just add a blank source. tsf = TsStrFactoryClass.Create(); ITsString tssBlank = tsf.MakeString("", m_wsAnalysis); vwenv.AddString(tssBlank); } vwenv.set_IntProperty((int)FwTextPropType.ktptMarginBottom, (int)FwTextPropVar.ktpvMilliPoint, 10000); vwenv.OpenParagraph(); if (stText.OwningFlid == TextTags.kflidContents) { vwenv.AddObjProp((int)CmObjectFields.kflidCmObject_Owner, this, kfragTextDescription); } vwenv.CloseParagraph(); base.Display(vwenv, hvo, frag); vwenv.CloseDiv(); break; case kfragTextDescription: vwenv.AddStringAltMember(CmMajorObjectTags.kflidDescription, m_wsAnalysis, this); break; default: base.Display(vwenv, hvo, frag); break; } }
private void DisplayWithWritingSystemLabel(IVwEnv vwenv, int ws) { ITsString tssLabel = NameOfWs(ws); // 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; int dxs; // Width of displayed string. int dys; // Height of displayed string (not used here). vwenv.get_StringWidth(tssLabel, null, out dxs, out dys); VwLength vlColWs; // 5-pt space plus max label width. vlColWs.nVal = dxs + 5000; vlColWs.unit = VwUnit.kunPoint1000; // The Main column is relative and uses the rest of the space. VwLength vlColMain; vlColMain.nVal = 1; vlColMain.unit = VwUnit.kunRelative; // Enhance JohnT: possibly allow for right-to-left UI by reversing columns? 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(); vwenv.OpenTableRow(); // First cell has writing system abbreviation displayed using m_ttpLabel. //vwenv.Props = m_ttpLabel; vwenv.OpenTableCell(1, 1); vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); vwenv.AddString(tssLabel); vwenv.CloseTableCell(); // Second cell has the string contents for the alternative. // DN version has some property setting, including trailing margin and RTL. if (m_fRtlScript) { vwenv.set_IntProperty((int) FwTextPropType.ktptRightToLeft, (int) FwTextPropVar.ktpvEnum, (int) FwTextToggleVal.kttvForceOn); vwenv.set_IntProperty((int) FwTextPropType.ktptAlign, (int) FwTextPropVar.ktpvEnum, (int) FwTextAlign.ktalTrailing); } //if (!m_editable) //{ // vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, // (int)TptEditable.ktptNotEditable); //} vwenv.set_IntProperty((int) FwTextPropType.ktptPadTop, (int) FwTextPropVar.ktpvMilliPoint, 2000); vwenv.OpenTableCell(1, 1); vwenv.AddStringProp(m_flid, this); vwenv.CloseTableCell(); vwenv.CloseTableRow(); vwenv.CloseTableBody(); vwenv.CloseTable(); }
public override void Display(IVwEnv vwenv, int hvo, int frag) { switch(frag) { case 1: { // The top-level. // Enhance JohnT: add a property setting to make the key bold // Roughly, vwenv.set_IntProperty(ktptBold, ktpvEnum, kttvForceOn); // If we can get an hvo and flid, display that property of that object. int flid = 0; if (hvo != 0) { flid = m_cp.FlidFor(m_index, hvo); } if (flid != 0) { // Warning (JohnT): this option not yet tested... vwenv.AddStringProp(flid, this); return; } else { // Otherwise display a literal string straight from the policy object. vwenv.AddString(m_cp.KeyFor(m_index, hvo)); } if (m_fExpanded) { vwenv.AddLazyVecItems(m_ni.ListFlid, this, 2); } break; } case 2: { // One line of context. // Figure the index of this object in the next object out (the root). int hvoOuter, tagOuter, ihvo; vwenv.GetOuterObject(vwenv.EmbeddingLevel - 1, out hvoOuter, out tagOuter, out ihvo); int ichKey = m_ni.ContextStringStartOffset(ihvo, hvo); int cchKey = m_ni.ContextStringLength(ihvo, hvo); // Enhance JohnT: make the alignment position a function of window width. // Enhance JohnT: change background if this is the selected context line. vwenv.OpenConcPara(ichKey, ichKey + cchKey, VwConcParaOpts.kcpoDefault, 72 * 2 * 1000); // 72 pts per inch * 2 inches * 1000 -> 2" in millipoints. int flidKey = m_ni.ContextStringFlid(ihvo, hvo); if (flidKey == 0) { // Not tested yet. vwenv.AddString(m_ni.ContextString(ihvo, hvo)); } else { vwenv.AddStringProp(flidKey, this); } vwenv.CloseParagraph(); break; } } }
/// <summary> /// Add the pile of labels used to identify the lines in interlinear text. /// </summary> /// <param name="vwenv"></param> /// <param name="tsf"></param> /// <param name="cache"></param> /// <param name="wsList">Null if don't want multiple writing systems.</param> /// <param name="fShowMutlilingGlosses"></param> public void AddLabelPile(IVwEnv vwenv, ITsStrFactory tsf, FdoCache cache, bool fWantMultipleSenseGloss, bool fShowMorphemes) { CheckDisposed(); int wsUI = cache.DefaultUserWs; var spaceStr = TsStringUtils.MakeTss(" ", wsUI); vwenv.set_IntProperty((int)FwTextPropType.ktptMarginTrailing, (int)FwTextPropVar.ktpvMilliPoint, 10000); vwenv.set_IntProperty((int)FwTextPropType.ktptBold, (int)FwTextPropVar.ktpvEnum, (int)FwTextToggleVal.kttvForceOn); vwenv.set_IntProperty((int)FwTextPropType.ktptMarginBottom, (int)FwTextPropVar.ktpvMilliPoint, 5000); // default spacing is fine for all embedded paragraphs. vwenv.OpenInnerPile(); for (var i = 0; i < m_lineChoices.Count; i++) { InterlinLineSpec spec = m_lineChoices[i]; if (!spec.WordLevel) break; SetColor(vwenv, LabelRGBFor(spec)); ITsString tss = MakeUiElementString(m_lineChoices.LabelFor(spec.Flid), wsUI, null); var bldr = tss.GetBldr(); if (m_lineChoices.RepetitionsOfFlid(spec.Flid) > 1) { bldr.Append(spaceStr); bldr.Append(spec.WsLabel(cache)); AddLineIndexProperty(bldr, i); // Enhance GJM: Might be able to do without paragraph now? vwenv.OpenParagraph(); vwenv.AddString(bldr.GetString()); vwenv.CloseParagraph(); } else { AddLineIndexProperty(bldr, i); vwenv.AddString(bldr.GetString()); } } vwenv.CloseInnerPile(); }
/// <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 Display(IVwEnv vwenv, int hvo, int frag) { CheckDisposed(); TriggerDisplay(vwenv); //if (m_rgws.Length == 1) //{ // // Single option...don't bother with labels. // if (m_rgws[0].RightToLeft) // { // vwenv.set_IntProperty((int)FwTextPropType.ktptRightToLeft, // (int)FwTextPropVar.ktpvEnum, // (int)FwTextToggleVal.kttvForceOn); // vwenv.set_IntProperty((int)FwTextPropType.ktptAlign, // (int)FwTextPropVar.ktpvEnum, // (int)FwTextAlign.ktalTrailing); // } // vwenv.set_IntProperty((int)FwTextPropType.ktptPadTop, (int)FwTextPropVar.ktpvMilliPoint, 2000); // vwenv.AddStringAltMember(m_flid, m_rgws[0].Hvo, this); // return; //} ITsStrFactory tsf = TsStrFactoryClass.Create(); // 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. for (int i = 0; i < m_rgws.Length; ++i) { // Set qtss to a string representing the writing system. vwenv.get_StringWidth(NameOfWs(tsf, i), 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(); Set<ILgWritingSystem> visibleWss = new Set<ILgWritingSystem>(); // if we passed in a view and have WritingSystemsToDisplay // then we'll load that list in order to filter our larger m_rgws list. AddViewWritingSystems(visibleWss); for (int i = 0; i < m_rgws.Length; ++i) { if (SkipEmptyWritingSystem(visibleWss, i, hvo)) continue; vwenv.OpenTableRow(); // First cell has writing system abbreviation displayed using m_ttpLabel. vwenv.Props = m_ttpLabel; vwenv.OpenTableCell(1,1); vwenv.AddString(NameOfWs(tsf, i)); vwenv.CloseTableCell(); // Second cell has the string contents for the alternative. // DN version has some property setting, including trailing margin and // RTL. if (m_rgws[i].RightToLeft) { vwenv.set_IntProperty((int)FwTextPropType.ktptRightToLeft, (int)FwTextPropVar.ktpvEnum, (int)FwTextToggleVal.kttvForceOn); vwenv.set_IntProperty((int)FwTextPropType.ktptAlign, (int)FwTextPropVar.ktpvEnum, (int)FwTextAlign.ktalTrailing); } if (!m_editable) { vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); } vwenv.set_IntProperty((int)FwTextPropType.ktptPadTop, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.OpenTableCell(1,1); vwenv.AddStringAltMember(m_flid, m_rgws[i].Hvo, this); vwenv.CloseTableCell(); vwenv.CloseTableRow(); } vwenv.CloseTableBody(); vwenv.CloseTable(); }
public override void Display(IVwEnv vwenv, int hvo, int frag) { CheckDisposed(); // Enhance JohnT: make the alignment position a function of window width. // Enhance JohnT: change background if this is the selected context line. vwenv.OpenConcPara(m_info.ContextStringStartOffset, m_info.ContextStringStartOffset + m_info.ContextStringLength, VwConcParaOpts.kcpoDefault, 72 * 2 * 1000); // 72 pts per inch * 2 inches * 1000 -> 2" in millipoints. if (m_info.Hvo == 0 || m_info.ContentStringFlid == 0) { vwenv.AddString(m_info.ContentString); } else { Debug.Assert(hvo == m_info.Hvo); vwenv.AddStringProp(m_info.ContentStringFlid, this); } vwenv.CloseParagraph(); }
public override void Display(IVwEnv vwenv, int hvo, int frag) { CheckDisposed(); // Enhance JohnT: change background if this is the selected slice. vwenv.OpenParagraph(); if (m_info.Hvo == 0 || m_info.ContentStringFlid == 0) { vwenv.AddString(m_info.ContentString); } else { Debug.Assert(hvo == m_info.Hvo); vwenv.AddStringProp(m_info.ContentStringFlid, this); } vwenv.CloseParagraph(); }
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 }
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; } } }
/// <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(); }
public override void Display(IVwEnv vwenv, int hvo, int frag) { switch (frag) { case AudioVisualView.kfragPathname: // Display the filename. ILgWritingSystemFactory wsf = m_cache.WritingSystemFactory; vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvDefault, (int)TptEditable.ktptNotEditable); ITsString tss; ITsStrFactory tsf = m_cache.TsStrFactory; Debug.Assert(hvo != 0); Debug.Assert(m_cache != null); var file = m_cache.ServiceLocator.GetInstance<ICmFileRepository>().GetObject(hvo); Debug.Assert(file != null); string path = file.AbsoluteInternalPath; tss = tsf.MakeString(path, m_cache.WritingSystemFactory.UserWs); vwenv.OpenParagraph(); vwenv.NoteDependency( new [] { m_cache.LangProject.Hvo, file.Hvo}, new [] {LangProjectTags.kflidLinkedFilesRootDir, CmFileTags.kflidInternalPath}, 2); vwenv.AddString(tss); vwenv.CloseParagraph(); break; default: throw new ArgumentException( "Don't know what to do with the given frag.", "frag"); } }
private void 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(); }
/// <summary> /// This is the basic method needed for the view constructor. /// </summary> public override void Display(IVwEnv vwenv, int hvo, int frag) { switch (frag) { case VectorReferenceView.kfragTargetVector: // Check for an empty vector. if (hvo == 0 || m_cache.DomainDataByFlid.get_VecSize(hvo, m_flid) == 0) { vwenv.set_IntProperty((int)FwTextPropType.ktptForeColor, (int)FwTextPropVar.ktpvDefault, (int)ColorUtil.ConvertColorToBGR(Color.Gray)); vwenv.set_IntProperty((int)FwTextPropType.ktptLeadingIndent, (int)FwTextPropVar.ktpvMilliPoint, 18000); vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvDefault, (int)TptEditable.ktptNotEditable); vwenv.set_IntProperty((int)FwTextPropType.ktptAlign, (int)FwTextPropVar.ktpvEnum, (int)FwTextAlign.ktalRight); //vwenv.AddString(m_cache.MakeUserTss("Click to select -->")); if (hvo != 0) { vwenv.NoteDependency(new[] { hvo }, new[] { m_flid }, 1); } } else { if (!string.IsNullOrEmpty(TextStyle)) { vwenv.set_StringProperty((int)FwTextPropType.ktptNamedStyle, TextStyle); } vwenv.OpenParagraph(); vwenv.AddObjVec(m_flid, this, frag); vwenv.CloseParagraph(); } break; case VectorReferenceView.kfragTargetObj: // Display one object from the vector. { ILgWritingSystemFactory wsf = m_cache.WritingSystemFactory; vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvDefault, (int)TptEditable.ktptNotEditable); ITsString tss; Debug.Assert(hvo != 0); #if USEBESTWS if (m_displayWs != null && m_displayWs.StartsWith("best")) { // The flid can be a variety of types, so deal with those. Debug.WriteLine("Using 'best ws': " + m_displayWs); int magicWsId = LgWritingSystem.GetMagicWsIdFromName(m_displayWs); int actualWS = m_cache.LanguageProject.ActualWs(magicWsId, hvo, m_flid); Debug.WriteLine("Actual ws: " + actualWS.ToString()); } else { #endif // Use reflection to get a prebuilt name if we can. Otherwise // settle for piecing together a string. Debug.Assert(m_cache != null); var obj = m_cache.ServiceLocator.GetInstance <ICmObjectRepository>().GetObject(hvo); Debug.Assert(obj != null); Type type = obj.GetType(); System.Reflection.PropertyInfo pi = type.GetProperty("TsName", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.FlattenHierarchy); if (pi != null) { tss = (ITsString)pi.GetValue(obj, null); } else { if (!string.IsNullOrEmpty(m_displayNameProperty)) { pi = type.GetProperty(m_displayNameProperty, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.FlattenHierarchy); } int ws = wsf.GetWsFromStr(obj.SortKeyWs); if (ws == 0) { ws = m_cache.ServiceLocator.WritingSystems.DefaultAnalysisWritingSystem.Handle; } if (pi != null) { object s = pi.GetValue(obj, null); if (s is ITsString) { tss = (ITsString)s; } else { tss = TsStringUtils.MakeString((string)s, ws); } } else { // ShortNameTss sometimes gets PropChanged, so worth letting the view know that's // what we're inserting. var flid = Cache.MetaDataCacheAccessor.GetFieldId2(obj.ClassID, "ShortNameTSS", true); vwenv.AddStringProp(flid, this); break; } #if USEBESTWS } #endif } if (!string.IsNullOrEmpty(TextStyle)) { vwenv.set_StringProperty((int)FwTextPropType.ktptNamedStyle, TextStyle); } vwenv.AddString(tss); } break; default: throw new ArgumentException( "Don't know what to do with the given frag.", "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) { 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> /// 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; } }