|
private BeginInvoke ( |
||
| method | ||
| return | IAsyncResult | |
/// <summary>
/// 跨线程访问控件
/// </summary>
/// <param name="ctrl">Form对象</param>
/// <param name="de">委托</param>
public static void Invoke(Control ctrl, Delegate de)
{
if (ctrl.IsHandleCreated)
{
ctrl.BeginInvoke(de);
}
}
public static void BeginInvokeInControlThread(Control c, MethodInvoker code)
{
//c.BeginInvoke(code);
if (c.InvokeRequired)
c.BeginInvoke(code);
else
c.Invoke(code);
}
private static void hider(Control frm)
{
frm.BeginInvoke((MethodInvoker)delegate
{
frm.Hide();
load.Hide();
});
}
void Run()
{
System.Windows.Forms.Control tmp = Sender as System.Windows.Forms.Control;
try
{
Command(Sender, this, Parameters);
if (OnAsyncStateChangeEventHandler != null)
{
if (tmp != null && tmp.InvokeRequired)
{
tmp.BeginInvoke(OnAsyncStateChangeEventHandler, Sender, this, Parameters, AsyncState.Finish, null);
}
else
{
OnAsyncStateChangeEventHandler(Sender, this, Parameters, AsyncState.Finish, null);
}
}
}
catch (Exception ex)
{
if (OnError == null)
{
if (tmp != null && tmp.InvokeRequired)
{
tmp.Invoke(new ErrorEventHandler(ShowError), Sender, ex);
}
else
{
ShowError(Sender, ex);
}
}
else
{
if (tmp != null && tmp.InvokeRequired)
{
tmp.Invoke(new ErrorEventHandler(OnError), Sender, ex);
}
else
{
OnError(Sender, ex);
}
}
if (OnAsyncStateChangeEventHandler != null)
{
if (tmp != null && tmp.InvokeRequired)
{
tmp.BeginInvoke(OnAsyncStateChangeEventHandler, Sender, this, Parameters, AsyncState.Finish, null);
}
else
{
OnAsyncStateChangeEventHandler(Sender, this, Parameters, AsyncState.Finish, null);
}
}
}
finally
{
Done.Set();
}
}
public void Go()
{
if (attachedLibrary == false)
{
control.BeginInvoke((Action)TimerGo, null);
}
}
private void InvokeOwnThread(Control control, Action action)
{
if (control.InvokeRequired)
control.BeginInvoke(action);
else
action();
}
/// <summary>
/// Performs the action on the control by calling BeginInvoke, if it is required to do so
/// </summary>
/// <param name="control"></param>
/// <param name="action"></param>
public static void PerformControlOperation(Control control, NoParam action)
{
if (control.InvokeRequired)
control.BeginInvoke(new InvokeDelegate(TryCatchInvoker), new Invoke(action, null));
else
TryCatchInvoker(new Invoke(action, null));
}
/// <summary>
/// Invokes asynchronously the specified action for this control.
/// </summary>
/// <param name="control">The control.</param>
/// <param name="action">The action.</param>
public static void BeginInvoke(Control control, Action action)
{
control.ThrowIfNull("control");
action.ThrowIfNull("action");
if (!control.Created || control.IsDisposed || !control.IsHandleCreated) return;
control.BeginInvoke(action);
}
static void QueueInvoke(System.Windows.Forms.Control ctl, Action doit)
{
if (ctl == null)
{
throw new ArgumentNullException("ctl");
}
ctl.BeginInvoke(doit);
}
/// <summary>
/// Simply changes the Width property with smoothing, for any controls
/// </summary>
/// <param name="control"></param>
/// <param name="max">max Width</param>
/// <param name="distance">Steps in the range (0-1)</param>
/// <param name="delay">in milliseconds</param>
public static void effectSmoothChangeWidth(Control control, int max, float distance, int delay)
{
distance = Math.Max(0, Math.Min(distance, 1));
(new System.Threading.Tasks.Task(() =>
{
int step = (int)(max * distance);
while(control.Width < max)
{
control.BeginInvoke((MethodInvoker)delegate {
control.Width += step;
});
System.Threading.Thread.Sleep(delay);
}
control.BeginInvoke((MethodInvoker)delegate {
control.Width = max;
});
})).Start();
}
public static void Invoke(this Forms.Control me, Action action)
{
if (me.InvokeRequired)
{
try { me.BeginInvoke((Delegate)action); }
catch (System.InvalidOperationException) { }
}
else
action();
}
public static void SafeInvokeAsync(Control ctr, Action action)
{
if (ctr == null || ctr.IsDisposed)
return;
if (ctr.InvokeRequired)
ctr.BeginInvoke(action);
else
action();
}
public static bool BeginInvokeIfControlCanHandleInvoke(Control control, Delegate method)
{
if (ControlCanHandleInvoke(control))
{
control.BeginInvoke(method);
return true;
}
return false;
}
public static void DoThreadSafe(Control control, MethodInvoker action)
{
if (control.InvokeRequired)
{
control.BeginInvoke(action);
}
else
{
action();
}
}
internal void BeginInvoke(MethodInvoker mi)
{
if (ctrlOwner != null)
{
ctrlOwner.BeginInvoke(mi);
}
else
{
mi();
}
}
/*############# Created By User on Stack OverFlow ###############################*/
//the function below safely invoke changes that need to happen to the GUI from the backgroundworker thread
//Or thread they were called on .
public static void SafeBeginInvoke(System.Windows.Forms.Control control, System.Action action)
{
if (control.InvokeRequired)
{
control.BeginInvoke(new System.Windows.Forms.MethodInvoker(() => { action(); }));
}
else
{
action();
}
}
public static void InvokeOnUiThreadIfRequired(this System.Windows.Forms.Control control, Action action)
{
if (control.InvokeRequired)
{
control.BeginInvoke(action);
}
else
{
action.Invoke();
}
}
public static void AfterAllClear(Control rate, Control pokemonNames)
{
if (Settings.Default.NoInputRate) {
pokemonNames.BeginInvoke((MethodInvoker)(() => {
pokemonNames.Select();
}));
} else {
rate.BeginInvoke((MethodInvoker)(() => {
rate.Select();
}));
}
}
/// <summary>
/// Attempts to run a delegate method on the UI thread of a System.Windows.Forms.Control
/// Basically a wrapper around BeginInvoke with testing for readiness / availability of the
/// control itself
/// </summary>
/// <param name="control">Control to run on</param>
/// <param name="method">delegate method to run</param>
public static void ExecuteOnUIThread(Control control, Delegate method)
{
for (var i = 0; i < 30; i++)
{
if (control.IsHandleCreated)
break;
if (control.IsDisposed || control.Disposing)
return;
Thread.Sleep(100);
}
control.BeginInvoke(method);
}
// activate / deactivate control
public static void ActivateControl(Control aControl, bool aActive)
{
if (aControl.InvokeRequired)
{
aControl.BeginInvoke(
new MethodInvoker(delegate() { ActivateControl(aControl, aActive); })
);
}
else
{
aControl.Enabled = aActive;
}
}
//***************************************************************************
// Static Methods
//
/// <summary>
/// Tells the specified control to invalidate its client area and immediately redraw itself.
/// </summary>
/// <param name="ctrl"></param>
public static void RefreshControl(Control ctrl)
{
if (ctrl.InvokeRequired)
{
RefreshControlDelegate del = new RefreshControlDelegate(CrossThreadUI.RefreshControl);
if (CrossThreadUI.ExecSync)
ctrl.Invoke(del);
else
ctrl.BeginInvoke(del);
}
else
ctrl.Invalidate();
}
//http://rsdn.ru/forum/dotnet/2285015.aspx
/// <summary>
/// private void SetIntSignalLevel(int SigValue)
/// {
/// SafeInvoker.Invoke(SigLevel,
/// delegate
/// {
/// SigLevel.Value = SigValue;
/// }
/// );
/// }
/// </summary>
/// <param name="ctrl"></param>
/// <param name="methodToInvoke"> delegate { ProgressBar.Value = value; } </param>
public static void BeginInvoke(Control ctrl, MethodInvoker methodToInvoke)
{
try {
if (ctrl == null || ctrl.IsDisposed)
return;
if (ctrl.InvokeRequired) {
ctrl.BeginInvoke (methodToInvoke);
} else {
methodToInvoke ();
}
} catch (ObjectDisposedException) {
}
}
/// <summary>
/// Shows standard decryption error UI within the context of a parent form
/// </summary>
public static DecryptionErrorAction OnDecryptionError(Control form, IContentEncryption encryptor)
{
if (form.InvokeRequired)
{
DecryptionErrorAction result = DecryptionErrorAction.Skip;
IAsyncResult async = form.BeginInvoke(new MethodInvoker(delegate
{
result = ShowDecryptionErrorDialog(form, encryptor);
}));
form.EndInvoke(async);
return result;
}
return ShowDecryptionErrorDialog(form, encryptor);
}
public static void SetVisible(Control control, bool visible)
{
if (control.InvokeRequired)
{
control.BeginInvoke(new Action(() =>
{
control.Visible = visible;
}));
}
else
{
control.Visible = visible;
}
}
/// <summary>
/// Invoke and action safely even if called from the background thread.
/// </summary>
/// <remarks>
/// Invoking on the ui thread from background threads works *most* of the time, with occasional crash.
/// Stackoverflow has a good collection of people trying to deal with these corner cases, where
/// InvokeRequired(), for example, is unreliable (it doesn't tell you if the control hasn't even
/// got a handle yet).
/// SIL.Core (lipalaso) has a SafeInvoke on its LogBox control, which sees heavy background/foreground interaction
/// and seems to work well over the course of years.
/// I think I (JH) wrote that, but it relies on a couple of odd things:
/// 1) it calls IsHandleCreated() (which can reportedly create the handle on the wrong thread?)
/// and 2) uses SynchronizationContext which works for that single control case but I'm not seeing how
/// to generalize that.
/// So now I'm trying something more mainstream here, from a highly voted SO answer.
/// </remarks>
public static void Invoke(string nameForErrorReporting, Control control, bool forceSynchronous, bool throwIfAnythingGoesWrong, Action action)
{
Guard.AgainstNull(control, nameForErrorReporting); // throw this one regardless of the throwIfAnythingGoesWrong
//mostly following http://stackoverflow.com/a/809186/723299
try
{
if (control.IsDisposed)
{
throw new ObjectDisposedException("Control is already disposed. (" + nameForErrorReporting + ")");
}
if (control.InvokeRequired)
{
var delgate = (Action)delegate { Invoke(nameForErrorReporting, control, forceSynchronous, throwIfAnythingGoesWrong, action); };
if (forceSynchronous)
{
control.Invoke(delgate);
}
else
{
control.BeginInvoke(delgate);
}
}
else
{
// InvokeRequired will return false if the control isn't set up yet
if (!control.IsHandleCreated)
{
//This situation happened in BL-2918, prompting the introduction of this safeinvoke
throw new ApplicationException("SafeInvoke.Invoke apparently called before control created ("+ nameForErrorReporting+")");
//note, resist the temptation to work around this by just making the handle be created with something like
//var unused = control.Handle
//I've read a rumour that this can create the handle "on the wrong thread".
//At a minimum, we would need to investigate the truth of that before using it here.
}
action();
}
}
catch (Exception error)
{
if (throwIfAnythingGoesWrong)
throw;
else
{
Debug.Fail("This error would be swallowed in release version: " + error.Message);
SIL.Reporting.Logger.WriteEvent("**** "+error.Message);
}
}
}
private void ProgressDispatcherProc()
{
m_stopThreads = false;
while (!m_stopThreads)
{
while (m_progressQueue.Count > 0)
{
ProgressChangedEventArgs args = m_progressQueue.Dequeue();
if (ProgressChanged != null)
{
m_guiMarshaller.BeginInvoke(new MethodInvoker(delegate()
{
ProgressChanged(this, args);
}));
Application.DoEvents();
}
}
// sleep longer if no pregress events are ever coming in
// keep the thread though in case they turn progress on at some point
Thread.Sleep(this.WorkerReportsProgress ? 5 : 1000);
}
}
/// <summary>
/// Shows standard content encryption UI
/// </summary>
public static DecryptResult GetPassword(Control form, string attachmentName, string passwordName, string passwordDescription, out string password)
{
if (form.InvokeRequired)
{
DecryptResult result = DecryptResult.Ok;
string pwd = string.Empty;
IAsyncResult async = form.BeginInvoke(new MethodInvoker(delegate
{
result = ShowPasswordRequestDialog(form, attachmentName, passwordName, passwordDescription, out pwd);
}));
form.EndInvoke(async);
password = pwd;
return result;
}
return ShowPasswordRequestDialog(form, attachmentName, passwordName, passwordDescription, out password);
}
public static void SimulateMotion(SWF.MenuItem item)
{
SWF.Menu parentMenu;
SWF.Control wnd = GetWnd(item, out parentMenu);
if (wnd == null)
{
return;
}
if (wnd.InvokeRequired)
{
wnd.BeginInvoke(new MenuItemOperator(SimulateMotion),
item);
return;
}
SWF.MouseEventArgs args = GetMouseArgs(item);
parentMenu.tracker.OnMotion(args);
}
private unsafe void SetFocusAsync(Message *ptrMessage, int messageNumber)
{
//must be first message
if (messageNumber != 1)
{
throw new Exception("SetFocusAsync must be the first message");
}
// p1 = handle
IntPtr control = GetParameterIntPtr(ptrMessage, 0);
//TODO WPF etc
WF.Control childControl = WF.Control.FromHandle(control);
if (childControl != null)
{
object[] theParameters = { control };
childControl.BeginInvoke(m_SetFocusAsyncDelegater, theParameters);
}
CleanUpMessage(ptrMessage);
}
public static void BeginInvoke(Control control, MethodInvoker method)
{
if (control == null)
{
throw new ArgumentNullException("control");
}
if (method == null)
{
throw new ArgumentNullException("method");
}
if (control.InvokeRequired)
{
control.BeginInvoke(method, null);
}
else
{
method();
}
}
/// <summary>
/// Shows standard content encryption UI
/// </summary>
public static DecryptResult GetPasswords(Control form, string attachmentName, string attachmentDisplayName, out string openPassword, out string modifyPassword)
{
if (form.InvokeRequired)
{
DecryptResult result = DecryptResult.Ok;
string pwdOpen = string.Empty;
string pwdModify = string.Empty;
IAsyncResult async = form.BeginInvoke(new MethodInvoker(delegate
{
result = ShowExtendedPasswordRequestDialog(form, attachmentName, attachmentDisplayName, out pwdOpen, out pwdModify);
}));
form.EndInvoke(async);
openPassword = pwdOpen;
modifyPassword = pwdModify;
return result;
}
return ShowExtendedPasswordRequestDialog(form, attachmentName, attachmentDisplayName, out openPassword, out modifyPassword);
}
protected override void Invalidate(Control containerControl)
{
if (this.DesignMode)
{
if (containerControl.InvokeRequired)
containerControl.BeginInvoke(new MethodInvoker(delegate { containerControl.Invalidate(); }));
else
containerControl.Invalidate();
}
else
{
if (containerControl.InvokeRequired)
containerControl.BeginInvoke(new MethodInvoker(delegate { containerControl.Invalidate(m_Rect, true); }));
else
containerControl.Invalidate(m_Rect, true);
}
}
// 安全版本
public static void FilterValueList(Control owner, Control control)
{
if (owner.InvokeRequired == true)
{
Delegate_filterValue d = new Delegate_filterValue(__FilterValueList);
owner.BeginInvoke(d, new object[] { control });
}
else
{
__FilterValueList((Control)control);
}
}
protected virtual void Update(Control containerControl)
{
if (containerControl.InvokeRequired)
containerControl.BeginInvoke(new MethodInvoker(delegate { containerControl.Update(); }));
else
containerControl.Update();
}
protected virtual void Invalidate(Control containerControl)
{
if (this.DesignMode)
{
if (containerControl is Form && !(containerControl is RadialMenuPopup))
{
if (IsHandleValid(containerControl))
InvalidateFormCaption(containerControl);
containerControl.Refresh();
}
else
{
if (containerControl.InvokeRequired)
containerControl.BeginInvoke(new MethodInvoker(delegate { containerControl.Invalidate(); }));
else
containerControl.Invalidate();
}
}
else
{
if (containerControl is Form && !(containerControl is RadialMenuPopup))
{
if (IsHandleValid(containerControl))
InvalidateFormCaption(containerControl);
}
else
{
if (containerControl.InvokeRequired)
containerControl.BeginInvoke(new MethodInvoker(delegate { containerControl.Invalidate(GetInvalidateBounds(), true); }));
else
containerControl.Invalidate(GetInvalidateBounds(), true);
}
}
}
private unsafe void PeakMessage(Message *ptrMessage, int messageNumber)
{
//must be first message
if (messageNumber != 1)
{
throw new Exception("PeakMessage must be the first message");
}
// p1 = handle
IntPtr handle = GetParameterIntPtr(ptrMessage, 0);
int timeoutMS = GetParameterInt32(ptrMessage, 1);
int threadId = NM.GetWindowThreadProcessId(handle, out int pid);
m_AllControls = new List <IntPtr>();
NM.EnumThreadWindows((uint)threadId, EnumThreadProcedue, IntPtr.Zero);
Stopwatch timer = Stopwatch.StartNew();
for (int loop = 0; loop < 2; loop++)
{
foreach (IntPtr hWnd in m_AllControls)
{
WF.Control control = WF.Control.FromHandle(hWnd);
if (control == null)
{
//Todo
}
else
{
while (true)
{
bool messageAvailble = false;
if (control.IsDisposed)
{
// Nothing
}
else if (control.Disposing)
{
messageAvailble = true; // Don't invoke anything just continue to loop till the control is fully disposed
}
else if (!control.IsHandleCreated)
{
// Nothing as to get to here the handle must have existed at some point so it must have been destroyed
}
else if (control.RecreatingHandle)
{
messageAvailble = true; // Don't invoke anything just continue to loop till the control has recreated the handle
}
else if (!control.Enabled)
{
// Nothing move on to the next window
}
else
{
try
{
//control.BeginInvoke(m_RefreshControlDelegater, new object[] { control });
IAsyncResult result = control.BeginInvoke(m_PeakMessagDelegater, null);
while (true)
{
int innerLoop = 0;
if (result.IsCompleted)
{
messageAvailble = (bool)control.EndInvoke(result);
break;
}
if (control.IsDisposed)
{
// Nothing
break;
}
else if (control.Disposing)
{
// Don't do anything just continue to loop till the control is fully disposed
}
else if (!control.IsHandleCreated)
{
// Nothing as to get to here the handle must have existed at some point so it must have been destroyed
break;
}
else if (control.RecreatingHandle)
{
messageAvailble = true; // Don't invoke anything just continue to loop till the control has recreated the handle
break;
}
else if (!control.Enabled)
{
// Nothing move on to the next window
break;
}
if (timer.ElapsedMilliseconds > timeoutMS)
{
throw new Exception("Thread failed to have zero messages within timeout");
}
innerLoop++;
if (innerLoop == 100)
{
innerLoop = 0;
Thread.Sleep(15);
}
else
{
Thread.Yield();
}
}
}
catch (ObjectDisposedException) { }
catch (InvalidAsynchronousStateException) { }
catch (NullReferenceException) { }
catch (InvalidOperationException) { }
}
if (!messageAvailble)
{
break;
}
if (timer.ElapsedMilliseconds > timeoutMS)
{
throw new Exception("Thread failed to have zero messages within timeout");
}
Thread.Sleep(15);
}
break;
}
}
}
CleanUpMessage(ptrMessage);
}
void RepairState(Control control, AnimateMode mode)
{
control.BeginInvoke(new MethodInvoker(() =>
{
switch (mode)
{
case AnimateMode.Hide: control.Visible = false; break;
case AnimateMode.Show: control.Visible = true; break;
}
}));
}
public static IAsyncResult BeginInvoke(Control c, Delegate f, params object[] p)
{
try
{
if (!IsExiting(c))
{
return c.BeginInvoke(f, p);
}
}
catch (ObjectDisposedException)
{
if (!IsExiting(c)) throw;
}
catch (InvalidAsynchronousStateException)
{
if (!IsExiting(c)) throw;
}
catch (InvalidOperationException)
{
if (!IsExiting(c)) throw;
}
return null;
}
public override void Post(SendOrPostCallback d, object state)
{
invoke_control.BeginInvoke(d, new object[] { state });
}
// 安全版本
/// <summary>
/// 过滤控件中的列表值
/// </summary>
/// <param name="owner">控件的宿主控件</param>
/// <param name="control">控件</param>
public static void FilterValueList(Control owner, Control control)
{
Delegate_filterValue d = new Delegate_filterValue(__FilterValueList);
if (owner.Created == false)
__FilterValueList((Control)control);
else
owner.BeginInvoke(d, new object[] { control });
}
public static void SetbackgroundImage(Control control, Image image)
{
if (control.InvokeRequired)
{
control.BeginInvoke(new Action(() =>
{
control.BackgroundImage = image;
}));
}
else
{
control.BackgroundImage = image;
}
}
public static void BeginInvoke(Control c, MethodInvoker f)
{
try
{
if (!IsExiting(c))
{
c.BeginInvoke(f);
}
}
catch (ObjectDisposedException)
{
if (!IsExiting(c)) throw;
}
catch (InvalidAsynchronousStateException)
{
if (!IsExiting(c)) throw;
}
catch (InvalidOperationException)
{
if (!IsExiting(c)) throw;
}
}