code style: dropped C prefix

src/lib/platform/XWindowsEventQueueBuffer.cpp

@@ -0,0 +1,289 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2012 Bolton Software Ltd.
+ * Copyright (C) 2004 Chris Schoeneman
+ * 
+ * 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, IEventQueue* events) :
+	m_events(events),
+	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,
+							m_events->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();
+}