/// ------------------------------------------------------------------------------------
/// <summary>
/// Resume execution of synchronize messages. If there are any messages in the queue
/// execute them now.
/// </summary>
/// ------------------------------------------------------------------------------------
public void ResumeSynchronize()
{
CheckDisposed();
if (m_suppressedCacheInfo == null)
return; // Nothing to do
m_suppressedCacheInfo.Count--;
if (m_suppressedCacheInfo.Count > 0)
return; // Still nested
BeginUpdate();
Queue<SyncMsg> messages = m_suppressedCacheInfo.Queue;
m_suppressedCacheInfo = null;
bool fProcessUndoRedoAfter = false;
SyncMsg savedUndoRedo = SyncMsg.ksyncFullRefresh; // Arbitrary
foreach (SyncMsg synchMsg in messages)
{
if (synchMsg == SyncMsg.ksyncUndoRedo)
{
// we must process this synch message after all the others
fProcessUndoRedoAfter = true;
savedUndoRedo = synchMsg;
continue;
}
// Do the synch
if (!Synchronize(synchMsg))
{
fProcessUndoRedoAfter = false; // Refresh already done, final UndoRedo unnecessary
break; // One resulted in Refresh everything, ignore other synch msgs.
}
}
if (fProcessUndoRedoAfter)
Synchronize(savedUndoRedo);
// NOTE: This code may present a race condition, because there is a slight
// possibility that a sync message can come to the App at
// this point and then get cleared from the syncMessages list and never get run.
EndUpdate();
}
/// <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)
{
System.Diagnostics.Debug.WriteLineIf(!disposing, "****** Missing Dispose() call for " + GetType().Name + ". ****** ");
// Must not be run more than once.
if (IsDisposed || BeingDisposed)
return;
BeingDisposed = true;
if (disposing)
{
UpdateAppRuntimeCounter();
Logger.WriteEvent("Disposing app: " + GetType().Name);
RegistrySettings.FirstTimeAppHasBeenRun = false;
// Dispose managed resources here.
List<IFwMainWnd> mainWnds = new List<IFwMainWnd>(m_rgMainWindows); // Use another array, since m_rgMainWindows may change.
m_rgMainWindows.Clear(); // In fact, just clear the main array, so the windows won't have to worry so much.
foreach (IFwMainWnd mainWnd in mainWnds)
{
if (mainWnd is Form)
{
Form wnd = (Form)mainWnd;
wnd.Closing -= OnClosingWindow;
wnd.Closed -= OnWindowClosed;
wnd.Activated -= fwMainWindow_Activated;
wnd.HandleDestroyed -= fwMainWindow_HandleDestroyed;
wnd.Dispose();
}
else if (mainWnd is IDisposable)
((IDisposable)mainWnd).Dispose();
}
if (m_findReplaceDlg != null)
m_findReplaceDlg.Dispose();
#if DEBUG
if (m_debugProcs != null)
m_debugProcs.Dispose();
#endif
ResourceHelper.ShutdownHelper();
if (m_registrySettings != null)
m_registrySettings.Dispose();
Application.EnterThreadModal -= Application_EnterThreadModal;
Application.LeaveThreadModal -= Application_LeaveThreadModal;
Application.RemoveMessageFilter(this);
PictureHolder.Dispose();
}
// Dispose unmanaged resources here, whether disposing is true or false.
m_rgMainWindows = null;
m_activeMainWindow = null;
m_registrySettings = null;
m_findPattern = null;
m_findReplaceDlg = null;
m_suppressedCacheInfo = null;
m_refreshView = null;
PictureHolder = null;
#if DEBUG
m_debugProcs = null;
#endif
IsDisposed = true;
BeingDisposed = false;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Suppress execution of all synchronize messages and store them in a queue instead.
/// </summary>
/// ------------------------------------------------------------------------------------
public void SuppressSynchronize()
{
CheckDisposed();
if (m_suppressedCacheInfo != null)
m_suppressedCacheInfo.Count++; // Nested call
else
m_suppressedCacheInfo = new SuppressedCacheInfo();
}
