path: root/krdc/vnc/threads.cpp

/***************************************************************************
                            threads.cpp  -  threads
                             -------------------
    begin                : Thu May 09 17:01:44 CET 2002
    copyright            : (C) 2002 by Tim Jansen
    email                : [email protected]
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include "kvncview.h"

#include <kdebug.h>
#include <tdeapplication.h>

#include "vncviewer.h"
#include "threads.h"

#include <tqcstring.h>

// Maximum idle time for writer thread in ms. When it timeouts, it will request
// another incremental update. Must be smaller than the timeout of the server
// (krfb's is 20s).
static const int MAXIMUM_WAIT_PERIOD = 8000;

// time to postpone incremental updates that have not been requested explicitly
static const int POSTPONED_INCRRQ_WAIT_PERIOD = 110;

static const int MOUSEPRESS_QUEUE_SIZE = 5;
static const int MOUSEMOVE_QUEUE_SIZE = 3;
static const int KEY_QUEUE_SIZE = 8192;


ControllerThread::ControllerThread(KVncView *v, WriterThread &wt, volatile bool &quitFlag) :
	m_view(v),
	m_status(REMOTE_VIEW_CONNECTING),
	m_wthread(wt),
	m_quitFlag(quitFlag),
	m_desktopInitialized(false)
{
}

void ControllerThread::changeStatus(RemoteViewStatus s) {
	m_status = s;
	TQApplication::postEvent(m_view, new StatusChangeEvent(s));
}

void ControllerThread::sendFatalError(ErrorCode s) {
	m_quitFlag = true;
	TQApplication::postEvent(m_view, new FatalErrorEvent(s));
	m_wthread.kick();
}

/*
 * Calls this from the X11 thread
 */
void ControllerThread::desktopInit() {
	SetVisualAndCmap();
	ToplevelInit();
	DesktopInit(m_view->winId());
	m_desktopInitialized = true;
	m_waiter.wakeAll();
}

void ControllerThread::kick() {
	m_waiter.wakeAll();
}

void ControllerThread::run() {
	int fd;
	fd = ConnectToRFBServer(m_view->host().latin1(), m_view->port());
	if (fd < 0) {
		if (fd == -(int)INIT_NO_SERVER)
			sendFatalError(ERROR_NO_SERVER);
		else if (fd == -(int)INIT_NAME_RESOLUTION_FAILURE)
			sendFatalError(ERROR_NAME);
		else
			sendFatalError(ERROR_CONNECTION);
		return;
	}
	if (m_quitFlag) {
		changeStatus(REMOTE_VIEW_DISCONNECTED);
		return;
	}

        changeStatus(REMOTE_VIEW_AUTHENTICATING);

	enum InitStatus s = InitialiseRFBConnection();
	if (s != INIT_OK) {
		if (s == INIT_CONNECTION_FAILED)
			sendFatalError(ERROR_IO);
		else if (s == INIT_SERVER_BLOCKED)
			sendFatalError(ERROR_SERVER_BLOCKED);
		else if (s == INIT_PROTOCOL_FAILURE)
			sendFatalError(ERROR_PROTOCOL);
		else if (s == INIT_AUTHENTICATION_FAILED)
			sendFatalError(ERROR_AUTHENTICATION);
		else if (s == INIT_ABORTED)
			changeStatus(REMOTE_VIEW_DISCONNECTED);
		else
			sendFatalError(ERROR_INTERNAL);
		return;
	}

	TQApplication::postEvent(m_view,
				new ScreenResizeEvent(si.framebufferWidth,
						      si.framebufferHeight));
	m_wthread.queueUpdateRequest(TQRegion(TQRect(0,0,si.framebufferWidth,
		si.framebufferHeight)));

	TQApplication::postEvent(m_view, new DesktopInitEvent());
	while ((!m_quitFlag) && (!m_desktopInitialized))
		m_waiter.wait(1000);

	if (m_quitFlag) {
		changeStatus(REMOTE_VIEW_DISCONNECTED);
		return;
	}

	changeStatus(REMOTE_VIEW_PREPARING);

	if (!SetFormatAndEncodings()) {
		sendFatalError(ERROR_INTERNAL);
		return;
	}

	changeStatus(REMOTE_VIEW_CONNECTED);

	m_wthread.start();

	while (!m_quitFlag) {
		if ((!HandleRFBServerMessage()) && (!m_quitFlag)) {
			sendFatalError(ERROR_IO);
			return;
		}
	}

	m_quitFlag = true;
	changeStatus(REMOTE_VIEW_DISCONNECTED);
	m_wthread.kick();
}

enum RemoteViewStatus ControllerThread::status() {
	return m_status;
}





static WriterThread *writerThread;
void queueIncrementalUpdateRequest() {
	writerThread->queueIncrementalUpdateRequest();
}

void announceIncrementalUpdateRequest() {
	writerThread->announceIncrementalUpdateRequest();
}


WriterThread::WriterThread(KVncView *v, volatile bool &quitFlag) :
	m_quitFlag(quitFlag),
	m_view(v),
	m_lastIncrUpdatePostponed(false),
	m_incrementalUpdateRQ(false),
	m_incrementalUpdateAnnounced(false),
	m_mouseEventNum(0),
	m_keyEventNum(0),
	m_clientCut(TQString())
{
	writerThread = this;
	m_lastIncrUpdate.start();
}

bool WriterThread::sendIncrementalUpdateRequest() {
	m_lastIncrUpdate.restart();
	return SendIncrementalFramebufferUpdateRequest();
}

bool WriterThread::sendUpdateRequest(const TQRegion &region) {
	TQMemArray<TQRect> r = region.rects();
	for (unsigned int i = 0; i < r.size(); i++)
		if (!SendFramebufferUpdateRequest(r[i].x(),
						  r[i].y(),
						  r[i].width(),
						  r[i].height(), False))
			return false;
	return true;
}

bool WriterThread::sendInputEvents(const TQValueList<InputEvent> &events) {
	TQValueList<InputEvent>::const_iterator it = events.begin();
	while (it != events.end()) {
		if ((*it).type == KeyEventType) {
			if (!SendKeyEvent((*it).e.k.k, (*it).e.k.down ? True : False))
				return false;
		}
		else
			if (!SendPointerEvent((*it).e.m.x, (*it).e.m.y, (*it).e.m.buttons))
				return false;
		it++;
	}
	return true;
}

void WriterThread::queueIncrementalUpdateRequest() {
	m_lock.lock();
	m_incrementalUpdateRQ = true;
	m_waiter.wakeAll();
	m_lock.unlock();
}

void WriterThread::announceIncrementalUpdateRequest() {
	m_lock.lock();
	m_incrementalUpdateAnnounced = true;
	m_lock.unlock();
}


void WriterThread::queueUpdateRequest(const TQRegion &r) {
	m_lock.lock();
	m_updateRegionRQ += r;
	m_waiter.wakeAll();
	m_lock.unlock();
}

void WriterThread::queueMouseEvent(int x, int y, int buttonMask) {
	InputEvent e;
	e.type = MouseEventType;
	e.e.m.x = x;
	e.e.m.y = y;
	e.e.m.buttons = buttonMask;

	m_lock.lock();
	if (m_mouseEventNum > 0) {
		if ((e.e.m.x == m_lastMouseEvent.x) &&
		    (e.e.m.y == m_lastMouseEvent.y) &&
		    (e.e.m.buttons == m_lastMouseEvent.buttons)) {
			m_lock.unlock();
			return;
		}
		if (m_mouseEventNum >= MOUSEPRESS_QUEUE_SIZE) {
			m_lock.unlock();
			return;
		}
		if ((m_lastMouseEvent.buttons == buttonMask) &&
		    (m_mouseEventNum >= MOUSEMOVE_QUEUE_SIZE)) {
			m_lock.unlock();
			return;
		}
	}

	m_mouseEventNum++;
	m_lastMouseEvent = e.e.m;

	m_inputEvents.push_back(e);
	m_waiter.wakeAll();
	m_lock.unlock();
}

void WriterThread::queueKeyEvent(unsigned int k, bool down) {
	InputEvent e;
	e.type = KeyEventType;
	e.e.k.k = k;
	e.e.k.down = down;

	m_lock.lock();
	if (m_keyEventNum >= KEY_QUEUE_SIZE) {
		m_lock.unlock();
		return;
	}

	m_keyEventNum++;
	m_inputEvents.push_back(e);
	m_waiter.wakeAll();
	m_lock.unlock();
}

void WriterThread::queueClientCut(const TQString &text) {
	m_lock.lock();

	m_clientCut = text;

	m_waiter.wakeAll();
	m_lock.unlock();
}

void WriterThread::kick() {
	m_waiter.wakeAll();
}

void WriterThread::run() {
	bool incrementalUpdateRQ = false;
	bool incrementalUpdateAnnounced = false;
	TQRegion updateRegionRQ;
	TQValueList<InputEvent> inputEvents;
	TQString clientCut;

	while (!m_quitFlag) {
		m_lock.lock();
		incrementalUpdateRQ = m_incrementalUpdateRQ;
		incrementalUpdateAnnounced = m_incrementalUpdateAnnounced;
		updateRegionRQ = m_updateRegionRQ;
		inputEvents = m_inputEvents;
		clientCut = m_clientCut;

		if ((!incrementalUpdateRQ) &&
		    (updateRegionRQ.isNull()) &&
		    (inputEvents.size() == 0) &&
		    (clientCut.isNull())) {
			if (!m_waiter.wait(&m_lock,
					   m_lastIncrUpdatePostponed ?
					   POSTPONED_INCRRQ_WAIT_PERIOD : MAXIMUM_WAIT_PERIOD))
				m_incrementalUpdateRQ = true;
			m_lock.unlock();
		}
		else {
			m_incrementalUpdateRQ = false;
			m_incrementalUpdateAnnounced = false;
			m_updateRegionRQ = TQRegion();
			m_inputEvents.clear();
			m_keyEventNum = 0;
			m_mouseEventNum = 0;
			m_clientCut = TQString();
			m_lock.unlock();

			// always send incremental update, unless
			// a) a framebuffer update is done ATM and will do the request later, or
			// b) the last unrequested update has been done less than 0.1s ago
			//
			// if the update has not been done because of b, postpone it.
			if (incrementalUpdateRQ || !incrementalUpdateAnnounced) {
				bool sendUpdate;
				if (incrementalUpdateRQ) {
					sendUpdate = true;
					m_lastIncrUpdatePostponed = false;
				}
				else {
					if (m_lastIncrUpdate.elapsed() < 100) {
						sendUpdate = false;
						m_lastIncrUpdatePostponed = true;
					}
					else {
						sendUpdate = true;
						m_lastIncrUpdatePostponed = false;
					}
				}

				if (sendUpdate)
					if (!sendIncrementalUpdateRequest()) {
						sendFatalError(ERROR_IO);
						break;
					}
			}
			else
				m_lastIncrUpdatePostponed = false;

			if (!updateRegionRQ.isNull())
				if (!sendUpdateRequest(updateRegionRQ)) {
					sendFatalError(ERROR_IO);
					break;
				}
			if (inputEvents.size() != 0)
				if (!sendInputEvents(inputEvents)) {
					sendFatalError(ERROR_IO);
					break;
				}
			if (!clientCut.isNull())  {
				TQCString cutTextUtf8(clientCut.utf8());
				if (!SendClientCutText(cutTextUtf8.data(),
						       (int)cutTextUtf8.length())) {
					sendFatalError(ERROR_IO);
					break;
				}
			}
		}
	}
	m_quitFlag = true;
}

void WriterThread::sendFatalError(ErrorCode s) {
	m_quitFlag = true;
	TQApplication::postEvent(m_view, new FatalErrorEvent(s));
}