Esempio n. 1
0
        private void CheckToolDisplaying()
        {
            if (!m_IsRunning)
            {
                return;
            }

            IntPtr foreWindow          = User32Windows.GetForegroundWindow();
            var    title               = User32Windows.GetWindowText(foreWindow, 255);
            bool   matchesTitlePattern = false;

            if (((foreWindow == m_HostWindowHwnd || foreWindow == this.Handle) &&
                 !User32Windows.IsIconic(m_HostWindowHwnd)) ||
                (title == m_HostWindowTitle && m_RunOnAllWindowsWithSameTitle) ||
                (m_TitlePattern != String.Empty && (matchesTitlePattern = m_TitleRegex.IsMatch(title))))
            {
                // if ((foreWindow != m_HostWindowHwnd) && (foreWindow != this.Handle))
                // {
                //     int pidFore, pidThis;
                //     User32Windows.GetWindowThreadProcessId(foreWindow, out pidFore);
                //     User32Windows.GetWindowThreadProcessId(this.Handle, out pidThis);
                //     if (pidFore == pidThis)
                //     {
                //         return;
                //     }
                //
                //     m_HostWindowHwnd = foreWindow;
                //     m_HostWindowTitle = title;
                //     if (!matchesTitlePattern)
                //     {
                //         CalculateCoordinates();
                //     }
                // }

                Rectangle rHost;
                User32Windows.GetWindowRect(m_HostWindowHwnd, out rHost);

                int newX = 0,
                    newY = 0;

                if (m_AnchorH == AnchorHorizontal.Left)
                {
                    newX = rHost.Left + m_HostWindowOffsetX;
                }
                else
                {
                    newX = rHost.Width + m_HostWindowOffsetX;
                }

                if (m_AnchorV == AnchorVertical.Top)
                {
                    newY = rHost.Top + m_HostWindowOffsetY;
                }
                else
                {
                    newY = rHost.Height + m_HostWindowOffsetY;
                }

                if ((this.Location.X != newX) || (this.Location.Y != newY))
                {
                    this.Location = new Point(newX, newY);
                }

                if (!this.Visible)
                {
                    Task.Delay(timer1.Interval).ContinueWith(t => this.Show());
                }
            }
            else if ((!m_RunOnAllWindowsWithSameTitle) && (!User32Windows.IsWindow(m_HostWindowHwnd)))
            {
                if (this.Exit != null)
                {
                    this.Exit.Invoke(this, new ToolEventArgs()
                    {
                        Title = m_HostWindowTitle
                    });
                }
                this.Close();
            }
            else if (User32Windows.IsIconic(m_HostWindowHwnd))
            {
                this.Hide();
            }
            else
            {
                Rectangle rForeWindow;
                User32Windows.GetWindowRect(foreWindow, out rForeWindow);

                var r        = this.RectangleToScreen(this.DisplayRectangle);
                var contains = RectangleContains(rForeWindow, r) ||
                               RectangleIntersects(rForeWindow, r);

                int processId,
                    ptocessIdThis;
                User32Windows.GetWindowThreadProcessId(foreWindow, out processId);
                User32Windows.GetWindowThreadProcessId(this.Handle, out ptocessIdThis);

                if (this.Visible && m_AutoHide && contains && (processId != ptocessIdThis))
                {
                    this.Hide();
                }
            }
        }
Esempio n. 2
0
        private void ProcessClick()
        {
            if (!m_IsRunning)
            {
                return;
            }

            if (!User32Windows.IsWindow(m_HostWindowHwnd))
            {
                MessageBox.Show("Hosting window not found. Close the tool or set its hosting window.",
                                this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            if (this.m_SendCommandType == SendCommandType.ActivateWindow)
            {
                int handleTmp;
                if (int.TryParse(m_Commands, out handleTmp))
                {
                    var handle = (IntPtr)handleTmp;
                    if (User32Windows.IsIconic(handle))
                    {
                        User32Windows.ShowWindow(handle, User32Windows.SW_RESTORE);
                    }
                    User32Windows.SetForegroundWindow(handle);
                }
                else
                {
                    MessageBox.Show(String.Format("Window {0} not found.", m_Commands),
                                    this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
                return;
            }
            else if (this.m_SendCommandType == SendCommandType.ActivateLastN)
            {
                int lastN;
                if (int.TryParse(m_Commands, out lastN))
                {
                    var handle = IntPtr.Zero;

                    var windows = User32Windows.GetDesktopWindows(getIcons: false);

                    int currentProcId;
                    User32Windows.GetWindowThreadProcessId(this.Handle, out currentProcId);

                    if (lastN < windows.Count)
                    {
                        var i = 0;
                        for ( ; i < lastN; i++)
                        {
                            int procId;
                            User32Windows.GetWindowThreadProcessId(windows[i].Handle, out procId);
                            if (procId == currentProcId)
                            {
                                lastN++;
                                if (lastN == windows.Count)
                                {
                                    return;
                                }
                            }
                        }
                        handle = windows[i - 1].Handle;
                    }
                    else
                    {
                        return;
                    }

                    if (User32Windows.IsIconic(handle))
                    {
                        User32Windows.ShowWindow(handle, User32Windows.SW_RESTORE);
                    }
                    User32Windows.SetForegroundWindow(handle);
                }
                else
                {
                    MessageBox.Show(String.Format("Window {0} not found.", m_Commands),
                                    this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
                return;
            }

            User32Windows.SetForegroundWindow(m_HostWindowHwnd);

            string backup = null;

            if (this.m_SendCommandType == SendCommandType.Clipboard)
            {
                backup     = m_Commands;
                m_Commands = m_Commands == String.Empty ?
                             Clipboard.GetText() :
                             m_Commands.Replace("{clipboard}", Clipboard.GetText());
            }

            if (m_Commands == String.Empty)
            {
                return;
            }

            if (this.m_Sleep)
            {
                Thread.Sleep(m_SleepTimeout);
            }

            //
            // Working code (using SendKeys class).
            //
            var commands = m_Commands.Split(new string[] { "\r\n" }, StringSplitOptions.None);

            for (int i = 0; i < commands.Length; i++)
            {
                if (this.m_Sleep)
                {
                    Thread.Sleep(m_SleepTimeout);
                }

                SendKeys.SendWait(commands[i]);
            }

            if (this.m_SendCommandType == SendCommandType.Clipboard)
            {
                m_Commands = backup;
            }

            var lastWindow = User32Windows.GetLastActiveWindow(hwndExcept: this.Handle);

            User32Windows.SetForegroundWindow(lastWindow.Handle);

            //
            // Working code (using InputSimulator http://inputsimulator.codeplex.com/).
            //
            // var simulator = new InputSimulator();
            // simulator.Keyboard.TextEntry(m_Commands);
        }