public override void TestSetup() { base.TestSetup(); Debug.Assert(m_mainWnd == null, "m_mainWnd is not null."); m_mainWnd = new DummyTeMainWnd(Cache); m_wsVern = Cache.DefaultVernWs; m_mainWnd.CreateDraftView(); m_mainWnd.Show(); }
public void Initialize() { CheckDisposed(); Debug.Assert(m_mainWnd == null, "m_mainWnd is not null."); //if (m_mainWnd != null) // m_mainWnd.Dispose(); m_mainWnd = new DummyTeMainWnd(); m_cache = m_mainWnd.Cache; m_scr = m_cache.LangProject.TranslatedScriptureOA; m_wsVern = m_cache.DefaultVernWs; m_mainWnd.CreateDraftView(); m_mainWnd.Show(); }
public override void TestTearDown() { if (m_mainWnd != null) { m_mainWnd.CloseViews(); // Before we close the main window undo anything on the main window's undo stack // (separate from the undo stack created when the cache was created). UndoAll(); m_mainWnd.Close(); } m_mainWnd = null; 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 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. // Dispose window first, as it needs the cache to clear out its notification. if (m_mainWnd != null) { m_mainWnd.Dispose(); } if (m_cache != null) { UndoResult ures = 0; while (m_cache.CanUndo) { m_cache.Undo(out ures); if (ures == UndoResult.kuresFailed || ures == UndoResult.kuresError) { Assert.Fail("ures should not be == " + ures.ToString()); } } m_cache.Dispose(); // Yes, since the window isn't supposed to do it. } } // Dispose unmanaged resources here, whether disposing is true or false. m_cache = null; m_mainWnd = null; m_scr = null; // Restore prompt setting Options.ShowEmptyParagraphPromptsSetting = m_saveShowPrompts; // Options is some kind of Registry gizmo. base.Dispose(disposing); }
public void CleanUp() { CheckDisposed(); UndoResult ures = 0; while (m_cache.CanUndo) { m_cache.Undo(out ures); if (ures == UndoResult.kuresFailed || ures == UndoResult.kuresError) { Assert.Fail("ures should not be == " + ures.ToString()); } } // Don't dispose the cache, until after the window closes, as it needs it // to clear its notification from the cache. // m_mainWnd.Hide(); m_mainWnd.Close(); // m_mainWnd.Dispose(); // Not needed, since Close calls Dispose. m_mainWnd = null; m_cache.Dispose(); m_cache = null; }
public void CleanUp() { CheckDisposed(); UndoResult ures = 0; while (m_cache.CanUndo) { m_cache.Undo(out ures); if (ures == UndoResult.kuresFailed || ures == UndoResult.kuresError) Assert.Fail("ures should not be == " + ures.ToString()); } // Don't dispose the cache, until after the window closes, as it needs it // to clear its notification from the cache. // m_mainWnd.Hide(); m_mainWnd.Close(); // m_mainWnd.Dispose(); // Not needed, since Close calls Dispose. m_mainWnd = null; m_cache.Dispose(); m_cache = 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"></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. // Dispose window first, as it needs the cache to clear out its notification. if (m_mainWnd != null) m_mainWnd.Dispose(); if (m_cache != null) { UndoResult ures = 0; while (m_cache.CanUndo) { m_cache.Undo(out ures); if (ures == UndoResult.kuresFailed || ures == UndoResult.kuresError) Assert.Fail("ures should not be == " + ures.ToString()); } m_cache.Dispose(); // Yes, since the window isn't supposed to do it. } } // Dispose unmanaged resources here, whether disposing is true or false. m_cache = null; m_mainWnd = null; m_scr = null; // Restore prompt setting Options.ShowEmptyParagraphPromptsSetting = m_saveShowPrompts; // Options is some kind of Registry gizmo. base.Dispose(disposing); }