/// ------------------------------------------------------------------------------------ /// <summary> /// Displays the specified vwenv. /// </summary> /// <param name="vwenv">The vwenv.</param> /// <param name="hvo">The hvo.</param> /// <param name="frag">The frag.</param> /// ------------------------------------------------------------------------------------ public override void Display(IVwEnv vwenv, int hvo, int frag) { CheckDisposed(); switch (frag) { case kfragLazyScripture: { // The configure method insists on trying to make an initial selection. // If there isn't something selectable there, it expands everything. vwenv.AddStringProp((int)Scripture.ScriptureTags.kflidChapterVerseSepr, this); vwenv.AddLazyVecItems((int)Scripture.ScriptureTags.kflidScriptureBooks, this, kfragLazyBook); break; } case kfragLazyBook: { vwenv.AddLazyVecItems((int)ScrBook.ScrBookTags.kflidSections, this, kfragDummySection); break; } case kfragDummySection: { vwenv.AddObjProp((int)ScrSection.ScrSectionTags.kflidHeading, this, kfragDummyStText); vwenv.AddObjProp((int)ScrSection.ScrSectionTags.kflidContent, this, kfragDummyStText); break; } case kfragDummyStText: { vwenv.AddObjVecItems((int)StText.StTextTags.kflidParagraphs, this, m_fParaWithContent ? kfragDummyParaWithContent : kfragDummyPara); break; } case kfragDummyPara: { // Display each dummy paragraph as a rectangle an inch high, which allows us // to accurately predict the height of a known number of them. vwenv.AddSimpleRect(0, MiscUtils.kdzmpInch, MiscUtils.kdzmpInch, 0); break; } case kfragDummyParaWithContent: { vwenv.OpenMappedTaggedPara(); vwenv.AddStringProp((int)StTxtPara.StTxtParaTags.kflidContents, null); vwenv.CloseParagraph(); break; } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Adds the current paragraph's contents (either once or thrice, depending on display /// flags) and then close the paragraph if necessary. /// </summary> /// <param name="vwenv">The view environment</param> /// ------------------------------------------------------------------------------------ private void AddParagraphContents(IVwEnv vwenv) { vwenv.AddStringProp(SimpleRootsiteTestsConstants.kflidParaContents, null); if ((m_displayType & DisplayType.kOnlyDisplayContentsOnce) != DisplayType.kOnlyDisplayContentsOnce) { vwenv.AddStringProp(SimpleRootsiteTestsConstants.kflidParaContents, null); vwenv.AddStringProp(SimpleRootsiteTestsConstants.kflidParaContents, null); } if ((m_displayType & DisplayType.kMappedPara) == DisplayType.kMappedPara) { 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: 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 by displaying the fake string property of that object which our special // private decorator stores for it. vwenv.AddStringProp(PossibilityVectorReferenceView.kflidFake, this); break; default: throw new ArgumentException( "Don't know what to do with the given frag.", "frag"); } }
public override void Display(IVwEnv vwenv, int hvo, int frag) { CheckDisposed(); if (m_wsDefault == -1) { // Set the underlying paragraph to RTL if the first writing system in the // string is RTL. if (m_cache != null) { ITsString tss = m_cache.MainCacheAccessor.get_StringProp(hvo, m_flid); ITsTextProps ttp = tss.get_Properties(0); int var; int ws = ttp.GetIntPropValues((int)FwTextPropType.ktptWs, out var); if (ws != 0) { SetParaRTLIfNeeded(vwenv, ws); } } vwenv.AddStringProp(m_flid, this); } else { SetParaRTLIfNeeded(vwenv, m_wsDefault); vwenv.AddStringAltMember(m_flid, m_wsDefault, this); } }
public override void Display(IVwEnv vwenv, int hvo, int frag) { switch (frag) { default: break; case HelloViewView.kfrText: vwenv.AddStringProp(HelloViewView.ktagProp, this); break; } }
public override void Display(IVwEnv vwenv, int hvo, int frag) { switch (frag) { default: break; case InterlinearView.kfrText: vwenv.OpenParagraph(); vwenv.AddObjVecItems(InterlinearView.ktagText_Words, this, InterlinearView.kfrWord); vwenv.CloseParagraph(); break; case InterlinearView.kfrWord: vwenv.set_IntProperty((int)FwKernelLib.FwTextPropType.ktptMarginTrailing, (int)FwKernelLib.FwTextPropVar.ktpvMilliPoint, 10000); vwenv.OpenInnerPile(); vwenv.AddStringProp(InterlinearView.ktagWord_Form, this); vwenv.AddStringProp(InterlinearView.ktagWord_Type, this); vwenv.CloseInnerPile(); break; } }
/// ------------------------------------------------------------------------------------ /// <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> /// All our display method does is to display the name of each item in the fake virtual property. /// If it is the active object we are editing, at the relevant position in the relevant owner, /// we display the name using the special marker property. /// </summary> /// <param name="vwenv"></param> /// <param name="hvo"></param> /// <param name="frag"></param> public override void Display(IVwEnv vwenv, int hvo, int frag) { int hvoParent, tag, ihvo; switch (frag) { case kfragName: vwenv.GetOuterObject(vwenv.EmbeddingLevel - 1, out hvoParent, out tag, out ihvo); if (m_fGotFocus && hvo == m_hvoTa && hvoParent == m_hvoParent && ihvo == m_ihvoTa) { vwenv.AddStringProp(m_taTagName, this); } else { vwenv.AddStringProp(m_snTagName, this); } break; default: throw new Exception("Unexpected fragment ID in TypeAheadSupportVc"); } }
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> /// Add a column to the header/footer /// </summary> /// <param name="vwenv"></param> /// <param name="align"></param> /// <param name="flid"></param> /// ------------------------------------------------------------------------------------ private void AddColumn(IVwEnv vwenv, FwTextAlign align, PubHeader.PubHeaderTags flid) { vwenv.OpenTableCell(1, 1); if (HeaderFooterParaStyle != null && HeaderFooterParaStyle != string.Empty) { vwenv.set_StringProperty((int)FwTextPropType.ktptNamedStyle, HeaderFooterParaStyle); } vwenv.set_IntProperty((int)FwTextPropType.ktptAlign, (int)FwTextPropVar.ktpvEnum, (int)align); vwenv.OpenMappedPara(); vwenv.AddStringProp((int)flid, this); vwenv.CloseParagraph(); vwenv.CloseTableCell(); }
/// ------------------------------------------------------------------------------------ /// <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()); }
/// ------------------------------------------------------------------------------------ /// <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(); switch (frag) { case 1: //The root is an StText, display paragraphs not lazily. vwenv.AddObjVecItems((int)StText.StTextTags.kflidParagraphs, this, 2); break; case 2: // StTxtPara, display contents vwenv.AddStringProp((int)StTxtPara.StTxtParaTags.kflidContents, null); break; default: throw new ApplicationException("Unexpected frag in SimpleViewVc"); } }
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) { switch (frag) { case AtomicReferenceView.kFragAtomicRef: // Display a paragraph with a single item. vwenv.OpenParagraph(); // vwenv.OpenMappedPara(); if (!string.IsNullOrEmpty(TextStyle)) { vwenv.set_StringProperty((int)FwTextPropType.ktptNamedStyle, TextStyle); } vwenv.AddStringProp(PossibilityAtomicReferenceView.kflidFake, this); vwenv.CloseParagraph(); break; default: throw new ArgumentException( "Don't know what to do with the given frag.", "frag"); } }
/// <summary></summary> public override void Display(IVwEnv vwenv, int hvo, int frag) { switch (frag) { case (int)SampleFrags.kfrText: if (m_fontName != null && m_fontName.Length > 0) { vwenv.set_StringProperty((int)FwTextPropType.ktptFontFamily, m_fontName); } // Force to 12 point. vwenv.set_IntProperty((int)FwTextPropType.ktptFontSize, (int)FwTextPropVar.ktpvMilliPoint, 12000); vwenv.OpenDiv(); vwenv.AddLazyVecItems((int)SampleTags.ktagTextParas, this, (int)SampleFrags.kfrPara); vwenv.CloseDiv(); break; case (int)SampleFrags.kfrPara: vwenv.AddStringProp((int)SampleTags.ktagParaContents, this); break; } }
public override void Display(IVwEnv vwenv, int hvo, int frag) { CheckDisposed(); switch (frag) { case PhoneEnvReferenceView.kFragEnvironmentObj: vwenv.AddStringProp(PhoneEnvReferenceView.kEnvStringRep, this); break; case PhoneEnvReferenceView.kFragEnvironments: vwenv.OpenParagraph(); vwenv.AddObjVec(PhoneEnvReferenceView.kMainObjEnvironments, this, frag); vwenv.CloseParagraph(); break; //case PhoneEnvReferenceView.kFragAnnotation: // break; default: throw new ArgumentException( "Don't know what to do with the given frag.", "frag"); } }
public override void Display(IVwEnv vwenv, int hvo, int frag) { if (m_fMultilingual) { SetParaRtlIfNeeded(vwenv, m_wsDefault); vwenv.AddStringAltMember(m_flid, m_wsDefault, this); } else { // Set the underlying paragraph to RTL if the first writing system in the // string is RTL. if (m_cache != null) { ITsString tss = m_cache.DomainDataByFlid.get_StringProp(hvo, m_flid); ITsTextProps ttp = tss.get_Properties(0); int var; int ws = ttp.GetIntPropValues((int)FwTextPropType.ktptWs, out var); if (ws == 0) { ws = m_wsDefault; } if (ws == 0) { ws = m_cache.DefaultAnalWs; } if (ws != 0) { SetParaRtlIfNeeded(vwenv, ws); if (m_fShowWsLabel) { DisplayWithWritingSystemLabel(vwenv, ws); return; } } } vwenv.AddStringProp(m_flid, this); } }
public override void Display(IVwEnv vwenv, int hvo, int frag) { switch (frag) { case kfragRoot: // draw a paragraph box but don't add a picture using (new VwConstructorServices.ParagraphBoxHelper(vwenv, null)) { vwenv.set_IntProperty((int)FwTextPropType.ktptMarginTrailing, (int)FwTextPropVar.ktpvMilliPoint, kmpIconMargin); vwenv.set_IntProperty((int)FwTextPropType.ktptOffset, (int)FwTextPropVar.ktpvMilliPoint, -2500); vwenv.AddPicture(m_picture.Picture, ktagPicture, 0, 0); AddParagraphBoxContents(vwenv, () => vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptIsEditable), () => vwenv.AddStringProp(SimpleRootSiteDataProviderView.kflidSimpleTsString, null)); } break; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Displays the specified vwenv. /// </summary> /// <param name="vwenv">The vwenv.</param> /// <param name="hvo">The hvo.</param> /// <param name="frag">The frag.</param> /// ------------------------------------------------------------------------------------ public override void Display(IVwEnv vwenv, int hvo, int frag) { switch (frag) { case kfragScrFootnotes: { vwenv.AddObjVecItems(ScriptureTags.kflidScriptureBooks, this, kfragBookFootnotes); break; } case kfragBookFootnotes: { vwenv.AddObjVecItems(ScrBookTags.kflidFootnotes, this, kfragFootnote); break; } case kfragFootnote: { // Display each dummy footnote as a rectangle a half inch high, which allows us // to accurately predict the height of a known number of them. Also put in a very // short editable string, which we use for some other tests, but should not // affect the paragraph height. vwenv.set_IntProperty((int)FwTextPropType.ktptMarginTop, (int)FwTextPropVar.ktpvMilliPoint, MiscUtils.kdzmpInch / 10); vwenv.set_IntProperty((int)FwTextPropType.ktptMarginBottom, (int)FwTextPropVar.ktpvMilliPoint, MiscUtils.kdzmpInch / 5); vwenv.OpenParagraph(); if (m_fWantStrings) vwenv.AddStringProp(StFootnoteTags.kflidFootnoteMarker, this); vwenv.AddSimpleRect(0, MiscUtils.kdzmpInch / 2, MiscUtils.kdzmpInch / 2, 0); vwenv.CloseParagraph(); break; } } }
/// ------------------------------------------------------------------------------------ /// <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; } }
public override void Display(IVwEnv vwenv, int hvo, int frag) { if (m_fMultilingual) { SetParaRtlIfNeeded(vwenv, m_wsDefault); vwenv.AddStringAltMember(m_flid, m_wsDefault, this); } else { // Set the underlying paragraph to RTL if the first writing system in the // string is RTL. if (m_cache != null) { ITsString tss = m_cache.DomainDataByFlid.get_StringProp(hvo, m_flid); ITsTextProps ttp = tss.get_Properties(0); int var; int ws = ttp.GetIntPropValues((int)FwTextPropType.ktptWs, out var); if (ws == 0) ws = m_wsDefault; if (ws == 0) ws = m_cache.DefaultAnalWs; if (ws != 0) { SetParaRtlIfNeeded(vwenv, ws); if (m_fShowWsLabel) { DisplayWithWritingSystemLabel(vwenv, ws); return; } } } vwenv.AddStringProp(m_flid, this); } }
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) { 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(); }
/// ------------------------------------------------------------------------------------ /// <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_displayType & DisplayType.kLiteralStringLabels) != 0) { ITsStrFactory factory = TsStrFactoryClass.Create(); vwenv.AddString(factory.MakeString("Label" + m_counter++, m_wsDefault)); } switch(frag) { case 1: // the root; display the subitems, first using non-lazy view, then lazy one. if ((m_displayType & DisplayType.kFootnoteDetailsSeparateParas) == DisplayType.kFootnoteDetailsSeparateParas) vwenv.AddObjVecItems(m_flid, this, 10); if ((m_displayType & DisplayType.kFootnoteDetailsSinglePara) == DisplayType.kFootnoteDetailsSinglePara) vwenv.AddObjVecItems(m_flid, this, 11); else { if ((m_displayType & DisplayType.kNormal) == DisplayType.kNormal) { vwenv.AddObjVecItems(m_flid, this, 3); } if ((m_displayType & DisplayType.kLazy) == DisplayType.kLazy) { vwenv.AddObjVecItems(m_flid, this, 2); } } if ((m_displayType & DisplayType.kTitle) == DisplayType.kTitle) vwenv.AddObjProp(SimpleRootsiteTestsConstants.kflidDocTitle, this, 3); if (m_displayType == DisplayType.kOuterObjDetails) vwenv.AddObjVecItems(m_flid, this, 6); break; case 2: // An StText, display paragraphs lazily if ((m_displayType & DisplayType.kWithTopMargin) == DisplayType.kWithTopMargin) vwenv.AddLazyVecItems(SimpleRootsiteTestsConstants.kflidTextParas, this, 4); vwenv.AddLazyVecItems(SimpleRootsiteTestsConstants.kflidTextParas, this, 5); break; case 3: // An StText, display paragraphs not lazily. if ((m_displayType & DisplayType.kWithTopMargin) == DisplayType.kWithTopMargin) vwenv.AddObjVecItems(SimpleRootsiteTestsConstants.kflidTextParas, this, 4); vwenv.AddObjVecItems(SimpleRootsiteTestsConstants.kflidTextParas, this, 5); if ((m_displayType & DisplayType.kDuplicateParagraphs) != 0) vwenv.AddObjVecItems(SimpleRootsiteTestsConstants.kflidTextParas, this, 5); break; case 4: // StTxtPara, display contents with top margin OpenParaIfNeeded(vwenv, hvo); vwenv.set_IntProperty((int)FwTextPropType.ktptMarginTop, (int)FwTextPropVar.ktpvMilliPoint, kMarginTop); AddParagraphContents(vwenv); break; case 5: // StTxtPara, display contents without top margin OpenParaIfNeeded(vwenv, hvo); AddParagraphContents(vwenv); break; case 6: // StTxtPara, display details of our outer object int hvoOuter, tag, ihvo; vwenv.GetOuterObject(vwenv.EmbeddingLevel - 1, out hvoOuter, out tag, out ihvo); ITsString tss = TsStringHelper.MakeTSS("Hvo = " + hvoOuter + "; Tag = " + tag + "; Ihvo = " + ihvo, m_wsDefault); vwenv.AddString(tss); break; case SimpleRootsiteTestsConstants.kflidDocDivisions: vwenv.AddObjVecItems(SimpleRootsiteTestsConstants.kflidDocDivisions, this, SimpleRootsiteTestsConstants.kflidSectionStuff); break; case SimpleRootsiteTestsConstants.kflidSectionStuff: if ((m_displayType & DisplayType.kNormal) == DisplayType.kNormal) vwenv.AddObjProp(frag, this, 3); if ((m_displayType & DisplayType.kLazy) == DisplayType.kLazy) vwenv.AddObjProp(frag, this, 2); break; case 7: // ScrBook vwenv.OpenDiv(); vwenv.AddObjVecItems(SimpleRootsiteTestsConstants.kflidDocFootnotes, this, 8); vwenv.CloseDiv(); break; case 8: // StFootnote vwenv.AddObjVecItems(SimpleRootsiteTestsConstants.kflidTextParas, this, 9); break; case 9: // StTxtPara vwenv.AddStringProp(SimpleRootsiteTestsConstants.kflidParaContents, null); break; case 10: // Display a Footnote by displaying its "FootnoteMarker" in a paragraph // by itself, followed by the sequence of paragraphs. vwenv.AddStringProp(SimpleRootsiteTestsConstants.kflidFootnoteMarker, null); vwenv.AddObjVecItems(SimpleRootsiteTestsConstants.kflidTextParas, this, 9); break; case 11: // Display a Footnote by displaying its "FootnoteMarker" followed by the // contents of its first paragraph (similar to the way footnotes are displayed in // real life. vwenv.AddObjVecItems(SimpleRootsiteTestsConstants.kflidTextParas, this, 12); break; case 12: // Footnote paragraph with marker vwenv.OpenMappedTaggedPara(); // The footnote marker is not editable. vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); vwenv.AddStringProp(SimpleRootsiteTestsConstants.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()); vwenv.AddStringProp(SimpleRootsiteTestsConstants.kflidParaContents, null); vwenv.CloseParagraph(); break; default: throw new ApplicationException("Unexpected frag in DummyBasicViewVc"); } }
private void RegurgitateIVwEnvCall(StoredMethod storedMethod) { int tag; int frag; IVwViewConstructor vc; switch (storedMethod.MethodType) { case DecoratorMethodTypes.AddObj: var hvo = (int)storedMethod.ParamArray[0]; vc = (IVwViewConstructor)storedMethod.ParamArray[1]; frag = (int)storedMethod.ParamArray[2]; m_vwEnv.AddObj(hvo, vc, frag); break; case DecoratorMethodTypes.AddObjProp: tag = (int)storedMethod.ParamArray[0]; vc = (IVwViewConstructor)storedMethod.ParamArray[1]; frag = (int)storedMethod.ParamArray[2]; m_vwEnv.AddObjProp(tag, vc, frag); break; case DecoratorMethodTypes.AddObjVec: tag = (int)storedMethod.ParamArray[0]; vc = (IVwViewConstructor)storedMethod.ParamArray[1]; frag = (int)storedMethod.ParamArray[2]; m_vwEnv.AddObjVec(tag, vc, frag); break; case DecoratorMethodTypes.AddObjVecItems: tag = (int)storedMethod.ParamArray[0]; vc = (IVwViewConstructor)storedMethod.ParamArray[1]; frag = (int)storedMethod.ParamArray[2]; m_vwEnv.AddObjVecItems(tag, vc, frag); break; case DecoratorMethodTypes.AddString: var tsStr = (ITsString)storedMethod.ParamArray[0]; m_vwEnv.AddString(tsStr); break; case DecoratorMethodTypes.AddStringProp: tag = (int)storedMethod.ParamArray[0]; vc = (IVwViewConstructor)storedMethod.ParamArray[1]; m_vwEnv.AddStringProp(tag, vc); break; case DecoratorMethodTypes.CloseParagraph: m_vwEnv.CloseParagraph(); break; case DecoratorMethodTypes.CloseTableCell: m_vwEnv.CloseTableCell(); break; case DecoratorMethodTypes.NoteDependency: var _rghvo = (int[])storedMethod.ParamArray[0]; var _rgtag = (int[])storedMethod.ParamArray[1]; var chvo = (int)storedMethod.ParamArray[2]; m_vwEnv.NoteDependency(_rghvo, _rgtag, chvo); break; case DecoratorMethodTypes.OpenParagraph: m_vwEnv.OpenParagraph(); break; case DecoratorMethodTypes.OpenTableCell: var nRows = (int)storedMethod.ParamArray[0]; var nCols = (int)storedMethod.ParamArray[1]; m_vwEnv.OpenTableCell(nRows, nCols); break; case DecoratorMethodTypes.SetIntProperty: var tpt = (int)storedMethod.ParamArray[0]; var tpv = (int)storedMethod.ParamArray[1]; var nValue = (int)storedMethod.ParamArray[2]; m_vwEnv.set_IntProperty(tpt, tpv, nValue); break; case DecoratorMethodTypes.PropsSetter: var value = (ITsTextProps)storedMethod.ParamArray[0]; m_vwEnv.Props = value; break; default: Debug.Assert(false, "Unknown DecoratorMethodType!"); break; } }
public override void Display(IVwEnv vwenv, int hvo, int frag) { // The property is absolutely arbitrary because the ghost DA ignores it. vwenv.AddStringProp(GhostStringSlice.kflidFake, this); }
/// ------------------------------------------------------------------------------------ /// <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(); switch(frag) { case 1: //The root is an StText, display paragraphs not lazily. vwenv.AddObjVecItems((int)StText.StTextTags.kflidParagraphs, this, 2); break; case 2: // StTxtPara, display contents vwenv.AddStringProp((int)StTxtPara.StTxtParaTags.kflidContents, null); break; default: throw new ApplicationException("Unexpected frag in SimpleViewVc"); } }
/// <summary></summary> public override void Display(IVwEnv vwenv, int hvo, int frag) { switch(frag) { case (int)SampleFrags.kfrText: if (m_fontName != null && m_fontName.Length > 0) vwenv.set_StringProperty((int)FwTextPropType.ktptFontFamily, m_fontName); // Force to 12 point. vwenv.set_IntProperty((int)FwTextPropType.ktptFontSize, (int)FwTextPropVar.ktpvMilliPoint, 12000); vwenv.OpenDiv(); vwenv.AddLazyVecItems((int)SampleTags.ktagTextParas, this, (int)SampleFrags.kfrPara); vwenv.CloseDiv(); break; case (int)SampleFrags.kfrPara: vwenv.AddStringProp((int)SampleTags.ktagParaContents, this); break; } }
/// <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; ITsStrFactory tsf = m_cache.TsStrFactory; 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 = tsf.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"); } }
public override void Display(IVwEnv vwenv, int hvo, int frag) { switch (frag) { default: break; case kfrBook: vwenv.set_IntProperty((int)FwKernelLib.FwTextPropType.ktptFontSize, (int)FwKernelLib.FwTextPropVar.ktpvMilliPoint, 24000); vwenv.set_IntProperty((int)FwKernelLib.FwTextPropType.ktptBold, (int)FwKernelLib.FwTextPropVar.ktpvEnum, (int)FwKernelLib.FwTextToggleVal.kttvOn); vwenv.set_IntProperty((int)FwKernelLib.FwTextPropType.ktptAlign, (int)FwKernelLib.FwTextPropVar.ktpvEnum, (int)FwKernelLib.FwTextAlign.ktalCenter); vwenv.AddStringProp(ktagBookName, this); vwenv.AddLazyVecItems(ktagBookSections, this, kfrSection); break; case kfrSection: vwenv.set_IntProperty((int)FwKernelLib.FwTextPropType.ktptItalic, (int)FwKernelLib.FwTextPropVar.ktpvEnum, (int)FwKernelLib.FwTextToggleVal.kttvOn); vwenv.OpenParagraph(); vwenv.AddStringProp(ktagSectionTitle, this); vwenv.AddString(m_tssLeftParen); vwenv.AddStringProp(ktagSectionRefs, this); vwenv.AddString(m_tssRightParen); vwenv.CloseParagraph(); vwenv.AddLazyVecItems(ktagSectionParas, this, kfrDoublePara); break; case kfrDoublePara: AddDoublePara(vwenv, hvo); // Now insert an interlinear version of the paragraph. This is basically editable. vwenv.set_IntProperty((int)FwKernelLib.FwTextPropType.ktptBackColor, (int)FwKernelLib.FwTextPropVar.ktpvDefault, m_colorEditable); vwenv.OpenParagraph(); vwenv.AddObjVecItems(ktagParaBundles, this, kfrBundle); vwenv.CloseParagraph(); break; case kfrBundle: // Put a little space after each bundle to separate them. vwenv.set_IntProperty((int)FwKernelLib.FwTextPropType.ktptMarginTrailing, (int)FwKernelLib.FwTextPropVar.ktpvMilliPoint, 5000); vwenv.OpenInnerPile(); vwenv.AddStringProp(ktagBundleBase, this); vwenv.set_IntProperty((int)FwKernelLib.FwTextPropType.ktptBold, (int)FwKernelLib.FwTextPropVar.ktpvEnum, (int)FwKernelLib.FwTextToggleVal.kttvOn); vwenv.set_IntProperty((int)FwKernelLib.FwTextPropType.ktptFontSize, (int)FwKernelLib.FwTextPropVar.ktpvMilliPoint, 13000); vwenv.AddStringProp(ktagBundleIdiom, this); vwenv.set_IntProperty((int)FwKernelLib.FwTextPropType.ktptFontSize, (int)FwKernelLib.FwTextPropVar.ktpvMilliPoint, 8000); vwenv.AddStringProp(ktagBundleLing, this); vwenv.CloseInnerPile(); break; } }
public override void Display(IVwEnv vwenv, int hvo, int frag) { CheckDisposed(); vwenv.AddStringProp(Flid, this); }
/// <summary> /// All our display method does is to display the name of each item in the fake virtual property. /// If it is the active object we are editing, at the relevant position in the relevant owner, /// we display the name using the special marker property. /// </summary> /// <param name="vwenv"></param> /// <param name="hvo"></param> /// <param name="frag"></param> public override void Display(IVwEnv vwenv, int hvo, int frag) { int hvoParent, tag, ihvo; switch(frag) { case kfragName: vwenv.GetOuterObject(vwenv.EmbeddingLevel - 1, out hvoParent, out tag, out ihvo); if (m_fGotFocus && hvo == m_hvoTa && hvoParent == m_hvoParent && ihvo == m_ihvoTa) vwenv.AddStringProp(m_taTagName, this); else vwenv.AddStringProp(m_snTagName, this); break; default: throw new Exception("Unexpected fragment ID in TypeAheadSupportVc"); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// The main method just displays the 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) { vwenv.set_IntProperty((int)FwTextPropType.ktptForeColor, (int)FwTextPropVar.ktpvDefault, (int)RGB(m_innerTextBox.ForeColor)); if (m_rtl) { vwenv.set_IntProperty((int)FwTextPropType.ktptRightToLeft, (int)FwTextPropVar.ktpvEnum, (int)FwTextToggleVal.kttvForceOn); } vwenv.set_IntProperty((int)FwTextPropType.ktptAlign, (int)FwTextPropVar.ktpvEnum, (int)m_innerTextBox.Alignment); vwenv.OpenParagraph(); vwenv.AddStringProp(InnerFwTextBox.ktagText, this); if (m_fSaveSize) { ITsString tss = vwenv.DataAccess.get_StringProp(hvo, InnerFwTextBox.ktagText); vwenv.get_StringWidth(tss, null, out m_dxWidth, out m_dyHeight); } vwenv.CloseParagraph(); }
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> /// Insert the body of a paragraph. This is normally (with fApplyProps true) the body /// of case kfrPara and kfrFootnotePara in the Display method, but some subclasses /// need to separate this from applying the properties. /// </summary> /// <param name="vwenv"></param> /// <param name="paraHvo"></param> /// <param name="frag"></param> /// <param name="fApplyProps"></param> /// <param name="contentType"></param> /// <param name="vc">The view constructor used to create the paragraphs</param> /// ------------------------------------------------------------------------------------ protected void InsertParagraphBody(IVwEnv vwenv, int paraHvo, int frag, bool fApplyProps, ContentTypes contentType, StVc vc) { vc.SetupWsAndDirectionForPara(vwenv, paraHvo); if (fApplyProps) { ApplyParagraphStyleProps(vwenv, paraHvo, vc); } // This was causing assertions in the layoutmgr // TODO (TE-5777): Should be able to do this with an in-memory stylesheet. // if (DisplayTranslation) // { // // display the back translation text as double spaced // vwenv.set_IntProperty((int)FwTextPropType.ktptLineHeight, // (int)FwTextPropVar.ktpvRelative, 20000); // } // The body of the paragraph is either editable or not. vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, vc.Editable ? (int)TptEditable.ktptIsEditable : (int)TptEditable.ktptNotEditable); // Make the paragraph containing the paragraph contents. OpenPara(vwenv, paraHvo); // Cause a regenerate when the style changes...this is mainly used for Undo. vwenv.NoteDependency(new[] { paraHvo }, new[] { StParaTags.kflidStyleRules }, 1); // Insert the label if it is the first paragraph. if (vc.Label != null) { int lev = vwenv.EmbeddingLevel; int hvoOuter; int ihvoItem; int tagOuter; vwenv.GetOuterObject(lev - 1, out hvoOuter, out tagOuter, out ihvoItem); if (ihvoItem == 0) { vwenv.AddObj(paraHvo, vc, (int)StTextFrags.kfrLabel); } } if (frag == (int)StTextFrags.kfrFootnotePara) { int lev = vwenv.EmbeddingLevel; int hvoOuter; int ihvoItem; int tagOuter; vwenv.GetOuterObject(lev - 1, out hvoOuter, out tagOuter, out ihvoItem); // Note a dependency on the footnote options so that the footnote will // be refreshed when these are changed. // If this is the 1st paragraph in the footnote... if (ihvoItem == 0) { vwenv.AddObj(hvoOuter, vc, (int)StTextFrags.kfrFootnoteMarker); vwenv.AddObj(hvoOuter, vc, (int)StTextFrags.kfrFootnoteReference); } } if (contentType == ContentTypes.kctSimpleBT) { // If a translation is being shown instead of the paragraph, then show it instead // of the text of the paragraph. vwenv.AddObj(GetTranslationForPara(paraHvo), vc, (int)StTextFrags.kfrTranslation); if (!PrintLayout) { // This dependency is here so that the "Missing" prompt will be added to the // view when the first character is typed in the contents. But to solve the // problem with losing the IP when typing (FWR-1415), the dependency is not // added in print layout views. The missing prompt seems less of a problem // than the problem with typing. vwenv.NoteDependency(new[] { paraHvo }, new[] { StTxtParaTags.kflidContents }, 1); } } else if (contentType == ContentTypes.kctSegmentBT) { vwenv.AddObjVecItems(StTxtParaTags.kflidSegments, vc, (int)StTextFrags.kfrSegmentFreeTranslations); } else if (!InsertParaContentsUserPrompt(vwenv, paraHvo)) { // Display the text paragraph contents, or its user prompt. vwenv.AddStringProp(StTxtParaTags.kflidContents, null); } // Display an "end-of-paragraph" marker if needed InsertEndOfParaMarks(vwenv, paraHvo); vwenv.CloseParagraph(); }
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(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Displays the specified vwenv. /// </summary> /// <param name="vwenv">The vwenv.</param> /// <param name="hvo">The hvo.</param> /// <param name="frag">The frag.</param> /// ------------------------------------------------------------------------------------ public override void Display(IVwEnv vwenv, int hvo, int frag) { CheckDisposed(); switch(frag) { case kfragLazyScripture: { // The configure method insists on trying to make an initial selection. // If there isn't something selectable there, it expands everything. vwenv.AddStringProp((int)Scripture.ScriptureTags.kflidChapterVerseSepr, this); vwenv.AddLazyVecItems((int)Scripture.ScriptureTags.kflidScriptureBooks, this, kfragLazyBook); break; } case kfragLazyBook: { vwenv.AddLazyVecItems((int)ScrBook.ScrBookTags.kflidSections, this, kfragDummySection); break; } case kfragDummySection: { vwenv.AddObjProp((int)ScrSection.ScrSectionTags.kflidHeading, this, kfragDummyStText); vwenv.AddObjProp((int)ScrSection.ScrSectionTags.kflidContent, this, kfragDummyStText); break; } case kfragDummyStText: { vwenv.AddObjVecItems((int)StText.StTextTags.kflidParagraphs, this, m_fParaWithContent ? kfragDummyParaWithContent : kfragDummyPara); break; } case kfragDummyPara: { // Display each dummy paragraph as a rectangle an inch high, which allows us // to accurately predict the height of a known number of them. vwenv.AddSimpleRect(0, MiscUtils.kdzmpInch, MiscUtils.kdzmpInch, 0); break; } case kfragDummyParaWithContent: { vwenv.OpenMappedTaggedPara(); vwenv.AddStringProp((int)StTxtPara.StTxtParaTags.kflidContents, null); vwenv.CloseParagraph(); break; } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// This is the main interesting method of displaying objects and fragments of them. /// Scripture Footnotes are displayed by displaying each footnote's reference and text. /// The text is displayed using the standard view constructor for StText. /// </summary> /// <param name="vwenv"></param> /// <param name="hvo"></param> /// <param name="frag"></param> /// ------------------------------------------------------------------------------------ public override void Display(IVwEnv vwenv, int hvo, int frag) { switch (frag) { case (int)StTextFrags.kfrFootnote: { // FWR-1640: Make the sequence of footnote paragraphs non-editable // since we only allow one para per footnote. This will cause // pasting multiple paragraphs to work correctly. vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); base.Display(vwenv, hvo, frag); break; } case (int)FootnoteFrags.kfrScripture: { vwenv.NoteDependency(new int[] { m_cache.LanguageProject.TranslatedScriptureOA.Hvo }, new int[] { (int)ScriptureTags.kflidScriptureBooks }, 1); vwenv.AddLazyVecItems(BooksTag, this, (int)FootnoteFrags.kfrBook); break; } case (int)FootnoteFrags.kfrRootInPageSeq: { vwenv.AddObjVec(ScrBookTags.kflidFootnotes, this, (int)FootnoteFrags.kfrAllFootnotesWithinPagePara); break; } case (int)FootnoteFrags.kfrFootnoteWithinPagePara: { // Insert the marker and reference vwenv.AddObj(hvo, this, (int)StTextFrags.kfrFootnoteMarker); vwenv.AddObj(hvo, this, (int)StTextFrags.kfrFootnoteReference); // Insert (we hope only one) paragraph contents. vwenv.AddObjVecItems(StTextTags.kflidParagraphs, this, (int)FootnoteFrags.kfrFootnoteParaWithinPagePara); break; } case (int)FootnoteFrags.kfrFootnoteParaWithinPagePara: { if (!InsertParaContentsUserPrompt(vwenv, hvo)) { // Display the text paragraph contents, or its user prompt. vwenv.AddStringProp(StTxtParaTags.kflidContents, null); } break; } case (int)FootnoteFrags.kfrBook: { vwenv.OpenDiv(); vwenv.AddObjVecItems(ScrBookTags.kflidFootnotes, this, (int)StTextFrags.kfrFootnote); vwenv.CloseDiv(); break; } case (int)StTextFrags.kfrFootnoteReference: { DisplayFootnoteReference(vwenv, hvo); break; } default: base.Display(vwenv, hvo, frag); break; } }
private void DisplayMorphForm(IVwEnv vwenv, int hvo, int frag, int ws, int choiceIndex) { int hvoMorphForm = vwenv.DataAccess.get_ObjectProp(hvo, ktagSbMorphForm); // Allow editing of the morpheme breakdown line. SetColor(vwenv, m_choices.LabelRGBFor(choiceIndex)); // On this line we want an icon only for the first column (and only if it is the first // occurrence of the flid). bool fWantIcon = m_fIsMorphemeFormEditable && (frag == kfragFirstMorph) && m_choices.IsFirstOccurrenceOfFlid(choiceIndex); if (!fWantIcon) SetIndentForMissingIcon(vwenv); vwenv.OpenParagraph(); bool fFirstMorphLine = (m_choices.IndexOf(InterlinLineChoices.kflidMorphemes) == choiceIndex); if (fWantIcon) // Review JohnT: should we do the 'edit box' for all first columns? { AddPullDownIcon(vwenv, ktagMorphFormIcon); // Create an edit box that stays visible when the user deletes // the first morpheme (like the WordGloss box). // This is especially useful if the user wants to // delete the entire MorphForm line (cf. LT-1621). vwenv.set_IntProperty((int)FwTextPropType.ktptMarginTrailing, (int)FwTextPropVar.ktpvMilliPoint, kmpIconMargin); vwenv.set_IntProperty((int)FwTextPropType.ktptPadTrailing, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.set_IntProperty((int)FwTextPropType.ktptPadLeading, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.set_IntProperty((int)FwTextPropType.ktptBackColor, (int)FwTextPropVar.ktpvDefault, krgbEditable); } // Per LT-14891, morpheme form is not editable except for the default vernacular. if (m_fIsMorphemeFormEditable && m_choices.IsFirstOccurrenceOfFlid(choiceIndex)) MakeNextFlowObjectEditable(vwenv); else MakeNextFlowObjectReadOnly(vwenv); vwenv.OpenInnerPile(); vwenv.OpenParagraph(); if (fFirstMorphLine) vwenv.AddStringProp(ktagSbMorphPrefix, this); // This is never missing, but may, or may not, be editable. vwenv.AddObjProp(ktagSbMorphForm, this, kfragNamedObjectNameChoices + choiceIndex); if (fFirstMorphLine) vwenv.AddStringProp(ktagSbMorphPostfix, this); // close the special edit box we opened for the first morpheme. vwenv.CloseParagraph(); vwenv.CloseInnerPile(); vwenv.CloseParagraph(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// This is the main interesting method of displaying objects and fragments of them. /// Scripture Footnotes are displayed by displaying each footnote's reference and text. /// The text is displayed using the standard view constructor for StText. /// </summary> /// <param name="vwenv"></param> /// <param name="hvo"></param> /// <param name="frag"></param> /// ------------------------------------------------------------------------------------ public override void Display(IVwEnv vwenv, int hvo, int frag) { switch (frag) { case (int)StTextFrags.kfrFootnote: { // FWR-1640: Make the sequence of footnote paragraphs non-editable // since we only allow one para per footnote. This will cause // pasting multiple paragraphs to work correctly. vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); base.Display(vwenv, hvo, frag); break; } case (int)FootnoteFrags.kfrScripture: { vwenv.NoteDependency(new int[] { m_cache.LanguageProject.TranslatedScriptureOA.Hvo }, new int[] { (int)ScriptureTags.kflidScriptureBooks }, 1); vwenv.AddLazyVecItems(BooksTag, this, (int)FootnoteFrags.kfrBook); break; } case (int)FootnoteFrags.kfrRootInPageSeq: { vwenv.AddObjVec(ScrBookTags.kflidFootnotes, this, (int)FootnoteFrags.kfrAllFootnotesWithinPagePara); break; } case (int)FootnoteFrags.kfrFootnoteWithinPagePara: { // Insert the marker and reference vwenv.AddObj(hvo, this, (int)StTextFrags.kfrFootnoteMarker); vwenv.AddObj(hvo, this,(int)StTextFrags.kfrFootnoteReference); // Insert (we hope only one) paragraph contents. vwenv.AddObjVecItems(StTextTags.kflidParagraphs, this, (int)FootnoteFrags.kfrFootnoteParaWithinPagePara); break; } case (int) FootnoteFrags.kfrFootnoteParaWithinPagePara: { if (!InsertParaContentsUserPrompt(vwenv, hvo)) { // Display the text paragraph contents, or its user prompt. vwenv.AddStringProp(StTxtParaTags.kflidContents, null); } break; } case (int)FootnoteFrags.kfrBook: { vwenv.OpenDiv(); vwenv.AddObjVecItems(ScrBookTags.kflidFootnotes, this, (int)StTextFrags.kfrFootnote); vwenv.CloseDiv(); break; } case (int)StTextFrags.kfrFootnoteReference: { DisplayFootnoteReference(vwenv, hvo); break; } default: base.Display(vwenv, hvo, frag); break; } }
public override void Display(IVwEnv vwenv, int hvo, int frag) { CheckDisposed(); vwenv.AddStringProp(m_flidGhost, this); }
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) { CheckDisposed(); if (m_wsDefault == -1) { // Set the underlying paragraph to RTL if the first writing system in the // string is RTL. if (m_cache != null) { ITsString tss = m_cache.MainCacheAccessor.get_StringProp(hvo, m_flid); ITsTextProps ttp = tss.get_Properties(0); int var; int ws = ttp.GetIntPropValues((int)FwTextPropType.ktptWs, out var); if (ws != 0) SetParaRTLIfNeeded(vwenv, ws); } vwenv.AddStringProp(m_flid, this); } else { SetParaRTLIfNeeded(vwenv, m_wsDefault); vwenv.AddStringAltMember(m_flid, m_wsDefault, this); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Adds the current paragraph's contents. /// </summary> /// <param name="vwenv">The view environment</param> /// <param name="setParagraphProps"></param> /// ------------------------------------------------------------------------------------ private void AddParagraphBoxContents(IVwEnv vwenv, Action setParagraphProps) { AddParagraphBoxContents(vwenv, setParagraphProps, () => vwenv.AddStringProp(SimpleRootSiteDataProviderView.kflidSimpleTsString, null)); }
/// ------------------------------------------------------------------------------------ /// <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_displayType & DisplayType.kLiteralStringLabels) != 0) { ITsStrFactory factory = TsStrFactoryClass.Create(); vwenv.AddString(factory.MakeString("Label" + m_counter++, m_wsDefault)); } switch (frag) { case 1: // the root; display the subitems, first using non-lazy view, then lazy one. if ((m_displayType & DisplayType.kBookFootnoteDetailsSeparateParas) == DisplayType.kBookFootnoteDetailsSeparateParas) { vwenv.AddObjVecItems(m_flid, this, 10); } if ((m_displayType & DisplayType.kBookFootnoteDetailsSinglePara) == DisplayType.kBookFootnoteDetailsSinglePara) { vwenv.AddObjVecItems(m_flid, this, 11); } else { if ((m_displayType & DisplayType.kNormal) == DisplayType.kNormal) { vwenv.AddObjVecItems(m_flid, this, 3); } if ((m_displayType & DisplayType.kLazy) == DisplayType.kLazy) { vwenv.AddObjVecItems(m_flid, this, 2); } } if ((m_displayType & DisplayType.kBookTitle) == DisplayType.kBookTitle) { vwenv.AddObjProp(ScrBookTags.kflidTitle, this, 3); } if (m_displayType == DisplayType.kOuterObjDetails) { vwenv.AddObjVecItems(m_flid, this, 6); } break; case 2: // An StText, display paragraphs lazily if ((m_displayType & DisplayType.kWithTopMargin) == DisplayType.kWithTopMargin) { vwenv.AddLazyVecItems(StTextTags.kflidParagraphs, this, 4); } vwenv.AddLazyVecItems(StTextTags.kflidParagraphs, this, 5); break; case 3: // An StText, display paragraphs not lazily. if ((m_displayType & DisplayType.kWithTopMargin) == DisplayType.kWithTopMargin) { vwenv.AddObjVecItems(StTextTags.kflidParagraphs, this, 4); } vwenv.AddObjVecItems(StTextTags.kflidParagraphs, this, 5); if ((m_displayType & DisplayType.kDuplicateParagraphs) != 0) { vwenv.AddObjVecItems(StTextTags.kflidParagraphs, this, 5); } break; case 4: // StTxtPara, display contents with top margin if ((m_displayType & DisplayType.kMappedPara) == DisplayType.kMappedPara) { vwenv.OpenMappedPara(); } vwenv.set_IntProperty((int)FwTextPropType.ktptMarginTop, (int)FwTextPropVar.ktpvMilliPoint, kMarginTop); vwenv.AddStringProp(StTxtParaTags.kflidContents, null); vwenv.AddStringProp(StTxtParaTags.kflidContents, null); vwenv.AddStringProp(StTxtParaTags.kflidContents, null); if ((m_displayType & DisplayType.kMappedPara) == DisplayType.kMappedPara) { vwenv.CloseParagraph(); } break; case 5: // StTxtPara, display contents without top margin //vwenv.set_IntProperty((int)FwTextPropType.ktptFontSize, // (int)FwTextPropVar.ktpvMilliPoint, 15000); if ((m_displayType & DisplayType.kMappedPara) == DisplayType.kMappedPara) { vwenv.OpenMappedPara(); } vwenv.AddStringProp(StTxtParaTags.kflidContents, null); vwenv.AddStringProp(StTxtParaTags.kflidContents, null); vwenv.AddStringProp(StTxtParaTags.kflidContents, null); if ((m_displayType & DisplayType.kMappedPara) == DisplayType.kMappedPara) { vwenv.CloseParagraph(); } break; case 6: // StTxtPara, display details of our outer object int hvoOuter, tag, ihvo; vwenv.GetOuterObject(vwenv.EmbeddingLevel - 1, out hvoOuter, out tag, out ihvo); ITsString tss = TsStringHelper.MakeTSS("Hvo = " + hvoOuter + "; Tag = " + tag + "; Ihvo = " + ihvo, m_wsDefault); vwenv.AddString(tss); break; case ScrBookTags.kflidSections: vwenv.AddObjVecItems(ScrBookTags.kflidSections, this, ScrSectionTags.kflidContent); break; case ScrSectionTags.kflidHeading: case ScrSectionTags.kflidContent: if ((m_displayType & DisplayType.kNormal) == DisplayType.kNormal) { vwenv.AddObjProp(frag, this, 3); } if ((m_displayType & DisplayType.kLazy) == DisplayType.kLazy) { vwenv.AddObjProp(frag, this, 2); } break; case 7: // ScrBook vwenv.OpenDiv(); vwenv.AddObjVecItems(ScrBookTags.kflidFootnotes, this, 8); vwenv.CloseDiv(); break; case 8: // StFootnote vwenv.AddObjVecItems(StTextTags.kflidParagraphs, this, 9); break; case 9: // StTxtPara vwenv.AddStringProp(StTxtParaTags.kflidContents, null); break; case 10: // Display a Footnote by displaying its "FootnoteMarker" in a paragraph // by itself, followed by the sequence of paragraphs. vwenv.AddStringProp(StFootnoteTags.kflidFootnoteMarker, null); vwenv.AddObjVecItems(StTextTags.kflidParagraphs, this, 9); break; case 11: // Display a Footnote by displaying its "FootnoteMarker" followed by the // contents of its first paragraph (similar to the way footnotes are displayed in // real life. vwenv.AddObjVecItems(StTextTags.kflidParagraphs, this, 12); break; case 12: // Footnote paragraph with marker vwenv.OpenMappedTaggedPara(); // The footnote marker is not editable. vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); // add a read-only space after the footnote marker vwenv.set_IntProperty((int)FwTextPropType.ktptEditable, (int)FwTextPropVar.ktpvEnum, (int)TptEditable.ktptNotEditable); ITsStrFactory strFactory = TsStrFactoryClass.Create(); vwenv.AddString(strFactory.MakeString(" ", DefaultWs)); vwenv.AddStringProp(StTxtParaTags.kflidContents, null); vwenv.CloseParagraph(); break; default: throw new ApplicationException("Unexpected frag in DummyBasicViewVc"); } }
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> /// 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) { 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"); } }
/// <summary> /// The hvo is for a Wfic (CmBaseAnnotation). /// </summary> /// <param name="vwenv"></param> /// <param name="hvoWfic"></param> internal override void AddExtraTwficRows(IVwEnv vwenv, int hvoWfic) { SetTrailingAlignmentIfNeeded(vwenv, hvoWfic); vwenv.AddStringProp(TextTagAnnotFlid, this); }
/// <summary> /// Displays Analysis using DisplayWordBundleMethod and closes the views Inner Pile. /// </summary> /// <param name="vwenv"></param> /// <param name="analysisOccurrence"></param> /// <param name="showMultipleAnalyses">Tells DisplayWordBundleMethod whether or not to show /// the colored highlighting if a word has multiple analyses</param> protected void DisplayAnalysisAndCloseInnerPile(IVwEnv vwenv, AnalysisOccurrence analysisOccurrence, bool showMultipleAnalyses) { // if it is just a punctuation annotation, we just insert the form. var analysis = analysisOccurrence.Analysis; if (analysis is IPunctuationForm) { vwenv.AddStringProp(PunctuationFormTags.kflidForm, this); } else { // It's a full wordform-possessing annotation, display the full bundle. new DisplayWordBundleMethod(vwenv, analysisOccurrence, this).Run(showMultipleAnalyses); } AddExtraBundleRows(vwenv, analysisOccurrence); vwenv.CloseInnerPile(); }
/// <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"); } }
private void DisplayMorphForm(IVwEnv vwenv, int hvo, int frag, int ws, int choiceIndex) { int hvoMorphForm = vwenv.DataAccess.get_ObjectProp(hvo, ktagSbMorphForm); // Allow editing of the morpheme breakdown line. SetColor(vwenv, m_choices.LabelRGBFor(choiceIndex)); // On this line we want an icon only for the first column (and only if it is the first // occurrence of the flid). bool fWantIcon = m_fIsMorphemeFormEditable && (frag == kfragFirstMorph) && m_choices.IsFirstOccurrenceOfFlid(choiceIndex); if (!fWantIcon) { SetIndentForMissingIcon(vwenv); } vwenv.OpenParagraph(); bool fFirstMorphLine = (m_choices.IndexOf(InterlinLineChoices.kflidMorphemes) == choiceIndex); if (fWantIcon) // Review JohnT: should we do the 'edit box' for all first columns? { AddPullDownIcon(vwenv, ktagMorphFormIcon); // Create an edit box that stays visible when the user deletes // the first morpheme (like the WordGloss box). // This is especially useful if the user wants to // delete the entire MorphForm line (cf. LT-1621). vwenv.set_IntProperty((int)FwTextPropType.ktptMarginTrailing, (int)FwTextPropVar.ktpvMilliPoint, kmpIconMargin); vwenv.set_IntProperty((int)FwTextPropType.ktptPadTrailing, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.set_IntProperty((int)FwTextPropType.ktptPadLeading, (int)FwTextPropVar.ktpvMilliPoint, 2000); vwenv.set_IntProperty((int)FwTextPropType.ktptBackColor, (int)FwTextPropVar.ktpvDefault, krgbEditable); } if (m_fIsMorphemeFormEditable) { MakeNextFlowObjectEditable(vwenv); } else { MakeNextFlowObjectReadOnly(vwenv); } vwenv.OpenInnerPile(); vwenv.OpenParagraph(); if (fFirstMorphLine) { vwenv.AddStringProp(ktagSbMorphPrefix, this); } // This is never missing, but may, or may not, be editable. vwenv.AddObjProp(ktagSbMorphForm, this, kfragNamedObjectNameChoices + choiceIndex); if (fFirstMorphLine) { vwenv.AddStringProp(ktagSbMorphPostfix, this); } // close the special edit box we opened for the first morpheme. vwenv.CloseParagraph(); vwenv.CloseInnerPile(); vwenv.CloseParagraph(); }
/// ----------------------------------------------------------------------------------- /// <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"); } }
/// ------------------------------------------------------------------------------------ /// <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; } }