C# FdoCache.GetObjProperty方法代码示例

		/// <summary>
		/// Initialize the required inventories.
		/// </summary>
		private void InitializePartInventories(FdoCache cache, bool fLoadUserOverrides)
		{
			WriteSplashScreen(LexTextStrings.ksInitializingLayouts_);
			LayoutCache.InitializePartInventories(false, cache.DatabaseName, fLoadUserOverrides);
			int flid = BaseVirtualHandler.GetInstalledHandlerTag(cache, "LexDb", "CurrentReversalIndices");
			if (flid == 0)
				flid = (int)LexDb.LexDbTags.kflidReversalIndexes;
			int[] rghvoIndexes = cache.GetVectorProperty(cache.LangProject.LexDbOA.Hvo, flid, false);
			foreach (int hvoIndex in rghvoIndexes)
			{
				int ws = cache.GetObjProperty(hvoIndex, (int)ReversalIndex.ReversalIndexTags.kflidWritingSystem);
				string sWs = cache.GetUnicodeProperty(ws, (int)LgWritingSystem.LgWritingSystemTags.kflidICULocale);
				LayoutCache.InitializeLayoutsForWsTag(sWs, cache.DatabaseName);
			}
		}

		/// <summary>
		/// Clean up anything we can find that uses the old dummy wordform.
		/// For each occurrence of the dummy wordform, update the Twfic's InstanceOf.
		/// Iterate over the Occurrences property to find them.
		/// </summary>
		/// <param name="fdoCache"></param>
		/// <param name="hvoDummyWordform"></param>
		/// <param name="hvoRealWordform"></param>
		internal static void CleanupDummyWordformReferences(FdoCache fdoCache, int hvoDummyWordform, int hvoRealWordform)
		{
			ISilDataAccess sda = fdoCache.MainCacheAccessor;
			int kflidOccurrences = WfiWordform.OccurrencesFlid(fdoCache);
			IVwCacheDa cda = fdoCache.VwCacheDaAccessor;
			int[] occurrences = fdoCache.GetVectorProperty(hvoDummyWordform, kflidOccurrences, true);
			for (int i = 0; i < occurrences.Length; i++)
			{
				int hvoDummyOccurrence = occurrences[i];
				cda.CacheObjProp(hvoDummyOccurrence, (int)CmAnnotation.CmAnnotationTags.kflidInstanceOf, hvoRealWordform);
				int ownerPrev = fdoCache.GetObjProperty(hvoDummyOccurrence, (int)CmObjectFields.kflidCmObject_Owner);
				if (ownerPrev == hvoDummyWordform)
					cda.CacheObjProp(hvoDummyOccurrence, (int)CmObjectFields.kflidCmObject_Owner, hvoRealWordform);
			}
			cda.CacheVecProp(hvoRealWordform, kflidOccurrences, occurrences, occurrences.Length);

		}

		/// <summary>
		/// Finds the wfiAnalysis the given wfic cba.InstanceOf. If it's an InstanceOf a WfiWordform,
		/// it'll return the wfiAnalysis of the guess, if found, otherwise it'll return the wfiWordform's first analysis.
		/// </summary>
		/// <param name="cache"></param>
		/// <param name="hvoCba"></param>
		/// <returns></returns>
		public static int GetWfiAnalysisFromInstanceOf(FdoCache cache, int hvoCba)
		{
			int cbaInstanceOf = cache.GetObjProperty(hvoCba, (int)CmAnnotation.CmAnnotationTags.kflidInstanceOf);
			Debug.Assert(cbaInstanceOf != 0);
			int hvoWordform;
			int hvoWfiAnalysis = GetWfiAnalysisFromWficInstanceOf(cache, cbaInstanceOf, out hvoWordform);
			if (hvoWfiAnalysis == 0 && hvoWordform != 0)
			{
				// we are probably an instance of a wordform. Try to use a guess or else use first analysis.
				int[] analyses = cache.GetVectorProperty(hvoWordform, (int)WfiWordform.WfiWordformTags.kflidAnalyses, false);
				if (analyses.Length > 0)
				{
					// first see if we have a guess we can use.
					int ktagTwficDefault = StTxtPara.TwficDefaultFlid(cache);
					int hvoTwficAnalysisGuess = cache.GetObjProperty(hvoCba, ktagTwficDefault);
					if (hvoTwficAnalysisGuess != 0)
						hvoWfiAnalysis = GetWfiAnalysisFromWficInstanceOf(cache, hvoTwficAnalysisGuess, out hvoWordform);
					if (hvoWfiAnalysis == 0)
					{
						if (analyses.Length > 1)
						{
							throw new ArgumentException(
								"Couldn't find a guess for a twfic with multiple analyses. Not sure which analysis to return.");
						}
						// since we have more than one Analyses, just return the first one.
						hvoWfiAnalysis = (int) analyses[0];
					}
				}
			}
			return hvoWfiAnalysis;
		}

		/// <summary>
		///
		/// </summary>
		/// <param name="fdoCache"></param>
		/// <param name="dummyAnnHvo"></param>
		/// <returns></returns>
		public static ICmBaseAnnotation ConvertBaseAnnotationToReal(FdoCache fdoCache, int dummyAnnHvo)
		{
			using (SuppressSubTasks supressActionHandler = new SuppressSubTasks(fdoCache, true))
			{
				Debug.Assert(fdoCache.IsDummyObject(dummyAnnHvo));
				if (!fdoCache.IsDummyObject(dummyAnnHvo) ||
					fdoCache.GetClassOfObject(dummyAnnHvo) != CmBaseAnnotation.kclsidCmBaseAnnotation)
				{
					return null; // indicate no change.
				}
				ISilDataAccess sda = fdoCache.MainCacheAccessor;
				ICmBaseAnnotation cbaDummy = (ICmBaseAnnotation)CmObject.CreateFromDBObject(fdoCache, dummyAnnHvo, false);
				ICmBaseAnnotation cbaReal = CreateRealAnnotation(fdoCache, cbaDummy.AnnotationTypeRAHvo, cbaDummy.InstanceOfRAHvo,
					cbaDummy.BeginObjectRAHvo, cbaDummy.Flid, cbaDummy.BeginOffset, cbaDummy.EndOffset);
				cbaReal.WritingSystemRAHvo = cbaDummy.WritingSystemRAHvo;
				int hvoRealAnn = cbaReal.Hvo;

				// transfer any default analysis (guess)
				int ktagTwficDefault = StTxtPara.TwficDefaultFlid(fdoCache);
				int hvoTwficAnalysisGuess = fdoCache.GetObjProperty(dummyAnnHvo, ktagTwficDefault);
				if (hvoTwficAnalysisGuess != 0)
				{
					fdoCache.VwCacheDaAccessor.CacheObjProp(hvoRealAnn, ktagTwficDefault, hvoTwficAnalysisGuess);
				}
				int textSegType = CmAnnotationDefn.TextSegment(fdoCache).Hvo;
				int twficType = CmAnnotationDefn.Twfic(fdoCache).Hvo;
				if (cbaDummy.AnnotationTypeRAHvo == twficType)
					StTxtPara.CacheReplaceTWFICAnnotation(fdoCache, dummyAnnHvo, hvoRealAnn);
				else if (cbaDummy.AnnotationTypeRAHvo == textSegType)
					StTxtPara.CacheReplaceTextSegmentAnnotation(fdoCache, dummyAnnHvo, hvoRealAnn);
				else
					Debug.Assert(true, "CacheReplace does not yet support annotation type " + cbaDummy.AnnotationTypeRAHvo);
				// now clear it from the cache, since we're done with it.
				if (fdoCache.ActionHandlerAccessor != null)
					fdoCache.ActionHandlerAccessor.AddAction(new ClearInfoOnCommitUndoAction(fdoCache, dummyAnnHvo));
				return cbaReal;
			}
		}

		/// <summary>
		/// Try to get a WfiWordform determined by the InstanceOf of a CmBaseAnnotation.
		/// Returns true if successful. Punctuation, for example, may answer false.
		/// </summary>
		/// <returns>true if hvoWordform is nonzero</returns>
		public static bool TryGetWfiWordformFromInstanceOf(FdoCache cache, int hvoCba, out int hvoWordform)
		{
			int cbaInstanceOf = cache.GetObjProperty(hvoCba, (int)CmAnnotation.CmAnnotationTags.kflidInstanceOf);
			hvoWordform = GetWordformFromWag(cache, cbaInstanceOf);
			return hvoWordform != 0;
		}

		/// <summary>
		/// Load the information we need to display a paragraph of free (back) translations: for each paragraph
		/// load its segments, for each segment load the free translation. We assume the segments
		/// property of each paragraph already exists, and want the BeginOffset, EndOffset, BeginObject, and Free Translation
		/// properties of each segment, and the Comment of the FT.
		/// Also ensures all the segments are real and have an FT annotation.
		/// </summary>
		/// <param name="paragraphs"></param>
		/// <param name="cache"></param>
		/// <param name="ws"></param>
		public static void LoadSegmentFreeTranslations(int[] paragraphs, FdoCache cache, int ws)
		{
			int kflidSegments = SegmentsFlid(cache);
			List<int> segments = new List<int>();
			foreach (int hvoPara in paragraphs)
			{
				int[] segs = cache.GetVectorProperty(hvoPara, kflidSegments, true);
				int iseg = 0;
				foreach (int hvoSeg in segs)
				{
					int hvoRealSeg = hvoSeg;
					if (cache.IsDummyObject(hvoSeg))
						hvoRealSeg = CmBaseAnnotation.ConvertBaseAnnotationToReal(cache, hvoSeg).Hvo;
					segments.Add(hvoRealSeg);
					segs[iseg++] = hvoRealSeg;
				}
				// Update the list.
				cache.VwCacheDaAccessor.CacheVecProp(hvoPara, kflidSegments, segs, segs.Length);
			}

			if (segments.Count == 0)
				return; // somehow we can have none, and then the query fails.

			int hvoFt = cache.GetIdFromGuid(LangProject.kguidAnnFreeTranslation);
			string ids = JoinIds(segments.ToArray(), ",");
			int kflidFT = SegmentFreeTranslationFlid(cache);

			if (cache.DatabaseAccessor != null)
			{
				string sql =
					@"select seg.id, seg.BeginObject, seg.BeginOffset, seg.EndOffset, ft.id, ft.class$, ft.UpdStmp, ftc.Txt, ftc.Fmt from CmBaseAnnotation seg
					join CmIndirectAnnotation_AppliesTo ftseg on ftseg.Dst = seg.id
					join CmIndirectAnnotation_ ft on ft.id = ftseg.Src and ft.AnnotationType = " +
					hvoFt + @"
					left outer join CmAnnotation_Comment ftc on ftc.Obj = ft.id and ftc.ws = " + ws +
					@"
					where seg.id in (" + ids + ")";
				IDbColSpec dcs = DbColSpecClass.Create();
				dcs.Push((int) DbColType.koctBaseId, 0, 0, 0); // ID (of segment)
				dcs.Push((int) DbColType.koctObj, 1, (int) CmBaseAnnotation.CmBaseAnnotationTags.kflidBeginObject, 0);
				dcs.Push((int) DbColType.koctInt, 1, (int) CmBaseAnnotation.CmBaseAnnotationTags.kflidBeginOffset, 0);
				dcs.Push((int) DbColType.koctInt, 1, (int) CmBaseAnnotation.CmBaseAnnotationTags.kflidEndOffset, 0);
				dcs.Push((int) DbColType.koctObj, 1, kflidFT, 0); // Free translation indirect annotation
				dcs.Push((int) DbColType.koctInt, 5, (int) CmObjectFields.kflidCmObject_Class, 0); // class of FT annotation
				dcs.Push((int) DbColType.koctTimeStamp, 5, 0, 0); // timestamp of FT annotation
				dcs.Push((int)DbColType.koctMlsAlt, 5, (int)CmAnnotation.CmAnnotationTags.kflidComment, ws);
				dcs.Push((int)DbColType.koctFmt, 5, (int)CmAnnotation.CmAnnotationTags.kflidComment, ws);
				cache.LoadData(sql, dcs, 0);
			}

			// Make sure each segment has a free translation.
			foreach (int hvoSeg in segments)
			{
				int hvoFT = cache.GetObjProperty(hvoSeg, kflidFT);
				if (hvoFT == 0)
				{
					ICmIndirectAnnotation ann = CmIndirectAnnotation.CreateUnownedIndirectAnnotation(cache);
					ann.AppliesToRS.Append(hvoSeg);
					ann.AnnotationTypeRAHvo = hvoFt;
					cache.VwCacheDaAccessor.CacheObjProp(hvoSeg, kflidFT, ann.Hvo);
				}
			}
		}

		/// <summary>
		/// get the ws at the twfic's BeginOffset in its paragraph.
		/// </summary>
		/// <param name="cache">The cache.</param>
		/// <param name="hvoTwfic">The hvo twfic.</param>
		/// <returns></returns>
		/// ------------------------------------------------------------------------------------
		public static int GetTwficWs(FdoCache cache, int hvoTwfic)
		{
			Debug.Assert(cache.IsValidObject(hvoTwfic, CmBaseAnnotation.kClassId),
				String.Format("expected valid hvo({0}).", hvoTwfic));
			if (hvoTwfic <= 0 && !cache.IsDummyObject(hvoTwfic))
				throw new ArgumentException(String.Format("expected valid hvo({0}).", hvoTwfic));
			int hvoPara = cache.GetObjProperty(hvoTwfic,
				(int)CmBaseAnnotation.CmBaseAnnotationTags.kflidBeginObject);
			int ichBeginOffset = cache.GetIntProperty(hvoTwfic,
				(int)CmBaseAnnotation.CmBaseAnnotationTags.kflidBeginOffset);
			int ws = GetWsAtParaOffset(cache, hvoPara, ichBeginOffset);
			return ws;
		}

		private static bool WordformHasOccurrenceInParas(FdoCache cache, int wfid, int[] hvoParasInView, FDOSequencePropertyVirtualHandler segmentsVh)
		{
			foreach (StTxtPara para in new FdoObjectSet<StTxtPara>(cache, hvoParasInView, false, typeof(StTxtPara)))
			{
				// we don't want to reload/parse paragraphs that haven't been loaded in this context. We are just
				// trying to keep the cached data consistent in the view.
				if (!segmentsVh.IsPropInCache(cache.MainCacheAccessor, para.Hvo, 0))
					continue;
				foreach (int hvoSeg in para.Segments)
				{
					foreach (int hvoSegForm in para.SegmentForms(hvoSeg))
					{
						int hvoInstanceOf = cache.GetObjProperty(hvoSegForm, (int)CmAnnotation.CmAnnotationTags.kflidInstanceOf);
						if (wfid == hvoInstanceOf)
							return true;
					}
				}
			}
			return false;
		}

		// Make a string representing a WfiAnalysis, suitable for use in a combo box item.
		static internal ITsString MakeAnalysisStringRep(int hvoWa, FdoCache fdoCache, bool fUseStyleSheet, int wsVern)
		{
			//			ITsTextProps boldItalicAnalysis = BoldItalicAnalysis(fdoCache);
			//			ITsTextProps italicAnalysis = ItalicAnalysis(fdoCache, Sandbox.SandboxVc.krgbRed);
			ITsTextProps posTextProperties = PartOfSpeechTextProperties(fdoCache, true, fUseStyleSheet);
			ITsTextProps formTextProperties = FormTextProperties(fdoCache, fUseStyleSheet, wsVern);
			ITsTextProps glossTextProperties = GlossTextProperties(fdoCache, true, fUseStyleSheet);
			ITsStrBldr tsb = TsStrBldrClass.Create();
			ISilDataAccess sda = fdoCache.MainCacheAccessor;
			int cmorph = fdoCache.GetVectorSize(hvoWa,
				(int)WfiAnalysis.WfiAnalysisTags.kflidMorphBundles);
			if (cmorph == 0)
				return fdoCache.MakeUserTss(ITextStrings.ksNoMorphemes);
			bool fRtl = fdoCache.LanguageWritingSystemFactoryAccessor.get_EngineOrNull(wsVern).RightToLeft;
			int start = 0;
			int lim = cmorph;
			int increment = 1;
			if (fRtl)
			{
				start = cmorph - 1;
				lim = -1;
				increment = -1;
			}
			for (int i = start; i != lim; i += increment)
			{
				int hvoMb = fdoCache.GetVectorItem(hvoWa,
					(int)WfiAnalysis.WfiAnalysisTags.kflidMorphBundles, i);
				int hvoMf = fdoCache.GetObjProperty(hvoMb,
					(int)WfiMorphBundle.WfiMorphBundleTags.kflidMorph);
				ITsString tssForm = null;
				if (hvoMf != 0)
				{
					int hvoEntry = fdoCache.GetOwnerOfObject(hvoMf);
					int hvoLexemeForm = sda.get_ObjectProp(hvoEntry, (int) LexEntry.LexEntryTags.kflidLexemeForm);
					if (hvoLexemeForm != 0)
					{
						tssForm = sda.get_MultiStringAlt(hvoLexemeForm, (int) MoForm.MoFormTags.kflidForm, wsVern);
					}
					if (tssForm == null || tssForm.Length == 0)
					{
						tssForm = fdoCache.MainCacheAccessor.get_MultiStringAlt(hvoEntry,
							(int)LexEntry.LexEntryTags.kflidCitationForm, wsVern);
					}
					if (tssForm.Length == 0)
					{
						// If there isn't a lexeme form OR citation form use the form of the morph.
						tssForm = fdoCache.MainCacheAccessor.get_MultiStringAlt(hvoMf,
							(int)MoForm.MoFormTags.kflidForm, wsVern);
					}
				}
				else // no MoForm linked to this bundle, use its own form.
				{
					tssForm = fdoCache.MainCacheAccessor.get_MultiStringAlt(hvoMb,
						(int)WfiMorphBundle.WfiMorphBundleTags.kflidForm, wsVern);
				}
				int ichForm = tsb.Length;
				tsb.ReplaceTsString(ichForm, ichForm, tssForm);
				tsb.SetProperties(ichForm, tsb.Length,formTextProperties);

				// add category (part of speech)
				int hvoMsa = fdoCache.GetObjProperty(hvoMb,
					(int)WfiMorphBundle.WfiMorphBundleTags.kflidMsa);
				tsb.Replace(tsb.Length, tsb.Length, " ", null);
				int ichMinMsa = tsb.Length;
				string interlinName = ksMissingString;
				if (hvoMsa != 0)
				{
					IMoMorphSynAnalysis msa =
						MoMorphSynAnalysis.CreateFromDBObject(fdoCache, hvoMsa);
					interlinName = msa.InterlinearAbbr;
				}
				tsb.Replace(ichMinMsa, ichMinMsa, interlinName, posTextProperties);

				//add sense
				int hvoSense = fdoCache.GetObjProperty(hvoMb,
					(int)WfiMorphBundle.WfiMorphBundleTags.kflidSense);
				tsb.Replace(tsb.Length, tsb.Length, " ", null);
				int ichMinSense = tsb.Length;
				if (hvoSense != 0)
				{
					ITsString tssGloss = fdoCache.MainCacheAccessor.get_MultiStringAlt(hvoSense,
						(int)LexSense.LexSenseTags.kflidGloss, fdoCache.DefaultAnalWs);
					tsb.Replace(ichMinSense, ichMinSense, tssGloss.Text, glossTextProperties);
				}
				else
					tsb.Replace(ichMinSense, ichMinSense, ksMissingString, glossTextProperties);

				// Enhance JohnT: use proper seps.
				tsb.Replace(tsb.Length, tsb.Length, ksPartSeparator, null);
			}
			// Delete the final separator. (Enhance JohnT: this needs to get smarter when we do
			// real seps.)
			int ichFrom = tsb.Length - ksPartSeparator.Length;
			if (ichFrom < 0)
				ichFrom = 0;
			tsb.Replace(ichFrom, tsb.Length, "", null);
			return tsb.GetString();
		}

		// Generate a suitable string representation of a WfiGloss.
		// Todo: finish implementing (add the gloss!)
		static internal ITsString MakeGlossStringRep(int hvoGloss, FdoCache fdoCache, bool fUseStyleSheet)
		{
			ITsStrBldr tsb = TsStrBldrClass.Create();
			int hvoWa = fdoCache.GetOwnerOfObject(hvoGloss);

			int hvoCategory = fdoCache.GetObjProperty(hvoWa,
				(int)WfiAnalysis.WfiAnalysisTags.kflidCategory);
			if(hvoCategory > 0)
			{
				ITsString tssPos = fdoCache.MainCacheAccessor.get_MultiStringAlt(hvoCategory,
					(int)CmPossibility.CmPossibilityTags.kflidAbbreviation,
					fdoCache.DefaultAnalWs);
				tsb.Replace(0, 0, tssPos.Text,
					PartOfSpeechTextProperties(fdoCache,false, fUseStyleSheet));
			}
			else
			{
				tsb.Replace(0, 0, ksMissingString,
					PartOfSpeechTextProperties(fdoCache,false, fUseStyleSheet));
			}
			tsb.Replace(tsb.Length, tsb.Length, " ", null);
			tsb.Replace(tsb.Length, tsb.Length,
				fdoCache.MainCacheAccessor.get_MultiStringAlt(hvoGloss,
				(int)WfiGloss.WfiGlossTags.kflidForm, fdoCache.DefaultAnalWs).Text,
				GlossTextProperties(fdoCache, false, fUseStyleSheet));

			//indent
			tsb.Replace(0,0, "    ", null);
			return tsb.GetString();
		}