开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
window.cs
资源名称：xmlnotepad.rar　[点击查看]
上传用户：hbhltzc
上传日期：2022-06-04
资源大小：1925k
文件大小：22k
源码类别：

xml/soap/webservice

开发平台：

Visual C++

window.cs：源码内容
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Runtime.InteropServices;
  4. using System.Text;
  5. using System.Windows.Forms;
  6. using System.Threading;
  7. using System.Drawing;
  8. using System.Reflection;
  9. using System.Diagnostics;
  11. namespace UnitTests {
  12.     public class Window : IDisposable {
  13.         Process p;
  14.         IntPtr handle;
  15.         bool closed;
  16.         TestBase test;
  17.         SystemAccessible acc;
  18.         Dictionary<string, SystemAccessible> map;
  19.         Window parent;
  20.         bool disposed;
  22.         static int delay = 100;
  24.         public Window(Window parent, IntPtr handle) {
  25.             this.parent = parent;
  26.             this.handle = handle;
  27.             this.acc = SystemAccessible.AccessibleObjectForWindow(handle);
  28.         }
  30.         public Window(Process p) {
  31.             this.p = p;
  32.             IntPtr h = p.Handle;
  33.             while (h == IntPtr.Zero || !p.Responding) {
  34.                 Sleep(1000);
  35.                 p.WaitForInputIdle();
  36.                 h = p.Handle;
  37.                 if (p.HasExited) {
  38.                     throw new InvalidOperationException(string.Format("Process '{0}' has exited!", p.StartInfo.FileName));
  39.                 }
  40.             }
  41.             p.Exited += new EventHandler(OnExited);
  42.             int id = p.Id;
  43.             if (handle == IntPtr.Zero) {
  44.                 // p.MainWindowHandle always returns 0 for some unknown reason...
  45.                 int retries = 20;
  46.                 while (retries-- > 0 && handle == IntPtr.Zero) {
  47.                     handle = FindWindowForProcessId(id);
  48.                     Sleep(1000);
  49.                 }
  50.                 if (handle == IntPtr.Zero) {
  51.                     throw new Exception("Process as no window handle");
  52.                 }
  53.             }
  54.             this.acc = SystemAccessible.AccessibleObjectForWindow(handle);
  55.         }
  57.         void OnExited(object sender, EventArgs e) {
  58.             if (!disposed) {
  59.                 throw new Exception("Process exited.");
  60.             }
  61.         }
  63.         private static IntPtr FindWindowForProcessId(int id) {
  64.             // Hmmm, try and find window for this process then.
  65.             IntPtr hwnd = GetWindow(GetDesktopWindow(), GetWindowOptions.Child);
  66.             while (hwnd != IntPtr.Zero) {
  67.                 int procid;
  68.                 int thread = GetWindowThreadProcessId(hwnd, out procid);
  69.                 if (procid == id && IsWindowVisible(hwnd)) {
  70.                     SystemAccessible acc = SystemAccessible.AccessibleObjectForWindow(hwnd);
  71.                     if (acc.Role == AccessibleRole.Client && 
  72.                         (acc.State & AccessibleStates.Invisible) == 0 &&
  73.                         !string.IsNullOrEmpty(acc.Name)) {
  74.                         // found it!
  75.                         return hwnd;
  76.                     }
  77.                 }
  78.                 hwnd = GetWindow(hwnd, GetWindowOptions.Next);
  79.             }
  80.             return IntPtr.Zero;
  81.         }
  83.         public Window WaitForPopup() {
  84.             Thread.Sleep(500);
  85.             IntPtr h = this.Handle;
  86.             int retries = 20;
  87.             while (retries-- > 0) {
  88.                 IntPtr hwnd = GetForegroundWindow();
  89.                 if (hwnd != h) {
  90.                     Trace.WriteLine("WindowChanged:" + GetForegroundWindowText());
  91.                     Sleep(500); // give it time to get keystrokes!
  92.                     return new Window(this, hwnd);
  93.                 }
  94.                 Sleep(1000);                
  95.             }
  96.             throw new ApplicationException("Window is not appearing!");
  97.         }
  100.         public void WaitForNewWindow() {
  101.             int retries = 20;
  102.             while (retries-- > 0) {
  103.                 IntPtr hwnd = GetForegroundWindow();
  104.                 if (hwnd != this.Handle) {
  105.                     Trace.WriteLine("NewWindowOpened");
  106.                     Sleep(1000); // give it time to get keystrokes!
  107.                     return;
  108.                 }
  109.                 Sleep(1000);
  110.             }
  111.             throw new ApplicationException("Window is not appearing!");
  112.         }
  114.         public static IntPtr GetForegroundWindowHandle() {
  115.             return GetForegroundWindow();
  116.         }
  118.         public static string GetForegroundWindowText() {
  119.             IntPtr hwnd = GetForegroundWindow();
  120.             if (hwnd == IntPtr.Zero)
  121.                 return "";
  122.             return GetWindowText(hwnd);
  123.         }
  125.         public static string GetWindowText(IntPtr hwnd) {
  126.             int len = GetWindowTextLength(hwnd);
  127.             if (len <= 0) return "";
  128.             len++; // include space for the null terminator.
  129.             IntPtr buffer = Marshal.AllocCoTaskMem(len * 2);
  130.             GetWindowText(hwnd, buffer, len);
  131.             string s = Marshal.PtrToStringUni(buffer, len - 1);
  132.             Marshal.FreeCoTaskMem(buffer);
  133.             return s;
  134.         }
  136.         public void DismissPopUp(string keys) {
  137.             Trace.WriteLine("Dismissing: " + GetForegroundWindowText());
  138.             System.Windows.Forms.SendKeys.SendWait(keys);
  139.             Thread.Sleep(500);
  140.             IntPtr h = this.Handle;
  141.             Sleep(1000);
  142.             int retries = 10;
  143.             while (retries-- > 0) {
  144.                 Trace.WriteLine("ForegroundWindow=" + GetForegroundWindowText());
  145.                 IntPtr hwnd = GetForegroundWindow();
  146.                 if (hwnd == h) {
  147.                     Trace.WriteLine("WindowChanged:" + GetForegroundWindowText());
  148.                     Sleep(500); // give it time to get keystrokes!
  149.                     return;
  150.                 }
  151.                 Sleep(200);
  152.             }
  153.             throw new ApplicationException("Foreground window is not changing!");
  154.         }
  156.         public Window ExpectingPopup(string name) {
  157.             Application.DoEvents();
  158.             Window popup = this.WaitForPopup();
  159.             string text = Window.GetForegroundWindowText();
  160.             if (text.ToLowerInvariant() != name.ToLowerInvariant()) {
  161.                 throw new ApplicationException(string.Format("Expecting popup '{0}'", name));
  162.             }
  163.             return popup;
  164.         }
  167.         public AccessibleObject AccessibleObject {
  168.             get {
  169.                 return this.acc;
  170.             }
  171.         }
  173.         SystemAccessible GetClient() {            
  174.             if (this.acc.Role == AccessibleRole.Client) {
  175.                 return this.acc;
  176.             } else {
  177.                 return (SystemAccessible)this.acc.FindChildByRole(AccessibleRole.Client);
  178.             }
  179.         }
  181.         public SystemAccessible FindDescendant(string name) {
  182.             ReloadMap(name);  
  183.             return map[name];
  184.         }
  186.         void ReloadMap(string name) {
  187.             if (map == null) {
  188.                 map = new Dictionary<string, SystemAccessible>();
  189.             }
  190.             if (map == null || !map.ContainsKey(name)) {
  191.                 SystemAccessible client = GetClient();
  192.                 if (client != null) {
  193.                     LoadChildren(client);
  194.                 }
  195.             }
  196.         }
  198.         void LoadChildren(SystemAccessible item) {
  199.             switch (item.Role) {
  200.                 case AccessibleRole.Alert:
  201.                     break;
  202.                 case AccessibleRole.Animation:
  203.                     break;
  204.                 case AccessibleRole.Application:
  205.                     break;
  206.                 case AccessibleRole.Border:
  207.                     break;
  208.                 case AccessibleRole.ButtonDropDown:
  209.                     break;
  210.                 case AccessibleRole.ButtonDropDownGrid:
  211.                     break;
  212.                 case AccessibleRole.ButtonMenu:
  213.                     break;
  214.                 case AccessibleRole.Caret:
  215.                     break;
  216.                 case AccessibleRole.Cell:
  217.                     break;
  218.                 case AccessibleRole.Character:
  219.                     break;
  220.                 case AccessibleRole.Chart:
  221.                     break;
  222.                 case AccessibleRole.CheckButton:
  223.                     break;
  224.                 case AccessibleRole.Client:
  225.                 case AccessibleRole.Window:
  226.                     this.LoadComplexChildren(item);
  227.                     break;
  228.                 case AccessibleRole.Clock:
  229.                     break;
  230.                 case AccessibleRole.Column:
  231.                     break;
  232.                 case AccessibleRole.ColumnHeader:
  233.                     break;
  234.                 case AccessibleRole.ComboBox:
  235.                     break;
  236.                 case AccessibleRole.Cursor:
  237.                     break;
  238.                 case AccessibleRole.Default:
  239.                     break;
  240.                 case AccessibleRole.Diagram:
  241.                     break;
  242.                 case AccessibleRole.Dial:
  243.                     break;
  244.                 case AccessibleRole.Dialog:
  245.                     break;
  246.                 case AccessibleRole.Document:
  247.                     break;
  248.                 case AccessibleRole.DropList:
  249.                     break;
  250.                 case AccessibleRole.Equation:
  251.                     break;
  252.                 case AccessibleRole.Graphic:
  253.                     break;
  254.                 case AccessibleRole.Grip:
  255.                     break;
  256.                 case AccessibleRole.Grouping:
  257.                     break;
  258.                 case AccessibleRole.HelpBalloon:
  259.                     break;
  260.                 case AccessibleRole.HotkeyField:
  261.                     break;
  262.                 case AccessibleRole.Indicator:
  263.                     break;
  264.                 case AccessibleRole.IpAddress:
  265.                     break;
  266.                 case AccessibleRole.Link:
  267.                     break;
  268.                 case AccessibleRole.List:
  269.                     break;
  270.                 case AccessibleRole.ListItem:
  271.                     break;
  272.                 case AccessibleRole.MenuBar:
  273.                 case AccessibleRole.MenuItem:
  274.                 case AccessibleRole.MenuPopup:
  275.                 case AccessibleRole.ToolBar:
  276.                     this.LoadSimpleChildren(item);
  277.                     break;
  278.                 case AccessibleRole.None:
  279.                     break;
  280.                 case AccessibleRole.Outline:
  281.                     break;
  282.                 case AccessibleRole.OutlineButton:
  283.                     break;
  284.                 case AccessibleRole.OutlineItem:
  285.                     break;
  286.                 case AccessibleRole.PageTab:
  287.                     break;
  288.                 case AccessibleRole.PageTabList:
  289.                     break;
  290.                 case AccessibleRole.Pane:
  291.                     break;
  292.                 case AccessibleRole.ProgressBar:
  293.                     break;
  294.                 case AccessibleRole.PropertyPage:
  295.                     break;
  296.                 case AccessibleRole.PushButton:
  297.                     break;
  298.                 case AccessibleRole.RadioButton:
  299.                     break;
  300.                 case AccessibleRole.Row:
  301.                     break;
  302.                 case AccessibleRole.RowHeader:
  303.                     break;
  304.                 case AccessibleRole.ScrollBar:
  305.                     break;
  306.                 case AccessibleRole.Separator:
  307.                     break;
  308.                 case AccessibleRole.Slider:
  309.                     break;
  310.                 case AccessibleRole.Sound:
  311.                     break;
  312.                 case AccessibleRole.SpinButton:
  313.                     break;
  314.                 case AccessibleRole.SplitButton:
  315.                     break;
  316.                 case AccessibleRole.StaticText:
  317.                     break;
  318.                 case AccessibleRole.StatusBar:
  319.                     break;
  320.                 case AccessibleRole.Table:
  321.                     break;
  322.                 case AccessibleRole.Text:
  323.                     break;
  324.                 case AccessibleRole.TitleBar:
  325.                     break;
  326.                 case AccessibleRole.ToolTip:
  327.                     break;
  328.                 case AccessibleRole.WhiteSpace:
  329.                     break;
  330.                 default:
  331.                     break;
  332.             }
  334.         }
  336.         void LoadComplexChildren(SystemAccessible item) {
  337.             SystemAccessible first = item.FirstChild;
  338.             if (first != null) {
  339.                 SystemAccessible last = item.LastChild;
  340.                 SystemAccessible child = first;
  341.                 while (child != null) {
  342.                     AddChild(child);
  343.                     if (child == last) break;
  344.                     child = child.NextSibling;
  345.                 }
  346.             }
  347.         }
  349.         void LoadSimpleChildren(SystemAccessible item) {
  350.             for (int i = 1, n = item.GetChildCount(); i <= n; i++) {
  351.                 SystemAccessible child = (SystemAccessible)item.GetChild(i);
  352.                 AddChild(child);
  353.             }
  354.         }
  356.         void AddChild(SystemAccessible child) {
  357.             string name = child.Name;
  358.             if (!string.IsNullOrEmpty(name) && child.Role != AccessibleRole.Window) {
  359.                 Trace.WriteLine("Found: " + name);
  360.                 if (!map.ContainsKey(name) || child.Role == AccessibleRole.Client) {
  361.                     map[name] = child;
  362.                 } else {
  363.                     Trace.WriteLine(string.Format("Ambiguous item name: '{0}'", name));
  364.                 }
  365.             }
  366.             if (child.GetChildCount() > 0) {
  367.                 LoadChildren(child);
  368.             }
  369.         }
  371.         public IntPtr Handle {
  372.             get {
  373.                 return handle; 
  374.             }
  375.         }
  377.         public TestBase TestBase {
  378.             get { return test; }
  379.             set { test = value; }
  380.         }
  382.         public void SetWindowSize(int cx, int cy) {
  383.             SetWindowPos(this.handle, IntPtr.Zero, 0, 0, cx, cy, (uint)SetWindowPosFlags.SWP_NOMOVE);
  384.         }
  386.         public void SetWindowPosition(int x, int y) {
  387.             SetWindowPos(this.handle, IntPtr.Zero, x, y, 0, 0, (uint)SetWindowPosFlags.SWP_NOSIZE);
  388.         }
  390.         public void WaitForIdle(int timeout) {
  391.             if (parent != null)
  392.                 parent.WaitForIdle(timeout);
  393.             else if (p != null) 
  394.                 p.WaitForInputIdle();
  395.         }
  397.         public bool Closed {
  398.             get { return closed; }
  399.             set { closed = value; }
  400.         }
  402.         public void Sleep(int ms) {
  403.             Thread.Sleep(ms);
  404.         }
  406.         public void Close() {
  407.             if (!closed) {
  408.                 SendMessage(this.handle, (uint)WindowsMessages.WM_CLOSE, IntPtr.Zero, IntPtr.Zero);
  409.                 Sleep(delay);
  410.             }
  411.             closed = true;
  412.         }
  414.         public Window OpenDialog(string menuCommand, string formName) {
  415.             InvokeAsyncMenuItem(menuCommand);
  416.             return this.WaitForPopup();
  417.         }
  419.         public void SendKeys(string keys) {
  420.             if (Window.GetForegroundWindow() != this.handle) {
  421.                 Activate();
  422.                 Sleep(200);
  423.             }
  424.             System.Windows.Forms.SendKeys.SendWait(keys);
  425.         }
  427.         public void Activate() {
  428.             SetForegroundWindow(this.handle);
  429.         }
  431.         const uint OBJID_CLIENT = 0xFFFFFFFC;
  433.         public void InvokeMenuItem(string menuItemName) {
  434.             this.ReloadMap(menuItemName);
  435.             Sleep(30);
  436.             this.WaitForIdle(2000);
  438.             SystemAccessible item;
  439.             if (!this.map.TryGetValue(menuItemName, out item)) {
  440.                 throw new Exception(string.Format("Menu item '{0}' not found", menuItemName));                
  441.             }
  442.             Trace.WriteLine("InvokeMenuItem(" + menuItemName + ")");
  443.             item.DoDefaultAction();
  444.         }
  446.         public void InvokeAsyncMenuItem(string menuItemName) {
  447.             this.ReloadMap(menuItemName);
  448.             Sleep(delay);
  449.             this.WaitForIdle(2000);
  451.             SystemAccessible item;
  452.             if (!this.map.TryGetValue(menuItemName, out item)) {
  453.                 throw new Exception(string.Format("Menu item '{0}' not found", menuItemName));                
  454.             }
  455.             Trace.WriteLine("InvokeAsyncMenuItem(" + menuItemName + ")");
  457.             // this is NOT async with things like SaveAs where a dialog pops up!
  458.             //item.DoDefaultAction();
  460.             this.WaitForIdle(1000);
  461.             Sleep(1000);
  462.             if (item.Role == AccessibleRole.PushButton) {
  463.                 // Toolbar buttons cannot be invoked from shortcuts.
  464.                 Mouse.MouseClick(Center(item.Bounds), MouseButtons.Left);
  465.             } else {
  466.                 TypeShortcut(item);
  467.             }
  468.         }
  470.         Point Center(Rectangle bounds) {
  471.             return new Point(bounds.Left + (bounds.Width / 2),
  472.                 bounds.Top + (bounds.Height / 2));
  473.         }
  476.         void TypeShortcut(AccessibleObject item) {
  477.             Sleep(1000);
  478.             AccessibleObject parent = item.Parent;
  479.             if (parent.Role == AccessibleRole.MenuItem) {
  480.                 TypeShortcut(parent);
  481.             }
  482.             string shortcut = item.KeyboardShortcut;
  483.             if (!string.IsNullOrEmpty(shortcut)) {
  484.                 SendShortcut(shortcut);
  485.             } else {
  486.                 throw new NotImplementedException("InvokeAsyncMenuItem can't work without menu item shortcuts");
  487.             }
  488.         }
  490.         public void SendShortcut(string shortcut) {
  491.             string keys = shortcut.Replace("Alt+", "%").Replace("Ctrl+", "^").Replace("Shift+", "+");
  492.             Sleep(200);
  493.             SendKeys(keys);
  494.         }
  496.         public Rectangle GetScreenBounds() {
  497.             WINDOWINFO wi = new WINDOWINFO();
  498.             wi.cbSize = Marshal.SizeOf(wi);
  499.             if (GetWindowInfo(this.handle, ref wi)) {
  500.                 RECT r = wi.rcWindow;
  501.                 return new Rectangle(r.left, r.top, r.right - r.left, r.bottom - r.top);
  502.             }
  503.             return Rectangle.Empty;
  504.         }
  506.         #region IDisposable Members
  508.         public void Dispose() {
  509.             disposed = true;
  510.             if (p != null && !p.HasExited) {
  511.                 this.Close();
  512.                 Sleep(1000);
  513.                 if (!p.HasExited) {
  514.                     p.Kill();
  515.                 }                
  516.             }
  517.         }
  519.         #endregion
  521.         enum GetWindowOptions {
  522.             First    = 0,
  523.             Last = 1,
  524.             Next = 2,
  525.             Previous = 3,
  526.             Owner = 5,
  527.             Child = 5
  528.         }
  530.         [DllImport("User32")]
  531.         public static extern IntPtr GetForegroundWindow();
  533.         [DllImport("User32")]
  534.         public static extern IntPtr GetTopWindow(IntPtr hwnd);
  536.         [DllImport("User32")]
  537.         public static extern IntPtr GetDesktopWindow();
  539.         [DllImport("User32")]
  540.         public static extern IntPtr GetLastActivePopup(IntPtr hWnd);
  542.         [DllImport("User32", CharSet = CharSet.Unicode)]
  543.         static extern int GetWindowTextLength(IntPtr hwnd);
  545.         [DllImport("User32", CharSet = CharSet.Unicode)]
  546.         static extern int GetWindowText(IntPtr hWnd, IntPtr lpString, int nMaxCount);
  548.         [DllImport("User32", CharSet = CharSet.Unicode)]
  549.         static extern IntPtr GetWindow(IntPtr hWnd, GetWindowOptions uCmd);
  551.         [DllImport("User32", CharSet = CharSet.Unicode)]
  552.         static extern int GetWindowThreadProcessId(IntPtr hWnd, out int lpdwProcessId);
  554.         [DllImport("User32", CharSet = CharSet.Unicode)]
  555.         static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);
  557.         [DllImport("User32", CharSet = CharSet.Unicode)]
  558.         static extern bool GetWindowInfo(IntPtr hwnd, ref WINDOWINFO pwi);
  560.         [DllImport("User32", CharSet = CharSet.Unicode)]
  561.         static extern bool IsWindowVisible(IntPtr hWnd);
  563.         [DllImport("User32", CharSet = CharSet.Unicode)]
  564.         static extern bool ShowWindow(IntPtr hWnd, int nCmdShows);
  566.         [DllImport("User32", CharSet = CharSet.Unicode)]
  567.         static extern void SetForegroundWindow(IntPtr hWnd);
  569.         enum WindowsMessages {
  570.             WM_CLOSE = 0x0010
  571.         }
  573.         [DllImport("User32", CharSet = CharSet.Unicode)]
  574.         static extern int SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
  576.         [StructLayout(LayoutKind.Sequential)]
  577.         struct WINDOWINFO {
  578.             public int cbSize;
  579.             public RECT rcWindow;
  580.             public RECT rcClient;
  581.             public int dwStyle;
  582.             public int dwExStyle;
  583.             public int dwWindowStatus;
  584.             public uint cxWindowBorders;
  585.             public uint cyWindowBorders;
  586.             public IntPtr atomWindowType;
  587.             public int wCreatorVersion;
  588.         }
  590.         enum SetWindowPosFlags {
  591.             SWP_NOSIZE = 0x0001,
  592.             SWP_NOMOVE = 0x0002,
  593.             SWP_NOZORDER = 0x0004,
  594.             SWP_NOREDRAW = 0x0008,
  595.             SWP_NOACTIVATE = 0x0010,
  596.             SWP_FRAMECHANGED = 0x0020,  /* The frame changed: send WM_NCCALCSIZE */
  597.             SWP_SHOWWINDOW = 0x0040,
  598.             SWP_HIDEWINDOW = 0x0080,
  599.             SWP_NOCOPYBITS = 0x0100,
  600.             SWP_NOOWNERZORDER = 0x0200, /* Don't do owner Z ordering */
  601.             SWP_NOSENDCHANGING = 0x0400,  /* Don't send WM_WINDOWPOSCHANGING */
  602.             SWP_DRAWFRAME = SWP_FRAMECHANGED,
  603.             SWP_NOREPOSITION = SWP_NOOWNERZORDER
  604.         }
  606.         enum ShowWindowFlags {
  607.             SW_HIDE = 0,
  608.             SW_SHOWNORMAL = 1,
  609.             SW_NORMAL = 1,
  610.             SW_SHOWMINIMIZED = 2,
  611.             SW_SHOWMAXIMIZED = 3,
  612.             SW_MAXIMIZE = 3,
  613.             SW_SHOWNOACTIVATE = 4,
  614.             SW_SHOW = 5,
  615.             SW_MINIMIZE = 6,
  616.             SW_SHOWMINNOACTIVE = 7,
  617.             SW_SHOWNA = 8,
  618.             SW_RESTORE = 9,
  619.             SW_SHOWDEFAULT = 10,
  620.             SW_FORCEMINIMIZE = 11,
  621.             SW_MAX = 11
  622.         }
  623.     }
  624. }