private void MenuImageCrop_Click(object sender, System.EventArgs e)
{
	if (AppWorkspace.ActiveDocumentWorkspace != null)
	{
		if (!AppWorkspace.ActiveDocumentWorkspace.Selection.IsEmpty)
		{
			AppWorkspace.ActiveDocumentWorkspace.ExecuteFunction(new CropToSelectionFunction());
		}
	}
}

private void MenuImageResize_Click(object sender, System.EventArgs e)
{
	if (AppWorkspace.ActiveDocumentWorkspace != null)
	{
		AppWorkspace.ActiveDocumentWorkspace.PerformAction(new ResizeAction());
	}
}

private void MenuFileOpen_Click(object sender, System.EventArgs e)
{
	AppWorkspace.PerformAction(new OpenFileAction());
}

   internal abstract class AppWorkspaceAction
   {
       public abstract void PerformAction(AppWorkspace appWorkspace);

       public AppWorkspaceAction()
       {
           SystemLayer.Tracing.LogFeature("AWAction(" + GetType().Name + ")");
       }
   }


/// <summary>
   /// Provides a way to do a tool-less action that operates on the DocumentWorkspace.
   /// DocumentActions must NOT touch directly the History -- they should return history 
   /// actions that can undo what they have already done. These history actions will
   /// then be placed in to the history by whomever invoked the DocumentAction.
   /// If the action does not affect the Document, it should return null from its
   /// PerformAction method.
   /// DocumentActions should ONLY mutate the DocumentWorkspace and any contained
   /// objects.
   /// </summary>
   internal abstract class DocumentWorkspaceAction
   {
       private ActionFlags actionFlags;
       public ActionFlags ActionFlags
       {
           get
           {
               return this.actionFlags;
           }
       }

       /// <summary>
       /// Implement this to provide an action. You must return a HistoryMemento so that you
       /// can be undone. However, you should return null if you didn't do anything that
       /// affected the document.
       /// </summary>
       /// <returns>A HistoryMemento object that will be placed onto the HistoryStack.</returns>
       public abstract HistoryMemento PerformAction(DocumentWorkspace documentWorkspace);

       /// <summary>
       /// Initializes an instance of a class dervied from DocumentAction.
       /// </summary>
       /// <param name="documentWorkspace">The DocumentWorkspace to interact with.</param>
       /// <param name="actionFlags">Flags that describe action behavior or requirements.</param>
       public DocumentWorkspaceAction(ActionFlags actionFlags)
       {
           this.actionFlags = actionFlags;
           SystemLayer.Tracing.LogFeature("DWAction(" + GetType().Name + ")");
       }
   }

public HistoryMemento Execute(IHistoryWorkspace historyWorkspace);
public abstract HistoryMemento OnExecute(IHistoryWorkspace historyWorkspace);

StartPart2
{                 
	Application.Run(this.mainForm); 
}

internal sealed class MainForm: PdnBaseForm
{
	private AppWorkspace appWorkspace;

	private void InitializeComponent()
	{
		this.components = new System.ComponentModel.Container();
		this.defaultButton = new System.Windows.Forms.Button();
		// 构造
		this.appWorkspace = new PaintDotNet.AppWorkspace();
		this.floaterOpacityTimer = new System.Windows.Forms.Timer(this.components);
		this.deferredInitializationTimer = new System.Windows.Forms.Timer(this.components);
		this.SuspendLayout();
		// 
		// appWorkspace
		// 
		this.appWorkspace.Dock = System.Windows.Forms.DockStyle.Fill;
		this.appWorkspace.Location = new System.Drawing.Point(0, 0);
		this.appWorkspace.Name = "appWorkspace";
		this.appWorkspace.Size = new System.Drawing.Size(752, 648);
		this.appWorkspace.TabIndex = 2;
		this.appWorkspace.ActiveDocumentWorkspaceChanging += new EventHandler(AppWorkspace_ActiveDocumentWorkspaceChanging);
		this.appWorkspace.ActiveDocumentWorkspaceChanged += new EventHandler(AppWorkspace_ActiveDocumentWorkspaceChanged);
		//...

		this.AutoScaleDimensions = new SizeF(96F, 96F);
		this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi;
		this.ClientSize = new System.Drawing.Size(950, 738);

		// 添加appWorkspace
		this.Controls.Add(this.appWorkspace);
		this.Controls.Add(this.defaultButton);
		//...
	}
}

internal class AppWorkspace: UserControl, ISnapObstacleHost
{
	private AppEnvironment appEnvironment; 
	private DocumentWorkspace activeDocumentWorkspace;

	// if a new workspace is added, and this workspace is not dirty, then it will be removed. 
	// This keeps track of the last workspace added via CreateBlankDocumentInNewWorkspace (if 
	// true was passed for its 2nd parameter)
	private DocumentWorkspace initialWorkspace; 

	private List<DocumentWorkspace> documentWorkspaces = new List<DocumentWorkspace>();
	private WorkspaceWidgets widgets;

	//状态栏, 工具条, 悬浮窗
	private Panel workspacePanel;
	private PdnToolBar toolBar;
	private PdnStatusBar statusBar;

	private ToolsForm mainToolBarForm;
	private LayerForm layerForm;
	private HistoryForm historyForm;
	private ColorsForm colorsForm;

	//...

	public AppWorkspace()
	{
		SuspendLayout();

		// initialize!
		InitializeComponent();
		InitializeFloatingForms();

		this.mainToolBarForm.ToolsControl.SetTools(DocumentWorkspace.ToolInfos);
		this.mainToolBarForm.ToolsControl.ToolClicked += new ToolClickedEventHandler(this.MainToolBar_ToolClicked);

		this.toolBar.ToolChooserStrip.SetTools(DocumentWorkspace.ToolInfos);
		this.toolBar.ToolChooserStrip.ToolClicked += new ToolClickedEventHandler(this.MainToolBar_ToolClicked);

		this.toolBar.AppWorkspace = this;

		// init the Widgets container
		this.widgets = new WorkspaceWidgets(this);
		this.widgets.ViewConfigStrip = this.toolBar.ViewConfigStrip;
		this.widgets.CommonActionsStrip = this.toolBar.CommonActionsStrip;
		this.widgets.ToolConfigStrip = this.toolBar.ToolConfigStrip;
		this.widgets.ToolsForm = this.mainToolBarForm;
		this.widgets.LayerForm = this.layerForm;
		this.widgets.HistoryForm = this.historyForm;
		this.widgets.ColorsForm = this.colorsForm;
		this.widgets.StatusBarProgress = this.statusBar;
		this.widgets.DocumentStrip = this.toolBar.DocumentStrip;

		// Load our settings and initialize the AppEnvironment
		LoadSettings();

		// hook into Environment *Changed events
		AppEnvironment.PrimaryColorChanged += PrimaryColorChangedHandler;
		AppEnvironment.SecondaryColorChanged += SecondaryColorChangedHandler;
		AppEnvironment.ShapeDrawTypeChanged += ShapeDrawTypeChangedHandler;
		AppEnvironment.GradientInfoChanged += GradientInfoChangedHandler;
		AppEnvironment.ToleranceChanged += OnEnvironmentToleranceChanged;
		AppEnvironment.AlphaBlendingChanged += AlphaBlendingChangedHandler;
		AppEnvironment.FontInfo = this.toolBar.ToolConfigStrip.FontInfo;
		AppEnvironment.TextAlignment = this.toolBar.ToolConfigStrip.FontAlignment;
		AppEnvironment.AntiAliasingChanged += Environment_AntiAliasingChanged;
		AppEnvironment.FontInfoChanged += Environment_FontInfoChanged;
		AppEnvironment.FontSmoothingChanged += Environment_FontSmoothingChanged;
		AppEnvironment.TextAlignmentChanged += Environment_TextAlignmentChanged;
		AppEnvironment.PenInfoChanged += Environment_PenInfoChanged;
		AppEnvironment.BrushInfoChanged += Environment_BrushInfoChanged;
		AppEnvironment.ColorPickerClickBehaviorChanged += Environment_ColorPickerClickBehaviorChanged;
		AppEnvironment.ResamplingAlgorithmChanged += Environment_ResamplingAlgorithmChanged;
		AppEnvironment.SelectionCombineModeChanged += Environment_SelectionCombineModeChanged;
		AppEnvironment.FloodModeChanged += Environment_FloodModeChanged;
		AppEnvironment.SelectionDrawModeInfoChanged += Environment_SelectionDrawModeInfoChanged;

		this.toolBar.DocumentStrip.RelinquishFocus += RelinquishFocusHandler;

		this.toolBar.ToolConfigStrip.ToleranceChanged += OnToolBarToleranceChanged;
		this.toolBar.ToolConfigStrip.FontAlignmentChanged += ToolConfigStrip_TextAlignmentChanged;
		this.toolBar.ToolConfigStrip.FontInfoChanged += ToolConfigStrip_FontTextChanged;
		this.toolBar.ToolConfigStrip.FontSmoothingChanged += ToolConfigStrip_FontSmoothingChanged;
		this.toolBar.ToolConfigStrip.RelinquishFocus += RelinquishFocusHandler2;

		this.toolBar.CommonActionsStrip.RelinquishFocus += OnToolStripRelinquishFocus;
		this.toolBar.CommonActionsStrip.MouseWheel += OnToolStripMouseWheel;
		this.toolBar.CommonActionsStrip.ButtonClick += CommonActionsStrip_ButtonClick;

		this.toolBar.ViewConfigStrip.DrawGridChanged += ViewConfigStrip_DrawGridChanged;
		this.toolBar.ViewConfigStrip.RulersEnabledChanged += ViewConfigStrip_RulersEnabledChanged;
		this.toolBar.ViewConfigStrip.ZoomBasisChanged += ViewConfigStrip_ZoomBasisChanged;
		this.toolBar.ViewConfigStrip.ZoomScaleChanged += ViewConfigStrip_ZoomScaleChanged;
		this.toolBar.ViewConfigStrip.ZoomIn += ViewConfigStrip_ZoomIn;
		this.toolBar.ViewConfigStrip.ZoomOut += ViewConfigStrip_ZoomOut;
		this.toolBar.ViewConfigStrip.UnitsChanged += ViewConfigStrip_UnitsChanged;
		this.toolBar.ViewConfigStrip.RelinquishFocus += OnToolStripRelinquishFocus;
		this.toolBar.ViewConfigStrip.MouseWheel += OnToolStripMouseWheel;

		this.toolBar.ToolConfigStrip.BrushInfoChanged += DrawConfigStrip_BrushChanged;
		this.toolBar.ToolConfigStrip.ShapeDrawTypeChanged += DrawConfigStrip_ShapeDrawTypeChanged;
		this.toolBar.ToolConfigStrip.PenInfoChanged += DrawConfigStrip_PenChanged;
		this.toolBar.ToolConfigStrip.GradientInfoChanged += ToolConfigStrip_GradientInfoChanged;
		this.toolBar.ToolConfigStrip.AlphaBlendingChanged += OnDrawConfigStripAlphaBlendingChanged;
		this.toolBar.ToolConfigStrip.AntiAliasingChanged += DrawConfigStrip_AntiAliasingChanged;
		this.toolBar.ToolConfigStrip.RelinquishFocus += OnToolStripRelinquishFocus;
		this.toolBar.ToolConfigStrip.ColorPickerClickBehaviorChanged += ToolConfigStrip_ColorPickerClickBehaviorChanged;
		this.toolBar.ToolConfigStrip.ResamplingAlgorithmChanged += ToolConfigStrip_ResamplingAlgorithmChanged;
		this.toolBar.ToolConfigStrip.SelectionCombineModeChanged += ToolConfigStrip_SelectionCombineModeChanged;
		this.toolBar.ToolConfigStrip.FloodModeChanged += ToolConfigStrip_FloodModeChanged;
		this.toolBar.ToolConfigStrip.SelectionDrawModeInfoChanged += ToolConfigStrip_SelectionDrawModeInfoChanged;
		this.toolBar.ToolConfigStrip.SelectionDrawModeUnitsChanging += ToolConfigStrip_SelectionDrawModeUnitsChanging;

		this.toolBar.ToolConfigStrip.MouseWheel += OnToolStripMouseWheel;

		this.toolBar.DocumentStrip.RelinquishFocus += OnToolStripRelinquishFocus;
		this.toolBar.DocumentStrip.DocumentClicked += DocumentStrip_DocumentTabClicked;
		this.toolBar.DocumentStrip.DocumentListChanged += DocumentStrip_DocumentListChanged;

		// Synchronize
		AppEnvironment.PerformAllChanged();

		this.globalToolTypeChoice = this.defaultToolTypeChoice;
		this.toolBar.ToolConfigStrip.ToolBarConfigItems = ToolBarConfigItems.None;

		this.layerForm.LayerControl.AppWorkspace = this;

		ResumeLayout();
		PerformLayout();
	}

	private void InitializeFloatingForms()
	{
		// MainToolBarForm
		mainToolBarForm = new ToolsForm();
		mainToolBarForm.RelinquishFocus += RelinquishFocusHandler;
		mainToolBarForm.ProcessCmdKeyEvent += OnToolFormProcessCmdKeyEvent;

		// LayerForm
		layerForm = new LayerForm();
		layerForm.LayerControl.AppWorkspace = this;
		layerForm.LayerControl.ClickedOnLayer += LayerControl_ClickedOnLayer;
		layerForm.NewLayerButtonClick += LayerForm_NewLayerButtonClicked;
		layerForm.DeleteLayerButtonClick += LayerForm_DeleteLayerButtonClicked;
		layerForm.DuplicateLayerButtonClick += LayerForm_DuplicateLayerButtonClick;
		layerForm.MergeLayerDownClick += new EventHandler(LayerForm_MergeLayerDownClick);
		layerForm.MoveLayerUpButtonClick += LayerForm_MoveLayerUpButtonClicked;
		layerForm.MoveLayerDownButtonClick += LayerForm_MoveLayerDownButtonClicked;
		layerForm.PropertiesButtonClick += LayerForm_PropertiesButtonClick;
		layerForm.RelinquishFocus += RelinquishFocusHandler;
		layerForm.ProcessCmdKeyEvent += OnToolFormProcessCmdKeyEvent;
		
		// HistoryForm
		historyForm = new HistoryForm();
		historyForm.RewindButtonClicked += HistoryForm_RewindButtonClicked;
		historyForm.UndoButtonClicked += HistoryForm_UndoButtonClicked;
		historyForm.RedoButtonClicked += HistoryForm_RedoButtonClicked;
		historyForm.FastForwardButtonClicked += HistoryForm_FastForwardButtonClicked;
		historyForm.RelinquishFocus += RelinquishFocusHandler;
		historyForm.ProcessCmdKeyEvent += OnToolFormProcessCmdKeyEvent;

		// ColorsForm
		colorsForm = new ColorsForm();
		colorsForm.PaletteCollection = new PaletteCollection();
		colorsForm.WhichUserColor = WhichUserColor.Primary;
		colorsForm.UserPrimaryColorChanged += ColorsForm_UserPrimaryColorChanged;
		colorsForm.UserSecondaryColorChanged += ColorsForm_UserSecondaryColorChanged;
		colorsForm.RelinquishFocus += RelinquishFocusHandler;
		colorsForm.ProcessCmdKeyEvent += OnToolFormProcessCmdKeyEvent;
	}
}

internal class ToolsForm 
	: FloatingToolForm
{
	private ToolsControl toolsControl = null;
}

   internal class ToolsControl 
       : UserControl, 
         IToolChooser
   {
       private ToolStripEx toolStripEx;

	//添加tool button
       public void SetTools(ToolInfo[] toolInfos)
       {
           if (this.toolStripEx != null)
           {
               this.toolStripEx.Items.Clear();
           }

           this.imageList = new ImageList();
           this.imageList.ColorDepth = ColorDepth.Depth32Bit;
           this.imageList.TransparentColor = Utility.TransparentKey;

           this.toolStripEx.ImageList = this.imageList;

           ToolStripItem[] buttons = new ToolStripItem[toolInfos.Length];
           string toolTipFormat = PdnResources.GetString("ToolsControl.ToolToolTip.Format");

           for (int i = 0; i < toolInfos.Length; ++i)
           {
               ToolInfo toolInfo = toolInfos[i];
               ToolStripButton button = new ToolStripButton();

               int imageIndex = imageList.Images.Add(
                   toolInfo.Image.Reference,
                   imageList.TransparentColor);

               button.ImageIndex = imageIndex;
               button.Tag = toolInfo.ToolType;
               button.ToolTipText = string.Format(toolTipFormat, toolInfo.Name, char.ToUpperInvariant(toolInfo.HotKey).ToString());
               buttons[i] = button;
           }

           this.toolStripEx.Items.AddRange(buttons);
       }

	// 增加tool按钮的点击事件
       private void ToolStripEx_ItemClicked(object sender, ToolStripItemClickedEventArgs e)
       {
           foreach (ToolStripButton button in this.toolStripEx.Items)
           {
               button.Checked = (button == e.ClickedItem);
           }

           OnToolClicked((Type)e.ClickedItem.Tag);
       }

	
       public event ToolClickedEventHandler ToolClicked;
       protected virtual void OnToolClicked(Type toolType)
       {
           if (this.ignoreToolClicked <= 0)
           {
               if (ToolClicked != null)
               {
                   ToolClicked(this, new ToolClickedEventArgs(toolType));
               }
           }
       }
}

internal class ToolInfo
   {
       private string name;
       private string helpText;
       private ImageResource image;
       private bool skipIfActiveOnHotKey;
       private char hotKey;
       private Type toolType; //具体的工具类型
       private ToolBarConfigItems toolBarConfigItems;
}

public AppWorkspace()
{
	SuspendLayout();

	// initialize!
	InitializeComponent();
	InitializeFloatingForms();

	this.mainToolBarForm.ToolsControl.SetTools(DocumentWorkspace.ToolInfos);
	this.mainToolBarForm.ToolsControl.ToolClicked += new ToolClickedEventHandler(this.MainToolBar_ToolClicked);
}

private void MainToolBar_ToolClicked(object sender, ToolClickedEventArgs e)
{
	if (ActiveDocumentWorkspace != null)
	{
		ActiveDocumentWorkspace.Focus();
		ActiveDocumentWorkspace.SetToolFromType(e.ToolType);
	}
}

public void SetToolFromType(Type toolType)
{
	if (toolType == GetToolType())
	{
		return;
	}
	else if (toolType == null)
	{
		SetTool(null);
	}
	else
	{
		Tool newTool = CreateTool(toolType);
		SetTool(newTool);
	}
}

// Methods to send messages to this class
public void PerformActivate()
{
	Activate();
}

protected override void OnActivate()
{
    base.OnActivate();

    this.pencilToolCursor = new Cursor(PdnResources.GetResourceStream("Cursors.PencilToolCursor.cur"));
    this.Cursor = this.pencilToolCursor; //改变鼠标形状

    this.savedRects = new List<Rectangle>();

    if (ActiveLayer != null)
    {
        bitmapLayer = (BitmapLayer)ActiveLayer;
        renderArgs = new RenderArgs(bitmapLayer.Surface);
        tracePoints = new List<Point>();
    }
    else
    {
        bitmapLayer = null;

        if (renderArgs != null)
        {
            renderArgs.Dispose();
            renderArgs = null;
        }
    }
}

//AppWorkspace.cs
protected virtual void OnActiveDocumentWorkspaceChanged()
{
		this.activeDocumentWorkspace.DocumentMouseEnter += this.DocumentMouseEnterHandler;
		this.activeDocumentWorkspace.DocumentMouseLeave += this.DocumentMouseLeaveHandler;
		this.activeDocumentWorkspace.DocumentMouseMove += this.DocumentMouseMoveHandler;
		this.activeDocumentWorkspace.DocumentMouseDown += this.DocumentMouseDownHandler;
		//...
	//...
}

private void DocumentMouseMoveHandler(object sender, MouseEventArgs e)
{
	if (ActiveDocumentWorkspace.Tool != null)
	{
		ActiveDocumentWorkspace.Tool.PerformMouseMove(e); // ActiveDocumentWorkspace.Tool为activeTool
	}
}

public void PerformMouseMove(MouseEventArgs e)
{
	if (IsOverflow(e)) 
	{
		return;
	}

	if (e is StylusEventArgs)
	{
		if (this.SupportsInk) 
		{
			StylusMove(e as StylusEventArgs);
		}

		// if the tool does not claim ink support, discard
	}
	else
	{
		MouseMove(e);
	}
}

// Draws a point, but first intersects it with the selection
private void DrawPoint(RenderArgs ra, Point p, ColorBgra color)
{
	if (ra.Surface.Bounds.Contains(p))
	{
		if (ra.Graphics.IsVisible(p))
		{
			BinaryPixelOp op = AppEnvironment.AlphaBlending ? blendOp : copyOp;
			ra.Surface[p.X, p.Y] = op.Apply(ra.Surface[p.X, p.Y], color);
		}
	}
}

//DocumentWorkspace.cs
	private static void InitializeTools()
	{
		// add all the tools
		tools = new Type[] 
		{
			typeof(RectangleSelectTool),
			typeof(MoveTool),
			typeof(LassoSelectTool),
			typeof(MoveSelectionTool),

			typeof(EllipseSelectTool),
			typeof(ZoomTool),

			typeof(MagicWandTool),
			typeof(PanTool),

			typeof(PaintBucketTool),
			typeof(GradientTool),

			typeof(PaintBrushTool),
			typeof(EraserTool),
			typeof(PencilTool),
			typeof(ColorPickerTool),
			typeof(CloneStampTool), 
			typeof(RecolorTool),
			typeof(TextTool),

			typeof(LineTool),
			typeof(RectangleTool),
			typeof(RoundedRectangleTool),
			typeof(EllipseTool),
			typeof(FreeformShapeTool),
		};
	}

	private static void InitializeToolInfos()
	{
		int i = 0;
		toolInfos = new ToolInfo[tools.Length];

		foreach (Type toolType in tools)
		{
			using (Tool tool = DocumentWorkspace.CreateTool(toolType, null))
			{
				toolInfos[i] = tool.Info;
				++i;
			}
		}
	}

using System;
using System.Threading;
using System.Windows;
using System.Diagnostics;
using System.Collections.Generic;
using MS.Internal.WindowsBase;

namespace System.Windows.Threading 
{
    /// <summary>
    ///     A timer that is integrated into the Dispatcher queues, and will
    ///     be processed after a given amount of time at a specified priority.
    /// </summary>
    public class DispatcherTimer
    {
        /// <summary>
        ///     Creates a timer that uses the current thread's Dispatcher to
        ///     process the timer event at background priority.
        /// </summary>
        public DispatcherTimer() : this(DispatcherPriority.Background)  // NOTE: should be Priority Dispatcher.BackgroundPriority
        {
        }
        
        /// <summary>
        ///     Creates a timer that uses the current thread's Dispatcher to
        ///     process the timer event at the specified priority.
        /// </summary>
        /// <param name="priority">
        ///     The priority to process the timer at.
        /// </param>
        public DispatcherTimer(DispatcherPriority priority) // NOTE: should be Priority
        {
            Initialize(Dispatcher.CurrentDispatcher, priority, TimeSpan.FromMilliseconds(0));
        }
        
        /// <summary>
        ///     Creates a timer that uses the specified Dispatcher to
        ///     process the timer event at the specified priority.
        /// </summary>
        /// <param name="priority">
        ///     The priority to process the timer at.
        /// </param>
        /// <param name="dispatcher">
        ///     The dispatcher to use to process the timer.
        /// </param>
        public DispatcherTimer(DispatcherPriority priority, Dispatcher dispatcher)  // NOTE: should be Priority
        {
            if(dispatcher == null)
            {
                throw new ArgumentNullException("dispatcher");
            }
            
            Initialize(dispatcher, priority, TimeSpan.FromMilliseconds(0));
        }

        /// <summary>
        ///     Creates a timer that is bound to the specified dispatcher and
        ///     will be processed at the specified priority, after the
        ///     specified timeout.
        /// </summary>
        /// <param name="interval">
        ///     The interval to tick the timer after.
        /// </param>
        /// <param name="priority">
        ///     The priority to process the timer at.
        /// </param>
        /// <param name="callback">
        ///     The callback to call when the timer ticks.
        /// </param>
        /// <param name="dispatcher">
        ///     The dispatcher to use to process the timer.
        /// </param>
        public DispatcherTimer(TimeSpan interval, DispatcherPriority priority, EventHandler callback, Dispatcher dispatcher) // NOTE: should be Priority
        {
            // 
            if(callback == null)
            {
                throw new ArgumentNullException("callback");
            }
            if(dispatcher == null)
            {
                throw new ArgumentNullException("dispatcher");
            }

            if (interval.TotalMilliseconds < 0)
                throw new ArgumentOutOfRangeException("interval", SR.Get(SRID.TimeSpanPeriodOutOfRange_TooSmall));

            if (interval.TotalMilliseconds > Int32.MaxValue)
                throw new ArgumentOutOfRangeException("interval", SR.Get(SRID.TimeSpanPeriodOutOfRange_TooLarge));

            Initialize(dispatcher, priority, interval);
            
            Tick += callback;
            Start();
        }

        /// <summary>
        ///     Gets the dispatcher this timer is associated with.
        /// </summary>
        public Dispatcher Dispatcher
        {
            get
            {
                return _dispatcher;
            }
        }

        /// <summary>
        ///     Gets or sets whether the timer is running.
        /// </summary>
        public bool IsEnabled
        {
            get
            {
                return _isEnabled;
            }

            set
            {
                lock(_instanceLock)
                {
                    if(!value && _isEnabled)
                    {
                        Stop();
                    }
                    else if(value && !_isEnabled)
                    {
                        Start();
                    }
                }
            }
        }

        /// <summary>
        ///     Gets or sets the time between timer ticks.
        /// </summary>
        public TimeSpan Interval
        {
            get
            {
                return _interval;
            }

            set
            {
                bool updateWin32Timer = false;
                
                if (value.TotalMilliseconds < 0)
                    throw new ArgumentOutOfRangeException("value", SR.Get(SRID.TimeSpanPeriodOutOfRange_TooSmall));

                if (value.TotalMilliseconds > Int32.MaxValue)
                    throw new ArgumentOutOfRangeException("value", SR.Get(SRID.TimeSpanPeriodOutOfRange_TooLarge));

                lock(_instanceLock)
                {
                    _interval = value;

                    if(_isEnabled)
                    {
                        _dueTimeInTicks = Environment.TickCount + (int)_interval.TotalMilliseconds;
                        updateWin32Timer = true;
                    }
                }

                if(updateWin32Timer)
                {
                    _dispatcher.UpdateWin32Timer();
                }
            }
        }
        
        /// <summary>
        ///     Starts the timer.
        /// </summary>
        public void Start()
        {
            lock(_instanceLock)
            {
                if(!_isEnabled)
                {
                    _isEnabled = true;

                    Restart();
                }
            }
        }

        /// <summary>
        ///     Stops the timer.
        /// </summary>
        public void Stop()
        {
            bool updateWin32Timer = false;
            
            lock(_instanceLock)
            {
                if(_isEnabled)
                {
                    _isEnabled = false;
                    updateWin32Timer = true;

                    // If the operation is in the queue, abort it.
                    if(_operation != null)
                    {
                        _operation.Abort();
                        _operation = null;
                    }
                    
                }
            }

            if(updateWin32Timer)
            {
                _dispatcher.RemoveTimer(this);
            }
        }
        
        /// <summary>
        ///     Occurs when the specified timer interval has elapsed and the
        ///     timer is enabled.
        /// </summary>
        public event EventHandler Tick;

        /// <summary>
        ///     Any data that the caller wants to pass along with the timer.
        /// </summary>
        public object Tag
        {
            get
            {
                return _tag;
            }

            set
            {
                _tag = value;
            }
        }


        private void Initialize(Dispatcher dispatcher, DispatcherPriority priority, TimeSpan interval)
        {
            // Note: all callers of this have a "priority" parameter.
            Dispatcher.ValidatePriority(priority, "priority");
            if(priority == DispatcherPriority.Inactive)
            {
                throw new ArgumentException(SR.Get(SRID.InvalidPriority), "priority");
            }

            _dispatcher = dispatcher;
            _priority = priority;
            _interval = interval;
        }
        
        private void Restart()
        {
            lock(_instanceLock)
            {
                if (_operation != null)
                {
                    // Timer has already been restarted, e.g. Start was called form the Tick handler.
                    return;
                }

                // BeginInvoke a new operation.
                _operation = _dispatcher.BeginInvoke(
                    DispatcherPriority.Inactive,
                    new DispatcherOperationCallback(FireTick),
                    null);

                
                _dueTimeInTicks = Environment.TickCount + (int) _interval.TotalMilliseconds;
                
                if (_interval.TotalMilliseconds == 0 && _dispatcher.CheckAccess())
                {
                    // shortcut - just promote the item now
                    Promote();
                }
                else
                {
                    _dispatcher.AddTimer(this);
                }
            }

        }

        internal void Promote() // called from Dispatcher
        {
            lock(_instanceLock)
            {
                // Simply promote the operation to it's desired priority.
                if(_operation != null)
                {
                    _operation.Priority = _priority;
                }
            }
        }

        private object FireTick(object unused)
        {
            // The operation has been invoked, so forget about it.
            _operation = null;
            
            // The dispatcher thread is calling us because item's priority
            // was changed from inactive to something else.
            if(Tick != null)
            {
                Tick(this, EventArgs.Empty);
            }

            // If we are still enabled, start the timer again.
            if(_isEnabled)
            {
                Restart();
            }

            return null;
        }
        
        // This is the object we use to synchronize access.
        private object _instanceLock = new object();
        
        // Note: We cannot BE a dispatcher-affinity object because we can be
        // created by a worker thread.  We are still associated with a
        // dispatcher (where we post the item) but we can be accessed
        // by any thread.
        private Dispatcher _dispatcher;
        
        private DispatcherPriority _priority;  // NOTE: should be Priority
        private TimeSpan _interval;
        private object _tag;
        private DispatcherOperation _operation;
        private bool _isEnabled;

        internal int _dueTimeInTicks; // used by Dispatcher
    }
}

//  DispatcherTimer setup
dispatcherTimer = new System.Windows.Threading.DispatcherTimer();
dispatcherTimer.Tick += new EventHandler(dispatcherTimer_Tick);
dispatcherTimer.Interval = new TimeSpan(0,0,1);
dispatcherTimer.Start();

/// <summary>
///     Creates a timer that uses the current thread's Dispatcher to
///     process the timer event at background priority.
/// </summary>
public DispatcherTimer() : this(DispatcherPriority.Background)  // NOTE: should be Priority Dispatcher.BackgroundPriority
{
}

/// <summary>
///     Starts the timer.
/// </summary>
public void Start()
{
    lock(_instanceLock)
    {
        if(!_isEnabled)
        {
            _isEnabled = true;

            Restart();
        }
    }
}

private void Restart()
{
    lock(_instanceLock)
    {
        if (_operation != null)
        {
            // Timer has already been restarted, e.g. Start was called form the Tick handler.
            return;
        }

        // BeginInvoke a new operation.
        _operation = _dispatcher.BeginInvoke(
            DispatcherPriority.Inactive,
            new DispatcherOperationCallback(FireTick),
            null);

        
        _dueTimeInTicks = Environment.TickCount + (int) _interval.TotalMilliseconds;
        
        if (_interval.TotalMilliseconds == 0 && _dispatcher.CheckAccess())
        {
            // shortcut - just promote the item now
            Promote();
        }
        else
        {
            _dispatcher.AddTimer(this);
        }
    }

}

internal void UpdateWin32Timer() // Called from DispatcherTimer
{
    if(CheckAccess())
    {
        UpdateWin32TimerFromDispatcherThread(null);
    }
    else
    {
        BeginInvoke(DispatcherPriority.Send,
                    new DispatcherOperationCallback(UpdateWin32TimerFromDispatcherThread),
                    null);
    }
}

private object UpdateWin32TimerFromDispatcherThread(object unused)
{

    lock(_instanceLock)
    {
        if(!_hasShutdownFinished) // Dispatcher thread, does not technically need the lock to read
        {
            bool oldDueTimeFound = _dueTimeFound;
            int oldDueTimeInTicks = _dueTimeInTicks;
            _dueTimeFound = false;
            _dueTimeInTicks = 0;

            if(_timers.Count > 0)
            {
                // We could do better if we sorted the list of timers.
                for(int i = 0; i < _timers.Count; i++)
                {
                    DispatcherTimer timer = _timers[i];

                    if(!_dueTimeFound || timer._dueTimeInTicks - _dueTimeInTicks < 0)
                    {
                        _dueTimeFound = true;
                        _dueTimeInTicks = timer._dueTimeInTicks;
                    }
                }
            }

            if(_dueTimeFound)
            {
                if(!_isWin32TimerSet || !oldDueTimeFound || (oldDueTimeInTicks != _dueTimeInTicks))
                {
                    SetWin32Timer(_dueTimeInTicks);
                }
            }
            else if(oldDueTimeFound)
            {
                KillWin32Timer();
            }
        }
    }

    return null;
}

///<SecurityNote>
/// Critical - accesses critical data
/// TreatAsSafe - we think it's ok to expose timers in the SEE.
///                      a denial-of-service attack may be possible - but these are low-pri and possible in many other ways.
///                      we can never bring down the iexplore process.
///</SecurityNote>
[SecurityCritical, SecurityTreatAsSafe]
private void SetWin32Timer(int dueTimeInTicks)
{
    if(!IsWindowNull())
    {
        int delta = dueTimeInTicks - Environment.TickCount;
        if(delta < 1)
        {
            delta = 1;
        }

        // We are being called on the dispatcher thread so we can rely on
        // _window.Value being non-null without taking the instance lock.

        SafeNativeMethods.SetTimer(
            new HandleRef(this, _window.Value.Handle),
            TIMERID_TIMERS,
            delta);

        _isWin32TimerSet = true;
    }
}

private IntPtr WndProcHook(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)

    else if(message == WindowMessage.WM_TIMER && (int) wParam == TIMERID_TIMERS)
    {
        // We want 1-shot only timers.  So stop the timer
        // that just fired.
        KillWin32Timer();

        PromoteTimers(Environment.TickCount);
    }

internal void PromoteTimers(int currentTimeInTicks)

                    while(iTimer < _timers.Count)
                    {
                        // WARNING: this is vulnerable to wrapping
                        if(timers[iTimer]._dueTimeInTicks - currentTimeInTicks <= 0) //判断时间有没有到
                        {
                            // Remove this timer from our list.
                            // Do not increment the index.
                            timer = timers[iTimer];
                            timers.RemoveAt(iTimer);
                            break;
                        }
                        else
                        {
                            iTimer++;
                        }
                    }

                // Now that we are outside of the lock, promote the timer.
                if(timer != null)
                {
                    timer.Promote();
                }

//Dispatcher.cs
private void PushFrameImpl(DispatcherFrame frame)

    //<SecurityNote>
    // Critical - as this calls critical methods (GetMessage, TranslateMessage, DispatchMessage).
    // TreatAsSafe - as the critical method is not leaked out, and not controlled by external inputs.
    //</SecurityNote>
    [SecurityCritical, SecurityTreatAsSafe ]
    private void PushFrameImpl(DispatcherFrame frame)
    {
        SynchronizationContext oldSyncContext = null;
        SynchronizationContext newSyncContext = null;
        MSG msg = new MSG();

        _frameDepth++;
        try
        {
            // Change the CLR SynchronizationContext to be compatable with our Dispatcher.
            oldSyncContext = SynchronizationContext.Current;
            newSyncContext = new DispatcherSynchronizationContext(this);
            SynchronizationContext.SetSynchronizationContext(newSyncContext);
            
            try
            {
                while(frame.Continue)
                {
                    if (!GetMessage(ref msg, IntPtr.Zero, 0, 0))
                        break;

                    TranslateAndDispatchMessage(ref msg);
                }

                // If this was the last frame to exit after a quit, we
                // can now dispose the dispatcher.
                if(_frameDepth == 1)
                {
                    if(_hasShutdownStarted)
                    {
                        ShutdownImpl();
                    }
                }
            }
            finally
            {
                // Restore the old SynchronizationContext.
                SynchronizationContext.SetSynchronizationContext(oldSyncContext);
            }
        }
        finally
        {
            _frameDepth--;
            if(_frameDepth == 0)
            {
                // We have exited all frames.
                _exitAllFrames = false;
            }
        }
    }

using System;
using System.Security; 

namespace System.Windows.Threading
{
    /// <summary>
    ///     Representation of Dispatcher frame.
    /// </summary>
    public class DispatcherFrame : DispatcherObject
    {

        /// <SecurityNote>
        ///     Critical: This code exists to ensure that the static variables initialized
        ///     do not cause security violations.The reason this comes into existance is because
        ///     of the call to RegisterWindowMessage
        ///     TreatAsSafe:This is safe to call
        /// </SecurityNote>
        [SecurityCritical,SecurityTreatAsSafe]
        static DispatcherFrame()
        {
        }

        /// <summary>
        ///     Constructs a new instance of the DispatcherFrame class.
        /// </summary>
        public DispatcherFrame() : this(true)
        {
        }
        
        /// <summary>
        ///     Constructs a new instance of the DispatcherFrame class.
        /// </summary>
        /// <param name="exitWhenRequested">
        ///     Indicates whether or not this frame will exit when all frames
        ///     are requested to exit.
        ///     <p/>
        ///     Dispatcher frames typically break down into two categories:
        ///     1) Long running, general purpose frames, that exit only when
        ///        told to.  These frames should exit when requested.
        ///     2) Short running, very specific frames that exit themselves
        ///        when an important criteria is met.  These frames may
        ///        consider not exiting when requested in favor of waiting
        ///        for their important criteria to be met.  These frames
        ///        should have a timeout associated with them.
        /// </param>
        public DispatcherFrame(bool exitWhenRequested)
        {
            _exitWhenRequested = exitWhenRequested;
            _continue = true;
        }

        /// <summary>
        ///     Indicates that this dispatcher frame should exit.
        /// </summary>
        /// <SecurityNote>
        ///     Critical - calls a critical method - postThreadMessage. 
        ///     PublicOK - all we're doing is posting a current message to our thread. 
        ///                net effect is the dispatcher "wakes up"
        ///                and uses the continue flag ( which may have just changed). 
        /// </SecurityNote> 
        public bool Continue
        {
            get
            {
                // This method is free-threaded.
                    
                // First check if this frame wants to continue.
                bool shouldContinue = _continue;
                if(shouldContinue)
                {
                    // This frame wants to continue, so next check if it will
                    // respect the "exit requests" from the dispatcher.
                    if(_exitWhenRequested)
                    {
                        Dispatcher dispatcher = Dispatcher;
                        
                        // This frame is willing to respect the "exit requests" of
                        // the dispatcher, so check them.
                        if(dispatcher._exitAllFrames || dispatcher._hasShutdownStarted)
                        {
                            shouldContinue = false;
                        }
                    }
                }
                
                return shouldContinue;
            }

            [SecurityCritical] 
            set
            {
                // This method is free-threaded.

                _continue = value;

                // Post a message so that the message pump will wake up and
                // check our continue state.
                Dispatcher.BeginInvoke(DispatcherPriority.Send, (DispatcherOperationCallback) delegate(object unused) {return null;}, null);
            }
        }

        private bool _exitWhenRequested;
        private bool _continue;
    }
}

//https://msdn.microsoft.com/zh-cn/library/system.windows.threading.dispatcher.pushframe.aspx
public static class ApplicationExtensions
{
    #region DoEvents using a DispatcherFrame

    public static void DoEvents(this Application application)
    {
        DispatcherFrame frame = new DispatcherFrame();
        Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Background, new ExitFrameHandler(frm => frm.Continue = false), frame);
        Dispatcher.PushFrame(frame);
    }

    private delegate void ExitFrameHandler(DispatcherFrame frame);

    #endregion
}

private void button1_Click(object sender, EventArgs e)  
{  
    for (int i = 0; i < 10000; i++)  
    {  
        label1.Text = i.ToString();  
        Application.DoEvents();  
    }  
}

Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Background, new ExitFrameHandler(frm => frm.Continue = false), frame);

//https://msdn.microsoft.com/en-us/library/system.windows.application(v=vs.110).aspx
using System; // STAThread
using System.Windows; // Application

namespace SDKSample
{
    public class AppCode : Application
    {
        // Entry point method
        [STAThread]
        public static void Main()
        {
            AppCode app = new AppCode();
            app.Run();
        }
    }
}

//Dispatcher.cs
    public static void Run()
    {
        PushFrame(new DispatcherFrame());
    }

    public static void PushFrame(DispatcherFrame frame)
    {
        if(frame == null)
        {
            throw new ArgumentNullException("frame");
        }

        Dispatcher dispatcher = Dispatcher.CurrentDispatcher;
        if(dispatcher._hasShutdownFinished) // Dispatcher thread - no lock needed for read
        {
            throw new InvalidOperationException(SR.Get(SRID.DispatcherHasShutdown));
        }

        if(frame.Dispatcher != dispatcher)
        {
            throw new InvalidOperationException(SR.Get(SRID.MismatchedDispatchers));
        }

        if(dispatcher._disableProcessingCount > 0)
        {
            throw new InvalidOperationException(SR.Get(SRID.DispatcherProcessingDisabled));
        }

        dispatcher.PushFrameImpl(frame);
    }

    //<SecurityNote>
    // Critical - as this calls critical methods (GetMessage, TranslateMessage, DispatchMessage).
    // TreatAsSafe - as the critical method is not leaked out, and not controlled by external inputs.
    //</SecurityNote>
    [SecurityCritical, SecurityTreatAsSafe ]
    private void PushFrameImpl(DispatcherFrame frame)
    {
        SynchronizationContext oldSyncContext = null;
        SynchronizationContext newSyncContext = null;
        MSG msg = new MSG();

        _frameDepth++;
        try
        {
            // Change the CLR SynchronizationContext to be compatable with our Dispatcher.
            oldSyncContext = SynchronizationContext.Current;
            newSyncContext = new DispatcherSynchronizationContext(this);
            SynchronizationContext.SetSynchronizationContext(newSyncContext);
            
            try
            {
                while(frame.Continue)
                {
                    if (!GetMessage(ref msg, IntPtr.Zero, 0, 0))
                        break;

                    TranslateAndDispatchMessage(ref msg);
                }

                // If this was the last frame to exit after a quit, we
                // can now dispose the dispatcher.
                if(_frameDepth == 1)
                {
                    if(_hasShutdownStarted)
                    {
                        ShutdownImpl();
                    }
                }
            }
            finally
            {
                // Restore the old SynchronizationContext.
                SynchronizationContext.SetSynchronizationContext(oldSyncContext);
            }
        }
        finally
        {
            _frameDepth--;
            if(_frameDepth == 0)
            {
                // We have exited all frames.
                _exitAllFrames = false;
            }
        }
    }

//Dispatcher.cs
    private IntPtr WndProcHook(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)  
    {
        //...
        if(message == WindowMessage.WM_DESTROY)
        {
            if(!_hasShutdownStarted && !_hasShutdownFinished) // Dispatcher thread - no lock needed for read
            {
                // Aack!  We are being torn down rudely!  Try to
                // shut the dispatcher down as nicely as we can.
                ShutdownImpl();
            }
        }
        else if(message == _msgProcessQueue)
        {
            ProcessQueue();
        }
        else if(message == WindowMessage.WM_TIMER && (int) wParam == TIMERID_BACKGROUND)
        {
            // This timer is just used to process background operations.
            // Stop the timer so that it doesn't fire again.
            SafeNativeMethods.KillTimer(new HandleRef(this, hwnd), TIMERID_BACKGROUND);

            ProcessQueue();
        }
        //...
    }

private Dispatcher()
{
    _queue = new PriorityQueue<DispatcherOperation>();

    _tlsDispatcher = this; // use TLS for ownership only
    _dispatcherThread = Thread.CurrentThread;

    // Add ourselves to the map of dispatchers to threads.
    lock(_globalLock)
    {
        _dispatchers.Add(new WeakReference(this));
    }

    _unhandledExceptionEventArgs = new DispatcherUnhandledExceptionEventArgs(this);
    _exceptionFilterEventArgs = new DispatcherUnhandledExceptionFilterEventArgs(this);

    _defaultDispatcherSynchronizationContext = new DispatcherSynchronizationContext(this);

    // Create the message-only window we use to receive messages
    // that tell us to process the queue.
    MessageOnlyHwndWrapper window = new MessageOnlyHwndWrapper();
    _window = new SecurityCriticalData<MessageOnlyHwndWrapper>( window );

    _hook = new HwndWrapperHook(WndProcHook);
    _window.Value.AddHook(_hook);
}