private void DeterMineCall(MethodInvoker method)
 {
     if (InvokeRequired && !this.IsDisposed)
         Invoke(method);
     else
         method();
 }

 public static Thread StartTry(MethodInvoker code, ErrorHandler on_error = null, MethodInvoker on_finally = null, bool background = true)
 {
     Thread t = new Thread(
         () => {
             try
             {
                 code.Invoke();
             }
             catch (ThreadAbortException e)
             {
                 Thread.ResetAbort();
             }
             catch (Exception e)
             {
                 if (on_error != null)
                     on_error.Invoke(e);
                 else
                     Message.Error(e);
             }
             finally
             {
                 on_finally?.Invoke();
             }
         }
     );
     t.IsBackground = background;
     t.Start();
     return t;
 }

 private void UpdateState()
 {
     MethodInvoker invoker = new MethodInvoker(delegate()
                 {
                     if ((File.GetAttributes(m_originalSolutionFullPath) & FileAttributes.ReadOnly) != 0)
                     {
                         m_labelState.ForeColor = Color.Red;
                         m_labelState.Text = "ReadOnly";
                         m_labelStateDescription.Visible = true;
                         m_buttonYes.Enabled = false;
                     }
                     else
                     {
                         m_labelState.ForeColor = Color.Black;
                         m_labelState.Text = "Writable";
                         m_labelStateDescription.Visible = false;
                         m_buttonYes.Enabled = true;
                     }
                 });
     if (m_labelState.InvokeRequired)
     {
         this.Invoke(invoker);
     }
     else
     {
         invoker.Invoke();
     }
 }

        /// <summary>
        /// Check to see if an update to the application is available.
        /// </summary>
        /// <param name="available">A <see cref="MethodInvoker"/> delegate which is called if an update is available.</param>
        internal static void CheckAvailable(MethodInvoker available)
        {
            ThreadPool.QueueUserWorkItem(delegate
            {
                CachedWebClient checkUpdate = CachedWebClient.GetInstance();
                string versionInfo = null;

                try
                {
                    versionInfo = checkUpdate.DownloadString(new Uri(BaseUrl + Application.ProductVersion), CacheHours);
                }
                catch (WebException)
                {
                    // Temporary problem downloading the information, try again later
                    return;
                }

                Settings.LastCheckForUpdates = DateTime.Now;

                if (!string.IsNullOrEmpty(versionInfo))
                {
                    versionInfo = versionInfo.Split(new string[] { "\r\n" }, StringSplitOptions.None)[0];

                    if (string.Compare(versionInfo, Application.ProductVersion, StringComparison.Ordinal) > 0)
                    {
                        // There is a new version available
                        available();
                    }
                }

                return;
            });
        }

		internal FTeams(ref Common.Interface newCommon)
		{
			//
			// Required for Windows Form Designer support
			//
			InitializeComponent();

			CommonCode = newCommon;

			Trace.WriteLine("FTeams: Creating");
			EnableMeInvoker = new MethodInvoker(this.enableMe);

			PopulateTeamsDropDownThreadInvoker += 
				new MethodInvoker(populateTeamsDropDownThread);
			try
			{
				height = this.Size.Height;
				width = this.Size.Width;
			}
			catch(Exception exc)
			{
				Trace.WriteLine("FTeams: Exception during creation:" + exc.ToString());
				throw;
			}
			finally
			{
				Trace.WriteLine("FTeams: Created.");
			}
		}

        /// <summary>
        /// Runs a MethodInvoker delegate on the UI thread from whichever thread we are currently calling from and BLOCKS until it is complete
        /// </summary>
        /// <param name="ivk"></param>
        public void UIBlockingInvoke(MethodInvoker ivk)
        {
            System.Threading.ManualResetEvent UIAsyncComplete = new System.Threading.ManualResetEvent(false);
            UIAsyncComplete.Reset();
            if (this.InvokeRequired)
            {
                this.BeginInvoke(new MethodInvoker(delegate()
                {
                    try
                    {
                        ivk();
                    }
                    finally
                    {
                        UIAsyncComplete.Set();
                    }
                }));

                UIAsyncComplete.WaitOne();
            }
            else
            {
                ivk();
            }
        }

 public static Button add_Button(this Control control, string text, int top, int left, int height, int width, MethodInvoker onClick)
 {
     return control.invokeOnThread(
         () =>
             {
                 var button = new Button {Text = text};
                 if (top > -1)
                     button.Top = top;
                 if (left > -1)
                     button.Left = left;
                 if (width == -1 && height == -1)
                     button.AutoSize = true;
                 else
                 {
                     if (width > -1)
                         button.Width = width;
                     if (height > -1)
                         button.Height = height;
                 }
                 button.onClick(onClick);
                 /*if (onClick != null)
                             button.Click += (sender, e) => onClick();*/
                 control.Controls.Add(button);
                 return button;
             });
 }

        /// <summary>
        /// Load default value to control and other initialize.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
                MethodInvoker runHitCount = new MethodInvoker(UpdateHitCount);
                runHitCount.BeginInvoke(CurrentWeb, HttpContext.Current, null, null);
                //dvBG.Attributes.Add("style", "background-image: url('" + DocLibUrl + "/statistic.jpg'); width: 118px; height: 35px;");
                //dvHitCount.InnerText = HitCountNumber.ToString();
                //dvBGDay.Attributes.Add("style", "background-image: url('" + DocLibUrl + "/statistic.jpg'); width: 118px; height: 35px;");
                //dvHitCountDay.InnerText = DayHitCountNumber.ToString();
                //dvBGNow.Attributes.Add("style", "background-image: url('" + DocLibUrl + "/statistic.jpg'); width: 118px; height: 35px;");
                //dvHitCountNow.InnerText = CurrentHitCountNumber.ToString();
                //dvBGWeek.Attributes.Add("style", "background-image: url('" + DocLibUrl + "/statistic.jpg'); width: 118px; height: 35px;");
                //dvHitCountWeek.InnerText = WeekHitCountNumber.ToString();
                //dvBGMonth.Attributes.Add("style", "background-image: url('" + DocLibUrl + "/statistic.jpg'); width: 118px; height: 35px;");
                //dvHitCountMonth.InnerText = MonthHitCountNumber.ToString();
                //dvBGYesterday.Attributes.Add("style", "background-image: url('" + DocLibUrl + "/statistic.jpg'); width: 118px; height: 35px;");
                //dvHitCountYesterday.InnerText = YesterdayHitCountNumber.ToString();

                tdAll.InnerText = HitCountNumber.ToString();
                tdToday.InnerText = DayHitCountNumber.ToString();
                lblCurrent.Text = "<span id='spCurrent'>" + CurrentHitCountNumber.ToString() + "</span>";
                tdThisWeek.InnerText = WeekHitCountNumber.ToString();
                tdThisMonth.InnerText = MonthHitCountNumber.ToString();
                tdYesterday.InnerText = YesterdayHitCountNumber.ToString();
            }
        }

 public FloodFillDrawer(PolygonsContainer data, MethodInvoker ImageRefresher = null)
 {
     this.ImageRefresher = ImageRefresher;
     this.data = data;
     InitializeFloodFillStrategies();
     floodFillerStrategy = strategiesList[0];
 }

 private void InvokeIfRequired(MethodInvoker _delegate)
 {
     if (this.InvokeRequired)
         this.BeginInvoke(_delegate);
     else
         _delegate();
 }

 private void MarshalToForm(MethodInvoker code)
 {
     if (m_form.InvokeRequired)
         m_form.BeginInvoke(code);
     else
         code();
 }

 private static void InvokeIfRequired(ISynchronizeInvoke control, MethodInvoker action)
 {
     if (control.InvokeRequired)
         control.Invoke(action, new object[0]);
     else
         action();
 }

		public ShortcutAction(Keys k, bool ctrl, bool editorMustBeFocused, MethodInvoker func)
		{
			Key = k;
			Ctrl = ctrl;
			EditorMustBeFocused = editorMustBeFocused;
			fMethodInvoker = func;
		}

 public static void InvokeIfRequired(this ISynchronizeInvoke control, MethodInvoker action)
 {
     if (control.InvokeRequired)
         control.Invoke(action, null);
     else
         action();
 }

 public override void Execute()
 {
     string msg = "";
     if (AppContext.IsAppInitializing && AppContext.IsGetSignalList && AppContext.SignalDatas.Count > 0)
     {
         signals = new Signal[AppContext.SignalDatas.Count];
         AppContext.SignalDatas.CopyTo(signals);
         MethodInvoker mi = new MethodInvoker(InitPriceList);
         priceListView.Invoke(mi);
         mi = new MethodInvoker(InitSignalList);
         signalListView.Invoke(mi);
         mi = new MethodInvoker(InitStatList);
         statListView.Invoke(mi);
     }
     else if (AppContext.IsAppInitializing && AppContext.IsGetSymbolPrices && AppContext.SymbolPrices.Count > 0)
     {
         MethodInvoker mi = new MethodInvoker(InitPriceList);
         priceListView.Invoke(mi);
         AppContext.IsStatListInitialized = true;
         AppContext.IsSignalListInitialized = true;
     }
     else
     {
         if (AppSetting.STATUS == AppSetting.TEST_ACCOUNT)  //  || AppSetting.STATUS == AppSetting.ADMIN_ACCOUNT
         {
             msg = NetHelper.BuildMsg(Protocol.C0004_1, new string[] { "2" });
         }
         else
         {
             msg = NetHelper.BuildMsg(Protocol.C0004_1, new string[] { "0" });
         }
         Send(msg);
     }
 }

 void DetermineCall(MethodInvoker method)
 {
     if (!this.IsDisposed && this.InvokeRequired)
         Invoke(method);
     else
         method();
 }

 /// <summary>
 /// Calls action on control, invokes if required.
 /// </summary>
 /// <param name="control"></param>
 /// <param name="action"></param>
 public static void InvokeIfRequired(this Control control, MethodInvoker action)
 {
     if (control.InvokeRequired)
         control.Invoke(action);
     else
         action();
 }

 /// <summary>
 /// Invokes the passed function if required.
 /// </summary>
 /// <param name="action">Function that should be invoked if required.</param>
 public void InvokeIfRequired(MethodInvoker action)
 {
     if (InvokeRequired)
         Invoke(action);
     else
         action();
 }

 private void RaiseOnUiThread(MethodInvoker methodToRaise)
 {
     if (synchronizeInvoke.InvokeRequired)
         synchronizeInvoke.BeginInvoke(methodToRaise, null);
     else
         methodToRaise();
 }

 private void InvokeForm(MethodInvoker mi)
 {
     if (InvokeRequired)
         Invoke(mi);
     else
         mi();
 }