protected override bool DispatchMessage(object message, DispatchTarget target)
        {
            if (target == DispatchTarget.LocalProcess)
            {
                InvokeMessageHandlers(message);
                return(true);
            }

            bool successfullyDispatched = false;

            NativeMethods.EnumWindowsProc enumProc = null;

            switch (target)
            {
            case DispatchTarget.FirstOtherProcess:
                enumProc = delegate(IntPtr hWnd, IntPtr lParam) {
                    if (ShouldSendToWindow(hWnd))
                    {
                        bool wasHandled = SendMessage(hWnd, message);

                        if (wasHandled)
                        {
                            successfullyDispatched = true;
                            return(NativeMethods.StopWindowEnumeration);
                        }
                    }

                    return(NativeMethods.ContinueWindowEnumeration);
                };
                break;

            case DispatchTarget.AllOtherProcesses:
                successfullyDispatched = true;
                enumProc = delegate(IntPtr hWnd, IntPtr lParam) {
                    if (ShouldSendToWindow(hWnd))
                    {
                        SendMessage(hWnd, message);
                    }

                    return(NativeMethods.ContinueWindowEnumeration);
                };
                break;

            default:
                throw new NotSupportedException();
            }

            NativeMethods.EnumWindows(enumProc, lParam: IntPtr.Zero);
            return(successfullyDispatched);
        }
        /// <summary>
        ///   Tries to send all queued messages to the passed in target processes.
        ///   Query <see cref="HasUndispatchedMessages"/> to determine if all messages
        ///   could be been dispatched successfully.
        /// </summary>
        public void DispatchMessages(DispatchTarget target)
        {
            while (HasUndispatchedMessages)
            {
                bool dispatchedSuccessfully = DispatchMessage(MessageQueue.Peek(), target);

                if (dispatchedSuccessfully)
                {
                    MessageQueue.Dequeue();
                }
                else
                {
                    break;
                }
            }
        }
 protected abstract bool DispatchMessage(object message, DispatchTarget target);