barrier/lib/platform/CXWindowsEventQueueBuffer.cpp

288 lines
7.1 KiB
C++

/*
* synergy -- mouse and keyboard sharing utility
* Copyright (C) 2004 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
*
* This package is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* found in the file COPYING that should have accompanied this file.
*
* This package is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "CXWindowsEventQueueBuffer.h"
#include "CLock.h"
#include "CThread.h"
#include "CEvent.h"
#include "IEventQueue.h"
#include <fcntl.h>
#if HAVE_UNISTD_H
# include <unistd.h>
#endif
#if HAVE_POLL
# include <poll.h>
#else
# if HAVE_SYS_SELECT_H
# include <sys/select.h>
# endif
# if HAVE_SYS_TIME_H
# include <sys/time.h>
# endif
# if HAVE_SYS_TYPES_H
# include <sys/types.h>
# endif
#endif
//
// CEventQueueTimer
//
class CEventQueueTimer { };
//
// CXWindowsEventQueueBuffer
//
CXWindowsEventQueueBuffer::CXWindowsEventQueueBuffer(
Display* display, Window window) :
m_display(display),
m_window(window),
m_waiting(false)
{
assert(m_display != NULL);
assert(m_window != None);
m_userEvent = XInternAtom(m_display, "SYNERGY_USER_EVENT", False);
// set up for pipe hack
int result = pipe(m_pipefd);
assert(result == 0);
int pipeflags;
pipeflags = fcntl(m_pipefd[0], F_GETFL);
fcntl(m_pipefd[0], F_SETFL, pipeflags | O_NONBLOCK);
pipeflags = fcntl(m_pipefd[1], F_GETFL);
fcntl(m_pipefd[1], F_SETFL, pipeflags | O_NONBLOCK);
}
CXWindowsEventQueueBuffer::~CXWindowsEventQueueBuffer()
{
// release pipe hack resources
close(m_pipefd[0]);
close(m_pipefd[1]);
}
void
CXWindowsEventQueueBuffer::waitForEvent(double dtimeout)
{
CThread::testCancel();
// clear out the pipe in preparation for waiting.
char buf[16];
ssize_t read_response = read(m_pipefd[0], buf, 15);
// with linux automake, warnings are treated as errors by default
if (read_response < 0)
{
// todo: handle read response
}
{
CLock lock(&m_mutex);
// we're now waiting for events
m_waiting = true;
// push out pending events
flush();
}
// calling flush may have queued up a new event.
if (!CXWindowsEventQueueBuffer::isEmpty()) {
CThread::testCancel();
return;
}
// use poll() to wait for a message from the X server or for timeout.
// this is a good deal more efficient than polling and sleeping.
#if HAVE_POLL
struct pollfd pfds[2];
pfds[0].fd = ConnectionNumber(m_display);
pfds[0].events = POLLIN;
pfds[1].fd = m_pipefd[0];
pfds[1].events = POLLIN;
int timeout = (dtimeout < 0.0) ? -1 :
static_cast<int>(1000.0 * dtimeout);
int remaining = timeout;
int retval = 0;
#else
struct timeval timeout;
struct timeval* timeoutPtr;
if (dtimeout < 0.0) {
timeoutPtr = NULL;
}
else {
timeout.tv_sec = static_cast<int>(dtimeout);
timeout.tv_usec = static_cast<int>(1.0e+6 *
(dtimeout - timeout.tv_sec));
timeoutPtr = &timeout;
}
// initialize file descriptor sets
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(ConnectionNumber(m_display), &rfds);
FD_SET(m_pipefd[0], &rfds);
int nfds;
if (ConnectionNumber(m_display) > m_pipefd[0]) {
nfds = ConnectionNumber(m_display) + 1;
}
else {
nfds = m_pipefd[0] + 1;
}
#endif
// It's possible that the X server has queued events locally
// in xlib's event buffer and not pushed on to the fd. Hence we
// can't simply monitor the fd as we may never be woken up.
// ie addEvent calls flush, XFlush may not send via the fd hence
// there is an event waiting to be sent but we must exit the poll
// before it can.
// Instead we poll for a brief period of time (so if events
// queued locally in the xlib buffer can be processed)
// and continue doing this until timeout is reached.
// The human eye can notice 60hz (ansi) which is 16ms, however
// we want to give the cpu a chance s owe up this to 25ms
#define TIMEOUT_DELAY 25
while( ((dtimeout < 0.0) || (remaining > 0)) && QLength(m_display)==0 && retval==0){
#if HAVE_POLL
retval = poll(pfds, 2, TIMEOUT_DELAY); //16ms = 60hz, but we make it > to play nicely with the cpu
if (pfds[1].revents & POLLIN) {
ssize_t read_response = read(m_pipefd[0], buf, 15);
// with linux automake, warnings are treated as errors by default
if (read_response < 0)
{
// todo: handle read response
}
}
#else
retval = select(nfds,
SELECT_TYPE_ARG234 &rfds,
SELECT_TYPE_ARG234 NULL,
SELECT_TYPE_ARG234 NULL,
SELECT_TYPE_ARG5 TIMEOUT_DELAY);
if (FD_SET(m_pipefd[0], &rfds) {
read(m_pipefd[0], buf, 15);
}
#endif
remaining-=TIMEOUT_DELAY;
}
{
// we're no longer waiting for events
CLock lock(&m_mutex);
m_waiting = false;
}
CThread::testCancel();
}
IEventQueueBuffer::Type
CXWindowsEventQueueBuffer::getEvent(CEvent& event, UInt32& dataID)
{
CLock lock(&m_mutex);
// push out pending events
flush();
// get next event
XNextEvent(m_display, &m_event);
// process event
if (m_event.xany.type == ClientMessage &&
m_event.xclient.message_type == m_userEvent) {
dataID = static_cast<UInt32>(m_event.xclient.data.l[0]);
return kUser;
}
else {
event = CEvent(CEvent::kSystem,
IEventQueue::getSystemTarget(), &m_event);
return kSystem;
}
}
bool
CXWindowsEventQueueBuffer::addEvent(UInt32 dataID)
{
// prepare a message
XEvent xevent;
xevent.xclient.type = ClientMessage;
xevent.xclient.window = m_window;
xevent.xclient.message_type = m_userEvent;
xevent.xclient.format = 32;
xevent.xclient.data.l[0] = static_cast<long>(dataID);
// save the message
CLock lock(&m_mutex);
m_postedEvents.push_back(xevent);
// if we're currently waiting for an event then send saved events to
// the X server now. if we're not waiting then some other thread
// might be using the display connection so we can't safely use it
// too.
if (m_waiting) {
flush();
// Send a character through the round-trip pipe to wake a thread
// that is waiting for a ConnectionNumber() socket to be readable.
// The flush call can read incoming data from the socket and put
// it in Xlib's input buffer. That sneaks it past the other thread.
ssize_t write_response = write(m_pipefd[1], "!", 1);
// with linux automake, warnings are treated as errors by default
if (write_response < 0)
{
// todo: handle read response
}
}
return true;
}
bool
CXWindowsEventQueueBuffer::isEmpty() const
{
CLock lock(&m_mutex);
return (XPending(m_display) == 0 );
}
CEventQueueTimer*
CXWindowsEventQueueBuffer::newTimer(double, bool) const
{
return new CEventQueueTimer;
}
void
CXWindowsEventQueueBuffer::deleteTimer(CEventQueueTimer* timer) const
{
delete timer;
}
void
CXWindowsEventQueueBuffer::flush()
{
// note -- m_mutex must be locked on entry
// flush the posted event list to the X server
for (size_t i = 0; i < m_postedEvents.size(); ++i) {
XSendEvent(m_display, m_window, False, 0, &m_postedEvents[i]);
}
XFlush(m_display);
m_postedEvents.clear();
}