/// ------------------------------------------------------------------------------------- /// <summary> /// Perform one-time initialization of a new Scripture project /// </summary> /// <returns>true if data loaded successfully; false, otherwise</returns> /// ------------------------------------------------------------------------------------- protected bool Initialize(IThreadedProgress progressDlg) { if (m_scr != null) { // Preload all book, section and paragraphs if we already have Scripture m_cache.ServiceLocator.DataSetup.LoadDomainAsync(BackendBulkLoadDomain.Scripture); ILangProject lp = m_cache.LanguageProject; if (m_scr.BookAnnotationsOS.Count != 0 && m_scr.PublicationsOC.Count != 0 && lp.KeyTermsList.PossibilitiesOS.Count >= 1 && m_scr.NoteCategoriesOA != null && m_scr.NoteCategoriesOA.PossibilitiesOS.Count > 0) { return(true); } } try { progressDlg.RunTask(InitializeScriptureProject); } catch (WorkerThreadException e) { while (m_cache.DomainDataByFlid.GetActionHandler().CanUndo()) { UndoResult ures = m_cache.DomainDataByFlid.GetActionHandler().Undo(); // Enhance JohnT: make use of ures? } MessageBox.Show(Form.ActiveForm, e.InnerException.Message, FwUtils.ksTeAppName, MessageBoxButtons.OK, MessageBoxIcon.Error); return(false); } return(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 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_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(); } } // Dispose unmanaged resources here, whether disposing is true or false. m_cache = null; m_styleSheet = null; base.Dispose(disposing); }
public virtual void TearDown() { if (m_fdoCache != null) { UndoResult ures = 0; while (m_fdoCache.CanUndo) { m_fdoCache.Undo(out ures); if (ures == UndoResult.kuresFailed || ures == UndoResult.kuresError) { Assert.Fail("ures should not be == " + ures.ToString()); } } } if (m_division != null) { m_division.m_hPagesBroken.Clear(); m_division.Dispose(); m_division = null; } // Make sure we close all the rootboxes if (m_ScrPubCtrl != null) { m_ScrPubCtrl.Dispose(); m_ScrPubCtrl = 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. if (m_fdoCache != null) { UndoResult ures = 0; while (m_fdoCache.CanUndo) { m_fdoCache.Undo(out ures); } m_fdoCache.Dispose(); } if (m_basicView != null) { m_basicView.Dispose(); } } // Dispose unmanaged resources here, whether disposing is true or false. m_fdoCache = null; m_basicView = 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; } if (disposing) { // Dispose managed resources here. UndoResult ures = 0; if (m_fdoCache != null) { while (m_fdoCache.CanUndo) { m_fdoCache.Undo(out ures); } m_fdoCache.Dispose(); } } // Dispose unmanaged resources here, whether disposing is true or false. m_fdoCache = null; m_styleSheet = null; m_scr = null; if (m_wsf != null) { Marshal.ReleaseComObject(m_wsf); m_wsf = null; } base.Dispose(disposing); }
public void CleanUp() { CheckDisposed(); UndoResult ures = 0; while (m_fdoCache.CanUndo) { m_fdoCache.Undo(out ures); if (ures == UndoResult.kuresFailed || ures == UndoResult.kuresError) { Assert.Fail("ures should not be == " + ures.ToString()); } } }
public void Destroy() { 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(); m_cache = null; }
public async Task CommandUndo() { var socketId = Context.ConnectionId; UndoResult result = placeShipSelection.Undo(socketId); List <int> buttons = result.removedButtons; int[] btns = buttons.ToArray(); if (result != null) { foreach (var coordinate in result.coordinates) { await Clients.Caller.SendAsync("undoShip", coordinate.x, coordinate.y); } await Clients.Caller.SendAsync("undoButtons", result.activeButton, btns); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Undo everything possible in the FDO cache /// </summary> /// ------------------------------------------------------------------------------------ protected virtual void UndoEverythingPossible() { if (m_fdoCache != null) { using (new IgnorePropChanged(m_fdoCache, PropChangedHandling.SuppressAll)) { UndoResult ures = 0; while (m_fdoCache.CanUndo) { m_fdoCache.Undo(out ures); if (ures == UndoResult.kuresFailed || ures == UndoResult.kuresError) { Assert.Fail("ures should not be == " + ures.ToString()); } } } } }
public virtual void CleanUp() { CheckDisposed(); UndoResult ures = 0; while (m_fdoCache.CanUndo) { m_fdoCache.Undo(out ures); if (ures == UndoResult.kuresFailed || ures == UndoResult.kuresError) { Assert.Fail("ures should not be == " + ures.ToString()); } } // Some tests are not at all happy to have m_basicView be disposed befroe the undoing. m_basicView.Dispose(); m_basicView = null; m_fdoCache.Dispose(); m_fdoCache = 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); }
public void FDOCompetingTransactions() { CheckDisposed(); FdoCache a = FdoCache.Create("TestlangProj"); AddWord(a); UndoResult ures_a = 0; while (a.CanUndo) { a.Undo(out ures_a); if (ures_a == UndoResult.kuresFailed || ures_a == UndoResult.kuresError) { Assert.Fail("ures should not be == " + ures_a.ToString()); } } a.Dispose(); FdoCache b = FdoCache.Create("TestlangProj"); AddWord(b); UndoResult ures_b = 0; while (b.CanUndo) { b.Undo(out ures_b); if (ures_b == UndoResult.kuresFailed || ures_b == UndoResult.kuresError) { Assert.Fail("ures should not be == " + ures_b.ToString()); } } b.Dispose(); }
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> /// Undo the action(s) in this object. /// </summary> /// <returns> /// Cumulative result of undoing all the actions. If we succeeded, then this will /// be kuresSuccess. /// </returns> /// ------------------------------------------------------------------------------------ protected UndoResult UndoRollbackCommon() { // Because of the complexities of our undo/redo system, we need to do the undo // in multiple passes: // 1) Restores any deleted objects. // 2) Undo any actions that are data change actions. // 3) Fire any PropChanges. // 4) Undo any actions that are not data change actions (e.g., selection change actions) m_uowService.SuppressSelections = true; UndoResult result = UndoResult.kuresSuccess; try { // Do the first pass (Restores any deleted objects) for (int i = m_changes.Count - 1; i >= 0; i--) { IUndoAction undoAction = m_changes[i]; if (undoAction is IFirstPassUndo) { ((IFirstPassUndo)undoAction).FirstPassUndo(); } } // Do the second pass (Undo any actions that are data change actions) for (int i = m_changes.Count - 1; i >= 0; i--) { if (m_changes[i].IsDataChange && !m_changes[i].Undo()) { // TODO: Redo any changes that have been undone return(UndoResult.kuresFailed); } } // Do the third pass (Fire any PropChanges) // swap cvIns and cvDel fields for each change notification, because we are doing the // reverse of the original change IEnumerable <ChangeInformation> changes = from change in GetPropChangeInformation(true).Reverse() select change.ChangeForUndo; // Fire PropChanged calls so display is updated. try { m_uowService.SendPropChangedNotifications(changes); } catch (Exception e) { Logger.WriteEvent("Exception during PropChanges in Undo"); Logger.WriteError(e); result = UndoResult.kuresRefresh; } } finally { m_uowService.SuppressSelections = false; } // Do the fourth pass (Undo any actions that are not data change actions) for (int i = m_changes.Count - 1; i >= 0; i--) { if (!m_changes[i].IsDataChange && !m_changes[i].Undo()) { // TODO: Redo any changes that have been undone return(UndoResult.kuresFailed); } } return(result); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Redo the action(s) in this object. This is overridden to do nothing in /// non-undoable unit of work, but may be called even from there in one special case. /// </summary> /// <returns> /// Cumulative result of redoing all the actions. If we succeeded, then this will /// be kuresSuccess. /// </returns> /// ------------------------------------------------------------------------------------ /// <summary> /// Redo the action(s) in this object. /// </summary> internal virtual UndoResult Redo() { // Because of the complexities of our undo/redo system, we need to do the redo // in multiple passes: // 1) Restores any created objects. // 2) Redo any actions that are data change actions. // 3) Fire any PropChanges. // 4) Redo any actions that are not data change actions (e.g., selection change actions) m_uowService.SuppressSelections = true; UndoResult result = UndoResult.kuresSuccess; try { // Do the first pass (Restores any created objects) foreach (IUndoAction undoAction in m_changes) { if (undoAction is IFirstPassRedo) { ((IFirstPassRedo)undoAction).FirstPassRedo(); } } // Do the second pass (Redo any actions that are data change actions) foreach (IUndoAction undoAction in m_changes) { if (undoAction.IsDataChange && !undoAction.Redo()) { // TODO: Undo any changes that have been redone return(UndoResult.kuresFailed); } } try { // Do the third pass (Fire any PropChanges) m_uowService.SendPropChangedNotifications(GetPropChangeInformation(false)); } catch (Exception e) { Logger.WriteEvent("Exception during PropChanges in Redo"); Logger.WriteError(e); result = UndoResult.kuresRefresh; } } finally { m_uowService.SuppressSelections = false; } // Do the fourth pass (Redo any actions that are not data change actions) foreach (IUndoAction undoAction in m_changes) { if (!undoAction.IsDataChange && !undoAction.Redo()) { // TODO: Undo any changes that have been redone return(UndoResult.kuresFailed); } } return(result); }
private void HandleUndoResult(UndoResult ures, bool fPrivate) { // Enhance JohnT: may want to display messages for kuresFailed, kuresError if (ures != UndoResult.kuresSuccess) { if (!fPrivate && m_app != null) { // currently implemented, this will cause this app to do a master refresh, m_app.Synchronize(SyncMsg.ksyncUndoRedo); } else { // EricP/JohnT -- this path will probably never be called in a production // context, since we'll have an FwApp. And even in the case of tests // taking this path, we wonder if we should issue a "MasterRefresh" instead m_mediator.SendMessage("Refresh", this); } } }
internal void OnUndo(out UndoResult ures) { TextSelInfo tsiBeforeUndo; OnUndo(out tsiBeforeUndo, out ures); }
internal void OnRedo(out TextSelInfo tsiBeforeRedo, out UndoResult ures) { using (new StateTransitionHelper(this, m_expectedTextAnnotationsDefnsAfterUndo, m_expectedTextAnnotationsDefnsAfterRedo)) { tsiBeforeRedo = this.CurrentSelectionInfo; Cache.Redo(out ures); if (ures == UndoResult.kuresRefresh) ResyncAllParaContents(); } }
internal void ValidateUndoRedo(UndoResult uresExpected, UndoResult uresActual, TextSelInfo tsiExpectedAfterUndoRedo) { Assert.AreEqual(uresExpected, uresActual, "UndoResult"); ValidateUndoRedo(tsiExpectedAfterUndoRedo); }