/// ----------------------------------------------------------------------------------- /// <summary> /// This version knows how to display a generic date as a string. /// </summary> /// ----------------------------------------------------------------------------------- public override ITsString DisplayVariant(IVwEnv vwenv, int tag, int frag) { if (vwenv.DataAccess.MetaDataCache.GetFieldType(tag) == (int)CellarPropertyType.GenDate) { // handle generic date. Because the actual GenDate struct is not available to // Views code, we have to handle the display of the GenDate here var sda = vwenv.DataAccess as ISilDataAccessManaged; Debug.Assert(sda != null); var genDate = sda.get_GenDateProp(vwenv.CurrentObject(), tag); var tsf = TsStrFactoryClass.Create(); string str = ""; switch (frag) { case kfragGenDateLong: str = genDate.ToLongString(); break; case kfragGenDateShort: str = genDate.ToShortString(); break; case kfragGenDateSort: str = genDate.ToSortString(); break; } return(tsf.MakeString(str, sda.WritingSystemFactory.UserWs)); } else { return(base.DisplayVariant(vwenv, tag, frag)); } }
public override ITsString DisplayVariant(IVwEnv vwenv, int tag, int frag) { // we use display variant to display literal strings that are editable ITsString tss; switch (frag) { case kfragFeatureLine: var value = m_cache.ServiceLocator.GetInstance <IFsClosedValueRepository>().GetObject(vwenv.CurrentObject()); tss = CreateFeatureLine(value); break; case kfragPlusVariableLine: case kfragMinusVariableLine: var var = m_cache.ServiceLocator.GetInstance <IPhFeatureConstraintRepository>().GetObject(vwenv.CurrentObject()); tss = CreateVariableLine(var, frag == kfragPlusVariableLine); break; case kfragIterCtxtMax: // if the max value is -1, it indicates that it is infinite int i = m_cache.DomainDataByFlid.get_IntProp(vwenv.CurrentObject(), tag); tss = i == -1 ? m_infinity : TsStringUtils.MakeString(Convert.ToString(i), m_cache.DefaultUserWs); break; case kfragXVariable: tss = m_x; break; default: tss = base.DisplayVariant(vwenv, tag, frag); break; } return(tss); }
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; } } }
public override ITsString DisplayVariant(IVwEnv vwenv, int tag, int frag) { // we use display variant to display literal strings that are editable ITsString tss = null; switch (frag) { case kfragFeatureLine: ComplexConcPatternNode node = ((ComplexConcPatternSda)vwenv.DataAccess).Nodes[vwenv.CurrentObject()]; switch (tag) { case ktagType: string typeStr = null; if (node is ComplexConcMorphNode) { typeStr = ITextStrings.ksComplexConcMorph; } else if (node is ComplexConcWordNode) { typeStr = ITextStrings.ksComplexConcWord; } else if (node is ComplexConcTagNode) { typeStr = ITextStrings.ksComplexConcTag; } tss = CreateFeatureLine(ITextStrings.ksComplexConcType, typeStr, m_cache.DefaultUserWs); break; case ktagForm: ITsString form = null; var formMorphNode = node as ComplexConcMorphNode; if (formMorphNode != null) { form = formMorphNode.Form; } else { var formWordNode = node as ComplexConcWordNode; if (formWordNode != null) { form = formWordNode.Form; } } Debug.Assert(form != null); tss = CreateFeatureLine(ITextStrings.ksComplexConcForm, form, false); break; case ktagEntry: ITsString entry = null; var entryMorphNode = node as ComplexConcMorphNode; if (entryMorphNode != null) { entry = entryMorphNode.Entry; } Debug.Assert(entry != null); tss = CreateFeatureLine(ITextStrings.ksComplexConcEntry, entry, false); break; case ktagGloss: ITsString gloss = null; var glossMorphNode = node as ComplexConcMorphNode; if (glossMorphNode != null) { gloss = glossMorphNode.Gloss; } else { var glossWordNode = node as ComplexConcWordNode; if (glossWordNode != null) { gloss = glossWordNode.Gloss; } } Debug.Assert(gloss != null); tss = CreateFeatureLine(ITextStrings.ksComplexConcGloss, gloss, false); break; case ktagCategory: IPartOfSpeech category = null; bool catNegated = false; var catMorphNode = node as ComplexConcMorphNode; if (catMorphNode != null) { category = catMorphNode.Category; catNegated = catMorphNode.NegateCategory; } else { var catWordNode = node as ComplexConcWordNode; if (catWordNode != null) { category = catWordNode.Category; catNegated = catWordNode.NegateCategory; } } Debug.Assert(category != null); tss = CreateFeatureLine(ITextStrings.ksComplexConcCategory, category.Abbreviation.BestAnalysisAlternative, catNegated); break; case ktagTag: ICmPossibility tagPoss = null; var tagNode = node as ComplexConcTagNode; if (tagNode != null) { tagPoss = tagNode.Tag; } Debug.Assert(tagPoss != null); tss = CreateFeatureLine(ITextStrings.ksComplexConcTag, tagPoss.Abbreviation.BestAnalysisAlternative, false); break; case ktagInfl: tss = CreateFeatureLine(ITextStrings.ksComplexConcInflFeatures, null, false); break; default: IFsFeatDefn feature = m_curInflFeatures.Keys.Single(f => f.Hvo == tag); if (feature is IFsComplexFeature) { tss = CreateFeatureLine(feature.Abbreviation.BestAnalysisAlternative, null, false); } else if (feature is IFsClosedFeature) { var value = (ClosedFeatureValue)m_curInflFeatures[feature]; tss = CreateFeatureLine(feature.Abbreviation.BestAnalysisAlternative, value.Symbol.Abbreviation.BestAnalysisAlternative, value.Negate); } break; } break; case kfragNodeMax: // if the max value is -1, it indicates that it is infinite ComplexConcPatternNode node1 = ((ComplexConcPatternSda)vwenv.DataAccess).Nodes[vwenv.CurrentObject()]; tss = node1.Maximum == -1 ? m_infinity : m_cache.TsStrFactory.MakeString(node1.Maximum.ToString(CultureInfo.InvariantCulture), m_cache.DefaultUserWs); break; case kfragNodeMin: ComplexConcPatternNode node2 = ((ComplexConcPatternSda)vwenv.DataAccess).Nodes[vwenv.CurrentObject()]; tss = m_cache.TsStrFactory.MakeString(node2.Minimum.ToString(CultureInfo.InvariantCulture), m_cache.DefaultUserWs); break; case kfragOR: tss = m_or; break; case kfragHash: tss = m_hash; break; default: tss = base.DisplayVariant(vwenv, tag, frag); break; } return(tss); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Add a user prompt for an empty paragraph. /// </summary> /// <param name="vwenv">View environment</param> /// <param name="tag">Tag</param> /// <param name="frag">Fragment to identify what type of prompt should be created.</param> /// <returns>ITsString that will be displayed as user prompt.</returns> /// ------------------------------------------------------------------------------------ public override ITsString DisplayVariant(IVwEnv vwenv, int tag, int frag) { string userPrompt = null; Color promptColor = Color.LightGray; int promptWs = Cache.DefaultUserWs; switch (frag) { case ScrBookTags.kflidTitle: ICmObject obj = Cache.ServiceLocator.GetInstance<ICmObjectRepository>().GetObject(vwenv.CurrentObject()); IScrBook book = obj.Owner.Owner as IScrBook; userPrompt = string.Format(TeResourceHelper.GetResourceString("kstidBookTitleUserPrompt"), book.Name.UserDefaultWritingSystem.Text); break; case ScrSectionTags.kflidHeading: userPrompt = TeResourceHelper.GetResourceString("kstidSectionHeadUserPrompt"); break; case CmTranslationTags.kflidTranslation: if (!PrintLayout && Editable) userPrompt = TeResourceHelper.GetResourceString("kstidBackTranslationUserPrompt"); else userPrompt = TeResourceHelper.GetResourceString("kstidBackTranslationUserPromptPrintLayout"); break; case SegmentTags.kflidFreeTranslation: // A missing BT of a segment in an interlinear draft back translation. if (!PrintLayout && Editable) { // There are typically several of these in a paragraph so we want to be subtle. // Also we have a difference of colors: this view has a subtle BG color to show everything // except the BTs is non-editable. The prompt needs to be white to show it IS editable. userPrompt = "\xA0\xA0\xA0"; // Three non-breaking spaces (trying not altogether successfully to prevent disappearing at margin) promptColor = SystemColors.Window; } else { userPrompt = TeResourceHelper.GetResourceString("kstidBackTranslationUserPromptPrintLayout"); } break; default: Debug.Assert(false, "DisplayVariant called with unexpected fragment"); break; } if (userPrompt == null) userPrompt = string.Empty; ITsPropsBldr ttpBldr = TsPropsBldrClass.Create(); ttpBldr.SetIntPropValues((int)FwTextPropType.ktptBackColor, (int) FwTextPropVar.ktpvDefault, (int)ColorUtil.ConvertColorToBGR(promptColor)); ttpBldr.SetIntPropValues((int)FwTextPropType.ktptWs, (int) FwTextPropVar.ktpvDefault, promptWs); // The use of the user-defined property here is to indicate that this is a // user prompt string. ttpBldr.SetIntPropValues(SimpleRootSite.ktptUserPrompt, (int)FwTextPropVar.ktpvDefault, 1); ttpBldr.SetIntPropValues((int)FwTextPropType.ktptSpellCheck, (int)FwTextPropVar.ktpvEnum, (int)SpellingModes.ksmDoNotCheck); ITsStrBldr bldr = TsStrBldrClass.Create(); bldr.Replace(0, 0, userPrompt, ttpBldr.GetTextProps()); // Begin the prompt with a zero-width space in the view's default writing system. // 200B == zero-width space. // This helps select the correct keyboard when the user selects the user prompt and // begins typing. Also prevent the DoNotSpellCheck and back color being applied // to what is typed. ITsPropsBldr ttpBldr2 = TsPropsBldrClass.Create(); ttpBldr2.SetIntPropValues((int)FwTextPropType.ktptWs, (int)FwTextPropVar.ktpvDefault, m_wsDefault); ttpBldr2.SetIntPropValues(SimpleRootSite.ktptUserPrompt, (int)FwTextPropVar.ktpvDefault, 1); bldr.Replace(0, 0, "\u200B", ttpBldr2.GetTextProps()); return bldr.GetString(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Add a user prompt for an empty paragraph. /// </summary> /// <param name="vwenv">View environment</param> /// <param name="tag">Tag</param> /// <param name="frag">Fragment to identify what type of prompt should be created.</param> /// <returns>ITsString that will be displayed as user prompt.</returns> /// ------------------------------------------------------------------------------------ public override ITsString DisplayVariant(IVwEnv vwenv, int tag, int frag) { string userPrompt = null; Color promptColor = Color.LightGray; int promptWs = Cache.DefaultUserWs; switch (frag) { case ScrBookTags.kflidTitle: ICmObject obj = Cache.ServiceLocator.GetInstance <ICmObjectRepository>().GetObject(vwenv.CurrentObject()); IScrBook book = obj.Owner.Owner as IScrBook; userPrompt = string.Format(TeResourceHelper.GetResourceString("kstidBookTitleUserPrompt"), book.Name.UserDefaultWritingSystem.Text); break; case ScrSectionTags.kflidHeading: userPrompt = TeResourceHelper.GetResourceString("kstidSectionHeadUserPrompt"); break; case CmTranslationTags.kflidTranslation: if (!PrintLayout && Editable) { userPrompt = TeResourceHelper.GetResourceString("kstidBackTranslationUserPrompt"); } else { userPrompt = TeResourceHelper.GetResourceString("kstidBackTranslationUserPromptPrintLayout"); } break; case SegmentTags.kflidFreeTranslation: // A missing BT of a segment in an interlinear draft back translation. if (!PrintLayout && Editable) { // There are typically several of these in a paragraph so we want to be subtle. // Also we have a difference of colors: this view has a subtle BG color to show everything // except the BTs is non-editable. The prompt needs to be white to show it IS editable. userPrompt = "\xA0\xA0\xA0"; // Three non-breaking spaces (trying not altogether successfully to prevent disappearing at margin) promptColor = SystemColors.Window; } else { userPrompt = TeResourceHelper.GetResourceString("kstidBackTranslationUserPromptPrintLayout"); } break; default: Debug.Assert(false, "DisplayVariant called with unexpected fragment"); break; } if (userPrompt == null) { userPrompt = string.Empty; } ITsPropsBldr ttpBldr = TsPropsBldrClass.Create(); ttpBldr.SetIntPropValues((int)FwTextPropType.ktptBackColor, (int)FwTextPropVar.ktpvDefault, (int)ColorUtil.ConvertColorToBGR(promptColor)); ttpBldr.SetIntPropValues((int)FwTextPropType.ktptWs, (int)FwTextPropVar.ktpvDefault, promptWs); // The use of the user-defined property here is to indicate that this is a // user prompt string. ttpBldr.SetIntPropValues(SimpleRootSite.ktptUserPrompt, (int)FwTextPropVar.ktpvDefault, 1); ttpBldr.SetIntPropValues((int)FwTextPropType.ktptSpellCheck, (int)FwTextPropVar.ktpvEnum, (int)SpellingModes.ksmDoNotCheck); ITsStrBldr bldr = TsStrBldrClass.Create(); bldr.Replace(0, 0, userPrompt, ttpBldr.GetTextProps()); // Begin the prompt with a zero-width space in the view's default writing system. // 200B == zero-width space. // This helps select the correct keyboard when the user selects the user prompt and // begins typing. Also prevent the DoNotSpellCheck and back color being applied // to what is typed. ITsPropsBldr ttpBldr2 = TsPropsBldrClass.Create(); ttpBldr2.SetIntPropValues((int)FwTextPropType.ktptWs, (int)FwTextPropVar.ktpvDefault, m_wsDefault); ttpBldr2.SetIntPropValues(SimpleRootSite.ktptUserPrompt, (int)FwTextPropVar.ktpvDefault, 1); bldr.Replace(0, 0, "\u200B", ttpBldr2.GetTextProps()); return(bldr.GetString()); }
public override ITsString DisplayVariant(IVwEnv vwenv, int tag, object v, int frag) { CheckDisposed(); // we use display variant to display literal strings that are editable ITsString tss = null; switch (frag) { case kfragEmpty: tss = m_empty; break; case kfragFeatureLine: IFsClosedValue value = new FsClosedValue(m_cache, vwenv.CurrentObject()); tss = CreateFeatureLine(value); break; case kfragPlusVariableLine: case kfragMinusVariableLine: IPhFeatureConstraint var = new PhFeatureConstraint(m_cache, vwenv.CurrentObject()); tss = CreateVariableLine(var, frag == kfragPlusVariableLine); break; case kfragIterCtxtMax: // if the max value is -1, it indicates that it is infinite int i = (int)v; if (i == -1) { tss = m_infinity; } else { tss = m_cache.MakeUserTss(Convert.ToString(i)); } break; case kfragLeftBracketUpHook: tss = m_leftBracketUpHook; break; case kfragLeftBracketExt: tss = m_leftBracketExt; break; case kfragLeftBracketLowHook: tss = m_leftBracketLowHook; break; case kfragRightBracketUpHook: tss = m_rightBracketUpHook; break; case kfragRightBracketExt: tss = m_rightBracketExt; break; case kfragRightBracketLowHook: tss = m_rightBracketLowHook; break; case kfragLeftBracket: tss = m_leftBracket; break; case kfragRightBracket: tss = m_rightBracket; break; case kfragQuestions: tss = m_questions; break; case kfragLeftParen: tss = m_leftParen; break; case kfragRightParen: tss = m_rightParen; break; case kfragXVariable: tss = m_x; break; case kfragZeroWidthSpace: tss = m_zwSpace; break; } return(tss); }
public override ITsString DisplayVariant(IVwEnv vwenv, int tag, int frag) { // we use display variant to display literal strings that are editable ITsString tss = null; switch (frag) { case kfragEmpty: tss = m_empty; break; case kfragFeatureLine: var value = m_cache.ServiceLocator.GetInstance<IFsClosedValueRepository>().GetObject(vwenv.CurrentObject()); tss = CreateFeatureLine(value); break; case kfragPlusVariableLine: case kfragMinusVariableLine: var var = m_cache.ServiceLocator.GetInstance<IPhFeatureConstraintRepository>().GetObject(vwenv.CurrentObject()); tss = CreateVariableLine(var, frag == kfragPlusVariableLine); break; case kfragIterCtxtMax: // if the max value is -1, it indicates that it is infinite int i = m_cache.DomainDataByFlid.get_IntProp(vwenv.CurrentObject(), tag); if (i == -1) tss = m_infinity; else tss = m_cache.TsStrFactory.MakeString(Convert.ToString(i), m_cache.DefaultUserWs); break; case kfragLeftBracketUpHook: tss = m_leftBracketUpHook; break; case kfragLeftBracketExt: tss = m_leftBracketExt; break; case kfragLeftBracketLowHook: tss = m_leftBracketLowHook; break; case kfragRightBracketUpHook: tss = m_rightBracketUpHook; break; case kfragRightBracketExt: tss = m_rightBracketExt; break; case kfragRightBracketLowHook: tss = m_rightBracketLowHook; break; case kfragLeftBracket: tss = m_leftBracket; break; case kfragRightBracket: tss = m_rightBracket; break; case kfragQuestions: tss = m_questions; break; case kfragLeftParen: tss = m_leftParen; break; case kfragRightParen: tss = m_rightParen; break; case kfragXVariable: tss = m_x; break; case kfragZeroWidthSpace: tss = m_zwSpace; break; } return tss; }
/// ----------------------------------------------------------------------------------- /// <summary> /// This version knows how to display a generic date as a string. /// </summary> /// ----------------------------------------------------------------------------------- public override ITsString DisplayVariant(IVwEnv vwenv, int tag, int frag) { if (vwenv.DataAccess.MetaDataCache.GetFieldType(tag) == (int)CellarPropertyType.GenDate) { // handle generic date. Because the actual GenDate struct is not available to // Views code, we have to handle the display of the GenDate here var sda = vwenv.DataAccess as ISilDataAccessManaged; Debug.Assert(sda != null); var genDate = sda.get_GenDateProp(vwenv.CurrentObject(), tag); var tsf = TsStrFactoryClass.Create(); string str = ""; switch (frag) { case kfragGenDateLong: str = genDate.ToLongString(); break; case kfragGenDateShort: str = genDate.ToShortString(); break; case kfragGenDateSort: str = genDate.ToSortString(); break; } return tsf.MakeString(str, sda.WritingSystemFactory.UserWs); } else return base.DisplayVariant(vwenv, tag, frag); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Handle display of a Scripture reference or range. /// </summary> /// <param name="vwenv">View environment</param> /// <param name="tag">Tag</param> /// <param name="frag">Fragment to identify what type of prompt should be created.</param> /// <returns> /// ITsString that will be displayed as user prompt. /// </returns> /// ------------------------------------------------------------------------------------ public override ITsString DisplayVariant(IVwEnv vwenv, int tag, int frag) { if (frag == (int)NotesFrags.kfrScrRef) { IScrScriptureNote ann = m_cache.ServiceLocator.GetInstance<IScrScriptureNoteRepository>().GetObject(vwenv.CurrentObject()); BCVRef startRef = new BCVRef(ann.BeginRef); string bookAbbrev = m_scrBooks.GetBookAbbrev(startRef.Book); string sAnnRef = ScrReference.MakeReferenceString(bookAbbrev, ann.BeginRef, ann.EndRef, m_scr.ChapterVerseSepr, m_scr.Bridge); return MakeLabelFromText(sAnnRef, ann); } return base.DisplayVariant(vwenv, tag, frag); }
public override ITsString DisplayVariant(IVwEnv vwenv, int tag, int frag) { // we use display variant to display literal strings that are editable ITsString tss = null; switch (frag) { case kfragFeatureLine: ComplexConcPatternNode node = ((ComplexConcPatternSda) vwenv.DataAccess).Nodes[vwenv.CurrentObject()]; switch (tag) { case ktagType: string typeStr = null; if (node is ComplexConcMorphNode) typeStr = ITextStrings.ksComplexConcMorph; else if (node is ComplexConcWordNode) typeStr = ITextStrings.ksComplexConcWord; else if (node is ComplexConcTagNode) typeStr = ITextStrings.ksComplexConcTag; tss = CreateFeatureLine(ITextStrings.ksComplexConcType, typeStr, m_cache.DefaultUserWs); break; case ktagForm: ITsString form = null; var formMorphNode = node as ComplexConcMorphNode; if (formMorphNode != null) { form = formMorphNode.Form; } else { var formWordNode = node as ComplexConcWordNode; if (formWordNode != null) form = formWordNode.Form; } Debug.Assert(form != null); tss = CreateFeatureLine(ITextStrings.ksComplexConcForm, form, false); break; case ktagEntry: ITsString entry = null; var entryMorphNode = node as ComplexConcMorphNode; if (entryMorphNode != null) entry = entryMorphNode.Entry; Debug.Assert(entry != null); tss = CreateFeatureLine(ITextStrings.ksComplexConcEntry, entry, false); break; case ktagGloss: ITsString gloss = null; var glossMorphNode = node as ComplexConcMorphNode; if (glossMorphNode != null) { gloss = glossMorphNode.Gloss; } else { var glossWordNode = node as ComplexConcWordNode; if (glossWordNode != null) gloss = glossWordNode.Gloss; } Debug.Assert(gloss != null); tss = CreateFeatureLine(ITextStrings.ksComplexConcGloss, gloss, false); break; case ktagCategory: IPartOfSpeech category = null; bool catNegated = false; var catMorphNode = node as ComplexConcMorphNode; if (catMorphNode != null) { category = catMorphNode.Category; catNegated = catMorphNode.NegateCategory; } else { var catWordNode = node as ComplexConcWordNode; if (catWordNode != null) { category = catWordNode.Category; catNegated = catWordNode.NegateCategory; } } Debug.Assert(category != null); tss = CreateFeatureLine(ITextStrings.ksComplexConcCategory, category.Abbreviation.BestAnalysisAlternative, catNegated); break; case ktagTag: ICmPossibility tagPoss = null; var tagNode = node as ComplexConcTagNode; if (tagNode != null) tagPoss = tagNode.Tag; Debug.Assert(tagPoss != null); tss = CreateFeatureLine(ITextStrings.ksComplexConcTag, tagPoss.Abbreviation.BestAnalysisAlternative, false); break; case ktagInfl: tss = CreateFeatureLine(ITextStrings.ksComplexConcInflFeatures, null, false); break; default: IFsFeatDefn feature = m_curInflFeatures.Keys.Single(f => f.Hvo == tag); if (feature is IFsComplexFeature) { tss = CreateFeatureLine(feature.Abbreviation.BestAnalysisAlternative, null, false); } else if (feature is IFsClosedFeature) { var value = (ClosedFeatureValue) m_curInflFeatures[feature]; tss = CreateFeatureLine(feature.Abbreviation.BestAnalysisAlternative, value.Symbol.Abbreviation.BestAnalysisAlternative, value.Negate); } break; } break; case kfragNodeMax: // if the max value is -1, it indicates that it is infinite ComplexConcPatternNode node1 = ((ComplexConcPatternSda) vwenv.DataAccess).Nodes[vwenv.CurrentObject()]; tss = node1.Maximum == -1 ? m_infinity : m_cache.TsStrFactory.MakeString(node1.Maximum.ToString(CultureInfo.InvariantCulture), m_cache.DefaultUserWs); break; case kfragNodeMin: ComplexConcPatternNode node2 = ((ComplexConcPatternSda) vwenv.DataAccess).Nodes[vwenv.CurrentObject()]; tss = m_cache.TsStrFactory.MakeString(node2.Minimum.ToString(CultureInfo.InvariantCulture), m_cache.DefaultUserWs); break; case kfragOR: tss = m_or; break; case kfragHash: tss = m_hash; break; default: tss = base.DisplayVariant(vwenv, tag, frag); break; } return tss; }
public override ITsString DisplayVariant(IVwEnv vwenv, int tag, int frag) { // we use display variant to display literal strings that are editable ITsString tss; switch (frag) { case kfragFeatureLine: var value = m_cache.ServiceLocator.GetInstance<IFsClosedValueRepository>().GetObject(vwenv.CurrentObject()); tss = CreateFeatureLine(value); break; case kfragPlusVariableLine: case kfragMinusVariableLine: var var = m_cache.ServiceLocator.GetInstance<IPhFeatureConstraintRepository>().GetObject(vwenv.CurrentObject()); tss = CreateVariableLine(var, frag == kfragPlusVariableLine); break; case kfragIterCtxtMax: // if the max value is -1, it indicates that it is infinite int i = m_cache.DomainDataByFlid.get_IntProp(vwenv.CurrentObject(), tag); tss = i == -1 ? m_infinity : m_cache.TsStrFactory.MakeString(Convert.ToString(i), m_cache.DefaultUserWs); break; case kfragXVariable: tss = m_x; break; default: tss = base.DisplayVariant(vwenv, tag, frag); break; } return tss; }
public override ITsString DisplayVariant(IVwEnv vwenv, int tag, int frag) { // we use display variant to display literal strings that are editable ITsString tss = null; switch (frag) { case kfragEmpty: tss = m_empty; break; case kfragFeatureLine: var value = m_cache.ServiceLocator.GetInstance <IFsClosedValueRepository>().GetObject(vwenv.CurrentObject()); tss = CreateFeatureLine(value); break; case kfragPlusVariableLine: case kfragMinusVariableLine: var var = m_cache.ServiceLocator.GetInstance <IPhFeatureConstraintRepository>().GetObject(vwenv.CurrentObject()); tss = CreateVariableLine(var, frag == kfragPlusVariableLine); break; case kfragIterCtxtMax: // if the max value is -1, it indicates that it is infinite int i = m_cache.DomainDataByFlid.get_IntProp(vwenv.CurrentObject(), tag); if (i == -1) { tss = m_infinity; } else { tss = m_cache.TsStrFactory.MakeString(Convert.ToString(i), m_cache.DefaultUserWs); } break; case kfragLeftBracketUpHook: tss = m_leftBracketUpHook; break; case kfragLeftBracketExt: tss = m_leftBracketExt; break; case kfragLeftBracketLowHook: tss = m_leftBracketLowHook; break; case kfragRightBracketUpHook: tss = m_rightBracketUpHook; break; case kfragRightBracketExt: tss = m_rightBracketExt; break; case kfragRightBracketLowHook: tss = m_rightBracketLowHook; break; case kfragLeftBracket: tss = m_leftBracket; break; case kfragRightBracket: tss = m_rightBracket; break; case kfragQuestions: tss = m_questions; break; case kfragLeftParen: tss = m_leftParen; break; case kfragRightParen: tss = m_rightParen; break; case kfragXVariable: tss = m_x; break; case kfragZeroWidthSpace: tss = m_zwSpace; break; } return(tss); }
public override ITsString DisplayVariant(IVwEnv vwenv, int tag, object v, int frag) { CheckDisposed(); // we use display variant to display literal strings that are editable ITsString tss = null; switch (frag) { case kfragEmpty: tss = m_empty; break; case kfragFeatureLine: IFsClosedValue value = new FsClosedValue(m_cache, vwenv.CurrentObject()); tss = CreateFeatureLine(value); break; case kfragPlusVariableLine: case kfragMinusVariableLine: IPhFeatureConstraint var = new PhFeatureConstraint(m_cache, vwenv.CurrentObject()); tss = CreateVariableLine(var, frag == kfragPlusVariableLine); break; case kfragIterCtxtMax: // if the max value is -1, it indicates that it is infinite int i = (int)v; if (i == -1) tss = m_infinity; else tss = m_cache.MakeUserTss(Convert.ToString(i)); break; case kfragLeftBracketUpHook: tss = m_leftBracketUpHook; break; case kfragLeftBracketExt: tss = m_leftBracketExt; break; case kfragLeftBracketLowHook: tss = m_leftBracketLowHook; break; case kfragRightBracketUpHook: tss = m_rightBracketUpHook; break; case kfragRightBracketExt: tss = m_rightBracketExt; break; case kfragRightBracketLowHook: tss = m_rightBracketLowHook; break; case kfragLeftBracket: tss = m_leftBracket; break; case kfragRightBracket: tss = m_rightBracket; break; case kfragQuestions: tss = m_questions; break; case kfragLeftParen: tss = m_leftParen; break; case kfragRightParen: tss = m_rightParen; break; case kfragXVariable: tss = m_x; break; case kfragZeroWidthSpace: tss = m_zwSpace; break; } return tss; }