///// <summary>
///// Return the WfiMorphBundleDefaultSenseHandler for the supplied cache, creating it if needed.
///// </summary>
///// <param name="cda"></param>
///// <returns></returns>
//public static WfiMorphBundleDefaultSenseHandler InstallHandler(IVwCacheDa cda)
//{
// WfiMorphBundleDefaultSenseHandler vh = (WfiMorphBundleDefaultSenseHandler)cda.GetVirtualHandlerName(kClassName, kFieldName);
// if (vh == null)
// {
// vh = new WfiMorphBundleDefaultSenseHandler();
// vh.Type = (int)CellarModuleDefns.kcptReferenceAtom;
// vh.ClassName = kClassName;
// vh.FieldName = kFieldName;
// cda.InstallVirtual(vh);
// }
// return vh;
//}
public override void Load(int hvo, int tag, int ws, IVwCacheDa cda)
{
ISilDataAccess sda = cda as ISilDataAccess;
int hvoSense = sda.get_ObjectProp(hvo, (int)WfiMorphBundle.WfiMorphBundleTags.kflidSense);
if (hvoSense == 0)
{
// Try for a default.
int hvoMsa = sda.get_ObjectProp(hvo, (int)WfiMorphBundle.WfiMorphBundleTags.kflidMsa);
if (hvoMsa != 0)
{
int hvoEntry = sda.get_ObjectProp(hvoMsa, (int)CmObjectFields.kflidCmObject_Owner);
if (hvoEntry != 0)
{
hvoSense = SenseWithMsa(sda, hvoEntry, (int)LexEntry.LexEntryTags.kflidSenses, hvoMsa);
if (hvoSense == 0)
{
// no sense has right MSA...go for the first sense of any kind.
int csense = sda.get_VecSize(hvoEntry, (int)LexEntry.LexEntryTags.kflidSenses);
if (csense > 0)
{
hvoSense = sda.get_VecItem(hvoEntry, (int)LexEntry.LexEntryTags.kflidSenses, 0);
}
}
}
}
}
cda.CacheObjProp(hvo, tag, hvoSense);
}
private bool SetAllMsaSameFlag(int chvo, int[] rghvo)
{
int hvoMsa = m_sda.get_ObjectProp(rghvo[0], kflidSenseMsa);
var fAllMsaSame = SubsenseMsasMatch(rghvo[0], hvoMsa);
for (var i = 1; fAllMsaSame && i < chvo; ++i)
{
int hvoMsa2 = m_sda.get_ObjectProp(rghvo[i], kflidSenseMsa);
fAllMsaSame = hvoMsa == hvoMsa2 && SubsenseMsasMatch(rghvo[i], hvoMsa);
}
return(fAllMsaSame);
}
public void ObjectProp()
{
int hvo = m_ISilDataAccess.get_ObjectProp(1000, 2000);
Assert.AreEqual(0, hvo);
m_IVwCacheDa.CacheObjProp(1000, 2000, 7777);
hvo = m_ISilDataAccess.get_ObjectProp(1000, 2000);
Assert.AreEqual(7777, hvo);
m_IVwCacheDa.CacheObjProp(1000, 2000, 8888);
hvo = m_ISilDataAccess.get_ObjectProp(1000, 2000);
Assert.AreEqual(8888, hvo);
}
/// <summary>
/// Select the word indicated by the text-wordform-in-context (twfic) annotation.
/// This ignores the Sandbox! This is 'public' because it overrides a public method.
/// </summary>
/// <param name="hvoAnn"></param>
public override void SelectAnnotation(int hvoAnn)
{
ISilDataAccess sda = Cache.MainCacheAccessor;
// We should assert that ann is Twfic
int twficType = CmAnnotationDefn.Twfic(Cache).Hvo;
int annoType = sda.get_ObjectProp(hvoAnn, (int)CmAnnotation.CmAnnotationTags.kflidAnnotationType);
Debug.Assert(annoType == twficType, "Given annotation type should be twfic("
+ twficType + ") but was " + annoType + ".");
// The following will select the Twfic, ... I hope!
// Scroll to selection into view
IVwSelection sel = SelectWficInIText(hvoAnn);
if (sel == null)
{
return;
}
if (!this.Focused)
{
this.Focus();
}
this.ScrollSelectionIntoView(sel, VwScrollSelOpts.kssoTop);
Update();
}
/// <summary>
/// Get the Hvo of the LangProject by tracing up the ownership chain from a known
/// CmPossibility with a fixed guid that exists in all FieldWorks projects.
/// </summary>
private int GetHvoOfProject(ISilDataAccess sda)
{
// fixed guid of a possibility eventually owned by LangProject
Guid guid = new Guid("d7f713e4-e8cf-11d3-9764-00c04f186933"); // MoMorphType: bound root
int hvoPoss = GetIdFromGuid(sda, ref guid);
int flidOwner = sda.MetaDataCache.GetFieldId("CmObject", "Owner", false);
int hvoNewOwner = sda.get_ObjectProp(hvoPoss, flidOwner);
int hvoOwner = 0;
while (hvoNewOwner != 0)
{
hvoOwner = hvoNewOwner;
hvoNewOwner = sda.get_ObjectProp(hvoOwner, flidOwner);
}
return(hvoOwner);
}
private void SetReferencesForReferenceFlid(int thisFlid, int flidType, int hvoSrc, int hvoCopy)
{
switch (flidType)
{
case (int)CellarPropertyType.ReferenceAtomic:
int hvoAtomic = m_sda.get_ObjectProp(hvoSrc, thisFlid);
if (hvoAtomic > 0)
{
// If we find the object referred to by the RA property in our copy map,
// put a reference to its copy in our copied object. Otherwise, use the same
// reference as our source object.
ICmObject copiedAtomic;
if (m_sourceToCopyMap.TryGetValue(hvoAtomic, out copiedAtomic))
{
m_sda.SetObjProp(hvoCopy, thisFlid, copiedAtomic.Hvo);
}
else
{
m_sda.SetObjProp(hvoCopy, thisFlid, hvoAtomic);
}
}
break;
case (int)CellarPropertyType.ReferenceCollection:
case (int)CellarPropertyType.ReferenceSequence:
// Handle Reference Vectors
int cVec = m_sda.get_VecSize(hvoSrc, thisFlid);
for (int i = 0; i < cVec; i++)
{
int hvoVecItem = m_sda.get_VecItem(hvoSrc, thisFlid, i);
ICmObject copiedVecItem;
if (m_sourceToCopyMap.TryGetValue(hvoVecItem, out copiedVecItem))
{
m_sda.Replace(hvoCopy, thisFlid, i, i, new[] { copiedVecItem.Hvo }, 1);
}
else
{
m_sda.Replace(hvoCopy, thisFlid, i, i, new[] { hvoVecItem }, 1);
}
}
break;
default:
throw new ArgumentException("Non-reference Field in wrong method!", "flidType");
}
}
private void PreviewCurrentSelection(int hvoOccurrence)
{
if (m_hvoSelectedOccurrence == hvoOccurrence)
{
return;
}
m_hvoSelectedOccurrence = hvoOccurrence;
m_previewPane.RootObjectHvo = m_decoratedSda.get_ObjectProp(m_hvoSelectedOccurrence, ConcDecorator.kflidSegment);
}
private static void AddHvoPOStoResults(ISilDataAccess sda, List <int> results, int hvoMsa, int flidPos)
{
int hvoPOS;
hvoPOS = sda.get_ObjectProp(hvoMsa, flidPos);
if (hvoPOS != 0)
{
results.Add(hvoPOS);
}
}
public void ObjectProp()
{
CheckDisposed();
int hvo = m_ISilDataAccess.get_ObjectProp(1000, 2000);
Assert.AreEqual(0, hvo);
Assert.IsFalse(m_ISilDataAccess.IsDirty());
m_ISilDataAccess.SetObjProp(1000, 2000, 7777);
hvo = m_ISilDataAccess.get_ObjectProp(1000, 2000);
Assert.AreEqual(7777, hvo);
Assert.IsTrue(m_ISilDataAccess.IsDirty());
m_ISilDataAccess.SetObjProp(1000, 2000, 8888);
hvo = m_ISilDataAccess.get_ObjectProp(1000, 2000);
Assert.AreEqual(8888, hvo);
Assert.IsTrue(m_ISilDataAccess.IsDirty());
CheckProp(1000, 2000, 8888, CellarModuleDefns.kcptOwningAtom);
}
public override void Load(int hvo, int tag, int ws, IVwCacheDa cda)
{
ISilDataAccess sda = cda as ISilDataAccess;
m_hvo = sda.get_ObjectProp(hvo, m_tagReal);
if (m_hvo == 0)
{
// Empty: need a fake object.
m_hvo = TypeAheadSupportVc.kBaseFakeObj;
}
cda.CacheObjProp(hvo, tag, m_hvo);
}
private bool IsItemEligible(ISilDataAccess sda, int hvo, HashSet <int> possiblePOS)
{
bool fEnable = false;
int hvoMsa = sda.get_ObjectProp(hvo, LexSenseTags.kflidMorphoSyntaxAnalysis);
if (hvoMsa != 0)
{
int clsid = m_cache.ServiceLocator.GetInstance <ICmObjectRepository>().GetObject(hvoMsa).ClassID;
if (clsid == MoStemMsaTags.kClassId)
{
int pos = sda.get_ObjectProp(hvoMsa, MoStemMsaTags.kflidPartOfSpeech);
if (pos != 0 && possiblePOS.Contains(pos))
{
// Only show it as a change if it is different
int hvoFeature = sda.get_ObjectProp(hvoMsa, MoStemMsaTags.kflidMsFeatures);
fEnable = hvoFeature != m_selectedHvo;
}
}
}
return(fEnable);
}
private bool IsItemEligible(ISilDataAccess sda, int hvo, Set <int> possiblePOS)
{
bool fEnable = false;
int hvoMsa = sda.get_ObjectProp(hvo, (int)LexSense.LexSenseTags.kflidMorphoSyntaxAnalysis);
if (hvoMsa != 0)
{
int clsid = m_cache.GetClassOfObject(hvoMsa);
if (clsid == MoStemMsa.kClassId)
{
int pos = sda.get_ObjectProp(hvoMsa, (int)MoStemMsa.MoStemMsaTags.kflidPartOfSpeech);
if (pos != 0 && possiblePOS.Contains(pos))
{
// Only show it as a change if it is different
int hvoClass = sda.get_ObjectProp(hvoMsa, (int)MoStemMsa.MoStemMsaTags.kflidInflectionClass);
fEnable = hvoClass != m_selectedHvo;
}
}
}
return(fEnable);
}
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);
}
/// <summary>
/// Make one AND make the change to the cache.
/// </summary>
/// <param name="sda"></param>
/// <param name="hvo"></param>
/// <param name="flid"></param>
/// <param name="newValue"></param>
public CacheObjPropUndoAction(ISilDataAccess sda, int hvo, int flid, int newValue)
{
m_sda = sda;
m_hvo = hvo;
m_flid = flid;
m_newValue = newValue;
m_oldValue = 0;
// Since this is used for fake props, if it isn't already cached, it doesn't have an old value.
if (sda.get_IsPropInCache(hvo, flid, (int)CellarModuleDefns.kcptReferenceAtom, 0))
{
m_oldValue = sda.get_ObjectProp(hvo, flid);
}
DoIt(m_newValue);
}
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);
}
/// <summary>
/// Get the items to be compared against the filter.
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
protected override int[] GetItems(IManyOnePathSortItem item)
{
ISilDataAccess sda = m_cache.DomainDataByFlid;
List <int> results = new List <int>();
if (item.PathLength > 0 && item.PathFlid(0) == kflidMsas)
{
// sorted by MSA, match just the one MSA.
// I don't think this path can occur with the current XML spec where this is used.
int hvoMsa;
if (item.PathLength > 1)
{
hvoMsa = item.PathObject(1);
}
else
{
hvoMsa = item.KeyObject;
}
GetItemsForMsaType(sda, ref results, hvoMsa);
}
else if (item.PathLength >= 1 && item.PathFlid(0) == kflidEntrySenses)
{
// sorted in a way that shows one sense per row, test that sense's MSA.
int hvoSense;
if (item.PathLength > 1)
{
hvoSense = item.PathObject(1);
}
else
{
hvoSense = item.KeyObject;
}
int hvoMsa = sda.get_ObjectProp(hvoSense, LexSenseTags.kflidMorphoSyntaxAnalysis);
GetItemsForMsaType(sda, ref results, hvoMsa);
}
else
{
int hvoEntry = item.RootObjectHvo;
int cmsa = sda.get_VecSize(hvoEntry, kflidMsas);
for (int imsa = 0; imsa < cmsa; imsa++)
{
int hvoMsa = sda.get_VecItem(hvoEntry, kflidMsas, imsa);
GetItemsForMsaType(sda, ref results, hvoMsa);
}
}
return(results.ToArray());
}
/// -----------------------------------------------------------------------------------
/// <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");
}
/// -------------------------------------------------------------------------------------
/// <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.
}
/// <summary>
/// Starting from hvoBase, which may be a LexEntry or LexSense, find the most desirable sense that has
/// the requested MSA. flidSense should be LexEntry.kflidSenses or LexSense.kflidSenses as
/// appropriate.
/// First tries all the top-level senses, if none matches, try children of each sense recursively.
/// Note: arguably, should try all level-two senses before trying level 3. But level-3 senses are
/// vanishingly rare; a level 3 sense with a different msa from its parent is so rare that it isn't
/// worth the effort to be more precise.
/// </summary>
/// <param name="sda"></param>
/// <param name="hvoBase"></param>
/// <param name="flidSenses"></param>
/// <param name="hvoMsa"></param>
/// <returns></returns>
int SenseWithMsa(ISilDataAccess sda, int hvoBase, int flidSenses, int hvoMsa)
{
int csense = sda.get_VecSize(hvoBase, flidSenses);
for (int i = 0; i < csense; i++)
{
int hvoSense = sda.get_VecItem(hvoBase, flidSenses, i);
int hvoThisMsa = sda.get_ObjectProp(hvoSense, (int)LexSense.LexSenseTags.kflidMorphoSyntaxAnalysis);
if (hvoThisMsa == hvoMsa)
{
return(hvoSense);
}
}
for (int i = 0; i < csense; i++)
{
int hvoSense = sda.get_VecItem(hvoBase, flidSenses, i);
int hvoSubSense = SenseWithMsa(sda, hvoSense, (int)LexSense.LexSenseTags.kflidSenses, hvoMsa);
if (hvoSubSense != 0)
{
return(hvoSubSense);
}
}
return(0); // no suitable sense found.
}
private bool IsItemEligible(ISilDataAccess sda, int hvo, Set<int> possiblePOS)
{
bool fEnable = false;
int hvoMsa = sda.get_ObjectProp(hvo, (int)LexSense.LexSenseTags.kflidMorphoSyntaxAnalysis);
if (hvoMsa != 0)
{
int clsid = m_cache.GetClassOfObject(hvoMsa);
if (clsid == MoStemMsa.kClassId)
{
int pos = sda.get_ObjectProp(hvoMsa, (int)MoStemMsa.MoStemMsaTags.kflidPartOfSpeech);
if (pos != 0 && possiblePOS.Contains(pos))
{
// Only show it as a change if it is different
int hvoFeature = sda.get_ObjectProp(hvoMsa, (int)MoStemMsa.MoStemMsaTags.kflidMsFeatures);
fEnable = hvoFeature != m_selectedHvo;
}
}
}
return fEnable;
}
public void Setup()
{
// Create the following:
// - part and layout inventories
// - metadata cache
// - DataAccess cache
// - collection of columns to display.
// We want a MetaDataCache that knows about
// - LexEntry.Senses, Msas, CitationForm, Bibliography, Etymology
// - LexSense.SemanticDomains, SenseType, Status, gloss
// - CmPossibility Name, abbr
// - MoMorphSynAnalysis
// - MoStemMsa
// - MoDerivationalMsa
string m_sTestPath = Path.Combine(DirectoryFinder.FwSourceDirectory,
Path.Combine("Common",
Path.Combine("Controls",
Path.Combine("XMLViews",
Path.Combine("XMLViewsTests", "SampleCm.xml")))));
m_mdc = MetaDataCache.CreateMetaDataCache(m_sTestPath);
// We want ISilDataAccess with:
// - LexEntry (1) with no senses and one MSA (2)
// - LexEntry (4) with one sense (5) and no MSA
// - LexEntry (6) with three senses (7, 8, 9) and two MSAs (10, 11)
// - sense(5) with no semantic domains
// - senses with one SD (7->30, 8->31)
// - sense with three SDs, one the same as the first (9->30, 31, 32)
// - MoStemMsa (2, 11)
// - MoDerivationalMsa (10)
m_cda = VwCacheDaClass.Create();
m_sda = m_cda as ISilDataAccess;
m_wsManager = new PalasoWritingSystemManager();
m_sda.WritingSystemFactory = m_wsManager;
var parser = new SimpleDataParser(m_mdc, m_cda);
parser.Parse(Path.Combine(DirectoryFinder.FwSourceDirectory,
Path.Combine("Common",
Path.Combine("Controls",
Path.Combine("XMLViews",
Path.Combine("XMLViewsTests", "SampleData.xml"))))));
int wsEn = m_wsManager.GetWsFromStr("en");
// These are mainly to check out the parser.
Assert.AreEqual(3, m_sda.get_ObjectProp(2, 23011), "part of speech of an MoStemMsa");
Assert.AreEqual(2, m_sda.get_VecItem(1, 2009, 0), "owned msa");
Assert.AreEqual("noun", m_sda.get_MultiStringAlt(3, 7003, wsEn).Text, "got ms property");
Assert.AreEqual(9, m_sda.get_VecItem(6, 2010, 2), "3rd sense");
Assert.AreEqual(31, m_sda.get_VecItem(9, 21016, 1), "2nd semantic domain");
// Columns includes
// - CitationForm (string inside span)
// - Bibliography (string not in span)
// - Sense glosses (string in para in seq, nested in column element)
// - Semantic domains (pair of strings in para in seq in seq, using layout refs)
// - MSAs (simplified, but polymorphic with one having <choice> and one <obj> to CmPossibility
XmlDocument docColumns = new XmlDocument();
docColumns.Load(Path.Combine(DirectoryFinder.FwSourceDirectory,
Path.Combine("Common",
Path.Combine("Controls",
Path.Combine("XMLViews",
Path.Combine("XMLViewsTests", "TestColumns.xml"))))));
m_columnList = docColumns.DocumentElement.ChildNodes;
// Parts just has what those columns need.
string partDirectory = Path.Combine(DirectoryFinder.FwSourceDirectory,
Path.Combine("Common",
Path.Combine("Controls",
Path.Combine("XMLViews", "XMLViewsTests"))));
Dictionary <string, string[]> keyAttrs = new Dictionary <string, string[]>();
keyAttrs["layout"] = new string[] { "class", "type", "name" };
keyAttrs["group"] = new string[] { "label" };
keyAttrs["part"] = new string[] { "ref" };
// Currently there are no specialized layout files that match.
m_layoutInventory = new Inventory(new string[] { partDirectory },
"*.fwlayout", "/LayoutInventory/*", keyAttrs, "TestManyOneBrowse", "ProjectPath");
keyAttrs = new Dictionary <string, string[]>();
keyAttrs["part"] = new string[] { "id" };
m_partInventory = new Inventory(new string[] { partDirectory },
"TestParts.xml", "/PartInventory/bin/*", keyAttrs, "TestManyOneBrowse", "ProjectPath");
m_layouts = new LayoutCache(m_mdc, m_layoutInventory, m_partInventory);
}
/// -----------------------------------------------------------------------------------
/// <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");
}
/// <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.
}
public override void DoIt(Set <int> itemsToChange, ProgressState state)
{
CheckDisposed();
ISilDataAccess sda = m_cache.MainCacheAccessor;
// Make a hashtable from HVO of entry to list of modified senses.
Dictionary <int, List <int> > sensesByEntry = new Dictionary <int, List <int> >();
int tagOwningEntry = m_cache.VwCacheDaAccessor.GetVirtualHandlerName("LexSense", "OwningEntry").Tag;
int i = 0;
// Report progress 50 times or every 100 items, whichever is more (but no more than once per item!)
int interval = Math.Min(100, Math.Max(itemsToChange.Count / 50, 1));
foreach (int hvoSense in itemsToChange)
{
i++;
if (i % interval == 0)
{
state.PercentDone = i * 20 / itemsToChange.Count;
state.Breath();
}
int hvoMsa = sda.get_ObjectProp(hvoSense, (int)LexSense.LexSenseTags.kflidMorphoSyntaxAnalysis);
if (hvoMsa != 0 && m_cache.GetClassOfObject(hvoMsa) != MoStemMsa.kclsidMoStemMsa)
{
continue; // can't fix this one, not a stem.
}
int hvoEntry = sda.get_ObjectProp(hvoSense, tagOwningEntry);
List <int> senses = null;
if (!sensesByEntry.TryGetValue(hvoEntry, out senses))
{
senses = new List <int>();
sensesByEntry[hvoEntry] = senses;
}
senses.Add(hvoSense);
}
m_cache.BeginUndoTask(FdoUiStrings.ksUndoBulkEditPOS, FdoUiStrings.ksRedoBulkEditPOS);
BulkEditBar.ForceRefreshOnUndoRedo(sda);
i = 0;
interval = Math.Min(100, Math.Max(sensesByEntry.Count / 50, 1));
foreach (KeyValuePair <int, List <int> > kvp in sensesByEntry)
{
i++;
if (i % interval == 0)
{
state.PercentDone = i * 80 / sensesByEntry.Count + 20;
state.Breath();
}
int hvoEntry = kvp.Key;
List <int> sensesToChange = kvp.Value;
int hvoMsmTarget = 0;
int cmsa = sda.get_VecSize(hvoEntry, (int)LexEntry.LexEntryTags.kflidMorphoSyntaxAnalyses);
bool fAssumeSurvives = true; // true if we know all old MSAs will survive.
for (int imsa = 0; imsa < cmsa; imsa++)
{
int hvoMsa = sda.get_VecItem(hvoEntry, (int)LexEntry.LexEntryTags.kflidMorphoSyntaxAnalyses, imsa);
if (m_cache.GetClassOfObject(hvoMsa) == MoStemMsa.kclsidMoStemMsa &&
sda.get_ObjectProp(hvoMsa, (int)MoStemMsa.MoStemMsaTags.kflidPartOfSpeech) == m_selectedHvo)
{
// Can reuse this one!
hvoMsmTarget = hvoMsa;
fAssumeSurvives = false; // old MSA may be redundant.
break;
}
}
if (hvoMsmTarget == 0)
{
// See if we can reuse an existing MoStemMsa by changing it.
// This is possible if it is used only by senses in the list, or not used at all.
List <int> otherSenses = new List <int>();
AddExcludedSenses(sda, hvoEntry, (int)LexEntry.LexEntryTags.kflidSenses, otherSenses, sensesToChange);
for (int imsa = 0; imsa < cmsa; imsa++)
{
int hvoMsa = sda.get_VecItem(hvoEntry, (int)LexEntry.LexEntryTags.kflidMorphoSyntaxAnalyses, imsa);
if (m_cache.GetClassOfObject(hvoMsa) != MoStemMsa.kclsidMoStemMsa)
{
continue;
}
bool fOk = true;
foreach (int hvoOtherSense in otherSenses)
{
if (sda.get_ObjectProp(hvoOtherSense, (int)LexSense.LexSenseTags.kflidMorphoSyntaxAnalysis) == hvoMsa)
{
fOk = false; // we can't change it, one of the unchanged senses uses it
break;
}
}
if (fOk)
{
// Can reuse this one! Nothing we don't want to change uses it. Go ahead and set it to the
// required POS.
hvoMsmTarget = hvoMsa;
int hvoOld = sda.get_ObjectProp(hvoMsmTarget, (int)MoStemMsa.MoStemMsaTags.kflidPartOfSpeech);
sda.SetObjProp(hvoMsmTarget, (int)MoStemMsa.MoStemMsaTags.kflidPartOfSpeech, m_selectedHvo);
sda.PropChanged(null, (int)PropChangeType.kpctNotifyAll,
hvoMsmTarget, (int)MoStemMsa.MoStemMsaTags.kflidPartOfSpeech,
0, 1, hvoOld == 0 ? 1 : 0);
// compare MoStemMsa.ResetInflectionClass: changing POS requires us to clear inflection class,
// if it is set.
if (hvoOld != 0 && sda.get_ObjectProp(hvoMsmTarget, (int)MoStemMsa.MoStemMsaTags.kflidInflectionClass) != 0)
{
sda.SetObjProp(hvoMsmTarget, (int)MoStemMsa.MoStemMsaTags.kflidInflectionClass, 0);
sda.PropChanged(null, (int)PropChangeType.kpctNotifyAll,
hvoMsmTarget, (int)MoStemMsa.MoStemMsaTags.kflidInflectionClass,
0, 0, 1);
}
break;
}
}
}
if (hvoMsmTarget == 0)
{
// Nothing we can reuse...make a new one.
hvoMsmTarget = sda.MakeNewObject((int)MoStemMsa.kclsidMoStemMsa, hvoEntry, (int)LexEntry.LexEntryTags.kflidMorphoSyntaxAnalyses, -1);
sda.SetObjProp(hvoMsmTarget, (int)MoStemMsa.MoStemMsaTags.kflidPartOfSpeech, m_selectedHvo);
sda.PropChanged(null, (int)PropChangeType.kpctNotifyAll,
hvoMsmTarget, (int)MoStemMsa.MoStemMsaTags.kflidInflectionClass,
m_cache.GetObjIndex(hvoEntry,
(int)LexEntry.LexEntryTags.kflidMorphoSyntaxAnalyses, hvoMsmTarget),
1, 0);
}
// Finally! Make the senses we want to change use it.
foreach (int hvoSense in sensesToChange)
{
int hvoOld = sda.get_ObjectProp(hvoSense, (int)LexSense.LexSenseTags.kflidMorphoSyntaxAnalysis);
if (hvoOld == hvoMsmTarget)
{
continue; // reusing a modified msa.
}
LexSense.HandleOldMSA(m_cache, hvoSense, hvoMsmTarget, fAssumeSurvives);
sda.SetObjProp(hvoSense, (int)LexSense.LexSenseTags.kflidMorphoSyntaxAnalysis, hvoMsmTarget);
sda.PropChanged(null, (int)PropChangeType.kpctNotifyAll,
hvoSense, (int)LexSense.LexSenseTags.kflidMorphoSyntaxAnalysis,
0, 1, hvoOld == 0 ? 1 : 0);
}
}
m_cache.EndUndoTask();
}
/// <summary>
/// Get the Hvo of the LangProject by tracing up the ownership chain from a known
/// CmPossibility with a fixed guid that exists in all FieldWorks projects.
/// </summary>
private int GetHvoOfProject(ISilDataAccess sda)
{
// fixed guid of a possibility eventually owned by LangProject
Guid guid = new Guid("d7f713e4-e8cf-11d3-9764-00c04f186933"); // MoMorphType: bound root
int hvoPoss = GetIdFromGuid(sda, ref guid);
int flidOwner = sda.MetaDataCache.GetFieldId("CmObject", "Owner", false);
int hvoNewOwner = sda.get_ObjectProp(hvoPoss, flidOwner);
int hvoOwner = 0;
while (hvoNewOwner != 0)
{
hvoOwner = hvoNewOwner;
hvoNewOwner = sda.get_ObjectProp(hvoOwner, flidOwner);
}
return hvoOwner;
}
public UpdateMorphEntryAction(SandboxBase sandbox, int hvoMorph)
{
m_oldVals = new int[m_tags.Length];
m_newVals = new int[m_tags.Length];
m_sandbox = sandbox;
m_sda = m_sandbox.Caches.DataAccess;
m_originalAnalysis = m_sandbox.Analysis;
m_hvoMorph = hvoMorph;
for (int i = 0; i < m_tags.Length; i++ )
m_oldVals[i] = m_sda.get_ObjectProp(m_hvoMorph, m_tags[i]);
}
public bool Test(int hvo, ISilDataAccess sda, Set <int> validHvos)
{
return(validHvos.Contains(sda.get_ObjectProp(hvo, m_flid)));
}
public bool Test(int hvo, ISilDataAccess sda, Set<int> validHvos)
{
return validHvos.Contains(sda.get_ObjectProp(hvo, m_flid));
}
/// <summary>
/// Starting from hvoBase, which may be a LexEntry or LexSense, find the most desirable sense that has
/// the requested MSA. flidSense should be LexEntry.kflidSenses or LexSense.kflidSenses as
/// appropriate.
/// First tries all the top-level senses, if none matches, try children of each sense recursively.
/// Note: arguably, should try all level-two senses before trying level 3. But level-3 senses are
/// vanishingly rare; a level 3 sense with a different msa from its parent is so rare that it isn't
/// worth the effort to be more precise.
/// </summary>
/// <param name="sda"></param>
/// <param name="hvoBase"></param>
/// <param name="flidSenses"></param>
/// <param name="hvoMsa"></param>
/// <returns></returns>
int SenseWithMsa(ISilDataAccess sda, int hvoBase, int flidSenses, int hvoMsa)
{
int csense = sda.get_VecSize(hvoBase, flidSenses);
for (int i = 0; i < csense; i++)
{
int hvoSense = sda.get_VecItem(hvoBase, flidSenses, i);
int hvoThisMsa = sda.get_ObjectProp(hvoSense, (int)LexSense.LexSenseTags.kflidMorphoSyntaxAnalysis);
if (hvoThisMsa == hvoMsa)
return hvoSense;
}
for (int i = 0; i < csense; i++)
{
int hvoSense = sda.get_VecItem(hvoBase, flidSenses, i);
int hvoSubSense = SenseWithMsa(sda, hvoSense, (int)LexSense.LexSenseTags.kflidSenses, hvoMsa);
if (hvoSubSense != 0)
return hvoSubSense;
}
return 0; // no suitable sense found.
}
public void Setup()
{
// Create the following:
// - part and layout inventories
// - metadata cache
// - DataAccess cache
// - collection of columns to display.
// We want a MetaDataCache that knows about
// - LexEntry.Senses, Msas, CitationForm, Bibliography, Etymology
// - LexSense.SemanticDomains, SenseType, Status, gloss
// - CmPossibility Name, abbr
// - MoMorphSynAnalysis
// - MoStemMsa
// - MoDerivationalMsa
m_mdc = FwMetaDataCacheClass.Create();
string m_sTestPath = Path.Combine(DirectoryFinder.FwSourceDirectory,
@"Common\Controls\XmlViews\XmlViewsTests\SampleCm.xml");
m_mdc.InitXml(m_sTestPath, true);
// We want ISilDataAccess with:
// - LexEntry (1) with no senses and one MSA (2)
// - LexEntry (4) with one sense (5) and no MSA
// - LexEntry (6) with three senses (7, 8, 9) and two MSAs (10, 11)
// - sense(5) with no semantic domains
// - senses with one SD (7->30, 8->31)
// - sense with three SDs, one the same as the first (9->30, 31, 32)
// - MoStemMsa (2, 11)
// - MoDerivationalMsa (10)
m_cda = VwCacheDaClass.Create();
m_sda = m_cda as ISilDataAccess;
m_wsf = LgWritingSystemFactoryClass.Create();
m_sda.WritingSystemFactory = m_wsf;
SimpleDataParser parser = new SimpleDataParser(m_mdc, m_cda);
parser.Parse(Path.Combine(DirectoryFinder.FwSourceDirectory,
@"Common\Controls\XmlViews\XmlViewsTests\SampleData.xml"));
int wsEn = m_wsf.GetWsFromStr("en");
// These are mainly to check out the parser.
Assert.AreEqual(3, m_sda.get_ObjectProp(2, 23011), "part of speech of an MoStemMsa");
Assert.AreEqual(2, m_sda.get_VecItem(1, 2009, 0), "owned msa");
Assert.AreEqual("noun", m_sda.get_MultiStringAlt(3, 7003, wsEn).Text, "got ms property");
Assert.AreEqual(9, m_sda.get_VecItem(6, 2010, 2), "3rd sense");
Assert.AreEqual(31, m_sda.get_VecItem(9, 21016, 1), "2nd semantic domain");
// Columns includes
// - CitationForm (string inside span)
// - Bibliography (string not in span)
// - Sense glosses (string in para in seq, nested in column element)
// - Semantic domains (pair of strings in para in seq in seq, using layout refs)
// - MSAs (simplified, but polymorphic with one having <choice> and one <obj> to CmPossibility
XmlDocument docColumns = new XmlDocument();
docColumns.Load(Path.Combine(DirectoryFinder.FwSourceDirectory,
@"Common\Controls\XmlViews\XmlViewsTests\TestColumns.xml"));
m_columnList = docColumns.DocumentElement.ChildNodes;
// Parts just has what those columns need.
string partDirectory = Path.Combine(DirectoryFinder.FwSourceDirectory,
@"Common\Controls\XmlViews\XmlViewsTests");
Dictionary<string, string[]> keyAttrs = new Dictionary<string, string[]>();
keyAttrs["layout"] = new string[] {"class", "type", "name" };
keyAttrs["group"] = new string[] {"label"};
keyAttrs["part"] = new string[] {"ref"};
// Currently there are no specialized layout files that match.
m_layoutInventory = new Inventory(new string[] {partDirectory},
"*Layouts.xml", "/LayoutInventory/*", keyAttrs);
keyAttrs = new Dictionary<string, string[]>();
keyAttrs["part"] = new string[] {"id"};
m_partInventory = new Inventory(new string[] {partDirectory},
"TestParts.xml", "/PartInventory/bin/*", keyAttrs);
if (m_layouts != null)
m_layouts.Dispose();
m_layouts = new LayoutCache(m_mdc, m_layoutInventory, m_partInventory);
}
/// <summary>
/// It's possible that hvoItem will be an owner of a ghost (ie. an absent source object for m_flidAtomicProp).
/// In that case, the cache should return 0.
/// </summary>
/// <param name="sda"></param>
/// <param name="hvoItem"></param>
/// <returns></returns>
private int GetOriginalListValue(ISilDataAccess sda, int hvoItem)
{
return sda.get_ObjectProp(hvoItem, m_flidAtomicProp);
}
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>
/// 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;
}
}
/// <summary>
///
/// </summary>
/// <param name="hvo"></param>
/// <param name="tag"></param>
/// <returns></returns>
public int get_ObjectProp(int hvo, int tag)
{
return(m_sda.get_ObjectProp(hvo, tag));
}
/// <summary>
/// Make one AND make the change to the cache.
/// </summary>
/// <param name="sda"></param>
/// <param name="hvo"></param>
/// <param name="flid"></param>
/// <param name="newValue"></param>
public CacheObjPropUndoAction(ISilDataAccess sda, int hvo, int flid, int newValue)
{
m_sda = sda;
m_hvo = hvo;
m_flid = flid;
m_newValue = newValue;
m_oldValue = 0;
// Since this is used for fake props, if it isn't already cached, it doesn't have an old value.
if (sda.get_IsPropInCache(hvo, flid, (int)CellarModuleDefns.kcptReferenceAtom, 0))
m_oldValue = sda.get_ObjectProp(hvo, flid);
DoIt(m_newValue);
}
/// <summary>
/// If object hvo has no cached value for the property flidVirtual, do nothing.
/// Otherwise, compute a new value for the property, and issue a PropChanged. (Currently only string type supported)
/// If it has owning properties of type clidVirtual, do the same for all their items.
/// </summary>
/// <param name="hvo"></param>
/// <param name="flidVirtual"></param>
/// <param name="mdc"></param>
/// <param name="sda"></param>
private void RecomputeVirtuals(int hvo, uint clidVirtual, int flidVirtual, int typeVirtual, IFwMetaDataCache mdc, ISilDataAccess sda,
IVwVirtualHandler vh)
{
if (Cache.GetClassOfObject(hvo) != clidVirtual)
return;
// Unless it's a computeEveryTime property, we don't need to worry if it's not already cached.
if (vh.ComputeEveryTime || sda.get_IsPropInCache(hvo, flidVirtual, typeVirtual, 0))
{
vh.Load(hvo, flidVirtual, 0, Cache.VwCacheDaAccessor);
switch (typeVirtual)
{
case (int)CellarModuleDefns.kcptString:
sda.PropChanged(null, (int)PropChangeType.kpctNotifyAll, hvo, flidVirtual, 0, 0, 0);
break;
default:
Debug.WriteLine("RecomputeVirtuals: unimplemented prop type");
break;
}
}
uint[] flids = DbOps.GetFieldsInClassOfType(mdc, (int)clidVirtual, FieldType.kgrfcptOwning);
foreach (uint flid in flids)
{
int type = mdc.GetFieldType(flid);
if (type == (int)CellarModuleDefns.kfcptOwningAtom)
{
RecomputeVirtuals(sda.get_ObjectProp(hvo, (int)flid), clidVirtual, flidVirtual, typeVirtual, mdc, sda, vh);
}
else
{
// must be owning sequence or collection; do them all.
int chvo = sda.get_VecSize(hvo, (int)flid);
for (int i = 0; i < chvo; i++)
RecomputeVirtuals(sda.get_VecItem(hvo, (int)flid, i), clidVirtual, flidVirtual, typeVirtual, mdc, sda, vh);
}
}
}
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());
}
}
private void TrySelectAnnotation(ISilDataAccess sda, InterlinDocChild pane, int annHvo)
{
// Try our best not to select an annotation we know won't work.
int annoType = sda.get_ObjectProp(annHvo, kflidAnnotationType);
int annInstanceOfRAHvo = sda.get_ObjectProp(annHvo, kflidInstanceOf);
if (annInstanceOfRAHvo == 0 || annoType != CmAnnotationDefn.Twfic(Cache).Hvo)
{
// if we didn't set annHvo by our marker or Clerk.CurrentObject,
// then we must have already tried the first word.
if (m_bookmark.IndexOfParagraph < 0 && Clerk.CurrentObject.Hvo == 0)
return;
// reset our marker and return to avoid trying to reuse an "orphan annotation"
// resulting from an Undo(). (cf. LT-2663).
m_bookmark.Reset();
return; // Can't select nothing, so return.
}
pane.SelectAnnotation(annHvo);
}
/// <summary>
/// Obtain the value of an atomic reference property, including owner.
///</summary>S
/// <param name='hvo'> </param>
/// <param name='tag'> </param>
/// <returns></returns>
public virtual int get_ObjectProp(int hvo, int tag)
{
return(m_baseSda.get_ObjectProp(hvo, tag));
}
private void ApplyAnalysisToInstancesOfWordform(ISilDataAccess sda, int hvoNewAnalysis, int hvoOldWordform, int hvoNewWordform, bool fIsSentenceInitialCaseChange)
{
foreach (int hvoAnn in GetNextXfic())
{
if (hvoAnn == m_hvoAnnotation)
continue; // already processed.
int hvoInstance = sda.get_ObjectProp(hvoAnn,
(int)CmAnnotation.CmAnnotationTags.kflidInstanceOf);
if (hvoInstance == 0)
continue; // skip punctuation.
if (CheckOkToConfirm(fIsSentenceInitialCaseChange,
hvoOldWordform, hvoNewWordform, hvoAnn, hvoInstance))
{
int hvoAnnNew = CacheAnalysisForAnnotation(hvoAnn, hvoNewAnalysis, sda);
if (hvoAnnNew != 0)
SimulateReplaceAnnotation(hvoAnnNew);
}
}
}
private void LoadSecDataForEntry(ILexEntry entryReal, ILexSense senseReal, int hvoSbWord, IVwCacheDa cda, int wsVern,
int hvoMbSec, int fGuessing, ISilDataAccess sdaMain, ITsStrFactory tsf)
{
int hvoEntry = m_caches.FindOrCreateSec(entryReal.Hvo, kclsidSbNamedObj,
hvoSbWord, ktagSbWordDummy);
// try to determine if the given entry is a variant of the sense we passed in (ie. not an owner)
ILexEntryRef ler = null;
int hvoEntryToDisplay = entryReal.Hvo;
if (senseReal != null)
{
if ((entryReal as ILexEntry).IsVariantOfSenseOrOwnerEntry(senseReal, out ler))
hvoEntryToDisplay = senseReal.EntryID;
}
ITsString tssLexEntry = LexEntryVc.GetLexEntryTss(Cache, hvoEntryToDisplay, wsVern, ler);
cda.CacheStringAlt(hvoEntry, ktagSbNamedObjName, wsVern, tssLexEntry);
cda.CacheObjProp(hvoMbSec, ktagSbMorphEntry, hvoEntry);
cda.CacheIntProp(hvoEntry, ktagSbNamedObjGuess, fGuessing);
List<int> writingSystems = m_choices.OtherWritingSystemsForFlid(InterlinLineChoices.kflidLexEntries, 0);
if (writingSystems.Count > 0)
{
// Sigh. We're trying for some reason to display other alternatives of the entry.
int hvoLf = sdaMain.get_ObjectProp(hvoEntryToDisplay, LexEntryTags.kflidLexemeForm);
if (hvoLf != 0)
CopyStringsToSecondary(writingSystems, sdaMain, hvoLf,
MoFormTags.kflidForm, cda, hvoEntry, ktagSbNamedObjName, tsf);
else
CopyStringsToSecondary(writingSystems, sdaMain, hvoEntryToDisplay,
LexEntryTags.kflidCitationForm, cda, hvoEntry, ktagSbNamedObjName, tsf);
}
}
private bool IsItemEligible(ISilDataAccess sda, int hvo, ICmObject selectedObject, string labelToShow)
{
bool fEnable = false;
if (string.IsNullOrEmpty(labelToShow))
return fEnable;
int hvoFeats = sda.get_ObjectProp(hvo, PhPhonemeTags.kflidFeatures);
if (hvoFeats == 0)
return true; // phoneme does not have any features yet, so it is eligible
var feats = m_cache.ServiceLocator.GetInstance<ICmObjectRepository>().GetObject(hvoFeats);
int clsid = feats.ClassID;
if (clsid == FsFeatStrucTags.kClassId)
{
// Only show it as a change if it is different
var features = feats as IFsFeatStruc;
switch (selectedObject.ClassID)
{
case FsSymFeatValTags.kClassId: // user has chosen a value for the targeted feature
var symFeatVal = selectedObject as IFsSymFeatVal;
if (symFeatVal != null && features != null)
{
var closedValue = from s in features.FeatureSpecsOC
where s.ClassID == FsClosedValueTags.kClassId &&
((IFsClosedValue) s).ValueRA == symFeatVal
select s;
fEnable = !closedValue.Any();
}
break;
case FsFeatStrucTags.kClassId: // user has specified one or more feature/value pairs
var fs = selectedObject as IFsFeatStruc;
if (fs != null)
{
var closedValue = from s in features.FeatureSpecsOC
where s.ClassID == FsClosedValueTags.kClassId &&
s.FeatureRA.Abbreviation.BestAnalysisAlternative.Text == m_featDefnAbbr &&
((IFsClosedValue) s).ValueRA.Abbreviation.BestAnalysisAlternative.Text == labelToShow
select s;
fEnable = !closedValue.Any();
}
break;
case FsClosedFeatureTags.kClassId: // user has chosen the remove targeted feature option
var closedFeature = selectedObject as IFsClosedFeature;
if (closedFeature != null)
{
var closedFeatures = from s in features.FeatureSpecsOC
where s.FeatureRA == closedFeature
select s;
fEnable = closedFeatures.Any();
}
break;
default:
fEnable = hvoFeats != SelectedHvo;
break;
}
}
return fEnable;
}
// Check that the specified WfiAnalysis includes at least one morpheme bundle, and that all morpheme
// bundles have the specified property set. Return true if all is well.
private static bool CheckPropSetForAllMorphs(ISilDataAccess sda, int hvoWfiAnalysis, int flid)
{
int cbundle = sda.get_VecSize(hvoWfiAnalysis, (int)WfiAnalysis.WfiAnalysisTags.kflidMorphBundles);
if (cbundle == 0)
return false;
for (int ibundle = 0; ibundle < cbundle; ibundle++)
{
int hvoBundle = sda.get_VecItem(hvoWfiAnalysis, (int)WfiAnalysis.WfiAnalysisTags.kflidMorphBundles, ibundle);
if (sda.get_ObjectProp(hvoBundle, flid) == 0)
return false;
}
return true;
}
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");
}
}
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);
}
}
protected virtual int HvoOfObjectToDisplay(IVwEnv vwenv, int hvo)
{
ISilDataAccess sda = vwenv.DataAccess;
return(sda.get_ObjectProp(hvo, m_flid));
}
/// -----------------------------------------------------------------------------------
/// <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();
}
private static void AddHvoPOStoResults(ISilDataAccess sda, List<int> results, int hvoMsa, int flidPos)
{
int hvoPOS;
hvoPOS = sda.get_ObjectProp(hvoMsa, flidPos);
if (hvoPOS != 0)
results.Add(hvoPOS);
}
int OwnerOf(int hvo, ISilDataAccess sda)
{
return sda.get_ObjectProp(hvo, (int)CmObjectFields.kflidCmObject_Owner);
}
