public void IntProp()
{
int valNew = m_ISilDataAccess.get_IntProp(1115, 2225);
Assert.AreEqual(0, valNew);
bool f;
valNew = m_IVwCacheDa.get_CachedIntProp(1115, 2225, out f);
Assert.AreEqual(false, f);
Assert.AreEqual(0, valNew);
m_IVwCacheDa.CacheIntProp(1115, 2225, int.MaxValue);
valNew = m_ISilDataAccess.get_IntProp(1115, 2225);
Assert.AreEqual(int.MaxValue, valNew);
valNew = m_IVwCacheDa.get_CachedIntProp(1115, 2225, out f);
Assert.AreEqual(true, f);
Assert.AreEqual(int.MaxValue, valNew);
m_IVwCacheDa.CacheIntProp(1115, 2225, int.MinValue);
valNew = m_ISilDataAccess.get_IntProp(1115, 2225);
Assert.AreEqual(int.MinValue, valNew);
valNew = m_IVwCacheDa.get_CachedIntProp(1115, 2225, out f);
Assert.AreEqual(true, f);
Assert.AreEqual(int.MinValue, valNew);
}
/// <summary>
/// Processes the empty vector.
/// </summary>
/// <param name="vwenv">The vwenv.</param>
/// <param name="hvo">The hvo.</param>
/// <param name="flid">The flid.</param>
private void ProcessEmptyVector(IVwEnv vwenv, int hvo, int flid)
{
// If we're collecting displayed items, and we could have a list of items but don't,
// add an hvo of 0 to the collection for use in filtering on missing information.
// See LT-9687.
if (vwenv is XmlBrowseViewBaseVc.ItemsCollectorEnv)
{
// The complexities of LexEntryRef objects makes the following special case code
// necessary to achieve satisfactory results for LT-9687.
if (flid == LexEntryRefTags.kflidComplexEntryTypes)
{
int type = m_sda.get_IntProp(hvo, LexEntryRefTags.kflidRefType);
if (type != LexEntryRefTags.krtComplexForm)
{
return;
}
}
else if (flid == LexEntryRefTags.kflidVariantEntryTypes)
{
int type = m_sda.get_IntProp(hvo, LexEntryRefTags.kflidRefType);
if (type != LexEntryRefTags.krtVariant)
{
return;
}
}
if ((vwenv as XmlBrowseViewBaseVc.ItemsCollectorEnv).HvosCollectedInCell.Count == 0)
{
(vwenv as XmlBrowseViewBaseVc.ItemsCollectorEnv).HvosCollectedInCell.Add(0);
}
}
}
internal void SelectAnnotation(int hvoStText, int hvoPara, int hvoAnn)
{
CheckDisposed();
// get the annotation properties
ISilDataAccess sda = Cache.MainCacheAccessor;
int annBeginOffset = sda.get_IntProp(hvoAnn, (int)CmBaseAnnotation.CmBaseAnnotationTags.kflidBeginOffset);
int annEndOffset = sda.get_IntProp(hvoAnn, (int)CmBaseAnnotation.CmBaseAnnotationTags.kflidEndOffset);
int annWSid = sda.get_ObjectProp(hvoAnn, (int)CmBaseAnnotation.CmBaseAnnotationTags.kflidWritingSystem);
// Now select the annotated word.
int ihvoPara = GetParagraphIndexForPara(Cache, hvoStText, hvoPara);
MakeTextSelectionAndScrollToView(annBeginOffset, annEndOffset, annWSid, ihvoPara);
}
private void TryToSetLangProjectHvo(ISilDataAccess sda, int hvo)
{
int hvoOwner = sda.get_IntProp(hvo, (int)CmObjectFields.kflidCmObject_Owner);
while (hvoOwner != 0)
{
int clsid = sda.get_IntProp(hvoOwner, (int)CmObjectFields.kflidCmObject_Class);
if (clsid == (int)LangProject.kclsidLangProject)
{
m_hvoLangProject = hvoOwner;
return;
}
hvoOwner = sda.get_IntProp(hvoOwner, (int)CmObjectFields.kflidCmObject_Owner);
}
m_hvoLangProject = 1; // true 99.999% of the time as of 11/24/2008
}
int GetProp(int hvo, XmlNode elt)
{
string propName = XmlUtils.GetMandatoryAttributeValue(elt, "prop");
int clsid = m_sda.get_IntProp(hvo, (int)CmObjectFields.kflidCmObject_Class);
return((int)m_mdc.GetFieldId2(clsid, propName, true));
}
/// <summary>
/// Get the boolean or integer model property as a boolean.
/// </summary>
/// <returns>
/// The regular boolean value for boolean properties.
/// For int model properties: 'false' for a '0' int value,
/// or 'true' for all other int values.
/// </returns>
public static bool GetBoolean(ISilDataAccess sda, int hvo, int tag)
{
if (sda == null) throw new ArgumentNullException("sda");
return (CellarPropertyType)sda.MetaDataCache.GetFieldType(tag) == CellarPropertyType.Boolean
? sda.get_BooleanProp(hvo, tag)
: sda.get_IntProp(hvo, tag) != 0;
}
/// -----------------------------------------------------------------------------------
/// <summary>
/// Attempts to look up the ownership hierarchy to find the HVO of the language project
/// to set the m_hvoLangProject member variable.
/// </summary>
/// -----------------------------------------------------------------------------------
private void TryToSetLangProjectHvo(ISilDataAccess sda, int hvo)
{
int hvoOwner = sda.get_ObjectProp(hvo, (int)CmObjectFields.kflidCmObject_Owner);
while (hvoOwner != 0)
{
int clsid = sda.get_IntProp(hvoOwner, (int)CmObjectFields.kflidCmObject_Class);
if (clsid == LangProjectTags.kClassId)
{
m_hvoLangProject = hvoOwner;
return;
}
hvoOwner = sda.get_IntProp(hvoOwner, (int)CmObjectFields.kflidCmObject_Owner);
}
// Not particularly true in the new architecture, since the WSes are loaded first, so get HVO 1.
// m_hvoLangProject = 1; // true 99.999% of the time as of 11/24/2008
throw new ArgumentException("Probably an ownerless object", "hvo");
}
public void IntProp()
{
CheckDisposed();
int valNew = m_ISilDataAccess.get_IntProp(1115, 2225);
Assert.AreEqual(0, valNew);
Assert.IsFalse(m_ISilDataAccess.IsDirty());
m_ISilDataAccess.SetInt(1115, 2225, int.MaxValue);
valNew = m_ISilDataAccess.get_IntProp(1115, 2225);
Assert.AreEqual(int.MaxValue, valNew);
Assert.IsTrue(m_ISilDataAccess.IsDirty());
m_ISilDataAccess.SetInt(1115, 2225, int.MinValue);
valNew = m_ISilDataAccess.get_IntProp(1115, 2225);
Assert.AreEqual(int.MinValue, valNew);
Assert.IsTrue(m_ISilDataAccess.IsDirty());
CheckProp(1115, 2225, int.MinValue, CellarModuleDefns.kcptInteger);
}
/// <summary>
/// Get the boolean or integer model property as a boolean.
/// </summary>
/// <returns>
/// The regular boolean value for boolean properties.
/// For int model properties: 'false' for a '0' int value,
/// or 'true' for all other int values.
/// </returns>
public static bool GetBoolean(ISilDataAccess sda, int hvo, int tag)
{
if (sda == null)
{
throw new ArgumentNullException("sda");
}
return((CellarPropertyType)sda.MetaDataCache.GetFieldType(tag) == CellarPropertyType.Boolean
? sda.get_BooleanProp(hvo, tag)
: sda.get_IntProp(hvo, tag) != 0);
}
public override void DisplayEmbeddedObject(IVwEnv vwenv, int hvo)
{
// See if it is a CmPicture.
ISilDataAccess sda = vwenv.DataAccess;
int clsid = sda.get_IntProp(hvo, (int)CmObjectFields.kflidCmObject_Class);
if (clsid != CmPictureTags.kClassId)
{
// don't know how to deal with it. Maybe the base implementation does.
base.DisplayEmbeddedObject(vwenv, hvo);
return;
}
int hvoFile = sda.get_ObjectProp(hvo, CmPictureTags.kflidPictureFile);
if (hvoFile == 0)
{
return;
}
string path;
string fileName = sda.get_UnicodeProp(hvoFile, CmFileTags.kflidInternalPath);
if (Path.IsPathRooted(fileName))
{
path = fileName;
}
else
{
if (m_hvoLangProject == 0)
{
// REVIEW (TimS/TomB): Hvo is for a CmPicture which means it might not be owned.
// If it's not owned, there will be no way to walk up the owner tree to find the
// Language Project. Review all clients to see if they have embedded objects.
// If so, they need to set the cache.
TryToSetLangProjectHvo(sda, hvo);
}
string linkedFilesRoot = sda.get_UnicodeProp(m_hvoLangProject, LangProjectTags.kflidLinkedFilesRootDir);
if (String.IsNullOrEmpty(linkedFilesRoot))
{
path = Path.Combine(DirectoryFinder.FWDataDirectory, fileName);
}
else
{
path = Path.Combine(linkedFilesRoot, fileName);
}
}
vwenv.set_IntProperty((int)FwTextPropType.ktptAlign,
(int)FwTextPropVar.ktpvEnum, (int)FwTextAlign.ktalCenter);
IPicture picture = new PictureWrapper(path);
// -1 is ktagNotAnAttr. 0 width & height mean use natural width/height.
vwenv.AddPictureWithCaption(picture, -1, CaptionProps, hvoFile, m_wsDefault, 0, 0, this);
}
public override bool Accept(IManyOnePathSortItem item)
{
int OccurrenceCount = m_sda.get_IntProp(item.RootObjectHvo, m_flid);
if (OccurrenceCount != 0)
{
return(true); // occurs in our corpus, we want to show it.
}
IWfiWordform wf = (IWfiWordform)item.RootObjectUsing(m_cache);
// Otherwise we want it only if it does NOT occur somewhere else.
return(wf.FullConcordanceCount == 0);
}
public void InstallVirtualHandler()
{
CheckDisposed();
StTextParaCountVh vh = new StTextParaCountVh();
ISilDataAccess sda = m_fdoCache.MainCacheAccessor;
IVwCacheDa cda = sda as IVwCacheDa;
vh.ClassName = "StText";
vh.FieldName = "ParagraphCount";
vh.Type = (int)CellarModuleDefns.kcptInteger;
cda.InstallVirtual(vh);
// Rather than try to find a real StText, simulate one.
cda.CacheVecProp(khvoTest, (int)StText.StTextTags.kflidParagraphs,
new int[] { 10, 20, 30, 40 }, 4);
Assert.AreEqual(4, sda.get_IntProp(khvoTest, vh.Tag));
}
/// -------------------------------------------------------------------------------------
/// <summary>
/// If the object specified by the HVO is one of the reference targets for this
/// subordinate view, return a 'path' for locating the object in the view.
/// The path works like the VwSelLevInfo objects passed to IVwRootBox.MakeTextSelection:
/// that is, the LAST one specifies a property of the root object and an index within
/// that property.
///
/// If the object specified by the HVO is not a reference target for this view at all
/// (perhaps it is a different kind of note), return null.
/// </summary>
/// <param name="hvo">The id of the object whose path is needed</param>
/// <returns>Selection level info identifying where the object is in the subordinate
/// stream</returns>
/// -------------------------------------------------------------------------------------
public SelLevInfo[] GetPathToObject(int hvo)
{
List <SelLevInfo> rgSelLevInfo = new List <SelLevInfo>(m_maxLevels);
// Loop over multiple owners up to m_hvoRoot and create a VwLevInfo for each level.
int hvoCurr = hvo;
for (int iLev = 0; iLev < m_maxLevels; iLev++)
{
int hvoOwner = m_sda.get_ObjectProp(hvoCurr,
(int)CmObjectFields.kflidCmObject_Owner);
int tag = m_sda.get_IntProp(hvoCurr,
(int)CmObjectFields.kflidCmObject_OwnFlid);
// use filtered tag if one has been provided.
if (m_tagMap.ContainsKey(tag))
{
tag = m_tagMap[tag];
}
// Search for hvoCurr in the owning property to determine its index.
// Todo: handle non-sequence property case.
int chvo = m_sda.get_VecSize(hvoOwner, tag);
int i;
for (i = 0; i < chvo; i++)
{
if (m_sda.get_VecItem(hvoOwner, tag, i) == hvoCurr)
{
break;
}
}
Debug.Assert(i < chvo);
SelLevInfo selLevInfo = new SelLevInfo();
selLevInfo.ihvo = i;
selLevInfo.tag = tag;
selLevInfo.cpropPrevious = 0;
rgSelLevInfo.Add(selLevInfo);
if (hvoOwner == m_hvoRoot)
{
return(rgSelLevInfo.ToArray());
}
hvoCurr = hvoOwner;
}
return(null); // Didn't find the root within the maximum number of levels, so give up.
}
public void AutoLoad()
{
// Get the language project as an FDO object
ILangProject lp = m_fdoCache.LangProject;
// Use it to get the HVO of the data notebook, but without making an FDO object
// and thus loading data.
Assert.IsTrue(m_sda.get_IsPropInCache(lp.Hvo,
(int)LangProject.LangProjectTags.kflidResearchNotebook,
(int)CellarModuleDefns.kcptOwningAtom, 0),
"LP notebook loaded by FDO");
int hvoNotebook = m_fdoCache.GetObjProperty(lp.Hvo,
(int)LangProject.LangProjectTags.kflidResearchNotebook);
// Owning atomic
Assert.IsFalse(m_sda.get_IsPropInCache(hvoNotebook,
(int)RnResearchNbk.RnResearchNbkTags.kflidEventTypes,
(int)CellarModuleDefns.kcptOwningAtom, 0),
"Notebook event types not preloaded");
int hvoEventTypes = m_sda.get_ObjectProp(hvoNotebook,
(int)RnResearchNbk.RnResearchNbkTags.kflidEventTypes);
Assert.IsTrue(m_sda.get_IsPropInCache(hvoNotebook,
(int)RnResearchNbk.RnResearchNbkTags.kflidEventTypes,
(int)CellarModuleDefns.kcptOwningAtom, 0),
"Notebook event types autoloaded");
Assert.IsTrue(hvoEventTypes != 0, "got real event types");
int flidET = m_sda.get_IntProp(hvoEventTypes, (int)CmObjectFields.kflidCmObject_OwnFlid);
Assert.AreEqual((int)RnResearchNbk.RnResearchNbkTags.kflidEventTypes, flidET,
"owning flid loaded correctly");
int clsidET = m_sda.get_IntProp(hvoEventTypes, (int)CmObjectFields.kflidCmObject_Class);
Assert.AreEqual((int)CmPossibilityList.kClassId, clsidET,
"class autoloaded");
int ownerET = m_sda.get_ObjectProp(hvoEventTypes, (int)CmObjectFields.kflidCmObject_Owner);
Assert.AreEqual(hvoNotebook, ownerET,
"owner auto-loaded");
// Todo: test ref atomic.
// Owning collection.
Assert.IsFalse(m_sda.get_IsPropInCache(hvoNotebook,
(int)RnResearchNbk.RnResearchNbkTags.kflidRecords,
(int)CellarModuleDefns.kcptOwningCollection, 0),
"Nb records not preloaded");
// Forces a load
int chvoRecs = m_sda.get_VecSize(hvoNotebook,
(int)RnResearchNbk.RnResearchNbkTags.kflidRecords);
Assert.IsTrue(m_sda.get_IsPropInCache(hvoNotebook,
(int)RnResearchNbk.RnResearchNbkTags.kflidRecords,
(int)CellarModuleDefns.kcptOwningCollection, 0),
"Nb records autoloaded");
// Be careful what we assert...don't want it too dependent on the exact data.
// Should be OK to assume at least a few records.
Assert.IsTrue(chvoRecs > 4, "at least 4 recs");
int hvoRec3 = m_sda.get_VecItem(hvoNotebook,
(int)RnResearchNbk.RnResearchNbkTags.kflidRecords, 3);
int clsIDR3 = m_sda.get_IntProp(hvoRec3, (int)CmObjectFields.kflidCmObject_Class);
Assert.IsTrue((int)RnEvent.kClassId == clsIDR3 || (int)RnAnalysis.kClassId == clsIDR3,
"class of rec 3 valid");
Assert.IsFalse(m_sda.get_IsPropInCache(hvoRec3,
(int)RnGenericRec.RnGenericRecTags.kflidResearchers,
(int)CellarModuleDefns.kcptReferenceCollection, 0),
"R3 researchers not preloaded");
int chvoR3Researchers = m_sda.get_VecSize(hvoRec3,
(int)RnGenericRec.RnGenericRecTags.kflidResearchers);
Assert.IsTrue(m_sda.get_IsPropInCache(hvoRec3,
(int)RnGenericRec.RnGenericRecTags.kflidResearchers,
(int)CellarModuleDefns.kcptReferenceCollection, 0),
"R3 researchers autoloaded");
// We can't assume anything about any one record, but we should be able to find
// at least one where researchers is non-empty. Along the way we do at least
// some testing of VecProp and also make sure we can load a string that is a
// BigString
bool fGotEmpty = false;
bool fGotNonEmpty = false;
bool fGotEvent = false;
int hvoEvent = 0; // some record will be an event...
int hvoText = 0; // that has a non-empty structured text...
int hvoPara = 0; // that has a non-empty paragraph with a label.
for (int ihvo = 0; ihvo < chvoRecs &&
((!fGotEmpty) || (!fGotNonEmpty) || (!fGotEvent) || hvoText == 0); ihvo++)
{
int hvoRec = m_sda.get_VecItem(hvoNotebook,
(int)RnResearchNbk.RnResearchNbkTags.kflidRecords, ihvo);
int chvoResearchers = m_sda.get_VecSize(hvoRec,
(int)RnGenericRec.RnGenericRecTags.kflidResearchers);
if (chvoResearchers > 0)
{
if (!fGotNonEmpty)
{
fGotNonEmpty = true;
// Try this on the first non-empty list.
int hvoResearcher = m_sda.get_VecItem(hvoRec,
(int)RnGenericRec.RnGenericRecTags.kflidResearchers, 0);
int clsidResearcher = m_sda.get_IntProp(hvoResearcher,
(int)CmObjectFields.kflidCmObject_Class);
Assert.AreEqual(CmPerson.kClassId, clsidResearcher, "class of researcher");
}
}
else
{
fGotEmpty = true;
// should now be considered cached anyway.
Assert.IsTrue(m_sda.get_IsPropInCache(hvoRec,
(int)RnGenericRec.RnGenericRecTags.kflidResearchers,
(int)CellarModuleDefns.kcptReferenceCollection, 0),
"empty researchers autoloaded");
}
int clsIDRec = m_sda.get_IntProp(hvoRec, (int)CmObjectFields.kflidCmObject_Class);
if (clsIDRec == (int)RnEvent.kClassId && !fGotEvent)
{
hvoEvent = hvoRec;
hvoText = m_sda.get_ObjectProp(hvoEvent, (int)RnEvent.RnEventTags.kflidDescription);
if (hvoText != 0)
{
int chvo;
using (ArrayPtr arrayPtr = MarshalEx.ArrayToNative(1000, typeof(int)))
{
// if there's a description with more than 1000 paragraphs this will break and
// we'll fix it then.
m_sda.VecProp(hvoText, (int)StText.StTextTags.kflidParagraphs,
1000, out chvo, arrayPtr);
int[] rgHvo = (int[])MarshalEx.NativeToArray(arrayPtr, chvo, typeof(int));
// search for the paragraph that has non-empty label (there are a couple).
for (int ihvoPara = 0; ihvoPara < chvo; ++ihvoPara)
{
hvoPara = rgHvo[ihvoPara];
// BigString
ITsString tssPara = m_sda.get_StringProp(hvoPara,
(int)StTxtPara.StTxtParaTags.kflidContents);
if (tssPara.Length > 0)
{
string sname = m_sda.get_UnicodeProp(hvoPara,
(int)StPara.StParaTags.kflidStyleName);
if (sname != null && sname.Length > 0)
{
fGotEvent = true;
}
// Todo: it would be nice to test UnicodePropRgch, but we can't test
// on the same prop because it's already loaded. Also, the modification
// for data loading is shared code. We could make another cache instance
// to test from, maybe? Or keep searching till we find another instance?
// Could also look for a kcptBigUnicode, but implementation is identical.
}
}
}
}
}
}
Assert.IsTrue(fGotEmpty && fGotNonEmpty, "found both empty and non-empty researcher lists");
Assert.IsTrue(hvoEvent != 0, "got at least one event");
// todo: test sequence (somehow verify order).
// todo: test ref seq/collection (verify it does NOT set the owner to the referring obj).
// Ref atomic
Assert.IsFalse(m_sda.get_IsPropInCache(hvoRec3,
(int)RnGenericRec.RnGenericRecTags.kflidConfidence,
(int)CellarModuleDefns.kcptReferenceAtom, 0),
"R3 confidence not preloaded");
int hvoConfidence = m_sda.get_ObjectProp(hvoRec3,
(int)RnGenericRec.RnGenericRecTags.kflidConfidence);
Assert.IsTrue(m_sda.get_IsPropInCache(hvoRec3,
(int)RnGenericRec.RnGenericRecTags.kflidConfidence,
(int)CellarModuleDefns.kcptReferenceAtom, 0),
"R3 confidence autoloaded");
if (hvoConfidence != 0)
{
int clsidConfidence = m_sda.get_IntProp(hvoConfidence,
(int)CmObjectFields.kflidCmObject_Class);
Assert.AreEqual(CmPossibility.kClassId, clsidConfidence, "class of confidence");
}
// TsString.
Assert.IsFalse(m_sda.get_IsPropInCache(hvoRec3,
(int)RnGenericRec.RnGenericRecTags.kflidTitle,
(int)CellarModuleDefns.kcptString, 0),
"title of rec 3 not preloaded");
ITsString qtssRec3Title = m_sda.get_StringProp(hvoRec3,
(int)RnGenericRec.RnGenericRecTags.kflidTitle);
Assert.IsTrue(m_sda.get_IsPropInCache(hvoRec3,
(int)RnGenericRec.RnGenericRecTags.kflidTitle,
(int)CellarModuleDefns.kcptString, 0),
"autoloaded title of rec 3");
// Int (e.g., gendate)
Assert.IsFalse(m_sda.get_IsPropInCache(hvoEvent,
(int)RnEvent.RnEventTags.kflidDateOfEvent,
(int)CellarModuleDefns.kcptInteger, 0),
"date of event not preloaded");
int nDateEvent = m_sda.get_IntProp(hvoEvent,
(int)RnEvent.RnEventTags.kflidDateOfEvent);
Assert.IsTrue(m_sda.get_IsPropInCache(hvoEvent,
(int)RnEvent.RnEventTags.kflidDateOfEvent,
(int)CellarModuleDefns.kcptInteger, 0),
"autoloaded date of event");
// Todo: find example of int64 prop and test.
// Test loading of binary data (into a TsTextProps).
object obj = m_sda.get_UnknownProp(hvoPara, (int)StPara.StParaTags.kflidStyleRules);
Assert.IsNotNull(obj as ITsTextProps);
// Also loading of raw binary data, using the same prop.
using (ArrayPtr rgbData = MarshalEx.ArrayToNative(10000, typeof(byte)))
{
int cb = -1;
m_sda.BinaryPropRgb(hvoPara, (int)StPara.StParaTags.kflidStyleRules,
rgbData, 10000, out cb);
Assert.IsTrue(cb > 0, "got some bytes using BinaryPropRgb");
// Enhance JohnT: wish I could figure what they ought to be and test...
// Get a UserView object (they have no owner, so go direct)
SqlConnection con = new SqlConnection(string.Format("Server={0}; Database={1}; User ID = fwdeveloper;"
+ "Password=careful; Pooling=false;",
m_fdoCache.ServerName, m_fdoCache.DatabaseName));
con.Open();
SqlCommand cmd = con.CreateCommand();
cmd.CommandText = "select top 2 id from UserView";
SqlDataReader reader = cmd.ExecuteReader();
reader.Read();
int hvoUv = reader.GetInt32(0);
reader.Close();
con.Close();
// Guid prop
Guid guidUv = m_sda.get_GuidProp(hvoUv, (int)UserView.UserViewTags.kflidApp);
Assert.IsFalse(guidUv == Guid.Empty, "got non-empty guid");
// Time prop
long lEventTime = m_sda.get_TimeProp(hvoEvent,
(int)RnGenericRec.RnGenericRecTags.kflidDateCreated);
Assert.IsFalse(lEventTime == 0, "got meaningful time"); // Enhance JohnT: really verify.
// Int prop
int viewSubtype = m_sda.get_IntProp(hvoUv, (int)UserView.UserViewTags.kflidSubType);
// Enhance JohnT: think of a way to verify...
// get_Prop: Time
object objMod = m_sda.get_Prop(hvoRec3,
(int)RnGenericRec.RnGenericRecTags.kflidDateModified);
Assert.IsTrue(objMod is long);
// get_Prop: String
int hvoRec0 = m_sda.get_VecItem(hvoNotebook,
(int)RnResearchNbk.RnResearchNbkTags.kflidRecords, 0);
object objTitle = m_sda.get_Prop(hvoRec0,
(int)RnGenericRec.RnGenericRecTags.kflidTitle);
Assert.IsTrue(objTitle is ITsString, "get_Prop title is string");
// get_Prop: Int
object objType = m_sda.get_Prop(hvoUv, (int)UserView.UserViewTags.kflidType);
Assert.IsTrue(objType is int, "get_Prop type is integer");
// Confirm some more results by loading through FDO
ICmObject objRec3 = CmObject.CreateFromDBObject(m_fdoCache, hvoRec3);
Assert.IsTrue(objRec3 is IRnGenericRec, "object of correct type");
IRnGenericRec grRec3 = (IRnGenericRec)objRec3;
// I'd prefer to use full ITsString equality test, but not sure how to get
// a regular ITsString from FDO obj.
Assert.AreEqual(qtssRec3Title.Text, grRec3.Title.Text,
"two ways to retrieve R3 title match");
// Can't try this yet because FDO GenDate not yet implemented. The data type might not
// be right anyway.
// CmObject objEvent = CmObject.CreateFromDBObject(m_fdoCache, hvoEvent);
// Assert.IsTrue(objEvent is RnEvent, "type of event");
// RnEvent ev1 = (RnEvent) objEvent;
// Assert.AreEqual(ev1.DateOfEvent, nDateEvent, "date of event matches");
}
}
/// <summary>
/// Get the value of a integer property. May also be used for enumerations.
/// 0 if no value known for this property.
/// ENHANCE JohnT: shouldn't it also return S_FALSE?
///</summary>
/// <param name='hvo'> </param>
/// <param name='tag'> </param>
/// <returns></returns>
public virtual int get_IntProp(int hvo, int tag)
{
return(m_baseSda.get_IntProp(hvo, tag));
}
/// <summary>
///
/// </summary>
/// <param name="hvo"></param>
/// <param name="tag"></param>
/// <returns></returns>
public int get_IntProp(int hvo, int tag)
{
return(m_sda.get_IntProp(hvo, tag));
}
/// -----------------------------------------------------------------------------------
/// <summary>
/// Attempts to look up the ownership hierarchy to find the HVO of the language project
/// to set the m_hvoLangProject member variable.
/// </summary>
/// -----------------------------------------------------------------------------------
private void TryToSetLangProjectHvo(ISilDataAccess sda, int hvo)
{
int hvoOwner = sda.get_ObjectProp(hvo, (int)CmObjectFields.kflidCmObject_Owner);
while (hvoOwner != 0)
{
int clsid = sda.get_IntProp(hvoOwner, (int)CmObjectFields.kflidCmObject_Class);
if (clsid == LangProjectTags.kClassId)
{
m_hvoLangProject = hvoOwner;
return;
}
hvoOwner = sda.get_IntProp(hvoOwner, (int)CmObjectFields.kflidCmObject_Owner);
}
// Not particularly true in the new architecture, since the WSes are loaded first, so get HVO 1.
// m_hvoLangProject = 1; // true 99.999% of the time as of 11/24/2008
throw new ArgumentException("Probably an ownerless object", "hvo");
}
private void AddHeadwordWithHomograph(IVwEnv vwenv, int hvo)
{
ISilDataAccess sda = vwenv.DataAccess;
int hvoLf = sda.get_ObjectProp(hvo,
LexEntryTags.kflidLexemeForm);
int hvoType = 0;
if (hvoLf != 0)
{
hvoType = sda.get_ObjectProp(hvoLf,
MoFormTags.kflidMorphType);
}
// If we have a type of morpheme, show the appropriate prefix that indicates it.
// We want vernacular so it will match the point size of any aligned vernacular text.
// (The danger is that the vernacular font doesn't have these characters...not sure what
// we can do about that, but most do, and it looks awful in analysis if that is a
// much different size from vernacular.)
string sPrefix = null;
if (hvoType != 0)
{
sPrefix = sda.get_UnicodeProp(hvoType, MoMorphTypeTags.kflidPrefix);
}
// LexEntry.ShortName1; basically tries for form of the lexeme form, then the citation form.
bool fGotLabel = false;
int wsActual = 0;
if (hvoLf != 0)
{
// if we have a lexeme form and its label is non-empty, use it.
if (TryMultiStringAlt(sda, hvoLf, MoFormTags.kflidForm, out wsActual))
{
m_wsActual = wsActual;
fGotLabel = true;
if (sPrefix != null)
{
vwenv.AddString(TsStringUtils.MakeTss(sPrefix, wsActual));
}
vwenv.AddObjProp(LexEntryTags.kflidLexemeForm, this, kfragFormForm);
}
}
if (!fGotLabel)
{
// If we didn't get a useful form from the lexeme form try the citation form.
if (TryMultiStringAlt(sda, hvo, LexEntryTags.kflidCitationForm, out wsActual))
{
m_wsActual = wsActual;
if (sPrefix != null)
{
vwenv.AddString(TsStringUtils.MakeTss(sPrefix, wsActual));
}
vwenv.AddStringAltMember(LexEntryTags.kflidCitationForm, wsActual, this);
fGotLabel = true;
}
}
int defUserWs = m_cache.WritingSystemFactory.UserWs;
if (!fGotLabel)
{
// If that fails just show two questions marks.
if (sPrefix != null)
{
vwenv.AddString(TsStringUtils.MakeTss(sPrefix, wsActual));
}
vwenv.AddString(m_cache.TsStrFactory.MakeString(FdoUiStrings.ksQuestions, defUserWs)); // was "??", not "???"
}
// If we have a lexeme form type show the appropriate postfix.
if (hvoType != 0)
{
vwenv.AddString(TsStringUtils.MakeTss(
sda.get_UnicodeProp(hvoType, MoMorphTypeTags.kflidPostfix), wsActual));
}
// Show homograph number if non-zero.
int nHomograph = sda.get_IntProp(hvo,
LexEntryTags.kflidHomographNumber);
vwenv.NoteDependency(new[] { hvo }, new[] { LexEntryTags.kflidHomographNumber }, 1);
if (nHomograph > 0)
{
// Use a string builder to embed the properties in with the TsString.
// this allows our TsStringCollectorEnv to properly encode the superscript.
// ideally, TsStringCollectorEnv could be made smarter to handle SetIntPropValues
// since AppendTss treats the given Tss as atomic.
ITsIncStrBldr tsBldr = TsIncStrBldrClass.Create();
tsBldr.SetIntPropValues((int)FwTextPropType.ktptSuperscript,
(int)FwTextPropVar.ktpvEnum,
(int)FwSuperscriptVal.kssvSub);
tsBldr.SetIntPropValues((int)FwTextPropType.ktptBold,
(int)FwTextPropVar.ktpvEnum,
(int)FwTextToggleVal.kttvForceOn);
tsBldr.SetIntPropValues((int)FwTextPropType.ktptWs,
(int)FwTextPropVar.ktpvDefault, defUserWs);
var hc = m_cache.ServiceLocator.GetInstance <HomographConfiguration>();
StringServices.InsertHomographNumber(tsBldr, nHomograph, hc, HomographConfiguration.HeadwordVariant.Main, m_cache);
vwenv.AddString(tsBldr.GetString());
}
}
/// <summary>
/// Returns an array of string values (keys) for the objects under this layout node.
/// </summary>
/// <param name="fdoCache">The fdo cache.</param>
/// <param name="sda">The sda.</param>
/// <param name="layout">The layout.</param>
/// <param name="hvo">The hvo.</param>
/// <param name="layoutCache">The layout cache.</param>
/// <param name="caller">where layout is a component of a 'part' element, caller
/// is the 'part ref' that invoked it.</param>
/// <param name="stringTbl">The string TBL.</param>
/// <param name="wsForce">if non-zero, "string" elements are forced to use that writing system for multistrings.</param>
/// <returns></returns>
static public string[] StringsFor(FdoCache fdoCache, ISilDataAccess sda, XmlNode layout, int hvo,
LayoutCache layoutCache, XmlNode caller, StringTable stringTbl, int wsForce)
{
// Some nodes are known to be uninteresting.
if (XmlVc.CanSkipNode(layout))
return new string[0]; // don't know how to sort, treat as empty key.
switch (layout.Name)
{
case "string":
{
int hvoTarget = hvo;
XmlVc.GetActualTarget(layout, ref hvoTarget, sda); // modify the hvo if needed
if (hvo != hvoTarget)
{
return AddStringFromOtherObj(layout, hvoTarget, fdoCache, sda);
}
int flid = GetFlid(sda, layout, hvo);
if (wsForce != 0)
{
// If we are forcing a writing system, and it's a multistring, get the forced alternative.
int itype = sda.MetaDataCache.GetFieldType(flid);
itype = itype & (int)CellarPropertyTypeFilter.VirtualMask;
switch (itype)
{
case (int) CellarPropertyType.MultiUnicode:
case (int) CellarPropertyType.MultiString:
if (wsForce < 0)
{
int wsActual;
var tss = WritingSystemServices.GetMagicStringAlt(fdoCache, sda, wsForce, hvo, flid, true, out wsActual);
return new[] {tss == null ? "" : tss.Text };
}
return new[]
{sda.get_MultiStringAlt(hvo, flid, wsForce).Text};
}
}
bool fFoundType;
var strValue = fdoCache.GetText(hvo, flid, layout, out fFoundType);
if (fFoundType)
return new[] {strValue};
throw new Exception("Bad property type (" + strValue + " for hvo " + hvo +
" found for string property "
+ flid + " in " + layout.OuterXml);
}
case "configureMlString":
{
int flid = GetFlid(sda, layout, hvo);
// The Ws info specified in the part ref node
HashSet<int> wsIds = WritingSystemServices.GetAllWritingSystems(fdoCache, caller, null, hvo, flid);
if (wsIds.Count == 1)
{
var strValue = sda.get_MultiStringAlt(hvo, flid, wsIds.First()).Text;
return new[] {strValue};
}
return new[] {AddMultipleAlternatives(fdoCache, sda, wsIds, hvo, flid, caller)};
}
case "multiling":
return ProcessMultiLingualChildren(fdoCache, sda, layout, hvo, layoutCache, caller, stringTbl, wsForce);
case "layout":
// "layout" can occur when GetNodeToUseForColumn returns a phony 'layout'
// formed by unifying a layout with child nodes. Assemble its children.
// (arguably, we should treat that like div if current flow is a pile.
// but we can't tell that and it rarely makes a difference.)
case "para":
case "span":
{
return AssembleChildKeys(fdoCache, sda, layout, hvo, layoutCache, caller, stringTbl, wsForce);
}
case "column":
// top-level node for whole column; concatenate children as for "para"
// if multipara is false, otherwise as for "div"
if (XmlUtils.GetOptionalBooleanAttributeValue(layout, "multipara", false))
return ChildKeys(fdoCache, sda, layout, hvo, layoutCache, caller, stringTbl, wsForce);
else
return AssembleChildKeys(fdoCache, sda, layout, hvo, layoutCache, caller, stringTbl, wsForce);
case "part":
{
string partref = XmlUtils.GetOptionalAttributeValue(layout, "ref");
if (partref == null)
return ChildKeys(fdoCache, sda, layout, hvo, layoutCache, caller, stringTbl, wsForce); // an actual part, made up of its pieces
XmlNode part = XmlVc.GetNodeForPart(hvo, partref, false, sda, layoutCache);
// This is the critical place where we introduce a caller. The 'layout' is really a 'part ref' which is the
// 'caller' for all embedded nodes in the called part.
return StringsFor(fdoCache, sda, part, hvo, layoutCache, layout, stringTbl, wsForce);
}
case "div":
case "innerpile":
{
// Concatenate keys for child nodes (as distinct strings)
return ChildKeys(fdoCache, sda, layout, hvo, layoutCache, caller, stringTbl, wsForce);
}
case "obj":
{
// Follow the property, get the object, look up the layout to use,
// invoke recursively.
int flid = GetFlid(sda, layout, hvo);
int hvoTarget = sda.get_ObjectProp(hvo, flid);
if (hvoTarget == 0)
break; // return empty key
string targetLayoutName = XmlUtils.GetOptionalAttributeValue(layout, "layout"); // uses 'default' if missing.
XmlNode layoutTarget = GetLayoutNodeForChild(sda, hvoTarget, flid, targetLayoutName, layout, layoutCache);
if (layoutTarget == null)
break;
return ChildKeys(fdoCache, sda, layoutTarget, hvoTarget, layoutCache, caller, stringTbl, wsForce);
}
case "seq":
{
// Follow the property. For each object, look up the layout to use,
// invoke recursively, concatenate
int flid = GetFlid(sda, layout, hvo);
int[] contents;
int ctarget = sda.get_VecSize(hvo, flid);
using (ArrayPtr arrayPtr = MarshalEx.ArrayToNative<int>(ctarget))
{
int chvo;
sda.VecProp(hvo, flid, ctarget, out chvo, arrayPtr);
contents = MarshalEx.NativeToArray<int>(arrayPtr, chvo);
}
string[] result = null;
string targetLayoutName = XmlVc.GetLayoutName(layout, caller); // also allows for finding "param" attr in caller, if not null
int i = 0;
foreach (int hvoTarget in contents)
{
int prevResultLength = GetArrayLength(result);
XmlNode layoutTarget = GetLayoutNodeForChild(sda, hvoTarget, flid, targetLayoutName, layout, layoutCache);
if (layoutTarget == null)
continue; // should not happen, but best recovery we can make
result = Concatenate(result, ChildKeys(fdoCache, sda, layoutTarget, hvoTarget, layoutCache, caller, stringTbl, wsForce));
// add a separator between the new childkey group and the previous childkey group
if (i > 0 && prevResultLength != GetArrayLength(result) && prevResultLength > 0)
{
int ichIns = 0;
if (result[prevResultLength - 1] != null)
ichIns = result[prevResultLength - 1].Length;
AddSeparator(ref result[prevResultLength - 1], ichIns, layout);
}
++i;
}
return result;
}
case "choice":
{
foreach(XmlNode whereNode in layout.ChildNodes)
{
if (whereNode.Name != "where")
{
if (whereNode.Name == "otherwise")
return StringsFor(fdoCache, sda, XmlUtils.GetFirstNonCommentChild(whereNode), hvo, layoutCache, caller, stringTbl, wsForce);
continue; // ignore any other nodes,typically comments
}
// OK, it's a where node.
if (XmlVc.ConditionPasses(whereNode, hvo, fdoCache, sda, caller))
return StringsFor(fdoCache, sda, XmlUtils.GetFirstNonCommentChild(whereNode), hvo, layoutCache, caller, stringTbl, wsForce);
}
break; // if no condition passes and no otherwise, return null.
}
case "if":
{
if (XmlVc.ConditionPasses(layout, hvo, fdoCache, sda, caller))
return StringsFor(fdoCache, sda, XmlUtils.GetFirstNonCommentChild(layout), hvo, layoutCache, caller, stringTbl, wsForce);
break;
}
case "ifnot":
{
if (!XmlVc.ConditionPasses(layout, hvo, fdoCache, sda, caller))
return StringsFor(fdoCache, sda, XmlUtils.GetFirstNonCommentChild(layout), hvo, layoutCache, caller, stringTbl, wsForce);
break;
}
case "lit":
{
string literal = layout.InnerText;
if (stringTbl != null)
{
string sTranslate = XmlUtils.GetOptionalAttributeValue(layout, "translate", "");
if (sTranslate.Trim().ToLower() != "do not translate")
literal = stringTbl.LocalizeLiteralValue(literal);
}
return new[] { literal };
}
case "int":
{
int flid = GetFlid(sda, layout, hvo);
int val = sda.get_IntProp(hvo, flid);
return new[] {AlphaCompNumberString(val)};
}
case "datetime":
{
int flid = GetFlid(sda, layout, hvo);
CellarPropertyType itype = (CellarPropertyType)sda.MetaDataCache.GetFieldType(flid);
if (itype == CellarPropertyType.Time)
{
DateTime dt = SilTime.GetTimeProperty(sda, hvo, flid);
return new[] {DateTimeCompString(dt)};
}
else
{
string stFieldName = XmlUtils.GetManditoryAttributeValue(layout, "field");
throw new Exception("Bad field type (" + stFieldName + " for hvo " + hvo + " found for " +
layout.Name + " property " + flid + " in " + layout.OuterXml);
}
}
case "picture":
// Treat a picture as a non-empty string for purposes of deciding whether something is empty.
// This string seems as good as anything for other purposes.
return new[] {"a picture"};
default: // unknown or comment node, adds nothing
Debug.Assert(false, "unrecognized XML node.");
break;
}
return new string[0]; // don't know how to sort, treat as empty key.
}
internal virtual int GetValueOfField(ISilDataAccess sda, int hvoField)
{
return sda.get_IntProp(hvoField, m_flidSub);
}
private void TryToSetLangProjectHvo(ISilDataAccess sda, int hvo)
{
int hvoOwner = sda.get_IntProp(hvo, (int)CmObjectFields.kflidCmObject_Owner);
while (hvoOwner != 0)
{
int clsid = sda.get_IntProp(hvoOwner, (int)CmObjectFields.kflidCmObject_Class);
if (clsid == (int)LangProject.kclsidLangProject)
{
m_hvoLangProject = hvoOwner;
return;
}
hvoOwner = sda.get_IntProp(hvoOwner, (int)CmObjectFields.kflidCmObject_Owner);
}
m_hvoLangProject = 1; // true 99.999% of the time as of 11/24/2008
}
public static void UpdateMainTransFromSegmented(StTxtPara para, int[] wss)
{
if (!para.IsValidObject())
{
return; // in merge, paragraph may be modified then deleted.
}
FdoCache cache = para.Cache;
BtConverter.EnsureMainParaSegments(para, wss[0]);
ISilDataAccess sda = cache.MainCacheAccessor;
List <int> segments = para.Segments;
int kflidFT = StTxtPara.SegmentFreeTranslationFlid(cache);
ITsString tssContents = para.Contents.UnderlyingTsString;
IScripture scr = para.Cache.LangProject.TranslatedScriptureOA;
ICmTranslation originalBT = para.GetBT(); // Can be null
string sUnfinished = BackTranslationStatus.Unfinished.ToString();
foreach (int ws in wss)
{
ITsStrBldr bldr = TsStrBldrClass.Create();
bool wantNextSpace = false; // suppresses space before the first thing we add.
bool haveBtText = false; // Text that isn't segment label text
foreach (int hvoSeg in segments)
{
// If it's a label, insert it directly. Suppress following space.
int beginOffset = sda.get_IntProp(hvoSeg, (int)CmBaseAnnotation.CmBaseAnnotationTags.kflidBeginOffset);
int endOffset = sda.get_IntProp(hvoSeg, (int)CmBaseAnnotation.CmBaseAnnotationTags.kflidEndOffset);
ITsString tssFt;
// Whether we want to insert a space before the current segment is determined by the previous one.
// Save that value so we can set wantSpace appropriately for the following one.
bool wantSpace = wantNextSpace;
if (SegmentBreaker.HasLabelText(tssContents, beginOffset, endOffset))
{
tssFt = (new CmBaseAnnotation(cache, hvoSeg)).TextAnnotated;
tssFt = scr.ConvertCVNumbersInStringForBT(CorrectFootnotes(tssFt), ws);
wantNextSpace = false;
}
else
{
int hvoFt = sda.get_ObjectProp(hvoSeg, kflidFT);
tssFt = sda.get_MultiStringAlt(hvoFt, (int)CmAnnotation.CmAnnotationTags.kflidComment, ws);
haveBtText |= (tssFt.Length > 0);
wantNextSpace = EndsWithNonSpace(tssFt);
}
if (tssFt.Length > 0)
{
if (wantSpace)
{
// The preceding segment should typically be followed by a space.
if (!StartsWithSpaceOrOrc(tssFt))
{
bldr.Replace(bldr.Length, bldr.Length, " ", null);
}
}
bldr.ReplaceTsString(bldr.Length, bldr.Length, tssFt);
}
}
// If the back translation doesn't have text, we don't want to create verse
// segment labels. This prevents the problem where the book thinks it has a
// back translation because of automatically generated verse labels (TE-8283).
if (!haveBtText)
{
// This check might not be needed, but it shouldn't hurt anything.
if (originalBT != null)
{
if (originalBT.Translation.GetAlternative(ws).Length > 0)
{
string origStatus = originalBT.Status.GetAlternative(ws);
if (!String.IsNullOrEmpty(origStatus) && origStatus != sUnfinished)
{
originalBT.Status.SetAlternative(sUnfinished, ws);
}
}
}
continue;
}
ITsString newFt = bldr.GetString();
ICmTranslation trans;
if (newFt.Length == 0)
{
trans = para.GetBT();
if (trans == null)
{
return; // don't bother creating one to store an empty translation!
}
}
else
{
trans = para.GetOrCreateBT();
}
// Don't write unless it changed...PropChanged can be expensive.
if (!trans.Translation.GetAlternative(ws).UnderlyingTsString.Equals(newFt))
{
trans.Translation.SetAlternative(newFt, ws);
trans.Status.SetAlternative(sUnfinished, ws);
}
}
}
/// -----------------------------------------------------------------------------------
/// <summary>
/// Display the specified object (from an ORC embedded in a string). The default
/// here knows how to display IPictures.
/// </summary>
/// <param name="vwenv"></param>
/// <param name="hvo"></param>
/// -----------------------------------------------------------------------------------
public virtual void DisplayEmbeddedObject(IVwEnv vwenv, int hvo)
{
CheckDisposed();
// See if it is a CmPicture.
ISilDataAccess sda = vwenv.DataAccess;
int clsid = sda.get_IntProp(hvo, (int)CmObjectFields.kflidCmObject_Class);
if (clsid != CmPicture.kclsidCmPicture)
{
return; // don't know how to deal with it.
}
int hvoFile = sda.get_ObjectProp(hvo, (int)CmPicture.CmPictureTags.kflidPictureFile);
if (hvoFile == 0)
{
return;
}
string path;
string fileName = sda.get_UnicodeProp(hvoFile, (int)CmFile.CmFileTags.kflidInternalPath);
if (Path.IsPathRooted(fileName))
{
path = fileName;
}
else
{
if (m_hvoLangProject == 0)
{
TryToSetLangProjectHvo(sda, hvo);
}
string externalRoot = sda.get_UnicodeProp(m_hvoLangProject, (int)LangProject.LangProjectTags.kflidExtLinkRootDir);
if (String.IsNullOrEmpty(externalRoot))
{
path = Path.Combine(DirectoryFinder.FWDataDirectory, fileName);
}
else
{
path = Path.Combine(externalRoot, fileName);
}
}
vwenv.set_IntProperty((int)FwTextPropType.ktptAlign,
(int)FwTextPropVar.ktpvEnum, (int)FwTextAlign.ktalCenter);
Image image;
try
{
image = Image.FromFile(FileUtils.ActualFilePath(path));
}
catch
{
// unable to read image. set to default image that indicates an invalid image.
image = ResourceHelper.ImageNotFoundX;
}
stdole.IPicture picture;
try
{
picture = (stdole.IPicture)OLECvt.ToOLE_IPictureDisp(image);
}
catch
{
// conversion to OLE format from current image format is not supported (e.g. WMF file)
// try to convert it to a bitmap and convert it to OLE format again.
// TODO: deal with transparency
// We could just do the following line (creating a new bitmap) instead of going
// through a memory stream, but then we end up with an image that is too big.
//image = new Bitmap(image, image.Size);
using (MemoryStream imageStream = new MemoryStream())
{
image.Save(imageStream, ImageFormat.Png);
image = Image.FromStream(imageStream, true);
}
picture = (stdole.IPicture)OLECvt.ToOLE_IPictureDisp(image);
}
// -1 is ktagNotAnAttr. 0 width & height mean use natural width/height.
vwenv.AddPictureWithCaption(picture, -1, CaptionProps, hvoFile, m_wsDefault, 0, 0, this);
image.Dispose();
}
/// <summary>
/// Recursive implementation method for GetDisplayCommandForColumn.
/// </summary>
/// <param name="bvi"></param>
/// <param name="node"></param>
/// <param name="mdc"></param>
/// <param name="sda"></param>
/// <param name="layouts"></param>
/// <param name="depth"></param>
/// <param name="hvo"></param>
/// <param name="collectOuterStructParts"></param>
/// <returns></returns>
static NodeDisplayCommand GetDisplayCommandForColumn1(IManyOnePathSortItem bvi, XmlNode node,
IFwMetaDataCache mdc, ISilDataAccess sda, LayoutCache layouts, int depth,
out int hvo, List<XmlNode> collectOuterStructParts)
{
hvo = bvi.PathObject(depth); // default
switch(node.Name)
{
case "obj":
case "seq":
{
// These two cases are the same here, because if the field matches, the object
// that determines the next step comes from the bvi, not from one or many items
// in the property.
if (bvi.PathLength == depth)
{
// No more path, we display the final object using the node we've deduced is
// appropriate for it.
// (We could put this test outside the switch. But then we don't dig into
// layout, para, span, etc elements at the end of the chain. It's more
// consistent if we always dig as deep as we can.
hvo = bvi.KeyObject;
return new NodeDisplayCommand(node);
}
int clsid = sda.get_IntProp(bvi.PathObject(depth), CmObjectTags.kflidClass);
int flid = mdc.GetFieldId2(clsid, XmlUtils.GetManditoryAttributeValue(node, "field"), true);
if (flid != bvi.PathFlid(depth))
return new NodeDisplayCommand(node); // different field, can't dig deeper.
int hvoDst = bvi.PathObject(depth + 1);
// If the path object has been deleted, fall back to displaying whatever the property currently holds.
if (sda.get_IntProp(hvoDst, CmObjectTags.kflidClass) == 0)
return new NodeDisplayCommand(node); // different field, can't dig deeper.
// At this point we have to mimic the process that XmlVc uses to come up with the
// node that will be used to process the destination item.
XmlNode dstNode = GetNodeForRelatedObject(hvoDst, null, node, layouts, sda);
return GetDisplayCommandForColumn1(bvi, dstNode, mdc, sda, layouts, depth + 1, out hvo, collectOuterStructParts);
}
case "para":
case "span":
case "div":
case "concpara":
case "innerpile":
{
XmlNode mainChild = FindMainChild(node);
if (mainChild == null)
return new NodeDisplayCommand(node); // can't usefully go further.
if (collectOuterStructParts != null)
collectOuterStructParts.Add(node);
return GetDisplayCommandForColumn1(bvi, mainChild, mdc, sda, layouts, depth, out hvo, collectOuterStructParts);
}
// Review JohnT: In XmlVc, "part" is the one thing that calls ProcessChildren with non-null caller.
// this should make some difference here, but I can't figure what yet, or come up with a test that fails.
// We may need a "caller" argument to pass this down so it can be used in GetNodeForRelatedObject.
case "part":
{
string layoutName = XmlUtils.GetOptionalAttributeValue(node, "ref");
if (layoutName != null)
{
// It's actually a part ref, in a layout, not a part looked up by one!
// Get the node it refers to, and make a command to process its children.
XmlNode part = XmlVc.GetNodeForPart(hvo, layoutName, false, sda, layouts);
if (part != null)
return new NodeChildrenDisplayCommand(part); // display this object using the children of the part referenced.
else
return new NodeDisplayCommand(node); // no matching part, do default.
}
// These are almost the same, but are never added to collectOuterStructParts.
// Also, expecially in the case of 'layout', they may result from unification, and be meaningless
// except for their children; in any case, the children are all we want to process.
// This is the main reason we return a command, not just a node: this case has to return the subclass.
XmlNode mainChild = FindMainChild(node);
if (mainChild == null)
return new NodeChildrenDisplayCommand(node); // can't usefully go further.
return GetDisplayCommandForColumn1(bvi, mainChild, mdc, sda, layouts, depth, out hvo, collectOuterStructParts);
}
case "column":
case "layout":
{
// These are almost the same as para, span, etc, but are never added to collectOuterStructParts.
// Also, expecially in the case of 'layout', they may result from unification, and be meaningless
// except for their children; in any case, the children are all we want to process.
// This is the main reason we return a command, not just a node: this case has to return the subclass.
XmlNode mainChild = FindMainChild(node);
if (mainChild == null)
return new NodeChildrenDisplayCommand(node); // can't usefully go further.
return GetDisplayCommandForColumn1(bvi, mainChild, mdc, sda, layouts, depth, out hvo, collectOuterStructParts);
}
default:
// If we can't find anything clever to do, we display the object at the
// current level using the current node.
return new NodeDisplayCommand(node);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Main (recursive) part of CollectBrowseItems. Given that hvo is to be displayed using node,
/// figure what objects to put in the list.
/// </summary>
/// <param name="hvo">The hvo.</param>
/// <param name="node">The node.</param>
/// <param name="collector">The collector.</param>
/// <param name="mdc">The MDC.</param>
/// <param name="sda">The sda.</param>
/// <param name="layouts">The layouts.</param>
/// <param name="caller">The caller.</param>
/// <param name="hvos">The hvos.</param>
/// <param name="flids">The flids.</param>
/// ------------------------------------------------------------------------------------
static void CollectBrowseItems(int hvo, XmlNode node, ArrayList collector,
IFwMetaDataCache mdc, ISilDataAccess sda, LayoutCache layouts, XmlNode caller, int[] hvos, int[] flids)
{
switch(node.Name)
{
case "obj":
{
int clsid = sda.get_IntProp(hvo, CmObjectTags.kflidClass);
int flid = mdc.GetFieldId2(clsid, XmlUtils.GetManditoryAttributeValue(node, "field"), true);
int hvoDst = sda.get_ObjectProp(hvo, flid);
if (hvoDst == 0)
{
// We want a row, even though it's blank for this column.
collector.Add(new ManyOnePathSortItem(hvo, hvos, flids));
return;
}
// At this point we have to mimic the process that XmlVc uses to come up with the
// node that will be used to process the destination item.
XmlNode dstNode = GetNodeForRelatedObject(hvoDst, caller, node, layouts, sda);
if (dstNode == null)
{
// maybe an old-style "frag" element? Anyway, we can't do anything smart,
// so just insert the original object.
collector.Add(new ManyOnePathSortItem(hvo, hvos, flids));
return;
}
CollectBrowseItems(hvoDst, dstNode, collector, mdc, sda, layouts, null, AppendInt(hvos, hvo), AppendInt(flids, flid));
}
break;
case "seq":
{
// very like "obj" except for the loop. How could we capture this?
int clsid = sda.get_IntProp(hvo, CmObjectTags.kflidClass);
int flid = mdc.GetFieldId2(clsid, XmlUtils.GetManditoryAttributeValue(node, "field"), true);
int chvo = sda.get_VecSize(hvo, flid);
if (chvo == 0)
{
// We want a row, even though it's blank for this column.
collector.Add(new ManyOnePathSortItem(hvo, hvos, flids));
return;
}
for (int ihvo = 0; ihvo < chvo; ihvo++)
{
int hvoDst = sda.get_VecItem(hvo, flid, ihvo);
// At this point we have to mimic the process that XmlVc uses to come up with the
// node that will be used to process the destination item.
XmlNode dstNode = GetNodeForRelatedObject(hvoDst, caller, node, layouts, sda);
if (dstNode == null)
{
if (ihvo == 0)
{
// maybe an old-style "frag" element? Anyway, we can't do anything smart,
// so just insert the original object.
collector.Add(new ManyOnePathSortItem(hvo, hvos, flids));
return;
}
// if this happens and it's not the first object, we have a funny mixture of modes.
// As a fall-back, skip this object.
continue;
}
CollectBrowseItems(hvoDst, dstNode, collector, mdc, sda, layouts, null, AppendInt(hvos, hvo), AppendInt(flids, flid));
}
}
break;
case "span":
case "para":
case "div":
case "concpara":
case "innerpile":
case "column":
// Review JohnT: In XmlVc, "part" is the one thing that calls ProcessChildren with non-null caller.
// this should make some difference here, but I can't figure what yet, or come up with a test that fails.
case "part":
case "layout":
// These are grouping nodes. In general this terminates things. However, if there is only
// one thing embedded apart from comments and properties, we can proceed.
XmlNode mainChild = FindMainChild(node);
if (mainChild == null)
{
// no single non-trivial child, keep our current object
collector.Add(new ManyOnePathSortItem(hvo, hvos, flids));
return;
}
// Recurse with same object, but process the 'main child'.
CollectBrowseItems(hvo, mainChild, collector, mdc, sda, layouts, caller, hvos, flids);
break;
default:
collector.Add(new ManyOnePathSortItem(hvo, hvos, flids));
break;
}
}
protected virtual int GetBasicPropertyValue(ISilDataAccess sda, int hvoOwner)
{
return sda.get_IntProp(hvoOwner, m_flid);
}
/// <summary>
/// Return true if the CCA is a CmBaseAnnotation (which in a CCA list makes it
/// a reference to a CmPossibility), also known as a generic marker.
/// </summary>
/// <param name="hvoCca"></param>
/// <returns></returns>
private static bool IsListRef(ISilDataAccess sda, int hvoCca)
{
int clsid = sda.get_IntProp(hvoCca, (int)CmObjectFields.kflidCmObject_Class);
return clsid == CmBaseAnnotation.kclsidCmBaseAnnotation;
}
protected virtual int GetBasicPropertyValue(ISilDataAccess sda, int hvoOwner)
{
int type = m_sda.MetaDataCache.GetFieldType(m_flid);
if (type == (int)CellarPropertyType.Boolean)
return sda.get_BooleanProp(hvoOwner, m_flid) ? 1 : 0;
else
return sda.get_IntProp(hvoOwner, m_flid);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Handles the flids for basic data (bool, string, int, etc.)
/// </summary>
/// <param name="thisFlid">The object type flid.</param>
/// <param name="flidType">The owning flid type.</param>
/// <param name="hvoSrc">The hvo of the source object.</param>
/// <param name="hvoNew">The hvo of the new object.</param>
/// ------------------------------------------------------------------------------------
private void HandleBasicOrStringFlid(int thisFlid, int flidType, int hvoSrc, int hvoNew)
{
// Basic and String properties are copied
switch (flidType)
{
// Basic Properties follow
case (int)CellarPropertyType.Binary:
string flidName = m_mdc.GetFieldName(thisFlid);
if (flidName == "Rules" || flidName == "StyleRules")
{
CopyBinaryAsTextProps(thisFlid, hvoSrc, hvoNew);
}
else
{
CopyBinaryAsBinary(thisFlid, hvoSrc, hvoNew);
}
break;
case (int)CellarPropertyType.Boolean:
// Copy boolean value
m_sda.SetBoolean(hvoNew, thisFlid, m_sda.get_BooleanProp(hvoSrc, thisFlid));
break;
case (int)CellarPropertyType.Guid:
// Copy guid value
// These are currently used as the ID for an application, or a version number, or a Scripture Check ID)
m_sda.SetGuid(hvoNew, thisFlid, m_sda.get_GuidProp(hvoSrc, thisFlid));
break;
case (int)CellarPropertyType.GenDate: // Fall through, since a GenDate is an int.
case (int)CellarPropertyType.Integer:
// Copy integer value
m_sda.SetInt(hvoNew, thisFlid, m_sda.get_IntProp(hvoSrc, thisFlid));
break;
case (int)CellarPropertyType.Time:
// Copy time value
m_sda.SetTime(hvoNew, thisFlid, m_sda.get_TimeProp(hvoSrc, thisFlid));
break;
// String Properties follow
case (int)CellarPropertyType.String:
// Copy string value
// Review: Please check these next three!
m_sda.SetString(hvoNew, thisFlid, m_sda.get_StringProp(hvoSrc, thisFlid));
break;
case (int)CellarPropertyType.Unicode:
// Copy Unicode string
m_sda.set_UnicodeProp(hvoNew, thisFlid, m_sda.get_UnicodeProp(hvoSrc, thisFlid));
break;
case (int)CellarPropertyType.MultiString: // Fall through
case (int)CellarPropertyType.MultiUnicode:
ITsMultiString sMulti = m_sda.get_MultiStringProp(hvoSrc, thisFlid);
for (int i = 0; i < sMulti.StringCount; i++)
{
int ws;
ITsString tss = sMulti.GetStringFromIndex(i, out ws);
m_sda.SetMultiStringAlt(hvoNew, thisFlid, ws, tss);
}
break;
default:
throw new FDOInvalidFieldTypeException(String.Format("CopyObject: Unsupported field type {0}.", flidType));
}
}
private void AddHeadwordWithHomograph(IVwEnv vwenv, int hvo)
{
ISilDataAccess sda = vwenv.DataAccess;
int hvoLf = sda.get_ObjectProp(hvo,
LexEntryTags.kflidLexemeForm);
int hvoType = 0;
if (hvoLf != 0)
{
hvoType = sda.get_ObjectProp(hvoLf,
MoFormTags.kflidMorphType);
}
// If we have a type of morpheme, show the appropriate prefix that indicates it.
// We want vernacular so it will match the point size of any aligned vernacular text.
// (The danger is that the vernacular font doesn't have these characters...not sure what
// we can do about that, but most do, and it looks awful in analysis if that is a
// much different size from vernacular.)
string sPrefix = null;
if (hvoType != 0)
{
sPrefix = sda.get_UnicodeProp(hvoType, MoMorphTypeTags.kflidPrefix);
}
// Show homograph number if non-zero.
int defUserWs = m_cache.WritingSystemFactory.UserWs;
int nHomograph = sda.get_IntProp(hvo, LexEntryTags.kflidHomographNumber);
var hc = m_cache.ServiceLocator.GetInstance <HomographConfiguration>();
//Insert HomographNumber when position is Before
if (hc.HomographNumberBefore)
{
InsertHomographNumber(vwenv, hc, nHomograph, defUserWs);
}
// LexEntry.ShortName1; basically tries for form of the lexeme form, then the citation form.
bool fGotLabel = false;
int wsActual = 0;
if (hvoLf != 0)
{
// if we have a lexeme form and its label is non-empty, use it.
if (TryMultiStringAlt(sda, hvoLf, MoFormTags.kflidForm, out wsActual))
{
m_wsActual = wsActual;
fGotLabel = true;
if (sPrefix != null)
{
vwenv.AddString(TsStringUtils.MakeString(sPrefix, wsActual));
}
vwenv.AddObjProp(LexEntryTags.kflidLexemeForm, this, kfragFormForm);
}
}
if (!fGotLabel)
{
// If we didn't get a useful form from the lexeme form try the citation form.
if (TryMultiStringAlt(sda, hvo, LexEntryTags.kflidCitationForm, out wsActual))
{
m_wsActual = wsActual;
if (sPrefix != null)
{
vwenv.AddString(TsStringUtils.MakeString(sPrefix, wsActual));
}
vwenv.AddStringAltMember(LexEntryTags.kflidCitationForm, wsActual, this);
fGotLabel = true;
}
}
if (!fGotLabel)
{
// If that fails just show two questions marks.
if (sPrefix != null)
{
vwenv.AddString(TsStringUtils.MakeString(sPrefix, wsActual));
}
vwenv.AddString(TsStringUtils.MakeString(FdoUiStrings.ksQuestions, defUserWs)); // was "??", not "???"
}
// If we have a lexeme form type show the appropriate postfix.
if (hvoType != 0)
{
vwenv.AddString(TsStringUtils.MakeString(
sda.get_UnicodeProp(hvoType, MoMorphTypeTags.kflidPostfix), wsActual));
}
vwenv.NoteDependency(new[] { hvo }, new[] { LexEntryTags.kflidHomographNumber }, 1);
//Insert HomographNumber when position is After
if (!hc.HomographNumberBefore)
{
InsertHomographNumber(vwenv, hc, nHomograph, defUserWs);
}
}
/// <summary>
/// This is a simplified version of XmlVc.GetFlid.
/// It does not look for a flid attr, nor try to cache the result.
/// It looks for a "field" property, and optionally a "class" one, and uses them
/// (or the class of hvo, if "class" is missing) to figure the flid.
/// Virtual properties are assumed already created.
/// </summary>
/// <param name="sda">The sda.</param>
/// <param name="frag">The frag.</param>
/// <param name="hvo">The hvo.</param>
/// <returns></returns>
static int GetFlid(ISilDataAccess sda, XmlNode frag, int hvo)
{
string stClassName = XmlUtils.GetOptionalAttributeValue(frag,"class");
string stFieldName = XmlUtils.GetManditoryAttributeValue(frag,"field");
if (string.IsNullOrEmpty(stClassName))
{
int clid = sda.get_IntProp(hvo, CmObjectTags.kflidClass);
return sda.MetaDataCache.GetFieldId2(clid, stFieldName, true);
}
return sda.MetaDataCache.GetFieldId(stClassName, stFieldName, true);
}