/// <summary>
/// Executes in two distinct scenarios.
///
/// 1. If disposing is true, the method has been called directly
/// or indirectly by a user's code via the Dispose method.
/// Both managed and unmanaged resources can be disposed.
///
/// 2. If disposing is false, the method has been called by the
/// runtime from inside the finalizer and you should not reference (access)
/// other managed objects, as they already have been garbage collected.
/// Only unmanaged resources can be disposed.
/// </summary>
/// <param name="disposing"></param>
/// <remarks>
/// If any exceptions are thrown, that is fine.
/// If the method is being done in a finalizer, it will be ignored.
/// If it is thrown by client code calling Dispose,
/// it needs to be handled by fixing the bug.
///
/// If subclasses override this method, they should call the base implementation.
/// </remarks>
protected override void Dispose(bool disposing)
{
//Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************");
// Must not be run more than once.
if (IsDisposed)
{
return;
}
if (disposing)
{
// Dispose managed resources here.
if (m_sda != null)
{
m_sda.RemoveNotification(this);
m_sda = null;
}
var arl = Control as AtomicReferenceLauncher;
if (arl != null)
{
arl.ChoicesMade -= RefreshTree;
arl.ViewSizeChanged -= OnViewSizeChanged;
var view = (AtomicReferenceView)arl.MainControl;
view.ViewSizeChanged -= OnViewSizeChanged;
}
}
// Dispose unmanaged resources here, whether disposing is true or false.
base.Dispose(disposing);
}
/// <summary>
/// Clean up any resources being used.
/// </summary>
protected override void Dispose(bool disposing)
{
//Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************");
// Must not be run more than once.
if (IsDisposed)
{
return;
}
base.Dispose(disposing);
if (disposing)
{
if (components != null)
{
components.Dispose();
}
if (m_vc != null)
{
m_vc.Dispose();
}
m_sda.RemoveNotification(this);
}
m_vc = null;
m_fs = null;
m_sda = null;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Executes in two distinct scenarios.
/// 1. If disposing is true, the method has been called directly
/// or indirectly by a user's code via the Dispose method.
/// Both managed and unmanaged resources can be disposed.
/// 2. If disposing is false, the method has been called by the
/// runtime from inside the finalizer and you should not reference (access)
/// other managed objects, as they already have been garbage collected.
/// Only unmanaged resources can be disposed.
/// </summary>
/// <param name="disposing">true to release both managed and unmanaged resources; false
/// to release only unmanaged resources.</param>
/// <remarks>
/// If any exceptions are thrown, that is fine.
/// If the method is being done in a finalizer, it will be ignored.
/// If it is thrown by client code calling Dispose,
/// it needs to be handled by fixing the bug.
/// If subclasses override this method, they should call the base implementation.
/// </remarks>
/// ------------------------------------------------------------------------------------
protected override void Dispose(bool disposing)
{
System.Diagnostics.Debug.WriteLineIf(!disposing, "****************** Missing Dispose() call for " + GetType().Name + " ******************");
// Must not be run more than once.
if (IsDisposed)
{
return;
}
if (disposing)
{
// Dispose managed resources here.
if (m_sda != null)
{
m_sda.RemoveNotification(this);
}
// m_innerFwTextBox is part of Controls collection and will be disposed there.
}
// Dispose unmanaged resources here, whether disposing is true or false.
m_innerFwTextBox = null;
m_sda = null;
base.Dispose(disposing);
}
/// <summary>
/// Executes in two distinct scenarios.
///
/// 1. If disposing is true, the method has been called directly
/// or indirectly by a user's code via the Dispose method.
/// Both managed and unmanaged resources can be disposed.
///
/// 2. If disposing is false, the method has been called by the
/// runtime from inside the finalizer and you should not reference (access)
/// other managed objects, as they already have been garbage collected.
/// Only unmanaged resources can be disposed.
/// </summary>
/// <param name="disposing"></param>
/// <remarks>
/// If any exceptions are thrown, that is fine.
/// If the method is being done in a finalizer, it will be ignored.
/// If it is thrown by client code calling Dispose,
/// it needs to be handled by fixing the bug.
///
/// If subclasses override this method, they should call the base implementation.
/// </remarks>
protected virtual void Dispose(bool disposing)
{
//Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************");
// Must not be run more than once.
if (m_isDisposed)
{
return;
}
// m_sda COM object block removed due to crash in Finializer thread LT-6124
if (disposing)
{
// Dispose managed resources here.
if (m_sda != null)
{
m_sda.RemoveNotification(this);
}
}
m_cache = null;
m_sda = null;
// Dispose unmanaged resources here, whether disposing is true or false.
m_isDisposed = true;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Executes in two distinct scenarios.
/// 1. If disposing is true, the method has been called directly
/// or indirectly by a user's code via the Dispose method.
/// Both managed and unmanaged resources can be disposed.
/// 2. If disposing is false, the method has been called by the
/// runtime from inside the finalizer and you should not reference (access)
/// other managed objects, as they already have been garbage collected.
/// Only unmanaged resources can be disposed.
/// </summary>
/// <param name="disposing">true to release both managed and unmanaged resources; false
/// to release only unmanaged resources.</param>
/// <remarks>
/// If any exceptions are thrown, that is fine.
/// If the method is being done in a finalizer, it will be ignored.
/// If it is thrown by client code calling Dispose,
/// it needs to be handled by fixing the bug.
/// If subclasses override this method, they should call the base implementation.
/// </remarks>
/// ------------------------------------------------------------------------------------
protected override void Dispose(bool disposing)
{
// Must not be run more than once.
if (IsDisposed)
{
return;
}
if (disposing)
{
// Dispose managed resources here.
if (m_sda != null)
{
m_sda.RemoveNotification(this);
}
// m_innerFwTextBox is part of Controls collection and will be disposed there.
}
// Dispose unmanaged resources here, whether disposing is true or false.
m_innerFwTextBox = null;
m_sda = null;
base.Dispose(disposing);
}
/// <summary>
/// Executes in two distinct scenarios.
///
/// 1. If disposing is true, the method has been called directly
/// or indirectly by a user's code via the Dispose method.
/// Both managed and unmanaged resources can be disposed.
///
/// 2. If disposing is false, the method has been called by the
/// runtime from inside the finalizer and you should not reference (access)
/// other managed objects, as they already have been garbage collected.
/// Only unmanaged resources can be disposed.
/// </summary>
/// <param name="disposing"></param>
/// <remarks>
/// If any exceptions are thrown, that is fine.
/// If the method is being done in a finalizer, it will be ignored.
/// If it is thrown by client code calling Dispose,
/// it needs to be handled by fixing the bug.
///
/// If subclasses override this method, they should call the base implementation.
/// </remarks>
protected virtual void Dispose(bool disposing)
{
//Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************");
// Must not be run more than once.
if (m_isDisposed)
{
return;
}
// m_sda COM object block removed due to crash in Finializer thread LT-6124
if (disposing)
{
if (m_sda != null)
{
m_sda.RemoveNotification(this);
}
if (m_cache.CreateModifyManager == this)
{
m_cache.CreateModifyManager = null;
}
}
// Dispose unmanaged resources here, whether disposing is true or false.
m_sda = null;
m_cache = null; // ensures it can't be used again without crashing.
m_mdc = null;
m_recentMods = null;
m_isDisposed = true;
}
private void Dispose(bool disposing)
{
System.Diagnostics.Debug.WriteLineIf(!disposing, "****** Missing Dispose() call for " + GetType() + " ******");
if (disposing)
{
m_sda.RemoveNotification(this);
}
}
/// <summary>
/// Clean up any resources being used.
/// </summary>
protected override void Dispose(bool disposing)
{
//Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************");
// Must not be run more than once.
if (IsDisposed)
{
return;
}
// m_sda COM object block removed due to crash in Finializer thread LT-6124
if (disposing)
{
if (m_button != null)
{
m_button.MouseDown -= new MouseEventHandler(m_button_MouseDown);
m_button.GotFocus -= new EventHandler(m_button_GotFocus);
m_button.LostFocus -= new EventHandler(m_button_LostFocus);
}
if (m_sda != null)
{
m_sda.RemoveNotification(this);
}
if (m_comboTextBox != null)
{
m_comboTextBox.KeyPress -= new KeyPressEventHandler(m_comboTextBox_KeyPress);
m_comboTextBox.KeyDown -= new KeyEventHandler(m_comboTextBox_KeyDown);
m_comboTextBox.MouseDown -= new MouseEventHandler(m_comboTextBox_MouseDown);
m_comboTextBox.GotFocus -= new EventHandler(m_comboTextBox_GotFocus);
m_comboTextBox.LostFocus -= new EventHandler(m_comboTextBox_LostFocus);
}
if (m_popupTree != null)
{
m_popupTree.AfterSelect -= new TreeViewEventHandler(m_tree_AfterSelect);
m_popupTree.BeforeSelect -= new TreeViewCancelEventHandler(m_popupTree_BeforeSelect);
m_popupTree.Load -= new EventHandler(m_tree_Load);
m_popupTree.VisibleChanged -= new EventHandler(m_popupTree_VisibleChanged);
}
if (m_popupTree != null && !m_popupTree.IsDisposed)
{
m_popupTree.Dispose();
}
}
m_button = null; // So OnLayout knows to do nothing.
m_comboTextBox = null;
m_popupTree = null;
m_sda = null;
base.Dispose(disposing);
}
internal override void Dispose(bool beforeDestructor)
{
if (beforeDestructor)
{
if (m_sda != null)
{
m_sda.RemoveNotification(this);
m_sda = null;
}
}
base.Dispose(beforeDestructor);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// If a test overrides this, it should call this base implementation.
/// </summary>
/// ------------------------------------------------------------------------------------
public override void TestTearDown()
{
m_sda.RemoveNotification(m_notifiee);
m_notifiee = null;
while (m_actionHandler.CanUndo())
{
m_actionHandler.Undo();
}
m_actionHandler.Commit();
base.TestTearDown();
}
/// <summary>
/// Executes in two distinct scenarios.
///
/// 1. If disposing is true, the method has been called directly
/// or indirectly by a user's code via the Dispose method.
/// Both managed and unmanaged resources can be disposed.
///
/// 2. If disposing is false, the method has been called by the
/// runtime from inside the finalizer and you should not reference (access)
/// other managed objects, as they already have been garbage collected.
/// Only unmanaged resources can be disposed.
/// </summary>
/// <param name="disposing"></param>
/// <remarks>
/// If any exceptions are thrown, that is fine.
/// If the method is being done in a finalizer, it will be ignored.
/// If it is thrown by client code calling Dispose,
/// it needs to be handled by fixing the bug.
///
/// If subclasses override this method, they should call the base implementation.
/// </remarks>
protected virtual void Dispose(bool disposing)
{
//Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************");
// Must not be run more than once.
if (m_isDisposed)
{
return;
}
// m_sda COM object block removed due to crash in Finializer thread LT-6124
if (disposing)
{
// Dispose managed resources here.
if (m_updateTimer != null)
{
m_updateTimer.Stop();
m_updateTimer.Tick -= new EventHandler(m_updateTimer_Elapsed);
m_updateTimer.Dispose();
}
if (m_sda != null)
{
m_sda.RemoveNotification(this);
}
m_mediator.RemoveColleague(this);
ParserConnection cnx = Connection;
if (cnx != null)
{
// Remove ParserConnection from the PropertyTable.
m_mediator.PropertyTable.SetProperty("ParserConnection", null, false);
m_mediator.PropertyTable.SetPropertyPersistence("ParserConnection", false);
m_mediator.PropertyTable.SetProperty("ParserListener", null, false);
m_mediator.PropertyTable.SetPropertyPersistence("ParserListener", false);
cnx.Dispose();
}
}
// Dispose unmanaged resources here, whether disposing is true or false.
m_sda = null;
m_mediator = null;
m_cache = null;
m_updateTimer = null;
m_traceSwitch = null;
m_isDisposed = true;
}
/// <summary>
/// Executes in two distinct scenarios.
///
/// 1. If disposing is true, the method has been called directly
/// or indirectly by a user's code via the Dispose method.
/// Both managed and unmanaged resources can be disposed.
///
/// 2. If disposing is false, the method has been called by the
/// runtime from inside the finalizer and you should not reference (access)
/// other managed objects, as they already have been garbage collected.
/// Only unmanaged resources can be disposed.
/// </summary>
/// <param name="disposing"></param>
/// <remarks>
/// If any exceptions are thrown, that is fine.
/// If the method is being done in a finalizer, it will be ignored.
/// If it is thrown by client code calling Dispose,
/// it needs to be handled by fixing the bug.
///
/// If subclasses override this method, they should call the base implementation.
/// </remarks>
protected virtual void Dispose(bool disposing)
{
Debug.WriteLineIf(!disposing, "****** Missing Dispose() call for " + GetType().Name + ". ****** ");
// Must not be run more than once.
if (m_isDisposed)
{
return;
}
// m_sda COM object block removed due to crash in Finializer thread LT-6124
if (disposing)
{
// other clients may now parse
// Dispose managed resources here.
if (m_timer != null)
{
m_timer.Stop();
m_timer.Tick -= m_timer_Tick;
}
if (m_sda != null)
{
m_sda.RemoveNotification(this);
}
m_mediator.RemoveColleague(this);
if (m_parserConnection != null)
{
m_parserConnection.Dispose();
}
if (m_lock != null)
{
m_lock.Dispose();
}
}
// Dispose unmanaged resources here, whether disposing is true or false.
m_timer = null;
m_sda = null;
m_mediator = null;
m_cache = null;
m_traceSwitch = null;
m_lock = null;
m_parserConnection = null;
m_isDisposed = true;
}
protected override void Dispose(bool disposing)
{
// Must not be run more than once.
if (IsDisposed)
{
return;
}
// m_sda COM object block removed due to crash in Finializer thread LT-6124
if (disposing)
{
if (SplitCont != null && !SplitCont.IsDisposed &&
SplitCont.Panel2 != null && !SplitCont.Panel2.IsDisposed)
{
SplitCont.Panel2.SizeChanged -= new EventHandler(SplitContPanel2_SizeChanged);
}
// Dispose managed resources here.
if (m_sda != null)
{
m_sda.RemoveNotification(this);
}
if (m_tree != null && m_tree.Parent == null)
{
m_tree.Dispose();
}
if (m_MSAPopupTreeManager != null)
{
m_MSAPopupTreeManager.AfterSelect -= new TreeViewEventHandler(m_MSAPopupTreeManager_AfterSelect);
m_MSAPopupTreeManager.Dispose();
}
}
// Dispose unmanaged resources here, whether disposing is true or false.
m_sda = null;
m_tree = null;
m_MSAPopupTreeManager = null;
m_persistProvider = null;
base.Dispose(disposing);
}
/// <summary>
/// Executes in two distinct scenarios.
///
/// 1. If disposing is true, the method has been called directly
/// or indirectly by a user's code via the Dispose method.
/// Both managed and unmanaged resources can be disposed.
///
/// 2. If disposing is false, the method has been called by the
/// runtime from inside the finalizer and you should not reference (access)
/// other managed objects, as they already have been garbage collected.
/// Only unmanaged resources can be disposed.
/// </summary>
/// <param name="disposing"></param>
/// <remarks>
/// If any exceptions are thrown, that is fine.
/// If the method is being done in a finalizer, it will be ignored.
/// If it is thrown by client code calling Dispose,
/// it needs to be handled by fixing the bug.
///
/// If subclasses override this method, they should call the base implementation.
/// </remarks>
protected override void Dispose(bool disposing)
{
//Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************");
// Must not be run more than once.
if (IsDisposed)
{
return;
}
// m_sda COM object block removed due to crash in Finializer thread LT-6124
if (disposing)
{
// Dispose managed resources here.
if (m_sda != null)
{
m_sda.RemoveNotification(this);
}
if (m_tree != null && m_tree.Parent == null)
{
m_tree.Dispose();
}
if (m_pOSPopupTreeManager != null)
{
m_pOSPopupTreeManager.AfterSelect -= new TreeViewEventHandler(m_pOSPopupTreeManager_AfterSelect);
m_pOSPopupTreeManager.Dispose();
}
}
// Dispose unmanaged resources here, whether disposing is true or false.
m_sda = null;
m_cache = null;
m_tree = null;
m_pOSPopupTreeManager = null;
m_persistProvider = null;
m_pos = null;
base.Dispose(disposing);
}
/// <summary>
/// Clean up any resources being used.
/// </summary>
protected override void Dispose(bool disposing)
{
//Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************");
// Must not be run more than once.
if (IsDisposed)
{
return;
}
if (disposing)
{
// Do this first, before setting m_fDisposing to true.
if (m_sda != null)
{
m_sda.RemoveNotification(this);
}
if (components != null)
{
components.Dispose();
}
}
base.Dispose(disposing);
}
/// <summary>
/// Executes in two distinct scenarios.
///
/// 1. If disposing is true, the method has been called directly
/// or indirectly by a user's code via the Dispose method.
/// Both managed and unmanaged resources can be disposed.
///
/// 2. If disposing is false, the method has been called by the
/// runtime from inside the finalizer and you should not reference (access)
/// other managed objects, as they already have been garbage collected.
/// Only unmanaged resources can be disposed.
/// </summary>
/// <param name="disposing"></param>
/// <remarks>
/// If any exceptions are thrown, that is fine.
/// If the method is being done in a finalizer, it will be ignored.
/// If it is thrown by client code calling Dispose,
/// it needs to be handled by fixing the bug.
///
/// If subclasses override this method, they should call the base implementation.
/// </remarks>
protected override void Dispose(bool disposing)
{
//Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************");
// Must not be run more than once.
if (IsDisposed)
{
return;
}
// m_sda COM object block removed due to crash in Finializer thread LT-6124
if (disposing)
{
// Dispose managed resources here.
if (m_sda != null)
{
m_sda.RemoveNotification(this);
}
if (m_cb != null)
{
m_cb.CheckedChanged -= new EventHandler(OnChanged);
m_cb.GotFocus -= new EventHandler(m_cb_GotFocus);
if (m_cb.Parent == null)
{
m_cb.Dispose();
}
}
}
// Dispose unmanaged resources here, whether disposing is true or false.
m_cb = null;
m_sda = null;
base.Dispose(disposing);
}
//public void AssertHasNotification(int hvo, int tag, int ivMin, int cvIns, int cvDel)
//{
// Assert.IsTrue(m_calls.Contains(new NotifyChangeInfo(hvo, tag, ivMin, cvIns, cvDel)));
//}
//public void AssertHasExactlyOneNotification(int hvo, int tag, int ivMin, int cvIns, int cvDel)
//{
// Assert.AreEqual(1, m_calls.Count);
// AssertHasNotification(hvo, tag, ivMin, cvIns, cvDel);
//}
#region IDisposable Members
public void Dispose()
{
m_sda.RemoveNotification(this);
GC.SuppressFinalize(this);
}
protected override void UpdateDisplayFromDatabase()
{
m_sda = m_cache.MainCacheAccessor;
m_sda.RemoveNotification(this); // Just in case...
m_sda.AddNotification(this);
}
public void TestLexSenseSideEffects()
{
var senseFactory = Cache.ServiceLocator.GetInstance <ILexSenseFactory>();
ILexEntry entry = null;
ILexSense sense, sense2 = null, sense3 = null, sense2_1 = null, sense2_2 = null, sense2_1_1 = null, sense2_2_1 = null;
UndoableUnitOfWorkHelper.Do("Undo add senses", "Redo add senses", m_actionHandler, () =>
{
entry = Cache.ServiceLocator.GetInstance <ILexEntryFactory>().Create();
sense = senseFactory.Create();
entry.SensesOS.Add(sense);
Assert.AreEqual("1", sense.LexSenseOutline.Text);
sense2 = senseFactory.Create();
entry.SensesOS.Add(sense2);
Assert.AreEqual("2", sense2.LexSenseOutline.Text);
sense3 = senseFactory.Create();
entry.SensesOS.Add(sense3);
Assert.AreEqual("3", sense3.LexSenseOutline.Text);
sense2_1 = senseFactory.Create();
sense2.SensesOS.Add(sense2_1);
Assert.AreEqual("2.1", sense2_1.LexSenseOutline.Text);
sense2_2 = senseFactory.Create();
sense2.SensesOS.Add(sense2_2);
Assert.AreEqual("2.2", sense2_2.LexSenseOutline.Text);
sense2_1_1 = senseFactory.Create();
sense2_1.SensesOS.Add(sense2_1_1);
Assert.AreEqual("2.1.1", sense2_1_1.LexSenseOutline.Text);
sense2_2_1 = senseFactory.Create();
sense2_2.SensesOS.Add(sense2_2_1);
Assert.AreEqual("2.2.1", sense2_2_1.LexSenseOutline.Text);
});
m_notifiee = new Notifiee();
var mdc = m_sda.MetaDataCache;
var lsoFlid = mdc.GetFieldId("LexSense", "LexSenseOutline", false);
m_sda.AddNotification(m_notifiee);
ILexSense senseInserted = null;
UndoableUnitOfWorkHelper.Do("Undo add another sense", "Redo add another sense", m_actionHandler, () =>
{
senseInserted = senseFactory.Create();
entry.SensesOS.Insert(1, senseInserted);
Assert.AreEqual("2", senseInserted.LexSenseOutline.Text);
});
int nosFlid = mdc.GetFieldId("LexEntry", "NumberOfSensesForEntry", false);
m_notifiee.CheckChangesWeaker(new[]
{
new ChangeInformationTest(entry.Hvo, nosFlid, 0, 0, 0),
new ChangeInformationTest(entry.Hvo, LexEntryTags.kflidSenses, 1, 1, 0),
new ChangeInformationTest(sense2.Hvo, lsoFlid, 0, "2".Length, "3".Length),
new ChangeInformationTest(sense3.Hvo, lsoFlid, 0, "3".Length, "4".Length),
new ChangeInformationTest(sense2_1.Hvo, lsoFlid, 0, "2.1".Length, "3.1".Length),
new ChangeInformationTest(sense2_2.Hvo, lsoFlid, 0, "2.1".Length, "3.1".Length),
new ChangeInformationTest(sense2_1_1.Hvo, lsoFlid, 0, "2.1.1".Length, "3.1.1".Length),
new ChangeInformationTest(sense2_2_1.Hvo, lsoFlid, 0, "2.2.1".Length, "3.2.1".Length),
}, "insert second sense in entry");
m_sda.RemoveNotification(m_notifiee);
Assert.AreEqual("3.1.1", sense2_1_1.LexSenseOutline.Text);
m_notifiee = new Notifiee();
m_sda.AddNotification(m_notifiee);
UndoableUnitOfWorkHelper.Do("Undo remove sense", "Redo remove sense", m_actionHandler, () =>
entry.SensesOS.Remove(senseInserted));
m_notifiee.CheckChangesWeaker(new[]
{
new ChangeInformationTest(entry.Hvo, nosFlid, 0, 0, 0),
new ChangeInformationTest(entry.Hvo, LexEntryTags.kflidSenses, 1, 0, 1),
new ChangeInformationTest(sense2.Hvo, lsoFlid, 0, "2".Length, "3".Length),
new ChangeInformationTest(sense3.Hvo, lsoFlid, 0, "3".Length, "4".Length),
new ChangeInformationTest(sense2_1.Hvo, lsoFlid, 0, "2.1".Length, "3.1".Length),
new ChangeInformationTest(sense2_2.Hvo, lsoFlid, 0, "2.1".Length, "3.1".Length),
new ChangeInformationTest(sense2_1_1.Hvo, lsoFlid, 0, "2.1.1".Length, "3.1.1".Length),
new ChangeInformationTest(sense2_2_1.Hvo, lsoFlid, 0, "2.2.1".Length, "3.2.1".Length),
}, "delete second sense in entry");
m_sda.RemoveNotification(m_notifiee);
Assert.AreEqual("2.1.1", sense2_1_1.LexSenseOutline.Text);
m_notifiee = new Notifiee();
m_sda.AddNotification(m_notifiee);
UndoableUnitOfWorkHelper.Do("Undo add another sense", "Redo add another sense", m_actionHandler, () =>
{
senseInserted = senseFactory.Create();
sense2.SensesOS.Insert(1, senseInserted);
Assert.AreEqual("2.2", senseInserted.LexSenseOutline.Text);
});
m_notifiee.CheckChangesWeaker(new[]
{
new ChangeInformationTest(entry.Hvo, nosFlid, 0, 0, 0),
new ChangeInformationTest(sense2.Hvo, LexSenseTags.kflidSenses, 1, 1, 0),
new ChangeInformationTest(sense2_2.Hvo, lsoFlid, 0, "2.2".Length, "2.3".Length),
new ChangeInformationTest(sense2_2_1.Hvo, lsoFlid, 0, "2.2.1".Length, "2.3.1".Length),
}, "insert subsense in sense");
m_sda.RemoveNotification(m_notifiee);
Assert.AreEqual("2.3.1", sense2_2_1.LexSenseOutline.Text);
m_notifiee = new Notifiee();
m_sda.AddNotification(m_notifiee);
UndoableUnitOfWorkHelper.Do("Undo get rid of sense", "Redo get rid of sense", m_actionHandler, () =>
sense2.SensesOS.Remove(senseInserted));
m_notifiee.CheckChangesWeaker(new[]
{
new ChangeInformationTest(entry.Hvo, nosFlid, 0, 0, 0),
new ChangeInformationTest(sense2.Hvo, LexSenseTags.kflidSenses, 1, 0, 1),
new ChangeInformationTest(sense2_2.Hvo, lsoFlid, 0, "2.2".Length, "2.3".Length),
new ChangeInformationTest(sense2_2_1.Hvo, lsoFlid, 0, "2.2.1".Length, "2.3.1".Length),
}, "remove subsense from sense");
m_sda.RemoveNotification(m_notifiee);
Assert.AreEqual("2.2.1", sense2_2_1.LexSenseOutline.Text);
}
/// <summary> Request removal from the list of objects to notify when properties change. </summary>
/// <param name='nchng'> </param>
public void RemoveNotification(IVwNotifyChange nchng)
{
m_baseSda.RemoveNotification(nchng);
}
/// <summary>
///
/// </summary>
/// <param name="_nchng"></param>
public void RemoveNotification(IVwNotifyChange _nchng)
{
m_sda.RemoveNotification(_nchng);
}
void BasicIPASymbolSlice_Disposed(object sender, EventArgs e)
{
m_sda.RemoveNotification(this);
m_IPAMapperDocument = null;
}
protected override void UpdateDisplayFromDatabase()
{
m_sda = m_cache.DomainDataByFlid;
m_sda.RemoveNotification(this); // Just in case...
m_sda.AddNotification(this);
}
protected override void UpdateDisplayFromDatabase()
{
m_sda = m_cache.DomainDataByFlid;
m_sda.RemoveNotification(this); // Just in case...
m_sda.AddNotification(this);
}
public void Dispose()
{
m_sda.RemoveNotification(this);
}
protected override void UpdateDisplayFromDatabase()
{
m_sda = m_cache.MainCacheAccessor;
m_sda.RemoveNotification(this); // Just in case...
m_sda.AddNotification(this);
}