public SearchResult(Win32.UsnEntry usnEntry, UsnJournal journal)
        {
            UsnEntry = usnEntry;

            _journal = journal;
            _driveName = journal.RootDirectory.FullName;
        }

		public DeviceDetectorEventArgs(Win32.DBT changeType, Win32.DBCH_DEVICETYPE? deviceType, object deviceInfo)
		{
			Cancel = false;
			_ChangeType = changeType;
			_DeviceInfo = deviceInfo;
			_DeviceType = deviceType;
		}

 public DataBase( Win32.USER32.TBBUTTON tbButton, string buttonText, IntPtr windowHandle, int imageIndex )
 {
     _TBButton = tbButton;
     _ButtonText = buttonText;
     _WindowHandle = windowHandle;
     _ImageIndex = imageIndex;
 }

		public void AddBubbleEvent(Func<BubbleEventArgs, bool> handleEvent, Win32.WM message)
		{
			messages.Add((int)message, new BubbleEvent
			{
				Message = message,
				HandleEvent = handleEvent
			});
		}

        private int WndProcHook(int nCode, IntPtr wParam, ref Win32.Message lParam)
        {
            if (nCode >= 0)
            {
                Win32.TranslateMessage(ref lParam); // You may want to remove this line, if you find your not quite getting the right messages through. This is here so that WM_CHAR is correctly called when a key is pressed.
                WndProc(ref lParam);
            }

            return Win32.CallNextHookEx(hHook, nCode, wParam, ref lParam);
        }

 public DeviceInfo(string deviceId, string manufacturer, string description, Guid classGuid, string classDescription, Win32.DeviceNodeStatus status, uint vid, uint pid, uint rev)
 {
     _DeviceId = deviceId ?? "";
     _Description = description ?? "";
     _Manufacturer = manufacturer ?? "";
     _ClassGuid = classGuid;
     _ClassDescription = classDescription ?? "";
     _Status = status;
     _VendorId = vid;
     _ProductId = pid;
     _Revision = rev;
 }

        static void HasTitleBarButtonChangedCallback(DependencyObject obj,
            DependencyPropertyChangedEventArgs e, Win32.WindowStyles button)
        {
            var window = obj as Window;
            if (window == null)
                return;

            if (!window.IsLoaded)
                window.Loaded += s_loadedHandler;
            else
                InternalSetStyleFlag(window, button, (bool)e.NewValue);
        }

        public DebugProcess(Debuggee dbg, Win32.CREATE_PROCESS_DEBUG_INFO info, uint id, uint threadId)
        {
            this.Debuggee = dbg;
            Handle = info.hProcess;
            Id = id == 0 ? API.GetProcessId(Handle) : id;

            var moduleFile = APIIntermediate.GetModulePath(Handle, info.lpBaseOfImage, info.hFile);

            // Deduce main module
            MainModule = new DebugProcessModule(info.lpBaseOfImage, moduleFile, ExecutableMetaInfo.ExtractFrom(moduleFile));
            RegModule(MainModule);

            // Create main thread
            MainThread = new DebugThread(this,
                info.hThread,
                threadId == 0 ? API.GetThreadId(info.hThread) : threadId,
                info.lpStartAddress,
                info.lpThreadLocalBase);
            RegThread(MainThread);
        }

 public static extern IntPtr SetWindowsHookEx(Win32.HookType code, HookProc func, IntPtr hInstance, int threadID);

 static bool GetDeviceNodeStatus(UInt32 dnDevInst, IntPtr hMachine, out Win32.DeviceNodeStatus status)
 {
     // c:\Program Files\Microsoft SDKs\Windows\v7.1\Include\cfg.h
     uint Status;
     uint ProblemNumber;
     bool success = false;
     // http://msdn.microsoft.com/en-gb/library/windows/hardware/ff538517%28v=vs.85%29.aspx
     var cr = CM_Get_DevNode_Status_Ex(out Status, out ProblemNumber, dnDevInst, 0, hMachine);
     status = 0;
     if (cr == CR.CR_SUCCESS)
     {
         status = (Win32.DeviceNodeStatus)Status;
         success = true;
     }
     return success;
 }

 public static extern int GetClipBox(IntPtr hDC, ref Win32.RECT rectBox); 

 /// <summary>
 /// Helper function to set or clear a bit in the flags field.
 /// </summary>
 /// <param name="flag">The Flag bit to set or clear.</param>
 /// <param name="value">True to set, false to clear the bit in the flags field.</param>
 private void SetFlag( Win32.NativeMethods.TASKDIALOG_FLAGS flag, bool value )
 {
     if ( value )
     {
         this.flags |= flag;
     }
     else
     {
         this.flags &= ~flag;
     }
 }

        public void DirectionResize(Win32.ResizeDirection direction)
        {
            int _direction = -1;

            switch (direction)
            {
                case Win32.ResizeDirection.Left:
                    _direction = Win32.HTLEFT;
                    break;
                case Win32.ResizeDirection.TopLeft:
                    _direction = Win32.HTTOPLEFT;
                    break;
                case Win32.ResizeDirection.Top:
                    _direction = Win32.HTTOP;
                    break;
                case Win32.ResizeDirection.TopRight:
                    _direction = Win32.HTTOPRIGHT;
                    break;
                case Win32.ResizeDirection.Right:
                    _direction = Win32.HTRIGHT;
                    break;
                case Win32.ResizeDirection.BottomRight:
                    _direction = Win32.HTBOTTOMRIGHT;
                    break;
                case Win32.ResizeDirection.Bottom:
                    _direction = Win32.HTBOTTOM;
                    break;
                case Win32.ResizeDirection.BottomLeft:
                    _direction = Win32.HTBOTTOMLEFT;
                    break;
            }

            if (_direction != -1)
            {
                Win32.ReleaseCapture();
                Win32.SendMessage(this.Handle, Win32.WM_NCLBUTTONDOWN, _direction, 0);
            }
        }

        internal void OnWM_MOUSEMOVE(Win32.POINT screenPos)
        {
            // Convert the mouse position to screen coordinates
            User32.ScreenToClient(this.Handle, ref screenPos);

            OnProcessMouseMove(screenPos.x, screenPos.y);
        }

 void hsServer_ClientStyleChanged(Win32.WindowShowStyle style)
 {
     MethodInvoker action = delegate
    {
        gbClient.Enabled = true;
        if (style == Win32.WindowShowStyle.Hide)
            cbShowHideClient.Checked = false;
        else if (style == Win32.WindowShowStyle.Show)
            cbShowHideClient.Checked = true;
    };
     this.Invoke(action);
 }

        /// <summary>
        /// GetUsnJournalState() gets the current state of the USN Journal if it is active.
        /// </summary>
        /// <param name="usnJournalState">
        /// Reference to usn journal data object filled with the current USN Journal state.
        /// </param>
        /// <returns>
        /// USN_JOURNAL_SUCCESS                 GetUsnJournalState() function succeeded. 
        /// VOLUME_NOT_NTFS                     volume is not an NTFS volume.
        /// INVALID_HANDLE_VALUE                NtfsUsnJournal object failed initialization.
        /// USN_JOURNAL_NOT_ACTIVE              usn journal is not active on volume.
        /// ERROR_ACCESS_DENIED                 accessing the usn journal requires admin rights, see remarks.
        /// ERROR_INVALID_FUNCTION              error generated by DeviceIoControl() call.
        /// ERROR_FILE_NOT_FOUND                error generated by DeviceIoControl() call.
        /// ERROR_PATH_NOT_FOUND                error generated by DeviceIoControl() call.
        /// ERROR_TOO_MANY_OPEN_FILES           error generated by DeviceIoControl() call.
        /// ERROR_INVALID_HANDLE                error generated by DeviceIoControl() call.
        /// ERROR_INVALID_DATA                  error generated by DeviceIoControl() call.
        /// ERROR_NOT_SUPPORTED                 error generated by DeviceIoControl() call.
        /// ERROR_INVALID_PARAMETER             error generated by DeviceIoControl() call.
        /// ERROR_JOURNAL_DELETE_IN_PROGRESS    usn journal delete is in progress.
        /// ERROR_INVALID_USER_BUFFER           error generated by DeviceIoControl() call.
        /// USN_JOURNAL_ERROR                   unspecified usn journal error.
        /// </returns>
        /// <remarks>
        /// If function returns ERROR_ACCESS_DENIED you need to run application as an Administrator.
        /// </remarks>
        public UsnJournalReturnCode GetUsnJournalState(ref Win32.USN_JOURNAL_DATA usnJournalState)
        {
            UsnJournalReturnCode returnCode = UsnJournalReturnCode.VOLUME_NOT_NTFS;

            if (IsNtfsVolume)
            {
                if (_usnJournalRootHandle.ToInt32() != Win32.INVALID_HANDLE_VALUE)
                {
                    returnCode = QueryUsnJournal(ref usnJournalState);
                }
                else
                {
                    returnCode = UsnJournalReturnCode.INVALID_HANDLE_VALUE;
                }
            }

            return returnCode;
        }

        /// <summary>
        /// Rests to see if there is a USN Journal on this volume and if there is 
        /// determines whether any journal entries have been lost.
        /// </summary>
        /// <returns>true if the USN Journal is active and if the JournalId's are the same 
        /// and if all the usn journal entries expected by the previous state are available 
        /// from the current state.
        /// false if not</returns>
        public bool IsUsnJournalValid(Win32.USN_JOURNAL_DATA usnJournalPreviousState)
        {
            bool bRtnCode = false;

            if (IsNtfsVolume)
            {
                if (_usnJournalRootHandle.ToInt32() != Win32.INVALID_HANDLE_VALUE)
                {
                    var usnJournalState = new Win32.USN_JOURNAL_DATA();
                    var usnError = QueryUsnJournal(ref usnJournalState);

                    if (usnError == UsnJournalReturnCode.USN_JOURNAL_SUCCESS)
                    {
                        if (usnJournalPreviousState.UsnJournalID == usnJournalState.UsnJournalID)
                        {
                            if (usnJournalPreviousState.NextUsn >= usnJournalState.NextUsn)
                            {
                                bRtnCode = true;
                            }
                        }
                    }
                }
            }
            return bRtnCode;
        }

        protected bool ProcessInterceptedMessage(ref Win32.MSG msg)
        {
            bool eat = false;

            switch(msg.message)
            {
                case (int)Win32.Msgs.WM_LBUTTONDOWN:
                case (int)Win32.Msgs.WM_MBUTTONDOWN:
                case (int)Win32.Msgs.WM_RBUTTONDOWN:
                case (int)Win32.Msgs.WM_XBUTTONDOWN:
                case (int)Win32.Msgs.WM_NCLBUTTONDOWN:
                case (int)Win32.Msgs.WM_NCMBUTTONDOWN:
                case (int)Win32.Msgs.WM_NCRBUTTONDOWN:
                    // Mouse clicks cause the end of simulated focus unless they are
                    // inside the client area of the menu control itself
                    Point pt = new Point( (int)((uint)msg.lParam & 0x0000FFFFU),
                                          (int)(((uint)msg.lParam & 0xFFFF0000U) >> 16));

                    if (!this.ClientRectangle.Contains(pt))
                        SimulateReturnFocus();
                    break;
                case (int)Win32.Msgs.WM_KEYDOWN:
                    // Find up/down state of shift and control keys
                    ushort shiftKey = User32.GetKeyState((int)Win32.VirtualKeys.VK_SHIFT);
                    ushort controlKey = User32.GetKeyState((int)Win32.VirtualKeys.VK_CONTROL);

                    // Basic code we are looking for is the key pressed...
                    int basecode = (int)msg.wParam;
                    int code = basecode;

                    // ...plus the modifier for SHIFT...
                    if (((int)shiftKey & 0x00008000) != 0)
                        code += 0x00010000;

                    // ...plus the modifier for CONTROL
                    if (((int)controlKey & 0x00008000) != 0)
                        code += 0x00020000;

                    if (code == (int)Win32.VirtualKeys.VK_ESCAPE)
                    {
                        // Is an item being tracked
                        if (_trackItem != -1)
                        {
                            // Is it also showing a submenu
                            if (_popupMenu == null)
                            {
                                // Unselect the current item
                                _trackItem = SwitchTrackingItem(_trackItem, -1);

                            }
                        }

                        SimulateReturnFocus();

                        // Prevent intended destination getting message
                        eat = true;
                    }
                    else if (code == (int)Win32.VirtualKeys.VK_LEFT)
                    {
                        if (_direction == Direction.Horizontal)
                            ProcessMoveLeft(false);

                        if (_selected)
                            _ignoreMouseMove = true;

                        // Prevent intended destination getting message
                        eat = true;
                    }
                    else if (code == (int)Win32.VirtualKeys.VK_RIGHT)
                    {
                        if (_direction == Direction.Horizontal)
                            ProcessMoveRight(false);
                        else
                            ProcessMoveDown();

                        if (_selected)
                            _ignoreMouseMove = true;

                        // Prevent intended destination getting message
                        eat = true;
                    }
                    else if (code == (int)Win32.VirtualKeys.VK_RETURN)
                    {
                        ProcessEnter();

                        // Prevent intended destination getting message
                        eat = true;
                    }
                    else if (code == (int)Win32.VirtualKeys.VK_DOWN)
                    {
                        if (_direction == Direction.Horizontal)
                            ProcessMoveDown();
                        else
                            ProcessMoveRight(false);

                        // Prevent intended destination getting message
                        eat = true;
                    }
                    else if (code == (int)Win32.VirtualKeys.VK_UP)
                    {
//.........这里部分代码省略.........

 private static void SetWindowFromInfo(IntPtr hwnd, Win32.WINDOWINFO info)
 {
     int x1 = info.rcWindow.left;
     int y1 = info.rcWindow.top;
     int x2 = info.rcWindow.right - x1;
     int y2 = info.rcWindow.bottom - y1;
     //Win32.SetWindowLong(hwnd, Win32.GWL_STYLE, (int)info.dwStyle);
     //Win32.SetWindowLong(hwnd, Win32.GWL_EXSTYLE, (int)info.dwExStyle);
     Win32.SetWindowPos(hwnd, Win32.HWND_NOTOPMOST, x1, y1, x2, y2, Win32.SWP_SHOWWINDOW);
 }

        private static string ReadRegistryString(Win32.RegistryKey key, string path, string registryValue)
        {
            RegistryKey subKey = key.OpenSubKey(path, false);

            object oValue = subKey?.GetValue(registryValue);
            if (oValue != null && subKey.GetValueKind(registryValue) == RegistryValueKind.String)
            {
                return (string)oValue;
            }

            return null;
        }