/// <summary>
///
/// </summary>
/// <param name="argument"></param>
public virtual void OnDeleteReversalIndex(object argument)
{
CheckDisposed();
string sGuid = m_mediator.PropertyTable.GetStringProperty("ReversalIndexGuid", null);
if (sGuid == null)
{
return;
}
Guid oldGuid;
try
{
oldGuid = new Guid(sGuid);
}
catch
{
return; // Can't delete an index if we have a bad guid.
}
if (Cache == null)
{
return;
}
IReversalIndex ri = (IReversalIndex)Cache.ServiceLocator.GetObject(oldGuid);
DeleteReversalIndex(ri);
}
protected virtual void ReallyDeleteReversalIndex(IReversalIndex ri)
{
try
{
Debug.Assert(ri.Hvo == m_list.OwningObject.Hvo);
m_list.ListModificationInProgress = true; // can't reload deleted list! (LT-5353)
// We're about to do a MasterRefresh which clobbers the Undo stack,
// so we might as well make this UOW not undoable
NonUndoableUnitOfWorkHelper.Do(Cache.ActionHandlerAccessor,
() =>
{
Cache.DomainDataByFlid.DeleteObj(ri.Hvo);
int cobjNew;
var idxNew = ReversalIndexAfterDeletion(Cache, out cobjNew);
SetReversalIndexGuid(idxNew.Guid);
});
ChangeOwningObjectIfPossible();
}
finally
{
m_list.ListModificationInProgress = false;
}
// Without this, stale data can still display in the BulkEditSenses tool if you
// recreate the deleted reversal index.
m_mediator.SendMessage("MasterRefresh", null);
}
public bool OnPromoteReversalindexEntry(object cmd)
{
//Command command = (Command) cmd;
Slice slice = m_dataEntryForm.CurrentSlice;
Debug.Assert(slice != null, "No slice was current");
if (slice != null)
{
FdoCache cache = m_dataEntryForm.Cache;
IReversalIndexEntry entry = slice.Object as IReversalIndexEntry;
int hvoNewOwner = cache.GetOwnerOfObject(entry.OwnerHVO);
switch (cache.GetClassOfObject(hvoNewOwner))
{
default:
throw new ArgumentException("Illegal class.");
case ReversalIndex.kclsidReversalIndex:
{
IReversalIndex ri = ReversalIndex.CreateFromDBObject(cache, hvoNewOwner);
ri.EntriesOC.Add(entry);
break;
}
case ReversalIndexEntry.kclsidReversalIndexEntry:
{
IReversalIndexEntry rie = ReversalIndexEntry.CreateFromDBObject(cache, hvoNewOwner);
rie.SubentriesOC.Add(entry);
break;
}
}
// We may need to notify everyone that a virtual property changed.
//NotifyVirtualChanged(cache, slice);
}
return(true);
}
internal int CountReversalIndexEntries(IReversalIndex ri)
{
int[] entries;
using (ReversalIndexActivator.ActivateReversalIndex(ri.Guid, m_mediator))
ConfiguredXHTMLGenerator.GetPublicationDecoratorAndEntries(m_mediator, out entries, ReversalType);
return(entries.Length);
}
public override void Init(FdoCache cache, Mediator mediator, XmlNode recordListNode)
{
CheckDisposed();
// <recordList owner="ReversalIndex" property="AllEntries" assemblyPath="RBRExtensions.dll" class="RBRExtensions.AllReversalEntriesRecordList"/>
BaseInit(cache, mediator, recordListNode);
//string owner = XmlUtils.GetOptionalAttributeValue(recordListNode, "owner");
IVwVirtualHandler vh = cache.VwCacheDaAccessor.GetVirtualHandlerName("ReversalIndex", "AllEntries");
if (vh == null)
{
vh = new AllReversalEntriesVh(null, cache);
cache.VwCacheDaAccessor.InstallVirtual(vh);
}
m_flid = vh.Tag;
int rih = GetReversalIndexHvo(mediator);
if (rih > 0)
{
IReversalIndex ri = ReversalIndex.CreateFromDBObject(cache, rih);
m_owningObject = ri;
m_fontName = ri.WritingSystemRA.DefaultSerif;
}
m_oldLength = 0;
}
/// <summary>
/// Resets the sorter so that it will use the writing system of the given reversal index.
/// </summary>
/// <param name="ri"></param>
private void ResetListSorter(IReversalIndex ri)
{
var sorter = Sorter as GenRecordSorter;
var writingSystem = (IWritingSystem)Cache.WritingSystemFactory.get_Engine(ri.WritingSystem);
if (sorter != null)
{
var stringFinderComparer = sorter.Comparer as StringFinderCompare;
if (stringFinderComparer != null)
{
var comparer = new StringFinderCompare(stringFinderComparer.Finder, new WritingSystemComparer(writingSystem));
sorter.Comparer = comparer;
}
}
else if (Sorter == null)
{
var fakevc = new XmlBrowseViewBaseVc {
SuppressPictures = true, Cache = Cache
}; // SuppressPictures to make sure that we don't leak anything as this will not be disposed.
m_list.Sorter = new GenRecordSorter(new StringFinderCompare(LayoutFinder.CreateFinder(Cache,
BrowseViewFormCol,
fakevc,
(IApp)m_mediator.PropertyTable.GetValue("App")),
new WritingSystemComparer(writingSystem)));
}
}
/// <summary>
///
/// </summary>
/// <param name="argument"></param>
public virtual void OnDeleteReversalIndex(object argument)
{
CheckDisposed();
string sHvo = m_mediator.PropertyTable.GetStringProperty("ReversalIndexHvo", null);
if (sHvo == null)
{
return;
}
int hvo = Convert.ToInt32(sHvo);
if (hvo <= 0)
{
return;
}
if (m_cache == null)
{
m_cache = (FdoCache)m_mediator.PropertyTable.GetValue("cache");
}
if (m_cache == null)
{
return;
}
IReversalIndex ri = ReversalIndex.CreateFromDBObject(m_cache, hvo);
DeleteReversalIndex(ri);
}
protected IReversalIndexEntry CreateReversalIndexEntry(string riForm)
{
var revIndexEntry = m_revIndexEntryFactory.Create();
var wsObj = Cache.LanguageProject.DefaultAnalysisWritingSystem;
IReversalIndex revIndex = m_revIndexRepo.FindOrCreateIndexForWs(wsObj.Handle);
//Add an entry to the Reveral index
revIndex.EntriesOC.Add(revIndexEntry);
revIndexEntry.ReversalForm.set_String(wsObj.Handle, Cache.TsStrFactory.MakeString(riForm, wsObj.Handle));
return(revIndexEntry);
}
/// <summary>
/// Any db object created here or in tests must be added to m_createdObjectList.
/// </summary>
protected void CreateTestData()
{
var rootMT = GetMorphTypeOrCreateOne("root");
var adjPOS = GetGrammaticalCategoryOrCreateOne("adjective", Cache.LangProject.PartsOfSpeechOA);
// le='pus' mtype='root' Sense1(gle='green' pos='adj.')
var lexEntry = AddLexeme(m_createdObjectList, "pus", rootMT, "green", adjPOS);
var revEntry = GetOrCreateReversalIndexEntry(m_createdObjectList);
m_revIndex = AddReversalIndex(m_createdObjectList, revEntry);
}
private static int GetWs(Mediator mediator, FdoCache cache, XmlNode node, string sAttr)
{
string wsSpec = XmlUtils.GetOptionalAttributeValue(node, sAttr);
if (wsSpec != null)
{
IWritingSystemContainer wsContainer = cache.ServiceLocator.WritingSystems;
int ws = 0;
switch (wsSpec)
{
case "vernacular":
ws = wsContainer.DefaultVernacularWritingSystem.Handle;
break;
case "analysis":
ws = wsContainer.DefaultAnalysisWritingSystem.Handle;
break;
case "pronunciation":
ws = wsContainer.DefaultPronunciationWritingSystem.Handle;
break;
case "reversal":
string sGuid = (string)mediator.PropertyTable.GetValue("ReversalIndexGuid", null);
if (sGuid != null)
{
try
{
Guid riGuid = new Guid(sGuid);
IReversalIndex ri = cache.ServiceLocator.GetObject(riGuid) as IReversalIndex;
ws = cache.ServiceLocator.WritingSystemManager.GetWsFromStr(ri.WritingSystem);
}
catch
{
throw new ApplicationException("Couldn't find current reversal index.");
}
}
else
{
throw new ApplicationException("Couldn't find current reversal index.");
}
break;
default:
throw new ApplicationException("ws must be 'vernacular', 'analysis', 'pronunciation', or 'reversal';" + " it said '" + wsSpec + "'.");
}
return(ws);
}
return(0);
}
protected virtual void ReallyDeleteReversalIndex(IReversalIndex ri)
{
try
{
Debug.Assert(ri.Hvo == m_list.OwningObject.Hvo);
m_list.ListModificationInProgress = true; // can't reload deleted list! (LT-5353)
// Clear out any virtual data stored in the cache for this reversal index.
IVwCacheDa cda = m_cache.MainCacheAccessor as IVwCacheDa;
IVwVirtualHandler vh = cda.GetVirtualHandlerName("LexSense",
LexSenseReversalEntriesTextHandler.StandardFieldName);
if (vh != null)
{
int wsDel = ri.WritingSystemRAHvo;
IEnumerator <IReversalIndexEntry> erie = ri.EntriesOC.GetEnumerator();
while (erie.MoveNext())
{
foreach (LinkedObjectInfo loi in erie.Current.BackReferences)
{
if (loi.RelObjClass == (int)LexSense.kClassId)
{
vh.Load(loi.RelObjId, vh.Tag, wsDel, cda);
}
}
}
}
m_cache.BeginUndoTask(LexEdStrings.ksUndoDelete, LexEdStrings.ksRedoDelete);
int cobjOld = m_cache.LangProject.LexDbOA.ReversalIndexesOC.Count;
ri.DeleteUnderlyingObject();
int cobjNew;
int hvoIdxNew = ReversalIndexAfterDeletion(m_cache, out cobjNew);
m_cache.EndUndoTask();
SetReversalIndexHvo(hvoIdxNew);
// Without this, switching to the ReversalEntries tool can crash if it was
// displaying data from the deleted reversal entry.
m_cache.PropChanged(null, PropChangeType.kpctNotifyAll,
m_cache.LangProject.LexDbOAHvo,
(int)LexDb.LexDbTags.kflidReversalIndexes,
0, cobjNew, cobjOld);
}
finally
{
m_list.ListModificationInProgress = false;
}
// Can't do this until ListModificationInProgress flag is cleared because it
// redisplays everything after reloading the list: if the list isn't actually
// reloaded, it tries to display a deleted object -- CRASH!
ChangeOwningObjectIfPossible();
// Without this, stale data can still display in the BulkEditSenses tool if you
// recreate the deleted reversal index.
m_mediator.SendMessage("MasterRefresh", null);
}
protected override FdoObjectSet <ICmObject> GetObjectSet()
{
IVwVirtualHandler handler = (m_cache.MainCacheAccessor as IVwCacheDa).GetVirtualHandlerId(m_flid);
Debug.Assert(handler != null);
IReversalIndex ri = m_owningObject as IReversalIndex;
Debug.Assert(ri != null && ri.IsValidObject(), "The owning ReversalIndex object is invalid!?");
// Force the handler to (re)load the property.
handler.Load(ri.Hvo, m_flid, ri.WritingSystemRAHvo, m_cache.MainCacheAccessor as IVwCacheDa);
int[] items = m_cache.GetVectorProperty(ri.Hvo, m_flid, true);
return(new FdoObjectSet <ICmObject>(m_cache, items, true));
}
protected override IEnumerable <int> GetObjectSet()
{
IReversalIndex ri = m_owningObject as IReversalIndex;
Debug.Assert(ri != null && ri.IsValidObject, "The owning IReversalIndex object is invalid!?");
// Review: is there a better to to convert from List<Subclass> to List<Class>???
List <IReversalIndexEntry> rgrie = ri.AllEntries;
var rgcmo = new List <int>(rgrie.Count);
foreach (IReversalIndexEntry rie in rgrie)
{
rgcmo.Add(rie.Hvo);
}
return(rgcmo);
}
protected IReversalIndex AddReversalIndex(List <ICmObject> addList, IReversalIndexEntry revIndexEntry)
{
Assert.IsNotNull(m_revIndexFactory, "Fixture Initialization is not complete.");
Assert.IsNotNull(m_window, "No window.");
//create a reversal index for this project.
var wsObj = Cache.LanguageProject.DefaultAnalysisWritingSystem;
IReversalIndex revIndex = m_revIndexRepo.FindOrCreateIndexForWs(wsObj.Handle);
//Add an entry to the Reveral index
revIndex.EntriesOC.Add(revIndexEntry);
addList.Add(revIndex);
return(revIndex);
}
public override void Init(LcmCache cache, Mediator mediator, PropertyTable propertyTable, XmlNode recordListNode)
{
CheckDisposed();
// <recordList owner="IReversalIndex" property="AllEntries" assemblyPath="RBRExtensions.dll" class="RBRExtensions.AllReversalEntriesRecordList"/>
BaseInit(cache, mediator, propertyTable, recordListNode);
m_flid = CmPossibilityListTags.kflidPossibilities;
Guid riGuid = AllReversalEntriesRecordList.GetReversalIndexGuid(mediator, propertyTable);
if (riGuid != Guid.Empty)
{
IReversalIndex ri = cache.ServiceLocator.GetObject(riGuid) as IReversalIndex;
m_owningObject = ri.PartsOfSpeechOA;
m_fontName = cache.ServiceLocator.WritingSystemManager.Get(ri.WritingSystem).DefaultFontName;
}
m_oldLength = 0;
}
public override void Init(FdoCache cache, Mediator mediator, XmlNode recordListNode)
{
CheckDisposed();
// <recordList owner="ReversalIndex" property="AllEntries" assemblyPath="RBRExtensions.dll" class="RBRExtensions.AllReversalEntriesRecordList"/>
BaseInit(cache, mediator, recordListNode);
m_flid = (int)CmPossibilityList.CmPossibilityListTags.kflidPossibilities;
int rih = AllReversalEntriesRecordList.GetReversalIndexHvo(mediator);
if (rih > 0)
{
IReversalIndex ri = ReversalIndex.CreateFromDBObject(cache, rih);
m_owningObject = ri.PartsOfSpeechOA;
m_fontName = ri.WritingSystemRA.DefaultSerif;
}
m_oldLength = 0;
}
public override void Init(FdoCache cache, Mediator mediator, XmlNode recordListNode)
{
CheckDisposed();
// <recordList owner="IReversalIndex" property="AllEntries" assemblyPath="RBRExtensions.dll" class="RBRExtensions.AllReversalEntriesRecordList"/>
BaseInit(cache, mediator, recordListNode);
//string owner = XmlUtils.GetOptionalAttributeValue(recordListNode, "owner");
m_flid = ReversalIndexTags.kflidEntries; //LT-12577 a record list needs a real flid.
Guid riGuid = GetReversalIndexGuid(mediator);
if (riGuid != Guid.Empty)
{
IReversalIndex ri = cache.ServiceLocator.GetObject(riGuid) as IReversalIndex;
m_owningObject = ri;
m_fontName = cache.ServiceLocator.WritingSystemManager.Get(ri.WritingSystem).DefaultFontName;
}
m_oldLength = 0;
}
/// <summary>
/// Look for a simple writing system spec as part of a node...currently either 'analysis' or 'vernacular'.
/// If not found, answer 0.
/// If found, answer the ID of the appropriate writing system, or throw exception if not valid.
/// </summary>
/// <param name="cache"></param>
/// <param name="node"></param>
/// <returns></returns>
static int GetWs(Mediator mediator, FdoCache cache, XmlNode node)
{
string wsSpec = XmlUtils.GetOptionalAttributeValue(node, "ws");
if (wsSpec != null)
{
int ws = 0;
switch (wsSpec)
{
case "vernacular":
ws = cache.LangProject.DefaultVernacularWritingSystem;
break;
case "analysis":
ws = cache.LangProject.DefaultAnalysisWritingSystem;
break;
case "pronunciation":
ws = cache.LangProject.DefaultPronunciationWritingSystem;
break;
case "reversal":
int rih = int.Parse((string)mediator.PropertyTable.GetValue("ReversalIndexHvo"));
if (rih > 0)
{
IReversalIndex ri = ReversalIndex.CreateFromDBObject(cache, rih);
ws = ri.WritingSystemRAHvo;
}
else
{
throw new ApplicationException("Couldn't find current reversal index.");
}
break;
default:
throw new ApplicationException("ws must be 'vernacular', 'analysis', 'pronunciation', or 'reversal';" + " it said '" + wsSpec + "'.");
}
return(ws);
}
else
{
return(0);
}
}
private void CreateReversalIndexDlg_FormClosing(object sender, FormClosingEventArgs e)
{
switch (DialogResult)
{
default:
{
Debug.Assert(false, "Unexpected DialogResult.");
break;
}
case DialogResult.Cancel:
{
if (!m_btnCancel.Visible)
{
e.Cancel = true;
MessageBox.Show(LexEdStrings.ksMustSelectOne);
}
break;
}
case DialogResult.OK:
{
NamedWritingSystem nws = m_cbWritingSystems.SelectedItem as NamedWritingSystem;
if (nws != null)
{
ILgWritingSystem lgws = LgWritingSystem.CreateFromDBObject(m_cache, nws.Hvo);
IReversalIndex newIdx = m_cache.LangProject.LexDbOA.ReversalIndexesOC.Add(new ReversalIndex());
newIdx.WritingSystemRA = lgws;
// Copy any and all alternatives from lgws.Name to newIdx.Name
// LT-4907 dies here.
foreach (ILgWritingSystem lgwsLoop in m_cache.LanguageEncodings)
{
string lgsNameAlt = lgws.Name.GetAlternative(lgwsLoop.Hvo);
if (lgsNameAlt != null && lgsNameAlt.Length > 0)
{
newIdx.Name.SetAlternative(lgsNameAlt, lgws.Hvo);
}
}
m_hvoRevIdx = newIdx.Hvo;
}
break;
}
}
}
private void ChangeOwningObject(int id)
{
if (id > 0)
{
if (m_cache == null)
{
m_cache = (FdoCache)m_mediator.PropertyTable.GetValue("cache");
}
IReversalIndex ri = ReversalIndex.CreateFromDBObject(m_cache, id);
ICmObject newOwningObj = NewOwningObject(ri);
if (newOwningObj != OwningObject)
{
OwningObject = newOwningObj;
m_mediator.PropertyTable.SetProperty("ActiveClerkOwningObject", newOwningObj, false);
m_mediator.PropertyTable.SetPropertyPersistence("ActiveClerkOwningObject", false);
m_mediator.SendMessage("ClerkOwningObjChanged", this);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="argument"></param>
public virtual void OnDeleteReversalIndex(object argument)
{
CheckDisposed();
var oldGuid = ReversalIndexEntryUi.GetObjectGuidIfValid(m_propertyTable, "ReversalIndexGuid");
if (oldGuid.Equals(Guid.Empty))
{
return;
}
if (Cache == null)
{
return;
}
IReversalIndex ri = (IReversalIndex)Cache.ServiceLocator.GetObject(oldGuid);
DeleteReversalIndex(ri);
}
private void CreateReversalIndexDlg_FormClosing(object sender, FormClosingEventArgs e)
{
switch (DialogResult)
{
default:
{
Debug.Assert(false, "Unexpected DialogResult.");
break;
}
case DialogResult.Cancel:
{
if (!m_btnCancel.Visible)
{
e.Cancel = true;
MessageBox.Show(LexEdStrings.ksMustSelectOne);
}
break;
}
case DialogResult.OK:
{
var wsObj = m_cbWritingSystems.SelectedItem as IWritingSystem;
if (wsObj != null)
{
UndoableUnitOfWorkHelper.Do(LexEdStrings.ksUndoCreateReversalIndex, LexEdStrings.ksRedoCreateReversalIndex,
m_cache.ActionHandlerAccessor,
() =>
{
IReversalIndex newIdx = m_cache.ServiceLocator.GetInstance <IReversalIndexFactory>().Create();
m_cache.LanguageProject.LexDbOA.ReversalIndexesOC.Add(newIdx);
newIdx.WritingSystem = wsObj.Id;
// TODO WS: should we use the DisplayLabel here?
newIdx.Name.SetAnalysisDefaultWritingSystem(wsObj.DisplayLabel);
newIdx.PartsOfSpeechOA = m_cache.ServiceLocator.GetInstance <ICmPossibilityListFactory>().Create();
m_hvoRevIdx = newIdx.Hvo;
});
}
break;
}
}
}
public void DeleteReversalIndex(IReversalIndex ri)
{
CheckDisposed();
Form mainWindow = (Form)m_mediator.PropertyTable.GetValue("window");
mainWindow.Cursor = Cursors.WaitCursor;
using (ConfirmDeleteObjectDlg dlg = new ConfirmDeleteObjectDlg())
{
SIL.FieldWorks.FdoUi.CmObjectUi ui = new SIL.FieldWorks.FdoUi.CmObjectUi(ri);
dlg.SetDlgInfo(ui, m_cache, m_mediator);
dlg.TopMessage = LexEdStrings.ksDeletingThisRevIndex;
dlg.BottomQuestion = LexEdStrings.ksReallyWantToDeleteRevIndex;
if (DialogResult.Yes == dlg.ShowDialog(mainWindow))
{
ReallyDeleteReversalIndex(ri);
}
}
mainWindow.Cursor = Cursors.Default;
}
public void DeleteReversalIndex(IReversalIndex ri)
{
CheckDisposed();
var mainWindow = (Form)m_mediator.PropertyTable.GetValue("window");
using (new WaitCursor(mainWindow))
{
using (var dlg = new ConfirmDeleteObjectDlg(m_mediator.HelpTopicProvider))
{
var ui = new CmObjectUi(ri);
dlg.SetDlgInfo(ui, Cache, m_mediator);
dlg.TopMessage = LexEdStrings.ksDeletingThisRevIndex;
dlg.BottomQuestion = LexEdStrings.ksReallyWantToDeleteRevIndex;
if (DialogResult.Yes == dlg.ShowDialog(mainWindow))
{
ReallyDeleteReversalIndex(ri);
}
}
}
}
public override void PropChanged(int hvo, int tag, int ivMin, int cvIns, int cvDel)
{
CheckDisposed();
if (hvo == m_cache.LangProject.LexDbOAHvo &&
tag == (int)LexDb.LexDbTags.kflidReversalIndexes &&
cvDel > 0)
{
// Our owning object may have been deleted.
int rih = int.Parse((string)m_mediator.PropertyTable.GetValue("ReversalIndexHvo"));
if (rih > 0 && !m_cache.IsValidObject(rih))
{
if (m_owningObject != null && m_owningObject.Hvo != rih && m_owningObject.IsValidObject())
{
rih = m_owningObject.Hvo;
}
else
{
int cobjNew;
rih = ReversalClerk.ReversalIndexAfterDeletion(m_cache, out cobjNew);
}
m_mediator.PropertyTable.SetProperty("ReversalIndexHvo", rih.ToString());
}
if (rih > 0 && (m_owningObject == null || m_owningObject.Hvo != rih))
{
IReversalIndex ri = ReversalIndex.CreateFromDBObject(m_cache, rih);
m_owningObject = ri;
m_fontName = ri.WritingSystemRA.DefaultSerif;
}
else
{
return; // We're still okay without any changes.
}
}
else if (m_owningObject != null && m_owningObject.Hvo != hvo)
{
return; // This PropChanged doesn't apply to us.
}
ReloadListIfPossible();
}
public override void Init(LcmCache cache, Mediator mediator, PropertyTable propertyTable, XmlNode recordListNode)
{
CheckDisposed();
// <recordList owner="IReversalIndex" property="AllEntries" assemblyPath="RBRExtensions.dll" class="RBRExtensions.AllReversalEntriesRecordList"/>
BaseInit(cache, mediator, propertyTable, recordListNode);
//string owner = XmlUtils.GetOptionalAttributeValue(recordListNode, "owner");
m_flid = ReversalIndexTags.kflidEntries; //LT-12577 a record list needs a real flid.
//LT-14722 Crash when clicking Reversal Indexes
//Clerk is null when going to Reversal Indexes for the first time.
if (Clerk != null)
{
Guid riGuid = GetReversalIndexGuid(mediator, propertyTable);
if (riGuid != Guid.Empty)
{
IReversalIndex ri = cache.ServiceLocator.GetObject(riGuid) as IReversalIndex;
m_owningObject = ri;
m_fontName = cache.ServiceLocator.WritingSystemManager.Get(ri.WritingSystem).DefaultFontName;
}
}
m_oldLength = 0;
}
public bool OnPromoteReversalindexEntry(object cmd)
{
//Command command = (Command) cmd;
Slice slice = m_dataEntryForm.CurrentSlice;
Debug.Assert(slice != null, "No slice was current");
if (slice != null)
{
FdoCache cache = m_dataEntryForm.Cache;
IReversalIndexEntry entry = slice.Object as IReversalIndexEntry;
ICmObject newOwner = entry.Owner.Owner;
UndoableUnitOfWorkHelper.Do(((Command)cmd).UndoText, ((Command)cmd).RedoText, newOwner,
() =>
{
switch (newOwner.ClassID)
{
default:
throw new ArgumentException("Illegal class.");
case ReversalIndexTags.kClassId:
{
IReversalIndex ri = (IReversalIndex)newOwner;
ri.EntriesOC.Add(entry);
break;
}
case ReversalIndexEntryTags.kClassId:
{
IReversalIndexEntry rie = (IReversalIndexEntry)newOwner;
rie.SubentriesOS.Add(entry);
break;
}
}
});
// We may need to notify everyone that a virtual property changed.
//NotifyVirtualChanged(cache, slice);
}
return(true);
}
public void DummyReversalCreatedOnFocusLost()
{
NonUndoableUnitOfWorkHelper.Do(Cache.ActionHandlerAccessor, () =>
{
m_lexEntry = Cache.ServiceLocator.GetInstance <ILexEntryFactory>().Create();
ILexSense sense = Cache.ServiceLocator.GetInstance <ILexSenseFactory>().Create();
m_lexEntry.SensesOS.Add(sense);
});
int engWsId = Cache.DefaultAnalWs;
m_reversalSlice = new DummyReversalIndexEntrySlice(m_lexEntry.SensesOS[0]);
m_reversalSlice.Cache = Cache;
// Creating the reversal index before the slice is fully initialized ensures the reversal index gets loaded into the dummy cache
IReversalIndex ri = m_revIndexRepo.FindOrCreateIndexForWs(engWsId);
m_reversalSlice.FinishInit();
DummyReversalIndexEntrySliceView reversalView = m_reversalSlice.DummyControl;
int indexFirstEntry = 0;
reversalView.CacheNewDummyEntry(ri.Hvo, engWsId); // Create an additional dummy reversal entry before we edit one
reversalView.EditRevIndexEntryInCache(ri.Hvo, indexFirstEntry, engWsId, TsStringUtils.MakeString("first", engWsId));
// The dummy cache will have two dummy reversal index entries, but non exists in the real data yet.
// The reversal index entry control must maintain a dummy entry at the end to allow a place to click to add new entries.
Assert.AreEqual(0, m_revIndexEntryRepo.Count);
Assert.AreEqual(2, reversalView.GetIndexSize(ri.Hvo)); // The second dummy entry will remain a dummy
reversalView.KillFocus(new Control());
Assert.AreEqual(1, m_revIndexEntryRepo.Count);
Assert.AreEqual(2, reversalView.GetIndexSize(ri.Hvo));
IReversalIndexEntry rie = m_revIndexEntryRepo.AllInstances().First();
Assert.AreEqual("first", rie.ShortName);
Assert.AreEqual(1, m_lexEntry.SensesOS[0].ReferringReversalIndexEntries.Count());
Assert.True(m_lexEntry.SensesOS[0].ReferringReversalIndexEntries.Contains(rie));
}
internal static int ReversalIndexAfterDeletion(FdoCache cache, out int cobjNew)
{
int hvoIdxNew = 0;
cobjNew = cache.LangProject.LexDbOA.ReversalIndexesOC.Count;
if (cobjNew == 0)
{
// Big trouble ensues if we don't have any reversal indexes at all, so ...
// Create a reversal index for the current default analysis writing system.
IReversalIndex newIdx = cache.LangProject.LexDbOA.ReversalIndexesOC.Add(new ReversalIndex());
ILgWritingSystem wsAnalysis = cache.LangProject.CurAnalysisWssRS[0];
newIdx.WritingSystemRA = wsAnalysis;
newIdx.Name.AnalysisDefaultWritingSystem = wsAnalysis.Name.AnalysisDefaultWritingSystem;
hvoIdxNew = newIdx.Hvo;
cobjNew = 1;
}
else
{
// Regardless, we need to change the reversal index hvo since the old one just
// disappeared.
hvoIdxNew = cache.LangProject.LexDbOA.ReversalIndexesOC.HvoArray[0];
}
return(hvoIdxNew);
}
public void DeleteReversalIndex(IReversalIndex ri)
{
CheckDisposed();
var mainWindow = (Form)m_mediator.PropertyTable.GetValue("window");
using (new WaitCursor(mainWindow))
{
using (var dlg = new ConfirmDeleteObjectDlg(m_mediator.HelpTopicProvider))
{
var ui = new CmObjectUi(ri);
dlg.SetDlgInfo(ui, Cache, m_mediator);
dlg.TopMessage = LexEdStrings.ksDeletingThisRevIndex;
dlg.BottomQuestion = LexEdStrings.ksReallyWantToDeleteRevIndex;
if (DialogResult.Yes == dlg.ShowDialog(mainWindow))
ReallyDeleteReversalIndex(ri);
}
}
}
protected virtual void ReallyDeleteReversalIndex(IReversalIndex ri)
{
try
{
Debug.Assert(ri.Hvo == m_list.OwningObject.Hvo);
m_list.ListModificationInProgress = true; // can't reload deleted list! (LT-5353)
// We're about to do a MasterRefresh which clobbers the Undo stack,
// so we might as well make this UOW not undoable
NonUndoableUnitOfWorkHelper.Do(Cache.ActionHandlerAccessor,
() =>
{
Cache.DomainDataByFlid.DeleteObj(ri.Hvo);
int cobjNew;
var idxNew = ReversalIndexAfterDeletion(Cache, out cobjNew);
SetReversalIndexGuid(idxNew.Guid);
});
ChangeOwningObjectIfPossible();
}
finally
{
m_list.ListModificationInProgress = false;
}
// Without this, stale data can still display in the BulkEditSenses tool if you
// recreate the deleted reversal index.
m_mediator.SendMessage("MasterRefresh", null);
}
abstract protected ICmObject NewOwningObject(IReversalIndex ri);
public void DeleteReversalIndex(IReversalIndex ri)
{
CheckDisposed();
Form mainWindow = (Form)m_mediator.PropertyTable.GetValue("window");
mainWindow.Cursor = Cursors.WaitCursor;
using (ConfirmDeleteObjectDlg dlg = new ConfirmDeleteObjectDlg())
{
SIL.FieldWorks.FdoUi.CmObjectUi ui = new SIL.FieldWorks.FdoUi.CmObjectUi(ri);
dlg.SetDlgInfo(ui, m_cache, m_mediator);
dlg.TopMessage = LexEdStrings.ksDeletingThisRevIndex;
dlg.BottomQuestion = LexEdStrings.ksReallyWantToDeleteRevIndex;
if (DialogResult.Yes == dlg.ShowDialog(mainWindow))
ReallyDeleteReversalIndex(ri);
}
mainWindow.Cursor = Cursors.Default;
}
protected override ICmObject NewOwningObject(IReversalIndex ri)
{
return(ri);
}
public ReversalEntryGoSearchEngine(FdoCache cache, IReversalIndex reversalIndex)
: base(cache, SearchType.Prefix)
{
m_reversalIndex = reversalIndex;
m_revEntryRepository = Cache.ServiceLocator.GetInstance<IReversalIndexEntryRepository>();
}
private IReversalIndexEntry MakeReversalIndexReference(ILexSense sense, string gloss, IReversalIndex ri)
{
var rie = Cache.ServiceLocator.GetInstance<IReversalIndexEntryFactory>().Create();
ri.EntriesOC.Add(rie);
rie.ReversalForm.AnalysisDefaultWritingSystem = Cache.TsStrFactory.MakeString(gloss,
Cache.DefaultAnalWs);
sense.ReversalEntriesRC.Add(rie);
return rie;
}
protected override ICmObject NewOwningObject(IReversalIndex ri)
{
return ri.PartsOfSpeechOA;
}
protected override ICmObject NewOwningObject(IReversalIndex ri)
{
return ri;
}
protected virtual void ReallyDeleteReversalIndex(IReversalIndex ri)
{
try
{
Debug.Assert(ri.Hvo == m_list.OwningObject.Hvo);
m_list.ListModificationInProgress = true; // can't reload deleted list! (LT-5353)
// Clear out any virtual data stored in the cache for this reversal index.
IVwCacheDa cda = m_cache.MainCacheAccessor as IVwCacheDa;
IVwVirtualHandler vh = cda.GetVirtualHandlerName("LexSense",
LexSenseReversalEntriesTextHandler.StandardFieldName);
if (vh != null)
{
int wsDel = ri.WritingSystemRAHvo;
IEnumerator<IReversalIndexEntry> erie = ri.EntriesOC.GetEnumerator();
while (erie.MoveNext())
{
foreach (LinkedObjectInfo loi in erie.Current.BackReferences)
{
if (loi.RelObjClass == (int)LexSense.kClassId)
vh.Load(loi.RelObjId, vh.Tag, wsDel, cda);
}
}
}
m_cache.BeginUndoTask(LexEdStrings.ksUndoDelete, LexEdStrings.ksRedoDelete);
int cobjOld = m_cache.LangProject.LexDbOA.ReversalIndexesOC.Count;
ri.DeleteUnderlyingObject();
int cobjNew;
int hvoIdxNew = ReversalIndexAfterDeletion(m_cache, out cobjNew);
m_cache.EndUndoTask();
SetReversalIndexHvo(hvoIdxNew);
// Without this, switching to the ReversalEntries tool can crash if it was
// displaying data from the deleted reversal entry.
m_cache.PropChanged(null, PropChangeType.kpctNotifyAll,
m_cache.LangProject.LexDbOAHvo,
(int)LexDb.LexDbTags.kflidReversalIndexes,
0, cobjNew, cobjOld);
}
finally
{
m_list.ListModificationInProgress = false;
}
// Can't do this until ListModificationInProgress flag is cleared because it
// redisplays everything after reloading the list: if the list isn't actually
// reloaded, it tries to display a deleted object -- CRASH!
ChangeOwningObjectIfPossible();
// Without this, stale data can still display in the BulkEditSenses tool if you
// recreate the deleted reversal index.
m_mediator.SendMessage("MasterRefresh", null);
}
/// <summary>
/// Any db object created here or in tests must be added to m_createdObjectList.
/// </summary>
protected void CreateTestData()
{
var rootMT = GetMorphTypeOrCreateOne("root");
var adjPOS = GetGrammaticalCategoryOrCreateOne("adjective", Cache.LangProject.PartsOfSpeechOA);
// le='pus' mtype='root' Sense1(gle='green' pos='adj.')
var lexEntry = AddLexeme(m_createdObjectList, "pus", rootMT, "green", adjPOS);
var revEntry = GetOrCreateReversalIndexEntry(m_createdObjectList);
m_revIndex = AddReversalIndex(m_createdObjectList, revEntry);
}
/// <summary>
/// Find the reversal index entry given by rgsForms, or if it doesn't exist, create
/// it. In either case, return its hvo.
/// </summary>
public static int FindOrCreateReversalEntry(IReversalIndex revIndex, List<string> rgsForms,
FdoCache cache)
{
List<List<IReversalIndexEntry>> rgrieMatching = new List<List<IReversalIndexEntry>>(rgsForms.Count);
// This could be SLOOOOOOOOOOW! But I don't see a better way of doing it...
for (int i = 0; i < rgsForms.Count; ++i)
rgrieMatching.Add(new List<IReversalIndexEntry>());
int wsIndex = cache.ServiceLocator.WritingSystemManager.GetWsFromStr(revIndex.WritingSystem);
foreach (IReversalIndexEntry rie in revIndex.AllEntries)
{
string form = rie.ReversalForm.get_String(wsIndex).Text;
int idx = rgsForms.IndexOf(form);
if (idx >= 0)
rgrieMatching[idx].Add(rie);
}
List<int> rghvoOwners = new List<int>(rgsForms.Count);
rghvoOwners.Add(revIndex.Hvo);
// The next two variables record the best partial match, if any.
int maxLevel = 0;
int maxOwner = revIndex.Hvo;
int hvo = FindMatchingReversalEntry(rgsForms, rghvoOwners, rgrieMatching,
0, ref maxLevel, ref maxOwner);
if (hvo == 0)
{
cache.DomainDataByFlid.BeginUndoTask(LexEdStrings.ksCreateReversal,
LexEdStrings.ksRecreateReversal);
// Create whatever we need to since we didn't find a full match.
ICmObject owner =
cache.ServiceLocator.GetInstance<ICmObjectRepository>().GetObject(maxOwner);
Debug.Assert(maxLevel < rgsForms.Count);
IReversalIndexEntryFactory fact = cache.ServiceLocator.GetInstance<IReversalIndexEntryFactory>();
for (int i = maxLevel; i < rgsForms.Count; ++i)
{
IReversalIndexEntry rie = fact.Create();
if (owner is IReversalIndex)
{
(owner as IReversalIndex).EntriesOC.Add(rie);
}
else
{
Debug.Assert(owner is IReversalIndexEntry);
(owner as IReversalIndexEntry).SubentriesOS.Add(rie);
}
rie.ReversalForm.set_String(wsIndex, rgsForms[i]);
owner = rie;
hvo = rie.Hvo;
}
Debug.Assert(hvo != 0);
cache.DomainDataByFlid.EndUndoTask();
}
return hvo;
}
public ReversalEntrySearchEngine(FdoCache cache, IReversalIndex revIndex) : base(cache, revIndex) {}
