public bool IsSystemWindowMatch(SystemWindow Window)
        {
            string compareMatchString = MatchString ?? String.Empty;
            string windowMatchString = String.Empty;
            try
            {
                switch (MatchUsing)
                {
                    case MatchUsing.WindowClass:
                        windowMatchString = Window.ClassName;

                        break;
                    case MatchUsing.WindowTitle:
                        windowMatchString = Window.Title;

                        break;
                    case MatchUsing.ExecutableFilename:
                        windowMatchString = Window.Process.MainModule.ModuleName;

                        break;
                    case MatchUsing.All:
                        return true;
                }

                return IsRegEx ? Regex.IsMatch(windowMatchString, compareMatchString, RegexOptions.Singleline | RegexOptions.IgnoreCase) : String.Equals(windowMatchString.Trim(), compareMatchString.Trim(), StringComparison.CurrentCultureIgnoreCase);
            }
            catch
            {
                return false;
            }
        }

 public PointInfo(List<Point> touchLocation, List<List<Point>> points)
 {
     _touchLocation = touchLocation;
     _window = SystemWindow.FromPointEx(_touchLocation[0].X, _touchLocation[0].Y, true, false);
     _windowHandle = _window == null ? IntPtr.Zero : _window.HWnd;
     Points = points;
 }

        public bool IsSystemWindowMatch(SystemWindow Window)
        {
            string compareMatchString = MatchString ?? String.Empty;
            string windowMatchString = String.Empty;

            switch (MatchUsing)
            {
                case MatchUsing.WindowClass:
                    windowMatchString = Window.ClassName;

                    break;
                case MatchUsing.WindowTitle:
                    windowMatchString = Window.Title;

                    break;
                case MatchUsing.ExecutableFilename:
                    windowMatchString = Window.Process.MainModule.FileName;

                    break;
                case MatchUsing.All:
                    return true;
            }

            return IsRegEx ? Regex.IsMatch(windowMatchString, compareMatchString, RegexOptions.Singleline | RegexOptions.IgnoreCase) : windowMatchString.Trim().ToLower() == compareMatchString.Trim().ToLower();
        }

 private void parseChildren(List<string> toFill, SystemWindow window)
 {
     foreach (SystemWindow child in window.AllChildWindows)
     {
         string clazz = child.ClassName;
         if (!toFill.Contains(clazz)) toFill.Add(clazz);
         parseChildren(toFill, child);
     }
 }

        void timer_Tick(object sender, EventArgs e)
        {
            if (IntPtr.Zero != windowToSnap)
            {
                SystemWindow win = new SystemWindow(windowToSnap);
                win.Location = zone.Location;
                win.Size = zone.Size;
                windowToSnap = IntPtr.Zero;
            }

            timer.Stop();
        }

 private void appendContent(StringBuilder sb, SystemWindow sw, WindowContent c)
 {
     if (c == null) {
         sb.AppendLine("<Unknown Type>");
         return;
     }
     sb.AppendLine(c.ShortDescription);
     sb.AppendLine("Class Name: " + sw.ClassName);
     String ldesc = c.LongDescription.Replace("\n", "\r\n").Replace("\r\r\n", "\r\n");
     if (ldesc != null && c.ShortDescription != ldesc) {
         sb.AppendLine("------------------------------------------------------------");
         sb.AppendLine(ldesc);
     }
 }

 public void guess(IGuesserListener listener, SystemWindow window)
 {
     string file;
     try
     {
         file = window.Process.MainModule.FileName;
     }
     catch (Win32Exception)
     {
         listener.guessInfo(2, "*** File access denied");
         return;
     }
     listener.guessInfo(2, "*** Detected File: " + file);
     ctrl.guessFile(listener, file);
 }

 private void Highlight(SystemWindow sw, SystemAccessibleObject acc)
 {
     if (sw == null) return;
     if (acc != null && acc != highlightedObject)
     {
         if (highlightedWindow != null)
             highlightedWindow.Refresh();
         acc.Highlight();
     }
     else if (sw != highlightedWindow)
     {
         if (highlightedWindow != null)
             highlightedWindow.Refresh();
         sw.Highlight();
     }
     highlightedObject = acc;
     highlightedWindow = sw;
 }

 public void guess(IGuesserListener listener, SystemWindow window)
 {
     string mainclass = window.ClassName;
     List<string> childClasses = new List<string>();
     childClasses.Add(mainclass);
     parseChildren(childClasses, window);
     childClasses.Sort();
     listener.guessInfo(1, "** Main class: " + mainclass);
     foreach (string c in childClasses)
     {
         listener.guessInfo(2, "*** Child class:" + c);
     }
     IList<string> results = sp.parse(mainclass, childClasses.ToArray());
     foreach (string r in results)
     {
         listener.guessInfo(0, "Wndclass suggests: " + r);
         listener.guessAttribute("WNDCLASS", r);
     }
 }

 private string getWindowProperties(SystemWindow sw)
 {
     string content;
     if (includeContents.Checked)
     {
         try
         {
             WindowContent cc = sw.Content;
             if (cc == null)
             {
                 content = "Unknown";
             }
             else
             {
                 content = "\"" + cc.ShortDescription + "\"\r\n" +
                     cc.LongDescription.Replace("\n", "\r\n").Replace("\r\r\n", "\r\n");
             }
         }
         catch (Exception ex)
         {
             content = "\"Exception\"\r\n" + ex.ToString();
         }
     }
     else
     {
         content = "(Enable in Options tab if desired)";
     }
     return "  Handle:\t\t0x" + sw.HWnd.ToString("x8") + " (" + sw.HWnd + ")\r\n" +
         "  DialogID:\t0x" + sw.DialogID.ToString("x8") + " (" + sw.DialogID + ")\r\n" +
         "  Position:\t\t(" + sw.Position.Left + ", " + sw.Position.Top + "), " + sw.Position.Width + "x" + sw.Position.Height + "\r\n" +
         "  Parent:\t\t" + (sw.Parent == null ? "None" : (sw.ParentSymmetric == null ? "Asymmetric" : "Symmetric") + " 0x" + sw.Parent.HWnd.ToString("x8")) + "\r\n" +
         "  Appearance:\t" + (sw.Enabled ? "Enabled " : "Disabled ") + (sw.Visible ? "Visible" : "Invisible") + "\r\n" +
         "  Changable:\t" + (sw.Movable ? "Movable " : "NotMovable ") + (sw.Resizable ? "Resizable" : "FixedSize") + "\r\n" +
         "  WindowState:\t" +
         (sw.TopMost ? "TopMost " : "") + sw.WindowState.ToString() + "\r\n" +
         "  Process:\t\t" + sw.Process.ProcessName + " (0x" + sw.Process.Id.ToString("x8") + "), " +
         "\r\n" +
         "  ClassName:\t\"" + sw.ClassName + "\"\r\n" +
         "  Title:\t\t\"" + sw.Title + "\"\r\n\r\n" +
         "Content:\t" + content;
 }

 private void ClickButton(SystemWindow systemWindow)
 {
     POINT pt = winMessenger.GetWindowCenter(systemWindow);
     winMessenger.MouseMove(pt.X, pt.Y);
     Thread.Sleep(100);
     winMessenger.Click();
 }

 /// <summary>
 /// Check whether this window is a descendant of <c>ancestor</c>
 /// </summary>
 /// <param name="ancestor">The suspected ancestor</param>
 /// <returns>If this is really an ancestor</returns>
 public bool IsDescendantOf(SystemWindow ancestor)
 {
     return IsChild(ancestor._hwnd, _hwnd);
 }

 private static int getArea(SystemWindow sw)
 {
     RECT rr = sw.Rectangle;
         return rr.Height * rr.Width;
 }

 internal WindowDeviceContext(SystemWindow sw, IntPtr hDC)
 {
     this.sw = sw;
         this.hDC = hDC;
 }

 /// <summary>
 /// Gets the automation object for a given window. 
 /// This is a COM object implementing the IDispatch interface, commonly 
 /// available from Microsoft Office windows.
 /// </summary>
 /// <param name="window">The window</param>
 public static object COMObjectFromWindow(SystemWindow window)
 {
     return AccessibleObjectFromWindow(window == null ? IntPtr.Zero : window.HWnd, OBJID_NATIVEOM, new Guid("{00020400-0000-0000-C000-000000000046}"));
 }

 public static SystemAccessibleObject FromWindow(SystemWindow window, AccessibleObjectID objectID)
 {
     IAccessible iacc = (IAccessible)AccessibleObjectFromWindow(window == null ? IntPtr.Zero : window.HWnd, (uint)objectID, new Guid("{618736E0-3C3D-11CF-810C-00AA00389B71}"));
     return new SystemAccessibleObject(iacc, 0);
 }

        public static void MouseHook(LowLevelMessage evt, ref bool handled)
        {
            LowLevelMouseMessage mevt = evt as LowLevelMouseMessage;
            if (mevt != null)
            {
                MouseButtons moveMouseState = OptionsManager.MoveOptions.mouseButton;
                MouseButtons resizeMouseState = OptionsManager.ResizeOptions.mouseButton;

                switch ((MouseState)mevt.Message)
                {
                    case MouseState.WM_LBUTTONDOWN:
                    case MouseState.WM_RBUTTONDOWN:
                    case MouseState.WM_MBUTTONDOWN:
                        // Get the window to move or resize
                        _currentWindow = GetTopLevel(SystemWindow.FromPoint(mevt.Point.X, mevt.Point.Y));

                        if (TestMoveKeyModifier() && TestMoveMouseState(mevt))
                        {
                            // Now we are moving...
                            _isMoving = true;

                            //... from here to somewhere.
                            _previousPoint = mevt.Point;

                            // Set cursor
                            SystemCursor.SetSystemCursor(Cursors.SizeAll);

                            // Prevent event to be forwarded
                            handled = true;
                        }
                        // Check that:
                        // - we are allowed to resize
                        // - we are not moving
                        // - keys and mouse buttons respect the options
                        else if (_currentWindow.Resizable && !_isMoving && TestResizeKeyModifier() && TestResizeMouseState(mevt))
                        {
                            // Now we are resizing...
                            _isResizing = true;

                            //... from this point/quarter.
                            _previousPoint = mevt.Point;
                            _clickedQuarter = GetQuarterFromPoint(_currentWindow, mevt.Point);

                            // Set cursor
                            if ((_clickedQuarter == WindowsQuarter.DIR_NW) || (_clickedQuarter == WindowsQuarter.DIR_SE))
                                SystemCursor.SetSystemCursor(Cursors.SizeNWSE);
                            else if ((_clickedQuarter == WindowsQuarter.DIR_NE) || (_clickedQuarter == WindowsQuarter.DIR_SW))
                                SystemCursor.SetSystemCursor(Cursors.SizeNESW);

                            // Prevent event to be forwarded
                            handled = true;
                        }
                        break;

                    case MouseState.WM_MOUSEMOVE:
                        if (_isMoving)
                        {
                            int dx = mevt.Point.X - _previousPoint.X;
                            int dy = mevt.Point.Y - _previousPoint.Y;

                            // Only move not left/right snaped window
                            if (!_leftSnapedWindows.ContainsKey(_currentWindow) && !_rightSnapedWindows.ContainsKey(_currentWindow))
                                MoveWindow(_currentWindow, dx, dy);

                            _previousPoint = mevt.Point;

                            // Snap/Unsnap
                            SnapTo(_currentWindow, mevt.Point);
                        }
                        else if (_isResizing)
                        {
                            int dx = mevt.Point.X - _previousPoint.X;
                            int dy = mevt.Point.Y - _previousPoint.Y;

                            // Resize current window
                            ResizeWindow(_currentWindow, dx, dy);

                            _previousPoint = mevt.Point;
                        }
                        break;

                    case MouseState.WM_LBUTTONUP:
                    case MouseState.WM_RBUTTONUP:
                    case MouseState.WM_MBUTTONUP:
                        if (TestMoveMouseState(mevt))
                        {
                            if (_isMoving)
                            {
                                // Prevent event to be forwarded
                                handled = true;

                                // Restore cursor
                                SystemCursor.RestoreSystemCursor();
                            }
                            _isMoving = false;
                        }
                        else if (TestResizeMouseState(mevt))
                        {
                            if (_isResizing)
                            {
//.........这里部分代码省略.........

        private void WinEventProc(IntPtr hWinEventHook, uint eventType, IntPtr hwnd, int idObject, int idChild, uint dwEventThread, uint dwmsEventTime)
        {
            if (State != CaptureState.Ready || Mode != CaptureMode.Normal || hwnd.Equals(IntPtr.Zero) ||
                Application.OpenForms.Count != 0 && hwnd.Equals(Application.OpenForms[0].Handle))
                return;
            var systemWindow = new SystemWindow(hwnd);
            var userApp = ApplicationManager.Instance.GetApplicationFromWindow(systemWindow, true);
            bool flag = userApp != null &&
                        (userApp.Any(app => app is UserApplication && ((UserApplication)app).InterceptTouchInput));

            _inputTargetWindow.InterceptTouchInput(flag);
        }

        private static void AnimateCursorOnWindow(SystemWindow window, Point point)
        {
            new Thread(new ThreadStart(delegate
                                           {
                                               // Create a device context that cover the whole display (all monitors)
                                               IntPtr hDC = CreateDC("DISPLAY", "", "", IntPtr.Zero);

                                               // Get a graphics
                                               using (Graphics g = Graphics.FromHdc(hDC))
                                               {
                                                   const int radius = 30;

                                                   g.SmoothingMode = SmoothingMode.AntiAlias;
                                                   g.CompositingMode = CompositingMode.SourceOver;
                                                   g.Clip = new Region(new Rectangle(point.X - (radius + 10) / 2, point.Y - (radius + 10) / 2,
                                                                                     radius + 10, radius + 10));

                                                   // Draw a growing circle upon the cursor
                                                   Brush trans = Brushes.Transparent;
                                                   Pen penGr = new Pen(Color.LightGray, 1);
                                                   Pen penDG = new Pen(Color.DimGray, 1);
                                                   Pen penLG = new Pen(Color.LightGray, 1);

                                                   for (int j = 0; j < 2; j++)
                                                   {
                                                       for (int i = 0; i < radius; i+=2)
                                                       {
                                                           Rectangle ellRect = new Rectangle(point.X - i / 2, point.Y - i / 2, i, i);

                                                           g.FillEllipse(trans, ellRect);
                                                           ellRect.Inflate(1, 1);
                                                           g.DrawEllipse(penGr, ellRect);
                                                           ellRect.Inflate(1, 1);
                                                           g.DrawEllipse(penDG, ellRect);
                                                           ellRect.Inflate(1, 1);
                                                           g.DrawEllipse(penLG, ellRect);

                                                           //g.Clear(Color.Transparent);

                                                           window.Refresh();
                                                       }

                                                       window.Refresh();
                                                   }
                                               }

                                               // Delete the device context
                                               DeleteDC(hDC);
                                           }
                           )).Start();
        }

 ///
 public bool Equals(SystemWindow sw)
 {
     if ((object)sw == null)
         {
             return false;
         }
         return _hwnd == sw._hwnd;
 }