Renamed WebSocket to QWebSocket

Renamed WebSocketProtocol to QWebSocketProtocol
Renamed WebSocketServer to QWebSocketServer
Adapted source files to include renamed headers
Added qwebsocketsglobal.h file

19 files changed, 300 insertions, 275 deletions

diff --git a/examples/echoclient/echoclient.h b/examples/echoclient/echoclient.h
index 4405071..36a3cad 100644
--- a/examples/echoclient/echoclient.h
+++ b/examples/echoclient/echoclient.h
@@ -2,7 +2,7 @@
 #define ECHOCLIENT_H
 
 #include <QObject>
-#include "websocket.h"
+#include "qwebsocket.h"
 
 class EchoClient : public QObject
 {
@@ -19,7 +19,7 @@ private Q_SLOTS:
 	void onTextMessageReceived(QString message);
 
 private:
-	WebSocket m_webSocket;
+	QWebSocket m_webSocket;
 };
 
 #endif // ECHOCLIENT_H
diff --git a/examples/echoserver/echoserver.cpp b/examples/echoserver/echoserver.cpp
index 1e223c9..c08aad1 100644
--- a/examples/echoserver/echoserver.cpp
+++ b/examples/echoserver/echoserver.cpp
@@ -1,6 +1,6 @@
 #include "echoserver.h"
-#include "websocketserver.h"
-#include "websocket.h"
+#include "qwebsocketserver.h"
+#include "qwebsocket.h"
 #include <QDebug>
 
 //! [constructor]
@@ -9,7 +9,7 @@ EchoServer::EchoServer(quint16 port, QObject *parent) :
 	m_pWebSocketServer(0),
 	m_clients()
 {
-	m_pWebSocketServer = new WebSocketServer("Echo Server", this);
+	m_pWebSocketServer = new QWebSocketServer("Echo Server", this);
 	if (m_pWebSocketServer->listen(QHostAddress::Any, port))
 	{
 		qDebug() << "Echoserver listening on port" << port;
@@ -21,7 +21,7 @@ EchoServer::EchoServer(quint16 port, QObject *parent) :
 //! [onNewConnection]
 void EchoServer::onNewConnection()
 {
-	WebSocket *pSocket = m_pWebSocketServer->nextPendingConnection();
+	QWebSocket *pSocket = m_pWebSocketServer->nextPendingConnection();
 
 	connect(pSocket, SIGNAL(textMessageReceived(QString)), this, SLOT(processMessage(QString)));
 	connect(pSocket, SIGNAL(binaryMessageReceived(QByteArray)), this, SLOT(processBinaryMessage(QByteArray)));
@@ -35,7 +35,7 @@ void EchoServer::onNewConnection()
 //! [processMessage]
 void EchoServer::processMessage(QString message)
 {
-	WebSocket *pClient = qobject_cast<WebSocket *>(sender());
+	QWebSocket *pClient = qobject_cast<QWebSocket *>(sender());
 	if (pClient != 0)
 	{
 		pClient->send(message);
@@ -46,7 +46,7 @@ void EchoServer::processMessage(QString message)
 //! [processBinaryMessage]
 void EchoServer::processBinaryMessage(QByteArray message)
 {
-	WebSocket *pClient = qobject_cast<WebSocket *>(sender());
+	QWebSocket *pClient = qobject_cast<QWebSocket *>(sender());
 	if (pClient != 0)
 	{
 		pClient->send(message);
@@ -57,7 +57,7 @@ void EchoServer::processBinaryMessage(QByteArray message)
 //! [socketDisconnected]
 void EchoServer::socketDisconnected()
 {
-	WebSocket *pClient = qobject_cast<WebSocket *>(sender());
+	QWebSocket *pClient = qobject_cast<QWebSocket *>(sender());
 	if (pClient != 0)
 	{
 		m_clients.removeAll(pClient);
diff --git a/examples/echoserver/echoserver.h b/examples/echoserver/echoserver.h
index 21cf0de..aa8c2ba 100644
--- a/examples/echoserver/echoserver.h
+++ b/examples/echoserver/echoserver.h
@@ -5,8 +5,8 @@
 #include <QList>
 #include <QByteArray>
 
-class WebSocketServer;
-class WebSocket;
+class QWebSocketServer;
+class QWebSocket;
 
 class EchoServer : public QObject
 {
@@ -23,8 +23,8 @@ private Q_SLOTS:
 	void socketDisconnected();
 
 private:
-	WebSocketServer *m_pWebSocketServer;
-	QList<WebSocket *> m_clients;
+	QWebSocketServer *m_pWebSocketServer;
+	QList<QWebSocket *> m_clients;
 };
 
 #endif //ECHOSERVER_H
diff --git a/source/dataprocessor_p.cpp b/source/dataprocessor_p.cpp
index a45cfad..a760787 100644
--- a/source/dataprocessor_p.cpp
+++ b/source/dataprocessor_p.cpp
@@ -1,5 +1,5 @@
 #include "dataprocessor_p.h"
-#include "websocketprotocol.h"
+#include "qwebsocketprotocol.h"
 #include <QTcpSocket>
 #include <QtEndian>
 #include <limits.h>
@@ -17,7 +17,7 @@ public:
 
 	const Frame &operator =(const Frame &other);
 
-	WebSocketProtocol::CloseCode getCloseCode() const;
+	QWebSocketProtocol::CloseCode getCloseCode() const;
 	QString getCloseReason() const;
 	bool isFinalFrame() const;
 	bool isControlFrame() const;
@@ -28,7 +28,7 @@ public:
 	int getRsv1() const;
 	int getRsv2() const;
 	int getRsv3() const;
-	WebSocketProtocol::OpCode getOpCode() const;
+	QWebSocketProtocol::OpCode getOpCode() const;
 	QByteArray getPayload() const;
 
 	void clear();       //resets all member variables, and invalidates the object
@@ -38,14 +38,14 @@ public:
 	static Frame readFrame(QTcpSocket *pSocket);
 
 private:
-	WebSocketProtocol::CloseCode m_closeCode;
+	QWebSocketProtocol::CloseCode m_closeCode;
 	QString m_closeReason;
 	bool m_isFinalFrame;
 	quint32 m_mask;
 	int m_rsv1; //reserved field 1
 	int m_rsv2; //reserved field 2
 	int m_rsv3; //reserved field 3
-	WebSocketProtocol::OpCode m_opCode;
+	QWebSocketProtocol::OpCode m_opCode;
 
 	quint8 m_length;        //length field as read from the header; this is 1 byte, which when 126 or 127, indicates a large payload
 	QByteArray m_payload;
@@ -63,19 +63,19 @@ private:
 		PS_WAIT_FOR_MORE_DATA
 	};
 
-	void setError(WebSocketProtocol::CloseCode code, QString closeReason);
+	void setError(QWebSocketProtocol::CloseCode code, QString closeReason);
 	bool checkValidity();
 };
 
 Frame::Frame() :
-	m_closeCode(WebSocketProtocol::CC_NORMAL),
+	m_closeCode(QWebSocketProtocol::CC_NORMAL),
 	m_closeReason(),
 	m_isFinalFrame(true),
 	m_mask(0),
 	m_rsv1(0),
 	m_rsv2(0),
 	m_rsv3(0),
-	m_opCode(WebSocketProtocol::OC_RESERVED_V),
+	m_opCode(QWebSocketProtocol::OC_RESERVED_V),
 	m_length(0),
 	m_payload(),
 	m_isValid(false)
@@ -114,7 +114,7 @@ const Frame &Frame::operator =(const Frame &other)
 	return *this;
 }
 
-WebSocketProtocol::CloseCode Frame::getCloseCode() const
+QWebSocketProtocol::CloseCode Frame::getCloseCode() const
 {
 	return m_closeCode;
 }
@@ -141,7 +141,7 @@ bool Frame::isDataFrame() const
 
 bool Frame::isContinuationFrame() const
 {
-	return isDataFrame() && (m_opCode == WebSocketProtocol::OC_CONTINUE);
+	return isDataFrame() && (m_opCode == QWebSocketProtocol::OC_CONTINUE);
 }
 
 bool Frame::hasMask() const
@@ -169,7 +169,7 @@ int Frame::getRsv3() const
 	return m_rsv3;
 }
 
-WebSocketProtocol::OpCode Frame::getOpCode() const
+QWebSocketProtocol::OpCode Frame::getOpCode() const
 {
 	return m_opCode;
 }
@@ -181,14 +181,14 @@ QByteArray Frame::getPayload() const
 
 void Frame::clear()
 {
-	m_closeCode = WebSocketProtocol::CC_NORMAL;
+	m_closeCode = QWebSocketProtocol::CC_NORMAL;
 	m_closeReason.clear();
 	m_isFinalFrame = true;
 	m_mask = 0;
 	m_rsv1 = 0;
 	m_rsv2 =0;
 	m_rsv3 = 0;
-	m_opCode = WebSocketProtocol::OC_RESERVED_V;
+	m_opCode = QWebSocketProtocol::OC_RESERVED_V;
 	m_length = 0;
 	m_payload.clear();
 	m_isValid = false;
@@ -221,7 +221,7 @@ Frame Frame::readFrame(QTcpSocket *pSocket)
 				bool ok = pSocket->waitForReadyRead(5000);
 				if (!ok)
 				{
-					frame.setError(WebSocketProtocol::CC_GOING_AWAY, "Timeout when reading data from socket.");
+					frame.setError(QWebSocketProtocol::CC_GOING_AWAY, "Timeout when reading data from socket.");
 					isDone = true;
 				}
 				else
@@ -241,7 +241,7 @@ Frame Frame::readFrame(QTcpSocket *pSocket)
 					frame.m_rsv1 = (header[0] & 0x40);
 					frame.m_rsv2 = (header[0] & 0x20);
 					frame.m_rsv3 = (header[0] & 0x10);
-					frame.m_opCode = static_cast<WebSocketProtocol::OpCode>(header[0] & 0x0F);
+					frame.m_opCode = static_cast<QWebSocketProtocol::OpCode>(header[0] & 0x0F);
 
 					//Mask, PayloadLength
 					hasMask = (header[1] & 0x80) != 0;
@@ -338,7 +338,7 @@ Frame Frame::readFrame(QTcpSocket *pSocket)
 				}
 				else if (payloadLength > MAX_FRAME_SIZE_IN_BYTES)
 				{
-					frame.setError(WebSocketProtocol::CC_TOO_MUCH_DATA, "Maximum framesize exceeded.");
+					frame.setError(QWebSocketProtocol::CC_TOO_MUCH_DATA, "Maximum framesize exceeded.");
 					processingState = PS_DISPATCH_RESULT;
 				}
 				else
@@ -349,7 +349,7 @@ Frame Frame::readFrame(QTcpSocket *pSocket)
 						frame.m_payload = pSocket->read(payloadLength);
 						if (hasMask)
 						{
-							WebSocketProtocol::mask(&frame.m_payload, frame.m_mask);
+							QWebSocketProtocol::mask(&frame.m_payload, frame.m_mask);
 						}
 						processingState = PS_DISPATCH_RESULT;
 					}
@@ -382,7 +382,7 @@ Frame Frame::readFrame(QTcpSocket *pSocket)
 	return frame;
 }
 
-void Frame::setError(WebSocketProtocol::CloseCode code, QString closeReason)
+void Frame::setError(QWebSocketProtocol::CloseCode code, QString closeReason)
 {
 	clear();
 	m_closeCode = code;
@@ -396,21 +396,21 @@ bool Frame::checkValidity()
 	{
 		if (m_rsv1 || m_rsv2 || m_rsv3)
 		{
-			setError(WebSocketProtocol::CC_PROTOCOL_ERROR, "Rsv field is non-zero");
+			setError(QWebSocketProtocol::CC_PROTOCOL_ERROR, "Rsv field is non-zero");
 		}
-		else if (WebSocketProtocol::isOpCodeReserved(m_opCode))
+		else if (QWebSocketProtocol::isOpCodeReserved(m_opCode))
 		{
-			setError(WebSocketProtocol::CC_PROTOCOL_ERROR, "Used reserved opcode");
+			setError(QWebSocketProtocol::CC_PROTOCOL_ERROR, "Used reserved opcode");
 		}
 		else if (isControlFrame())
 		{
 			if (m_length > 125)
 			{
-				setError(WebSocketProtocol::CC_PROTOCOL_ERROR, "Controle frame is larger than 125 bytes");
+				setError(QWebSocketProtocol::CC_PROTOCOL_ERROR, "Controle frame is larger than 125 bytes");
 			}
 			else if (!m_isFinalFrame)
 			{
-				setError(WebSocketProtocol::CC_PROTOCOL_ERROR, "Controle frames cannot be fragmented");
+				setError(QWebSocketProtocol::CC_PROTOCOL_ERROR, "Controle frames cannot be fragmented");
 			}
 			else
 			{
@@ -430,7 +430,7 @@ DataProcessor::DataProcessor(QObject *parent) :
 	m_processingState(PS_READ_HEADER),
 	m_isFinalFrame(false),
 	m_isFragmented(false),
-	m_opCode(WebSocketProtocol::OC_CLOSE),
+	m_opCode(QWebSocketProtocol::OC_CLOSE),
 	m_isControlFrame(false),
 	m_hasMask(false),
 	m_mask(0),
@@ -472,13 +472,13 @@ void DataProcessor::process(QTcpSocket *pSocket)
 				if (!m_isFragmented && frame.isContinuationFrame())
 				{
 					clear();
-					Q_EMIT errorEncountered(WebSocketProtocol::CC_PROTOCOL_ERROR, "Received Continuation frame /*with FIN=true*/, while there is nothing to continue.");
+					Q_EMIT errorEncountered(QWebSocketProtocol::CC_PROTOCOL_ERROR, "Received Continuation frame /*with FIN=true*/, while there is nothing to continue.");
 					return;
 				}
 				if (m_isFragmented && frame.isDataFrame() && !frame.isContinuationFrame())
 				{
 					clear();
-					Q_EMIT errorEncountered(WebSocketProtocol::CC_PROTOCOL_ERROR, "All data frames after the initial data frame must have opcode 0 (continuation).");
+					Q_EMIT errorEncountered(QWebSocketProtocol::CC_PROTOCOL_ERROR, "All data frames after the initial data frame must have opcode 0 (continuation).");
 					return;
 				}
 				if (!frame.isContinuationFrame())
@@ -486,22 +486,22 @@ void DataProcessor::process(QTcpSocket *pSocket)
 					m_opCode = frame.getOpCode();
 					m_isFragmented = !frame.isFinalFrame();
 				}
-				quint64 messageLength = (quint64)(m_opCode == WebSocketProtocol::OC_TEXT) ? m_textMessage.length() : m_binaryMessage.length();
+				quint64 messageLength = (quint64)(m_opCode == QWebSocketProtocol::OC_TEXT) ? m_textMessage.length() : m_binaryMessage.length();
 				if ((messageLength + quint64(frame.getPayload().length())) > MAX_MESSAGE_SIZE_IN_BYTES)
 				{
 					clear();
-					Q_EMIT errorEncountered(WebSocketProtocol::CC_TOO_MUCH_DATA, "Received message is too big.");
+					Q_EMIT errorEncountered(QWebSocketProtocol::CC_TOO_MUCH_DATA, "Received message is too big.");
 					return;
 				}
 
-				if (m_opCode == WebSocketProtocol::OC_TEXT)
+				if (m_opCode == QWebSocketProtocol::OC_TEXT)
 				{
 					QString frameTxt = m_pTextCodec->toUnicode(frame.getPayload().constData(), frame.getPayload().size(), m_pConverterState);
 					bool failed = (m_pConverterState->invalidChars != 0) || (frame.isFinalFrame() && (m_pConverterState->remainingChars != 0));
 					if (failed)
 					{
 						clear();
-						Q_EMIT errorEncountered(WebSocketProtocol::CC_WRONG_DATATYPE, "Invalid UTF-8 code encountered.");
+						Q_EMIT errorEncountered(QWebSocketProtocol::CC_WRONG_DATATYPE, "Invalid UTF-8 code encountered.");
 						return;
 					}
 					else
@@ -518,7 +518,7 @@ void DataProcessor::process(QTcpSocket *pSocket)
 
 				if (frame.isFinalFrame())
 				{
-					if (m_opCode == WebSocketProtocol::OC_TEXT)
+					if (m_opCode == QWebSocketProtocol::OC_TEXT)
 					{
 						Q_EMIT textMessageReceived(m_textMessage);
 					}
@@ -545,7 +545,7 @@ void DataProcessor::clear()
 	m_processingState = PS_READ_HEADER;
 	m_isFinalFrame = false;
 	m_isFragmented = false;
-	m_opCode = WebSocketProtocol::OC_CLOSE;
+	m_opCode = QWebSocketProtocol::OC_CLOSE;
 	m_hasMask = false;
 	m_mask = 0;
 	m_binaryMessage.clear();
diff --git a/source/dataprocessor_p.h b/source/dataprocessor_p.h
index f184f35..be23788 100644
--- a/source/dataprocessor_p.h
+++ b/source/dataprocessor_p.h
@@ -5,7 +5,7 @@
 #include <QByteArray>
 #include <QString>
 #include <QTextCodec>
-#include "websocketprotocol.h"
+#include "qwebsocketprotocol.h"
 
 class QTcpSocket;
 
@@ -21,12 +21,12 @@ public:
 	virtual ~DataProcessor();
 
 Q_SIGNALS:
-	void controlFrameReceived(WebSocketProtocol::OpCode opCode, QByteArray frame);
+	void controlFrameReceived(QWebSocketProtocol::OpCode opCode, QByteArray frame);
 	void textFrameReceived(QString frame, bool lastFrame);
 	void binaryFrameReceived(QByteArray frame, bool lastFrame);
 	void textMessageReceived(QString message);
 	void binaryMessageReceived(QByteArray message);
-	void errorEncountered(WebSocketProtocol::CloseCode code, QString description);
+	void errorEncountered(QWebSocketProtocol::CloseCode code, QString description);
 
 public Q_SLOTS:
 	void process(QTcpSocket *pSocket);
@@ -46,7 +46,7 @@ private:
 
 	bool m_isFinalFrame;
 	bool m_isFragmented;
-	WebSocketProtocol::OpCode m_opCode;
+	QWebSocketProtocol::OpCode m_opCode;
 	bool m_isControlFrame;
 	bool m_hasMask;
 	quint32 m_mask;
diff --git a/source/handshakerequest_p.cpp b/source/handshakerequest_p.cpp
index 84f9778..c2b2403 100644
--- a/source/handshakerequest_p.cpp
+++ b/source/handshakerequest_p.cpp
@@ -5,7 +5,7 @@
 #include <QUrl>
 #include <QList>
 #include <QStringList>
-#include "websocketprotocol.h"
+#include "qwebsocketprotocol.h"
 
 HandshakeRequest::HandshakeRequest(int port, bool isSecure) :
 	m_port(port),
@@ -59,7 +59,7 @@ QMap<QString, QString> HandshakeRequest::getHeaders() const
 	return m_headers;
 }
 
-QList<WebSocketProtocol::Version> HandshakeRequest::getVersions() const
+QList<QWebSocketProtocol::Version> HandshakeRequest::getVersions() const
 {
 	return m_versions;
 }
@@ -140,11 +140,11 @@ QTextStream &HandshakeRequest::readFromStream(QTextStream &textStream)
 			QStringList versions = versionLine.split(",", QString::SkipEmptyParts);
 			Q_FOREACH(QString version, versions)
 			{
-				WebSocketProtocol::Version ver = WebSocketProtocol::versionFromString(version.trimmed());
+				QWebSocketProtocol::Version ver = QWebSocketProtocol::versionFromString(version.trimmed());
 				m_versions << ver;
 			}
 		}
-		qStableSort(m_versions.begin(), m_versions.end(), qGreater<WebSocketProtocol::Version>());	//sort in descending order
+		qStableSort(m_versions.begin(), m_versions.end(), qGreater<QWebSocketProtocol::Version>());	//sort in descending order
 		m_key = m_headers.value("Sec-WebSocket-Key", "");
 		QString upgrade = m_headers.value("Upgrade", ""); //must be equal to "websocket", case-insensitive
 		QString connection = m_headers.value("Connection", "");	//must contain "Upgrade", case-insensitive
diff --git a/source/handshakerequest_p.h b/source/handshakerequest_p.h
index 708950a..2e8fc5e 100644
--- a/source/handshakerequest_p.h
+++ b/source/handshakerequest_p.h
@@ -7,7 +7,7 @@
 #include <QUrl>
 #include <QSet>
 
-#include "websocketprotocol.h"
+#include "qwebsocketprotocol.h"
 
 class QTextStream;
 
@@ -23,7 +23,7 @@ public:
 	bool isSecure() const;
 	bool isValid() const;
 	QMap<QString, QString> getHeaders() const;
-	QList<WebSocketProtocol::Version> getVersions() const;
+	QList<QWebSocketProtocol::Version> getVersions() const;
 	QString getKey() const;
 	QString getOrigin() const;
 	QList<QString> getProtocols() const;
@@ -41,7 +41,7 @@ private:
 	bool m_isSecure;
 	bool m_isValid;
 	QMap<QString, QString> m_headers;
-	QList<WebSocketProtocol::Version> m_versions;
+	QList<QWebSocketProtocol::Version> m_versions;
 	QString m_key;
 	QString m_origin;
 	QList<QString> m_protocols;
diff --git a/source/handshakeresponse_p.cpp b/source/handshakeresponse_p.cpp
index fdee13d..ca7bd0d 100644
--- a/source/handshakeresponse_p.cpp
+++ b/source/handshakeresponse_p.cpp
@@ -12,7 +12,7 @@
 HandshakeResponse::HandshakeResponse(const HandshakeRequest &request,
 									 const QString &serverName,
 									 bool isOriginAllowed,
-									 const QList<WebSocketProtocol::Version> &supportedVersions,
+									 const QList<QWebSocketProtocol::Version> &supportedVersions,
 									 const QList<QString> &supportedProtocols,
 									 const QList<QString> &supportedExtensions) :
 	m_isValid(false),
@@ -20,7 +20,7 @@ HandshakeResponse::HandshakeResponse(const HandshakeRequest &request,
 	m_response(),
 	m_acceptedProtocol(),
 	m_acceptedExtension(),
-	m_acceptedVersion(WebSocketProtocol::V_Unknow)
+	m_acceptedVersion(QWebSocketProtocol::V_Unknow)
 {
 	m_response = getHandshakeResponse(request, serverName, isOriginAllowed, supportedVersions, supportedProtocols, supportedExtensions);
 	m_isValid = true;
@@ -55,7 +55,7 @@ QString HandshakeResponse::calculateAcceptKey(const QString &key) const
 QString HandshakeResponse::getHandshakeResponse(const HandshakeRequest &request,
 												const QString &serverName,
 												bool isOriginAllowed,
-												const QList<WebSocketProtocol::Version> &supportedVersions,
+												const QList<QWebSocketProtocol::Version> &supportedVersions,
 												const QList<QString> &supportedProtocols,
 												const QList<QString> &supportedExtensions)
 {
@@ -76,8 +76,8 @@ QString HandshakeResponse::getHandshakeResponse(const HandshakeRequest &request,
 			QString acceptKey = calculateAcceptKey(request.getKey());
 			QList<QString> matchingProtocols = supportedProtocols.toSet().intersect(request.getProtocols().toSet()).toList();
 			QList<QString> matchingExtensions = supportedExtensions.toSet().intersect(request.getExtensions().toSet()).toList();
-			QList<WebSocketProtocol::Version> matchingVersions = request.getVersions().toSet().intersect(supportedVersions.toSet()).toList();
-			qStableSort(matchingVersions.begin(), matchingVersions.end(), qGreater<WebSocketProtocol::Version>());	//sort in descending order
+			QList<QWebSocketProtocol::Version> matchingVersions = request.getVersions().toSet().intersect(supportedVersions.toSet()).toList();
+			qStableSort(matchingVersions.begin(), matchingVersions.end(), qGreater<QWebSocketProtocol::Version>());	//sort in descending order
 
 			if (matchingVersions.isEmpty())
 			{
@@ -112,7 +112,7 @@ QString HandshakeResponse::getHandshakeResponse(const HandshakeRequest &request,
 							"Access-Control-Allow-Origin: " + origin		<<
 							"Date: " + QDateTime::currentDateTimeUtc().toString("ddd, dd MMM yyyy hh:mm:ss 'GMT'");
 
-				m_acceptedVersion = WebSocketProtocol::currentVersion();
+				m_acceptedVersion = QWebSocketProtocol::currentVersion();
 				m_canUpgrade = true;
 			}
 		}
@@ -124,7 +124,7 @@ QString HandshakeResponse::getHandshakeResponse(const HandshakeRequest &request,
 		{
 			response << "HTTP/1.1 400 Bad Request";
 			QStringList versions;
-			Q_FOREACH(WebSocketProtocol::Version version, supportedVersions)
+			Q_FOREACH(QWebSocketProtocol::Version version, supportedVersions)
 			{
 				versions << QString::number(static_cast<int>(version));
 			}
@@ -153,7 +153,7 @@ QTextStream &operator <<(QTextStream &stream, const HandshakeResponse &response)
 	return response.writeToStream(stream);
 }
 
-WebSocketProtocol::Version HandshakeResponse::getAcceptedVersion() const
+QWebSocketProtocol::Version HandshakeResponse::getAcceptedVersion() const
 {
 	return m_acceptedVersion;
 }
diff --git a/source/handshakeresponse_p.h b/source/handshakeresponse_p.h
index 38e60b5..ed7ada2 100644
--- a/source/handshakeresponse_p.h
+++ b/source/handshakeresponse_p.h
@@ -2,7 +2,7 @@
 #define HANDSHAKERESPONSE_P_H
 
 #include <QObject>
-#include "websocketprotocol.h"
+#include "qwebsocketprotocol.h"
 
 class HandshakeRequest;
 class QString;
@@ -15,7 +15,7 @@ public:
 	HandshakeResponse(const HandshakeRequest &request,
 					  const QString &serverName,
 					  bool isOriginAllowed,
-					  const QList<WebSocketProtocol::Version> &supportedVersions,
+					  const QList<QWebSocketProtocol::Version> &supportedVersions,
 					  const QList<QString> &supportedProtocols,
 					  const QList<QString> &supportedExtensions);
 
@@ -25,7 +25,7 @@ public:
 	bool canUpgrade() const;
 	QString getAcceptedProtocol() const;
 	QString getAcceptedExtension() const;
-	WebSocketProtocol::Version getAcceptedVersion() const;
+	QWebSocketProtocol::Version getAcceptedVersion() const;
 
 public Q_SLOTS:
 
@@ -38,13 +38,13 @@ private:
 	QString m_response;
 	QString m_acceptedProtocol;
 	QString m_acceptedExtension;
-	WebSocketProtocol::Version m_acceptedVersion;
+	QWebSocketProtocol::Version m_acceptedVersion;
 
 	QString calculateAcceptKey(const QString &key) const;
 	QString getHandshakeResponse(const HandshakeRequest &request,
 								 const QString &serverName,
 								 bool isOriginAllowed,
-								 const QList<WebSocketProtocol::Version> &supportedVersions,
+								 const QList<QWebSocketProtocol::Version> &supportedVersions,
 								 const QList<QString> &supportedProtocols,
 								 const QList<QString> &supportedExtensions);
 
diff --git a/source/websocket.cpp b/source/qwebsocket.cpp
index 1eaf240..8ac59c3 100644
--- a/source/websocket.cpp
+++ b/source/qwebsocket.cpp
@@ -1,4 +1,4 @@
-#include "websocket.h"
+#include "qwebsocket.h"
 #include "handshakerequest_p.h"
 #include "handshakeresponse_p.h"
 #include <QUrl>
@@ -16,8 +16,8 @@
 #include <limits>
 
 /*!
-	\class WebSocket
-	\brief The class WebSocket implements a TCP socket that talks the websocket protocol.
+	\class QWebSocket
+	\brief The class QWebSocket implements a TCP socket that talks the websocket protocol.
 
 	WebSockets is a web technology providing full-duplex communications channels over a single TCP connection.
 	The WebSocket protocol was standardized by the IETF as RFC 6455 in 2011 (see http://tools.ietf.org/html/rfc6455).
@@ -30,7 +30,7 @@
 	\author Kurt Pattyn (pattyn.kurt@gmail.com)
 */
 /*!
-  \page echoclient WebSocket client example
+  \page echoclient QWebSocket client example
   \brief A sample websocket client that sends a message and displays the message that it receives back.
 
   \section Description
@@ -50,17 +50,17 @@
 */
 
 /*!
-  \fn void WebSocket::connected()
+  \fn void QWebSocket::connected()
   \brief Emitted when a connection is successfully established.
   \sa open(), disconnected()
 */
 /*!
-  \fn void WebSocket::disconnected()
+  \fn void QWebSocket::disconnected()
   \brief Emitted when the socket is disconnected.
   \sa close(), connected()
 */
 /*!
-	\fn void WebSocket::aboutToClose()
+	\fn void QWebSocket::aboutToClose()
 
 	This signal is emitted when the socket is about to close.
 	Connect this signal if you have operations that need to be performed before the socket closes
@@ -69,7 +69,7 @@
 	\sa close()
  */
 /*!
-\fn void WebSocket::proxyAuthenticationRequired(const QNetworkProxy &proxy, QAuthenticator *authenticator)
+\fn void QWebSocket::proxyAuthenticationRequired(const QNetworkProxy &proxy, QAuthenticator *authenticator)
 
 This signal can be emitted when a \a proxy that requires
 authentication is used. The \a authenticator object can then be
@@ -83,9 +83,9 @@ not been filled in with new information when the signal returns.
 \sa QAuthenticator, QNetworkProxy
 */
 /*!
-	\fn void WebSocket::stateChanged(QAbstractSocket::SocketState state);
+	\fn void QWebSocket::stateChanged(QAbstractSocket::SocketState state);
 
-	This signal is emitted whenever WebSocket's state changes.
+	This signal is emitted whenever QWebSocket's state changes.
 	The \a socketState parameter is the new state.
 
 	QAbstractSocket::SocketState is not a registered metatype, so for queued
@@ -95,7 +95,7 @@ not been filled in with new information when the signal returns.
 	\sa state()
 */
 /*!
-	\fn void WebSocket::readChannelFinished()
+	\fn void QWebSocket::readChannelFinished()
 
 	This signal is emitted when the input (reading) stream is closed in this device. It is emitted as soon as the closing is detected.
 
@@ -103,7 +103,7 @@ not been filled in with new information when the signal returns.
 */
 
 /*!
-	\fn void WebSocket::textFrameReceived(QString frame, bool isLastFrame);
+	\fn void QWebSocket::textFrameReceived(QString frame, bool isLastFrame);
 
 	This signal is emitted whenever a text frame is received. The \a frame contains the data and
 	\a isLastFrame indicates whether this is the last frame of the complete message.
@@ -114,7 +114,7 @@ not been filled in with new information when the signal returns.
 	\sa binaryFrameReceived(QByteArray, bool), textMessageReceived(QString)
 */
 /*!
-	\fn void WebSocket::binaryFrameReceived(QByteArray frame, bool isLastFrame);
+	\fn void QWebSocket::binaryFrameReceived(QByteArray frame, bool isLastFrame);
 
 	This signal is emitted whenever a binary frame is received. The \a frame contains the data and
 	\a isLastFrame indicates whether this is the last frame of the complete message.
@@ -125,21 +125,21 @@ not been filled in with new information when the signal returns.
 	\sa textFrameReceived(QString, bool), binaryMessageReceived(QByteArray)
 */
 /*!
-	\fn void WebSocket::textMessageReceived(QString message);
+	\fn void QWebSocket::textMessageReceived(QString message);
 
 	This signal is emitted whenever a text message is received. The \a message contains the received text.
 
 	\sa textFrameReceived(QString, bool), binaryMessageReceived(QByteArray)
 */
 /*!
-	\fn void WebSocket::binaryMessageReceived(QByteArray message);
+	\fn void QWebSocket::binaryMessageReceived(QByteArray message);
 
 	This signal is emitted whenever a binary message is received. The \a message contains the received bytes.
 
 	\sa binaryFrameReceived(QByteArray, bool), textMessageReceived(QString)
 */
 /*!
-	\fn void WebSocket::error(QAbstractSocket::SocketError error);
+	\fn void QWebSocket::error(QAbstractSocket::SocketError error);
 
 	This signal is emitted after an error occurred. The \a socketError
 	parameter describes the type of error that occurred.
@@ -151,7 +151,7 @@ not been filled in with new information when the signal returns.
 	\sa error(), errorString()
 */
 /*!
-  \fn void WebSocket::pong(quint64 elapsedTime)
+  \fn void QWebSocket::pong(quint64 elapsedTime)
 
   Emitted when a pong message is received in reply to a previous ping.
 
@@ -161,13 +161,13 @@ not been filled in with new information when the signal returns.
 const quint64 FRAME_SIZE_IN_BYTES = 512 * 512 * 2;	//maximum size of a frame when sending a message
 
 /*!
- * \brief Creates a new WebSocket with the given \a origin, the \a version of the protocol to use and \a parent.
+ * \brief Creates a new QWebSocket with the given \a origin, the \a version of the protocol to use and \a parent.
  *
  * The \a origin of the client is as specified in http://tools.ietf.org/html/rfc6454.
  * (The \a origin is not required for non-web browser clients (see RFC 6455)).
  * \note Currently only V13 (RFC 6455) is supported
  */
-WebSocket::WebSocket(QString origin, WebSocketProtocol::Version version, QObject *parent) :
+QWebSocket::QWebSocket(QString origin, QWebSocketProtocol::Version version, QObject *parent) :
 	QObject(parent),
 	m_pSocket(new QTcpSocket(this)),
 	m_errorString(),
@@ -196,9 +196,9 @@ WebSocket::WebSocket(QString origin, WebSocketProtocol::Version version, QObject
 
 	pTcpSocket The tcp socket to use for this websocket
 	version The version of the protocol to speak (currently only V13 is supported)
-	parent The parent object of the WebSocket object
+	parent The parent object of the QWebSocket object
 */
-WebSocket::WebSocket(QTcpSocket *pTcpSocket, WebSocketProtocol::Version version, QObject *parent) :
+QWebSocket::QWebSocket(QTcpSocket *pTcpSocket, QWebSocketProtocol::Version version, QObject *parent) :
 	QObject(parent),
 	m_pSocket(pTcpSocket),
 	m_errorString(pTcpSocket->errorString()),
@@ -220,13 +220,13 @@ WebSocket::WebSocket(QTcpSocket *pTcpSocket, WebSocketProtocol::Version version,
 }
 
 /*!
- * \brief Destroys the WebSocket. Closes the socket if it is still open, and releases any used resources.
+ * \brief Destroys the QWebSocket. Closes the socket if it is still open, and releases any used resources.
  */
-WebSocket::~WebSocket()
+QWebSocket::~QWebSocket()
 {
 	if (state() == QAbstractSocket::ConnectedState)
 	{
-		close(WebSocketProtocol::CC_GOING_AWAY, "Connection closed");
+		close(QWebSocketProtocol::CC_GOING_AWAY, "Connection closed");
 	}
 	releaseConnections(m_pSocket);
 	m_pSocket->deleteLater();
@@ -236,7 +236,7 @@ WebSocket::~WebSocket()
 /*!
  * \brief Aborts the current socket and resets the socket. Unlike close(), this function immediately closes the socket, discarding any pending data in the write buffer.
  */
-void WebSocket::abort()
+void QWebSocket::abort()
 {
 	m_pSocket->abort();
 }
@@ -245,7 +245,7 @@ void WebSocket::abort()
  * Returns the type of error that last occurred
  * \sa errorString()
  */
-QAbstractSocket::SocketError WebSocket::error() const
+QAbstractSocket::SocketError QWebSocket::error() const
 {
 	return m_pSocket->error();
 }
@@ -255,7 +255,7 @@ QAbstractSocket::SocketError WebSocket::error() const
  *
  * \sa error()
  */
-QString WebSocket::errorString() const
+QString QWebSocket::errorString() const
 {
 	if (!m_errorString.isEmpty())
 	{
@@ -277,7 +277,7 @@ QString WebSocket::errorString() const
 
 	\sa send() and waitForBytesWritten().
 */
-bool WebSocket::flush()
+bool QWebSocket::flush()
 {
 	return m_pSocket->flush();
 }
@@ -288,7 +288,7 @@ bool WebSocket::flush()
  * \return The number of bytes actually sent.
  * \sa send(const QString &message)
  */
-qint64 WebSocket::send(const char *message)
+qint64 QWebSocket::send(const char *message)
 {
 	return send(QString::fromUtf8(message));
 }
@@ -298,7 +298,7 @@ qint64 WebSocket::send(const char *message)
  * @param message The message to be sent
  * @return The number of bytes actually sent.
  */
-qint64 WebSocket::send(const QString &message)
+qint64 QWebSocket::send(const QString &message)
 {
 	return doWriteData(message.toUtf8(), false);
 }
@@ -308,7 +308,7 @@ qint64 WebSocket::send(const QString &message)
  * @param data The binary data to be sent.
  * @return The number of bytes actually sent.
  */
-qint64 WebSocket::send(const QByteArray &data)
+qint64 QWebSocket::send(const QByteArray &data)
 {
 	return doWriteData(data, true);
 }
@@ -316,12 +316,12 @@ qint64 WebSocket::send(const QByteArray &data)
 /*!
   \internal
  */
-WebSocket *WebSocket::upgradeFrom(QTcpSocket *pTcpSocket,
+QWebSocket *QWebSocket::upgradeFrom(QTcpSocket *pTcpSocket,
 								  const HandshakeRequest &request,
 								  const HandshakeResponse &response,
 								  QObject *parent)
 {
-	WebSocket *pWebSocket = new WebSocket(pTcpSocket, response.getAcceptedVersion(), parent);
+	QWebSocket *pWebSocket = new QWebSocket(pTcpSocket, response.getAcceptedVersion(), parent);
 	pWebSocket->setExtension(response.getAcceptedExtension());
 	pWebSocket->setOrigin(request.getOrigin());
 	pWebSocket->setRequestUrl(request.getRequestUrl());
@@ -334,10 +334,10 @@ WebSocket *WebSocket::upgradeFrom(QTcpSocket *pTcpSocket,
 
 /*!
  * \brief Gracefully closes the socket with the given \a closeCode and \a reason. Any data in the write buffer is flushed before the socket is closed.
- * \param closeCode The WebSocketProtocol::CloseCode indicating the reason to close.
+ * \param closeCode The QWebSocketProtocol::CloseCode indicating the reason to close.
  * \param reason A string describing the error more in detail
  */
-void WebSocket::close(WebSocketProtocol::CloseCode closeCode, QString reason)
+void QWebSocket::close(QWebSocketProtocol::CloseCode closeCode, QString reason)
 {
 	if (!m_isClosingHandshakeSent)
 	{
@@ -355,9 +355,9 @@ void WebSocket::close(WebSocketProtocol::CloseCode closeCode, QString reason)
 		}
 		if (m_mustMask)
 		{
-			WebSocketProtocol::mask(payload.data(), payload.size(), maskingKey);
+			QWebSocketProtocol::mask(payload.data(), payload.size(), maskingKey);
 		}
-		QByteArray frame = getFrameHeader(WebSocketProtocol::OC_CLOSE, payload.size(), maskingKey, true);
+		QByteArray frame = getFrameHeader(QWebSocketProtocol::OC_CLOSE, payload.size(), maskingKey, true);
 		frame.append(payload);
 		m_pSocket->write(frame);
 		m_pSocket->flush();
@@ -376,7 +376,7 @@ void WebSocket::close(WebSocketProtocol::CloseCode closeCode, QString reason)
  * \param mask When true, all frames are masked
  * \note A client socket must *always* mask its frames; servers may *never* mask its frames
  */
-void WebSocket::open(const QUrl &url, bool mask)
+void QWebSocket::open(const QUrl &url, bool mask)
 {
 	m_dataProcessor.clear();
 	m_isClosingHandshakeReceived = false;
@@ -401,10 +401,10 @@ void WebSocket::open(const QUrl &url, bool mask)
  *
  * \sa pong()
  */
-void WebSocket::ping()
+void QWebSocket::ping()
 {
 	m_pingTimer.restart();
-	QByteArray pingFrame = getFrameHeader(WebSocketProtocol::OC_PING, 0, 0, true);
+	QByteArray pingFrame = getFrameHeader(QWebSocketProtocol::OC_PING, 0, 0, true);
 	writeFrame(pingFrame);
 }
 
@@ -412,7 +412,7 @@ void WebSocket::ping()
   \internal
 	Sets the version to use for the websocket protocol; this must be set before the socket is opened.
 */
-void WebSocket::setVersion(WebSocketProtocol::Version version)
+void QWebSocket::setVersion(QWebSocketProtocol::Version version)
 {
 	m_version = version;
 }
@@ -421,7 +421,7 @@ void WebSocket::setVersion(WebSocketProtocol::Version version)
 	\internal
 	Sets the resource name of the connection; must be set before the socket is openend
 */
-void WebSocket::setResourceName(QString resourceName)
+void QWebSocket::setResourceName(QString resourceName)
 {
 	m_resourceName = resourceName;
 }
@@ -429,7 +429,7 @@ void WebSocket::setResourceName(QString resourceName)
 /*!
   \internal
  */
-void WebSocket::setRequestUrl(QUrl requestUrl)
+void QWebSocket::setRequestUrl(QUrl requestUrl)
 {
 	m_requestUrl = requestUrl;
 }
@@ -437,7 +437,7 @@ void WebSocket::setRequestUrl(QUrl requestUrl)
 /*!
   \internal
  */
-void WebSocket::setOrigin(QString origin)
+void QWebSocket::setOrigin(QString origin)
 {
 	m_origin = origin;
 }
@@ -445,7 +445,7 @@ void WebSocket::setOrigin(QString origin)
 /*!
   \internal
  */
-void WebSocket::setProtocol(QString protocol)
+void QWebSocket::setProtocol(QString protocol)
 {
 	m_protocol = protocol;
 }
@@ -453,7 +453,7 @@ void WebSocket::setProtocol(QString protocol)
 /*!
   \internal
  */
-void WebSocket::setExtension(QString extension)
+void QWebSocket::setExtension(QString extension)
 {
 	m_extension = extension;
 }
@@ -461,7 +461,7 @@ void WebSocket::setExtension(QString extension)
 /*!
   \internal
  */
-void WebSocket::enableMasking(bool enable)
+void QWebSocket::enableMasking(bool enable)
 {
 	m_mustMask = enable;
 }
@@ -469,7 +469,7 @@ void WebSocket::enableMasking(bool enable)
 /*!
  * \internal
  */
-qint64 WebSocket::doWriteData(const QByteArray &data, bool isBinary)
+qint64 QWebSocket::doWriteData(const QByteArray &data, bool isBinary)
 {
 	return doWriteFrames(data, isBinary);
 }
@@ -477,7 +477,7 @@ qint64 WebSocket::doWriteData(const QByteArray &data, bool isBinary)
 /*!
  * \internal
  */
-void WebSocket::makeConnections(const QTcpSocket *pTcpSocket)
+void QWebSocket::makeConnections(const QTcpSocket *pTcpSocket)
 {
 	//pass through signals
 	connect(pTcpSocket, SIGNAL(error(QAbstractSocket::SocketError)), this, SIGNAL(error(QAbstractSocket::SocketError)));
@@ -490,18 +490,18 @@ void WebSocket::makeConnections(const QTcpSocket *pTcpSocket)
 	connect(pTcpSocket, SIGNAL(stateChanged(QAbstractSocket::SocketState)), this, SLOT(processStateChanged(QAbstractSocket::SocketState)));
 	connect(pTcpSocket, SIGNAL(readyRead()), this, SLOT(processData()));
 
-	connect(&m_dataProcessor, SIGNAL(controlFrameReceived(WebSocketProtocol::OpCode, QByteArray)), this, SLOT(processControlFrame(WebSocketProtocol::OpCode, QByteArray)));
+	connect(&m_dataProcessor, SIGNAL(controlFrameReceived(QWebSocketProtocol::OpCode, QByteArray)), this, SLOT(processControlFrame(QWebSocketProtocol::OpCode, QByteArray)));
 	connect(&m_dataProcessor, SIGNAL(textFrameReceived(QString,bool)), this, SIGNAL(textFrameReceived(QString,bool)));
 	connect(&m_dataProcessor, SIGNAL(binaryFrameReceived(QByteArray,bool)), this, SIGNAL(binaryFrameReceived(QByteArray,bool)));
 	connect(&m_dataProcessor, SIGNAL(binaryMessageReceived(QByteArray)), this, SIGNAL(binaryMessageReceived(QByteArray)));
 	connect(&m_dataProcessor, SIGNAL(textMessageReceived(QString)), this, SIGNAL(textMessageReceived(QString)));
-	connect(&m_dataProcessor, SIGNAL(errorEncountered(WebSocketProtocol::CloseCode,QString)), this, SLOT(close(WebSocketProtocol::CloseCode,QString)));
+	connect(&m_dataProcessor, SIGNAL(errorEncountered(QWebSocketProtocol::CloseCode,QString)), this, SLOT(close(QWebSocketProtocol::CloseCode,QString)));
 }
 
 /*!
  * \internal
  */
-void WebSocket::releaseConnections(const QTcpSocket *pTcpSocket)
+void QWebSocket::releaseConnections(const QTcpSocket *pTcpSocket)
 {
 	if (pTcpSocket)
 	{
@@ -516,18 +516,18 @@ void WebSocket::releaseConnections(const QTcpSocket *pTcpSocket)
 		disconnect(pTcpSocket, SIGNAL(stateChanged(QAbstractSocket::SocketState)), this, SLOT(processStateChanged(QAbstractSocket::SocketState)));
 		disconnect(pTcpSocket, SIGNAL(readyRead()), this, SLOT(processData()));
 	}
-	disconnect(&m_dataProcessor, SIGNAL(controlFrameReceived(WebSocketProtocol::OpCode,QByteArray)), this, SLOT(processControlFrame(WebSocketProtocol::OpCode,QByteArray)));
+	disconnect(&m_dataProcessor, SIGNAL(controlFrameReceived(QWebSocketProtocol::OpCode,QByteArray)), this, SLOT(processControlFrame(QWebSocketProtocol::OpCode,QByteArray)));
 	disconnect(&m_dataProcessor, SIGNAL(textFrameReceived(QString,bool)), this, SIGNAL(textFrameReceived(QString,bool)));
 	disconnect(&m_dataProcessor, SIGNAL(binaryFrameReceived(QByteArray,bool)), this, SIGNAL(binaryFrameReceived(QByteArray,bool)));
 	disconnect(&m_dataProcessor, SIGNAL(binaryMessageReceived(QByteArray)), this, SIGNAL(binaryMessageReceived(QByteArray)));
 	disconnect(&m_dataProcessor, SIGNAL(textMessageReceived(QString)), this, SIGNAL(textMessageReceived(QString)));
-	disconnect(&m_dataProcessor, SIGNAL(errorEncountered(WebSocketProtocol::CloseCode,QString)), this, SLOT(close(WebSocketProtocol::CloseCode,QString)));
+	disconnect(&m_dataProcessor, SIGNAL(errorEncountered(QWebSocketProtocol::CloseCode,QString)), this, SLOT(close(QWebSocketProtocol::CloseCode,QString)));
 }
 
 /*!
  * \brief Returns the version the socket is currently using
  */
-WebSocketProtocol::Version WebSocket::version()
+QWebSocketProtocol::Version QWebSocket::version()
 {
 	return m_version;
 }
@@ -535,7 +535,7 @@ WebSocketProtocol::Version WebSocket::version()
 /**
  * @brief Returns the name of the resource currently accessed.
  */
-QString WebSocket::resourceName()
+QString QWebSocket::resourceName()
 {
 	return m_resourceName;
 }
@@ -543,7 +543,7 @@ QString WebSocket::resourceName()
 /*!
  * \brief Returns the url the socket is connected to or will connect to.
  */
-QUrl WebSocket::requestUrl()
+QUrl QWebSocket::requestUrl()
 {
 	return m_requestUrl;
 }
@@ -551,7 +551,7 @@ QUrl WebSocket::requestUrl()
 /*!
   Returns the current origin
  */
-QString WebSocket::origin()
+QString QWebSocket::origin()
 {
 	return m_origin;
 }
@@ -559,7 +559,7 @@ QString WebSocket::origin()
 /*!
   Returns the currently used protocol.
  */
-QString WebSocket::protocol()
+QString QWebSocket::protocol()
 {
 	return m_protocol;
 }
@@ -567,7 +567,7 @@ QString WebSocket::protocol()
 /*!
   Returns the currently used extension.
  */
-QString WebSocket::extension()
+QString QWebSocket::extension()
 {
 	return m_extension;
 }
@@ -575,7 +575,7 @@ QString WebSocket::extension()
 /*!
  * \internal
  */
-QByteArray WebSocket::getFrameHeader(WebSocketProtocol::OpCode opCode, quint64 payloadLength, quint32 maskingKey, bool lastFrame) const
+QByteArray QWebSocket::getFrameHeader(QWebSocketProtocol::OpCode opCode, quint64 payloadLength, quint32 maskingKey, bool lastFrame) const
 {
 	QByteArray header;
 	quint8 byte = 0x00;
@@ -633,9 +633,9 @@ QByteArray WebSocket::getFrameHeader(WebSocketProtocol::OpCode opCode, quint64 p
 /*!
  * \internal
  */
-qint64 WebSocket::doWriteFrames(const QByteArray &data, bool isBinary)
+qint64 QWebSocket::doWriteFrames(const QByteArray &data, bool isBinary)
 {
-	const WebSocketProtocol::OpCode firstOpCode = isBinary ? WebSocketProtocol::OC_BINARY : WebSocketProtocol::OC_TEXT;
+	const QWebSocketProtocol::OpCode firstOpCode = isBinary ? QWebSocketProtocol::OC_BINARY : QWebSocketProtocol::OC_TEXT;
 
 	int numFrames = data.size() / FRAME_SIZE_IN_BYTES;
 	QByteArray tmpData(data);
@@ -667,7 +667,7 @@ qint64 WebSocket::doWriteFrames(const QByteArray &data, bool isBinary)
 		bool isFirstFrame = (i == 0);
 
 		quint64 size = qMin(bytesLeft, FRAME_SIZE_IN_BYTES);
-		WebSocketProtocol::OpCode opcode = isFirstFrame ? firstOpCode : WebSocketProtocol::OC_CONTINUE;
+		QWebSocketProtocol::OpCode opcode = isFirstFrame ? firstOpCode : QWebSocketProtocol::OC_CONTINUE;
 
 		//write header
 		bytesWritten += m_pSocket->write(getFrameHeader(opcode, size, maskingKey, isLastFrame));
@@ -678,7 +678,7 @@ qint64 WebSocket::doWriteFrames(const QByteArray &data, bool isBinary)
 			char *currentData = payload + currentPosition;
 			if (m_mustMask)
 			{
-				WebSocketProtocol::mask(currentData, size, maskingKey);
+				QWebSocketProtocol::mask(currentData, size, maskingKey);
 			}
 			qint64 written = m_pSocket->write(currentData, static_cast<qint64>(size));
 			if (written > 0)
@@ -710,7 +710,7 @@ qint64 WebSocket::doWriteFrames(const QByteArray &data, bool isBinary)
 /*!
  * \internal
  */
-quint32 WebSocket::generateRandomNumber() const
+quint32 QWebSocket::generateRandomNumber() const
 {
 	return static_cast<quint32>((static_cast<double>(qrand()) / RAND_MAX) * std::numeric_limits<quint32>::max());
 }
@@ -718,7 +718,7 @@ quint32 WebSocket::generateRandomNumber() const
 /*!
 	\internal
  */
-quint32 WebSocket::generateMaskingKey() const
+quint32 QWebSocket::generateMaskingKey() const
 {
 	return generateRandomNumber();
 }
@@ -726,7 +726,7 @@ quint32 WebSocket::generateMaskingKey() const
 /*!
 	\internal
  */
-QByteArray WebSocket::generateKey() const
+QByteArray QWebSocket::generateKey() const
 {
 	QByteArray key;
 
@@ -743,7 +743,7 @@ QByteArray WebSocket::generateKey() const
 /*!
 	\internal
  */
-QString WebSocket::calculateAcceptKey(const QString &key) const
+QString QWebSocket::calculateAcceptKey(const QString &key) const
 {
 	QString tmpKey = key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 	QByteArray hash = QCryptographicHash::hash(tmpKey.toLatin1(), QCryptographicHash::Sha1);
@@ -753,7 +753,7 @@ QString WebSocket::calculateAcceptKey(const QString &key) const
 /*!
 	\internal
  */
-qint64 WebSocket::writeFrames(const QList<QByteArray> &frames)
+qint64 QWebSocket::writeFrames(const QList<QByteArray> &frames)
 {
 	qint64 written = 0;
 	for (int i = 0; i < frames.size(); ++i)
@@ -766,7 +766,7 @@ qint64 WebSocket::writeFrames(const QList<QByteArray> &frames)
 /*!
 	\internal
  */
-qint64 WebSocket::writeFrame(const QByteArray &frame)
+qint64 QWebSocket::writeFrame(const QByteArray &frame)
 {
 	return m_pSocket->write(frame);
 }
@@ -797,7 +797,7 @@ QString readLine(QTcpSocket *pSocket)
 /*!
 	\internal
  */
-void WebSocket::processHandshake(QTcpSocket *pSocket)
+void QWebSocket::processHandshake(QTcpSocket *pSocket)
 {
 	if (pSocket == 0)
 	{
@@ -877,7 +877,7 @@ void WebSocket::processHandshake(QTcpSocket *pSocket)
 			if (!version.isEmpty())
 			{
 				QStringList versions = version.split(", ", QString::SkipEmptyParts);
-				if (!versions.contains(QString::number(WebSocketProtocol::currentVersion())))
+				if (!versions.contains(QString::number(QWebSocketProtocol::currentVersion())))
 				{
 					//if needed to switch protocol version, then we are finished here
 					//because we cannot handle other protocols than the RFC one (v13)
@@ -916,7 +916,7 @@ void WebSocket::processHandshake(QTcpSocket *pSocket)
 /*!
 	\internal
  */
-void WebSocket::processStateChanged(QAbstractSocket::SocketState socketState)
+void QWebSocket::processStateChanged(QAbstractSocket::SocketState socketState)
 {
 	QAbstractSocket::SocketState webSocketState = this->state();
 	switch (socketState)
@@ -976,7 +976,7 @@ void WebSocket::processStateChanged(QAbstractSocket::SocketState socketState)
 /*!
  \internal
  */
-void WebSocket::processData()
+void QWebSocket::processData()
 {
 	while (m_pSocket->bytesAvailable())
 	{
@@ -994,43 +994,43 @@ void WebSocket::processData()
 /*!
 	\internal
  */
-void WebSocket::processControlFrame(WebSocketProtocol::OpCode opCode, QByteArray frame)
+void QWebSocket::processControlFrame(QWebSocketProtocol::OpCode opCode, QByteArray frame)
 {
 	switch (opCode)
 	{
-		case WebSocketProtocol::OC_PING:
+		case QWebSocketProtocol::OC_PING:
 		{
 			quint32 maskingKey = 0;
 			if (m_mustMask)
 			{
 				maskingKey = generateMaskingKey();
 			}
-			m_pSocket->write(getFrameHeader(WebSocketProtocol::OC_PONG, frame.size(), maskingKey, true));
+			m_pSocket->write(getFrameHeader(QWebSocketProtocol::OC_PONG, frame.size(), maskingKey, true));
 			if (frame.size() > 0)
 			{
 				if (m_mustMask)
 				{
-					WebSocketProtocol::mask(&frame, maskingKey);
+					QWebSocketProtocol::mask(&frame, maskingKey);
 				}
 				m_pSocket->write(frame);
 			}
 			break;
 		}
-		case WebSocketProtocol::OC_PONG:
+		case QWebSocketProtocol::OC_PONG:
 		{
 			Q_EMIT pong(static_cast<quint64>(m_pingTimer.elapsed()));
 			break;
 		}
-		case WebSocketProtocol::OC_CLOSE:
+		case QWebSocketProtocol::OC_CLOSE:
 		{
-			quint16 closeCode = WebSocketProtocol::CC_NORMAL;
+			quint16 closeCode = QWebSocketProtocol::CC_NORMAL;
 			QString closeReason;
 			if (frame.size() > 0)   //close frame can have a close code and reason
 			{
 				closeCode = qFromBigEndian<quint16>(reinterpret_cast<const uchar *>(frame.constData()));
-				if (!WebSocketProtocol::isCloseCodeValid(closeCode))
+				if (!QWebSocketProtocol::isCloseCodeValid(closeCode))
 				{
-					closeCode = WebSocketProtocol::CC_PROTOCOL_ERROR;
+					closeCode = QWebSocketProtocol::CC_PROTOCOL_ERROR;
 					closeReason = QString("Invalid close code %1 detected").arg(closeCode);
 				}
 				else
@@ -1043,29 +1043,29 @@ void WebSocket::processControlFrame(WebSocketProtocol::OpCode opCode, QByteArray
 						bool failed = (state.invalidChars != 0) || (state.remainingChars != 0);
 						if (failed)
 						{
-							closeCode = WebSocketProtocol::CC_WRONG_DATATYPE;
+							closeCode = QWebSocketProtocol::CC_WRONG_DATATYPE;
 							closeReason = "Invalid UTF-8 code encountered.";
 						}
 					}
 				}
 			}
 			m_isClosingHandshakeReceived = true;
-			close(static_cast<WebSocketProtocol::CloseCode>(closeCode), closeReason);
+			close(static_cast<QWebSocketProtocol::CloseCode>(closeCode), closeReason);
 			break;
 		}
-		case WebSocketProtocol::OC_CONTINUE:
-		case WebSocketProtocol::OC_BINARY:
-		case WebSocketProtocol::OC_TEXT:
-		case WebSocketProtocol::OC_RESERVED_3:
-		case WebSocketProtocol::OC_RESERVED_4:
-		case WebSocketProtocol::OC_RESERVED_5:
-		case WebSocketProtocol::OC_RESERVED_6:
-		case WebSocketProtocol::OC_RESERVED_7:
-		case WebSocketProtocol::OC_RESERVED_B:
-		case WebSocketProtocol::OC_RESERVED_D:
-		case WebSocketProtocol::OC_RESERVED_E:
-		case WebSocketProtocol::OC_RESERVED_F:
-		case WebSocketProtocol::OC_RESERVED_V:
+		case QWebSocketProtocol::OC_CONTINUE:
+		case QWebSocketProtocol::OC_BINARY:
+		case QWebSocketProtocol::OC_TEXT:
+		case QWebSocketProtocol::OC_RESERVED_3:
+		case QWebSocketProtocol::OC_RESERVED_4:
+		case QWebSocketProtocol::OC_RESERVED_5:
+		case QWebSocketProtocol::OC_RESERVED_6:
+		case QWebSocketProtocol::OC_RESERVED_7:
+		case QWebSocketProtocol::OC_RESERVED_B:
+		case QWebSocketProtocol::OC_RESERVED_D:
+		case QWebSocketProtocol::OC_RESERVED_E:
+		case QWebSocketProtocol::OC_RESERVED_F:
+		case QWebSocketProtocol::OC_RESERVED_V:
 		{
 			//do nothing
 			//case added to make C++ compiler happy
@@ -1083,7 +1083,7 @@ void WebSocket::processControlFrame(WebSocketProtocol::OpCode opCode, QByteArray
 /*!
 	\internal
  */
-QString WebSocket::createHandShakeRequest(QString resourceName,
+QString QWebSocket::createHandShakeRequest(QString resourceName,
 										  QString host,
 										  QString origin,
 										  QString extensions,
@@ -1101,7 +1101,7 @@ QString WebSocket::createHandShakeRequest(QString resourceName,
 	{
 		handshakeRequest << "Origin: " + origin;
 	}
-	handshakeRequest << "Sec-WebSocket-Version: " + QString::number(WebSocketProtocol::currentVersion());
+	handshakeRequest << "Sec-WebSocket-Version: " + QString::number(QWebSocketProtocol::currentVersion());
 	if (extensions.length() > 0)
 	{
 		handshakeRequest << "Sec-WebSocket-Extensions: " + extensions;
@@ -1118,7 +1118,7 @@ QString WebSocket::createHandShakeRequest(QString resourceName,
 /*!
   Returns the current state of the socket
  */
-QAbstractSocket::SocketState WebSocket::state() const
+QAbstractSocket::SocketState QWebSocket::state() const
 {
 	return m_socketState;
 }
@@ -1143,7 +1143,7 @@ QAbstractSocket::SocketState WebSocket::state() const
 
 	\sa connected(), open(), state()
  */
-bool WebSocket::waitForConnected(int msecs)
+bool QWebSocket::waitForConnected(int msecs)
 {
 	bool retVal = false;
 	if (m_pSocket)
@@ -1162,7 +1162,7 @@ bool WebSocket::waitForConnected(int msecs)
 
   \sa close(), state()
 */
-bool WebSocket::waitForDisconnected(int msecs)
+bool QWebSocket::waitForDisconnected(int msecs)
 {
 	bool retVal = true;
 	if (m_pSocket)
@@ -1176,7 +1176,7 @@ bool WebSocket::waitForDisconnected(int msecs)
  \internal
  Sets the internal socket state
 */
-void WebSocket::setSocketState(QAbstractSocket::SocketState state)
+void QWebSocket::setSocketState(QAbstractSocket::SocketState state)
 {
 	if (m_socketState != state)
 	{
@@ -1190,7 +1190,7 @@ void WebSocket::setSocketState(QAbstractSocket::SocketState state)
   Sets the error string.
   Only used internally.
 */
-void WebSocket::setErrorString(QString errorString)
+void QWebSocket::setErrorString(QString errorString)
 {
 	m_errorString = errorString;
 }
@@ -1198,7 +1198,7 @@ void WebSocket::setErrorString(QString errorString)
 /*!
   Returns the local address
  */
-QHostAddress WebSocket::localAddress() const
+QHostAddress QWebSocket::localAddress() const
 {
 	QHostAddress address;
 	if (m_pSocket)
@@ -1211,7 +1211,7 @@ QHostAddress WebSocket::localAddress() const
 /*!
   Returns the local port
  */
-quint16 WebSocket::localPort() const
+quint16 QWebSocket::localPort() const
 {
 	quint16 port = 0;
 	if (m_pSocket)
@@ -1224,7 +1224,7 @@ quint16 WebSocket::localPort() const
 /*!
   Returns the peer address
  */
-QHostAddress WebSocket::peerAddress() const
+QHostAddress QWebSocket::peerAddress() const
 {
 	QHostAddress peer;
 	if (m_pSocket)
@@ -1237,7 +1237,7 @@ QHostAddress WebSocket::peerAddress() const
 /*!
   Returns the peerName
  */
-QString WebSocket::peerName() const
+QString QWebSocket::peerName() const
 {
 	QString name;
 	if (m_pSocket)
@@ -1250,7 +1250,7 @@ QString WebSocket::peerName() const
 /*!
   Returns the peerport
  */
-quint16 WebSocket::peerPort() const
+quint16 QWebSocket::peerPort() const
 {
 	quint16 port = 0;
 	if (m_pSocket)
@@ -1263,7 +1263,7 @@ quint16 WebSocket::peerPort() const
 /*!
   * Returns the currently configured proxy
  */
-QNetworkProxy WebSocket::proxy() const
+QNetworkProxy QWebSocket::proxy() const
 {
 	QNetworkProxy proxy;
 	if (m_pSocket)
@@ -1276,7 +1276,7 @@ QNetworkProxy WebSocket::proxy() const
 /*!
  * Returns the size in bytes of the readbuffer that is used by the socket.
  */
-qint64 WebSocket::readBufferSize() const
+qint64 QWebSocket::readBufferSize() const
 {
 	qint64 readBuffer = 0;
 	if (m_pSocket)
@@ -1289,7 +1289,7 @@ qint64 WebSocket::readBufferSize() const
 /*!
   Sets the proxy to \a networkProxy
  */
-void WebSocket::setProxy(const QNetworkProxy &networkProxy)
+void QWebSocket::setProxy(const QNetworkProxy &networkProxy)
 {
 	if (m_pSocket)
 	{
@@ -1304,7 +1304,7 @@ void WebSocket::setProxy(const QNetworkProxy &networkProxy)
 	This option is useful if you only read the data at certain points in time (e.g., in a real-time streaming application) or if you want to protect your socket against receiving too much data, which may eventually cause your application to run out of memory.
 	\sa readBufferSize() and read().
 */
-void WebSocket::setReadBufferSize(qint64 size)
+void QWebSocket::setReadBufferSize(qint64 size)
 {
 	if (m_pSocket)
 	{
@@ -1316,7 +1316,7 @@ void WebSocket::setReadBufferSize(qint64 size)
 	Sets the given \a option to the value described by \a value.
 	\sa socketOption().
 */
-void WebSocket::setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value)
+void QWebSocket::setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value)
 {
 	if (m_pSocket)
 	{
@@ -1328,7 +1328,7 @@ void WebSocket::setSocketOption(QAbstractSocket::SocketOption option, const QVar
 	Returns the value of the option \a option.
 	\sa setSocketOption().
 */
-QVariant WebSocket::socketOption(QAbstractSocket::SocketOption option)
+QVariant QWebSocket::socketOption(QAbstractSocket::SocketOption option)
 {
 	QVariant result;
 	if (m_pSocket)
@@ -1341,7 +1341,7 @@ QVariant WebSocket::socketOption(QAbstractSocket::SocketOption option)
 /*!
   Returns true if the WebSocket is valid.
  */
-bool WebSocket::isValid()
+bool QWebSocket::isValid()
 {
 	bool valid = false;
 	if (m_pSocket)
diff --git a/source/websocket.h b/source/qwebsocket.h
index 10e9676..8a861b7 100644
--- a/source/websocket.h
+++ b/source/qwebsocket.h
@@ -8,13 +8,13 @@
  * @author Kurt Pattyn (pattyn.kurt@gmail.com)
  */
 
-#ifndef WEBSOCKET_H
-#define WEBSOCKET_H
+#ifndef QWEBSOCKET_H
+#define QWEBSOCKET_H
 
 #include <QUrl>
 #include <QAbstractSocket>
 #include <QHostAddress>
-#include "websocketprotocol.h"
+#include "qwebsocketprotocol.h"
 #include "dataprocessor_p.h"
 #include <QNetworkProxy>
 #include <QTime>
@@ -23,13 +23,13 @@ class HandshakeRequest;
 class HandshakeResponse;
 class QTcpSocket;
 
-class WebSocket:public QObject
+class QWebSocket:public QObject
 {
 	Q_OBJECT
 
 public:
-	explicit WebSocket(QString origin = QString(), WebSocketProtocol::Version version = WebSocketProtocol::V_LATEST, QObject *parent = 0);
-	virtual ~WebSocket();
+	explicit QWebSocket(QString origin = QString(), QWebSocketProtocol::Version version = QWebSocketProtocol::V_LATEST, QObject *parent = 0);
+	virtual ~QWebSocket();
 
 	void abort();
 	QAbstractSocket::SocketError error() const;
@@ -52,7 +52,7 @@ public:
 	bool waitForConnected(int msecs = 30000);
 	bool waitForDisconnected(int msecs = 30000);
 
-	WebSocketProtocol::Version version();
+	QWebSocketProtocol::Version version();
 	QString resourceName();
 	QUrl requestUrl();
 	QString origin();
@@ -64,7 +64,7 @@ public:
 	qint64 send(const QByteArray &data);	//send data as binary
 
 public Q_SLOTS:
-	virtual void close(WebSocketProtocol::CloseCode closeCode = WebSocketProtocol::CC_NORMAL, QString reason = QString());
+	virtual void close(QWebSocketProtocol::CloseCode closeCode = QWebSocketProtocol::CC_NORMAL, QString reason = QString());
 	virtual void open(const QUrl &url, bool mask = true);
 	void ping();
 
@@ -84,15 +84,15 @@ Q_SIGNALS:
 
 private Q_SLOTS:
 	void processData();
-	void processControlFrame(WebSocketProtocol::OpCode opCode, QByteArray frame);
+	void processControlFrame(QWebSocketProtocol::OpCode opCode, QByteArray frame);
 	void processHandshake(QTcpSocket *pSocket);
 	void processStateChanged(QAbstractSocket::SocketState socketState);
 
 private:
-	Q_DISABLE_COPY(WebSocket)
+	Q_DISABLE_COPY(QWebSocket)
 
-	WebSocket(QTcpSocket *pTcpSocket, WebSocketProtocol::Version version, QObject *parent = 0);
-	void setVersion(WebSocketProtocol::Version version);
+	QWebSocket(QTcpSocket *pTcpSocket, QWebSocketProtocol::Version version, QObject *parent = 0);
+	void setVersion(QWebSocketProtocol::Version version);
 	void setResourceName(QString resourceName);
 	void setRequestUrl(QUrl requestUrl);
 	void setOrigin(QString origin);
@@ -108,7 +108,7 @@ private:
 	void makeConnections(const QTcpSocket *pTcpSocket);
 	void releaseConnections(const QTcpSocket *pTcpSocket);
 
-	QByteArray getFrameHeader(WebSocketProtocol::OpCode opCode, quint64 payloadLength, quint32 maskingKey, bool lastFrame) const;
+	QByteArray getFrameHeader(QWebSocketProtocol::OpCode opCode, quint64 payloadLength, quint32 maskingKey, bool lastFrame) const;
 	QString calculateAcceptKey(const QString &key) const;
 	QString createHandShakeRequest(QString resourceName,
 								   QString host,
@@ -123,15 +123,15 @@ private:
 	qint64 writeFrames(const QList<QByteArray> &frames);
 	qint64 writeFrame(const QByteArray &frame);
 
-	static WebSocket *upgradeFrom(QTcpSocket *tcpSocket,
+	static QWebSocket *upgradeFrom(QTcpSocket *tcpSocket,
 								  const HandshakeRequest &request,
 								  const HandshakeResponse &response,
 								  QObject *parent = 0);
-	friend class WebSocketServer;
+	friend class QWebSocketServer;
 
 	QTcpSocket *m_pSocket;
 	QString m_errorString;
-	WebSocketProtocol::Version m_version;
+	QWebSocketProtocol::Version m_version;
 	QUrl m_resource;
 	QString m_resourceName;
 	QUrl m_requestUrl;
@@ -152,4 +152,4 @@ private:
 	DataProcessor m_dataProcessor;
 };
 
-#endif // WEBSOCKET_H
+#endif // QWEBSOCKET_H
diff --git a/source/websocketprotocol.cpp b/source/qwebsocketprotocol.cpp
index 269c1cb..44694dc 100644
--- a/source/websocketprotocol.cpp
+++ b/source/qwebsocketprotocol.cpp
@@ -1,4 +1,4 @@
-#include "websocketprotocol.h"
+#include "qwebsocketprotocol.h"
 #include <QString>
 #include <QSet>
 #include <QtEndian>
@@ -142,7 +142,7 @@
 /**
  * @brief Contains constants related to the WebSocket standard.
  */
-namespace WebSocketProtocol
+namespace QWebSocketProtocol
 {
 	/*!
 		Parses the \a versionString and converts it to a Version value
diff --git a/source/websocketprotocol.h b/source/qwebsocketprotocol.h
index ba385c5..a2f39f1 100644
--- a/source/websocketprotocol.h
+++ b/source/qwebsocketprotocol.h
@@ -3,14 +3,14 @@
  * @brief Contains constants related to the WebSocket standard.
  * @author Kurt Pattyn (pattyn.kurt@gmail.com)
  */
-#ifndef WEBSOCKETPROTOCOL_H
-#define WEBSOCKETPROTOCOL_H
+#ifndef QWEBSOCKETPROTOCOL_H
+#define QWEBSOCKETPROTOCOL_H
 
 class QString;
 class QByteArray;
 #include <qglobal.h>
 
-namespace WebSocketProtocol
+namespace QWebSocketProtocol
 {
 	enum Version
 	{
@@ -84,6 +84,6 @@ namespace WebSocketProtocol
 
 	inline Version currentVersion() { return V_LATEST; }
 
-}	//end namespace WebSocketProtocol
+}	//end namespace QWebSocketProtocol
 
-#endif // WEBSOCKETPROTOCOL_H
+#endif // QWEBSOCKETPROTOCOL_H
diff --git a/source/websocketserver.cpp b/source/qwebsocketserver.cpp
index b9308e5..9866cef 100644
--- a/source/websocketserver.cpp
+++ b/source/qwebsocketserver.cpp
@@ -1,11 +1,11 @@
-#include "websocketserver.h"
+#include "qwebsocketserver.h"
 #include <QTcpServer>
 #include <QTcpSocket>
 #include <QNetworkProxy>
-#include "websocketprotocol.h"
+#include "qwebsocketprotocol.h"
 #include "handshakerequest_p.h"
 #include "handshakeresponse_p.h"
-#include "websocket.h"
+#include "qwebsocket.h"
 
 /*!
 	\class WebSocketServer
@@ -72,7 +72,7 @@
 
 	\a parent is passed to the QObject constructor.
  */
-WebSocketServer::WebSocketServer(const QString &serverName, QObject *parent) :
+QWebSocketServer::QWebSocketServer(const QString &serverName, QObject *parent) :
 	QObject(parent),
 	m_pTcpServer(0),
 	m_serverName(serverName),
@@ -88,12 +88,12 @@ WebSocketServer::WebSocketServer(const QString &serverName, QObject *parent) :
 
 	\sa close()
  */
-WebSocketServer::~WebSocketServer()
+QWebSocketServer::~QWebSocketServer()
 {
 	while (!m_pendingConnections.isEmpty())
 	{
-		WebSocket *pWebSocket = m_pendingConnections.dequeue();
-		pWebSocket->close(WebSocketProtocol::CC_GOING_AWAY, "Server closed.");
+		QWebSocket *pWebSocket = m_pendingConnections.dequeue();
+		pWebSocket->close(QWebSocketProtocol::CC_GOING_AWAY, "Server closed.");
 		pWebSocket->deleteLater();
 	}
 	m_pTcpServer->deleteLater();
@@ -102,7 +102,7 @@ WebSocketServer::~WebSocketServer()
 /*!
   Closes the server. The server will no longer listen for incoming connections.
  */
-void WebSocketServer::close()
+void QWebSocketServer::close()
 {
 	m_pTcpServer->close();
 }
@@ -112,7 +112,7 @@ void WebSocketServer::close()
 
 	\sa serverError().
 */
-QString WebSocketServer::errorString() const
+QString QWebSocketServer::errorString() const
 {
 	return m_pTcpServer->errorString();
 }
@@ -122,7 +122,7 @@ QString WebSocketServer::errorString() const
 
 	\sa nextPendingConnection() and setMaxPendingConnections().
  */
-bool WebSocketServer::hasPendingConnections() const
+bool QWebSocketServer::hasPendingConnections() const
 {
 	return !m_pendingConnections.isEmpty();
 }
@@ -132,7 +132,7 @@ bool WebSocketServer::hasPendingConnections() const
 
 	\sa listen().
  */
-bool WebSocketServer::isListening() const
+bool QWebSocketServer::isListening() const
 {
 	return m_pTcpServer->isListening();
 }
@@ -146,7 +146,7 @@ bool WebSocketServer::isListening() const
 
 	\sa isListening().
  */
-bool WebSocketServer::listen(const QHostAddress &address, quint16 port)
+bool QWebSocketServer::listen(const QHostAddress &address, quint16 port)
 {
 	return m_pTcpServer->listen(address, port);
 }
@@ -156,7 +156,7 @@ bool WebSocketServer::listen(const QHostAddress &address, quint16 port)
 
 	\sa setMaxPendingConnections() and hasPendingConnections().
  */
-int WebSocketServer::maxPendingConnections() const
+int QWebSocketServer::maxPendingConnections() const
 {
 	return m_pTcpServer->maxPendingConnections();
 }
@@ -166,7 +166,7 @@ int WebSocketServer::maxPendingConnections() const
 
 	\sa nextPendingConnection() and hasPendingConnections()
 */
-void WebSocketServer::addPendingConnection(WebSocket *pWebSocket)
+void QWebSocketServer::addPendingConnection(QWebSocket *pWebSocket)
 {
 	if (m_pendingConnections.size() < maxPendingConnections())
 	{
@@ -183,9 +183,9 @@ void WebSocketServer::addPendingConnection(WebSocket *pWebSocket)
 
 	\sa hasPendingConnections().
 */
-WebSocket *WebSocketServer::nextPendingConnection()
+QWebSocket *QWebSocketServer::nextPendingConnection()
 {
-	WebSocket *pWebSocket = 0;
+	QWebSocket *pWebSocket = 0;
 	if (!m_pendingConnections.isEmpty())
 	{
 		pWebSocket = m_pendingConnections.dequeue();
@@ -198,7 +198,7 @@ WebSocket *WebSocketServer::nextPendingConnection()
 
 	\sa setProxy().
 */
-QNetworkProxy WebSocketServer::proxy() const
+QNetworkProxy QWebSocketServer::proxy() const
 {
 	return m_pTcpServer->proxy();
 }
@@ -208,7 +208,7 @@ QNetworkProxy WebSocketServer::proxy() const
 
 	\sa serverPort() and listen().
  */
-QHostAddress WebSocketServer::serverAddress() const
+QHostAddress QWebSocketServer::serverAddress() const
 {
 	return m_pTcpServer->serverAddress();
 }
@@ -217,7 +217,7 @@ QHostAddress WebSocketServer::serverAddress() const
 	Returns an error code for the last error that occurred.
 	\sa errorString().
  */
-QAbstractSocket::SocketError WebSocketServer::serverError() const
+QAbstractSocket::SocketError QWebSocketServer::serverError() const
 {
 	return m_pTcpServer->serverError();
 }
@@ -226,7 +226,7 @@ QAbstractSocket::SocketError WebSocketServer::serverError() const
 	Returns the server's port if the server is listening for connections; otherwise returns 0.
 	\sa serverAddress() and listen().
  */
-quint16 WebSocketServer::serverPort() const
+quint16 QWebSocketServer::serverPort() const
 {
 	return m_pTcpServer->serverPort();
 }
@@ -239,7 +239,7 @@ quint16 WebSocketServer::serverPort() const
 	Clients may still able to connect after the server has reached its maximum number of pending connections (i.e., WebSocket can still emit the connected() signal). WebSocketServer will stop accepting the new connections, but the operating system may still keep them in queue.
 	\sa maxPendingConnections() and hasPendingConnections().
  */
-void WebSocketServer::setMaxPendingConnections(int numConnections)
+void QWebSocketServer::setMaxPendingConnections(int numConnections)
 {
 	m_pTcpServer->setMaxPendingConnections(numConnections);
 }
@@ -255,7 +255,7 @@ void WebSocketServer::setMaxPendingConnections(int numConnections)
 
 	\sa proxy().
 */
-void WebSocketServer::setProxy(const QNetworkProxy &networkProxy)
+void QWebSocketServer::setProxy(const QNetworkProxy &networkProxy)
 {
 	m_pTcpServer->setProxy(networkProxy);
 }
@@ -268,7 +268,7 @@ void WebSocketServer::setProxy(const QNetworkProxy &networkProxy)
 
 	\sa socketDescriptor() and isListening().
  */
-bool WebSocketServer::setSocketDescriptor(int socketDescriptor)
+bool QWebSocketServer::setSocketDescriptor(int socketDescriptor)
 {
 	return m_pTcpServer->setSocketDescriptor(socketDescriptor);
 }
@@ -279,7 +279,7 @@ bool WebSocketServer::setSocketDescriptor(int socketDescriptor)
 
 	\sa setSocketDescriptor() and isListening().
  */
-int WebSocketServer::socketDescriptor() const
+int QWebSocketServer::socketDescriptor() const
 {
 	return m_pTcpServer->socketDescriptor();
 }
@@ -297,7 +297,7 @@ int WebSocketServer::socketDescriptor() const
 
 	\sa hasPendingConnections() and nextPendingConnection().
 */
-bool WebSocketServer::waitForNewConnection(int msec, bool *timedOut)
+bool QWebSocketServer::waitForNewConnection(int msec, bool *timedOut)
 {
 	return m_pTcpServer->waitForNewConnection(msec, timedOut);
 }
@@ -305,17 +305,17 @@ bool WebSocketServer::waitForNewConnection(int msec, bool *timedOut)
 /*!
   Returns a list of websocket versions that this server is supporting.
  */
-QList<WebSocketProtocol::Version> WebSocketServer::supportedVersions() const
+QList<QWebSocketProtocol::Version> QWebSocketServer::supportedVersions() const
 {
-	QList<WebSocketProtocol::Version> supportedVersions;
-	supportedVersions << WebSocketProtocol::currentVersion();	//we only support V13
+	QList<QWebSocketProtocol::Version> supportedVersions;
+	supportedVersions << QWebSocketProtocol::currentVersion();	//we only support V13
 	return supportedVersions;
 }
 
 /*!
   Returns a list of websocket subprotocols that this server supports.
  */
-QList<QString> WebSocketServer::supportedProtocols() const
+QList<QString> QWebSocketServer::supportedProtocols() const
 {
 	QList<QString> supportedProtocols;
 	return supportedProtocols;	//no protocols are currently supported
@@ -324,7 +324,7 @@ QList<QString> WebSocketServer::supportedProtocols() const
 /*!
   Returns a list of websocket extensions that this server supports.
  */
-QList<QString> WebSocketServer::supportedExtensions() const
+QList<QString> QWebSocketServer::supportedExtensions() const
 {
 	QList<QString> supportedExtensions;
 	return supportedExtensions;	//no extensions are currently supported
@@ -334,19 +334,19 @@ QList<QString> WebSocketServer::supportedExtensions() const
 //via a non-browser client, as that client can set whatever origin header it likes
 //In case of a browser client, the server SHOULD check the validity of the origin
 //see http://tools.ietf.org/html/rfc6455#section-10
-bool WebSocketServer::isOriginAllowed(const QString &origin) const
+bool QWebSocketServer::isOriginAllowed(const QString &origin) const
 {
 	Q_UNUSED(origin)
 	return true;
 }
 
-void WebSocketServer::onNewConnection()
+void QWebSocketServer::onNewConnection()
 {
 	QTcpSocket *pTcpSocket = m_pTcpServer->nextPendingConnection();
 	connect(pTcpSocket, SIGNAL(readyRead()), this, SLOT(handshakeReceived()));
 }
 
-void WebSocketServer::onCloseConnection()
+void QWebSocketServer::onCloseConnection()
 {
 	QTcpSocket *pTcpSocket = qobject_cast<QTcpSocket*>(sender());
 	if (pTcpSocket != 0)
@@ -355,7 +355,7 @@ void WebSocketServer::onCloseConnection()
 	}
 }
 
-void WebSocketServer::handshakeReceived()
+void QWebSocketServer::handshakeReceived()
 {
 	QTcpSocket *pTcpSocket = qobject_cast<QTcpSocket*>(sender());
 	if (pTcpSocket != 0)
@@ -382,7 +382,7 @@ void WebSocketServer::handshakeReceived()
 
 			if (response.canUpgrade())
 			{
-				WebSocket *pWebSocket = WebSocket::upgradeFrom(pTcpSocket, request, response);
+				QWebSocket *pWebSocket = QWebSocket::upgradeFrom(pTcpSocket, request, response);
 				if (pWebSocket)
 				{
 					pWebSocket->setParent(this);
diff --git a/source/websocketserver.h b/source/qwebsocketserver.h
index 0401050..136c839 100644
--- a/source/websocketserver.h
+++ b/source/qwebsocketserver.h
@@ -4,24 +4,24 @@
  * @brief Defines the WebSocketServer class.
  */
 
-#ifndef WEBSOCKETSERVER_H
-#define WEBSOCKETSERVER_H
+#ifndef QWEBSOCKETSERVER_H
+#define QWEBSOCKETSERVER_H
 
 #include <QObject>
 #include <QQueue>
 #include <QString>
 #include <QHostAddress>
-#include "websocket.h"
+#include "qwebsocket.h"
 
 class QTcpServer;
 
-class WebSocketServer : public QObject
+class QWebSocketServer : public QObject
 {
 	Q_OBJECT
 
 public:
-	explicit WebSocketServer(const QString &serverName, QObject *parent = 0);
-	virtual ~WebSocketServer();
+	explicit QWebSocketServer(const QString &serverName, QObject *parent = 0);
+	virtual ~QWebSocketServer();
 
 	void close();
 	QString errorString() const;
@@ -29,7 +29,7 @@ public:
 	bool isListening() const;
 	bool listen(const QHostAddress &address = QHostAddress::Any, quint16 port = 0);
 	int maxPendingConnections() const;
-	virtual WebSocket *nextPendingConnection();
+	virtual QWebSocket *nextPendingConnection();
 	QNetworkProxy proxy() const;
 	QHostAddress serverAddress() const;
 	QAbstractSocket::SocketError serverError() const;
@@ -40,7 +40,7 @@ public:
 	int socketDescriptor() const;
 	bool waitForNewConnection(int msec = 0, bool *timedOut = 0);
 
-	QList<WebSocketProtocol::Version> supportedVersions() const;
+	QList<QWebSocketProtocol::Version> supportedVersions() const;
 	QList<QString> supportedProtocols() const;
 	QList<QString> supportedExtensions() const;
 
@@ -56,13 +56,13 @@ private Q_SLOTS:
 	void handshakeReceived();
 
 private:
-	Q_DISABLE_COPY(WebSocketServer)
+	Q_DISABLE_COPY(QWebSocketServer)
 
 	QTcpServer *m_pTcpServer;
 	QString m_serverName;
-	QQueue<WebSocket *> m_pendingConnections;
+	QQueue<QWebSocket *> m_pendingConnections;
 
-	void addPendingConnection(WebSocket *pWebSocket);
+	void addPendingConnection(QWebSocket *pWebSocket);
 };
 
-#endif // WEBSOCKETSERVER_H
+#endif // QWEBSOCKETSERVER_H
diff --git a/source/qwebsocketsglobal.h b/source/qwebsocketsglobal.h
new file mode 100644
index 0000000..822f41b
--- /dev/null
+++ b/source/qwebsocketsglobal.h
@@ -0,0 +1,24 @@
+#ifndef QWEBSOCKETSGLOBAL_H
+#define QWEBSOCKETSGLOBAL_H
+
+#include <QtCore/qglobal.h>
+
+QT_BEGIN_NAMESPACE
+
+#ifndef QT_STATIC
+#  if defined(QT_BUILD_SERIALPORT_LIB)
+#    define Q_WEBSOCKETS_EXPORT Q_DECL_EXPORT
+#  else
+#    define Q_WEBSOCKETS_EXPORT Q_DECL_IMPORT
+#  endif
+#else
+#  define Q_WEBSOCKETS_EXPORT
+#endif
+
+// The macro has been available only since Qt 5.0
+#ifndef Q_DECL_OVERRIDE
+#define Q_DECL_OVERRIDE
+#endif
+
+QT_END_NAMESPACE
+#endif // QWEBSOCKETSGLOBAL_H
diff --git a/source/websocket.pri b/source/websocket.pri
index f70a1d0..dc44611 100644
--- a/source/websocket.pri
+++ b/source/websocket.pri
@@ -1,18 +1,19 @@
 QT       *= network
 
-SOURCES += $$PWD/websocket.cpp \
-	$$PWD/websocketserver.cpp \
-	$$PWD/websocketprotocol.cpp \
+SOURCES += $$PWD/qwebsocket.cpp \
+	$$PWD/qwebsocketserver.cpp \
+	$$PWD/qwebsocketprotocol.cpp \
 	$$PWD/handshakerequest_p.cpp \
 	$$PWD/handshakeresponse_p.cpp \
 	$$PWD/dataprocessor_p.cpp
 
-HEADERS += $$PWD/websocket.h \
-	$$PWD/websocketserver.h \
-	$$PWD/websocketprotocol.h \
+HEADERS += $$PWD/qwebsocket.h \
+	$$PWD/qwebsocketserver.h \
+	$$PWD/qwebsocketprotocol.h \
 	$$PWD/handshakerequest_p.h \
 	$$PWD/handshakeresponse_p.h \
-	$$PWD/dataprocessor_p.h
+	$$PWD/dataprocessor_p.h \
+	$$PWD/qwebsocketsglobal.h
 
 INCLUDEPATH += $$PWD
 DEPENDPATH += $$PWD
diff --git a/test/tst_compliance.cpp b/test/tst_compliance.cpp
index 1992631..b450887 100644
--- a/test/tst_compliance.cpp
+++ b/test/tst_compliance.cpp
@@ -3,7 +3,7 @@
 #include <QSignalSpy>
 #include <QHostInfo>
 #include <QDebug>
-#include "websocket.h"
+#include "qwebsocket.h"
 #include "unittests.h"
 
 class ComplianceTest : public QObject
@@ -57,16 +57,16 @@ void ComplianceTest::runTestCase(int nbr, int total)
 	{
 		return;
 	}
-	WebSocket *pWebSocket = new WebSocket;
+	QWebSocket *pWebSocket = new QWebSocket;
 	QSignalSpy spy(pWebSocket, SIGNAL(disconnected()));
 
 	//next for every case, connect to url
 	//ws://ipaddress:port/runCase?case=<number>&agent=<agentname>
 	//where agent name will be QWebSocket
-	QObject::connect(pWebSocket, &WebSocket::textMessageReceived, [=](QString message) {
+	QObject::connect(pWebSocket, &QWebSocket::textMessageReceived, [=](QString message) {
 		pWebSocket->send(message);
 	});
-	QObject::connect(pWebSocket, &WebSocket::binaryMessageReceived, [=](QByteArray message) {
+	QObject::connect(pWebSocket, &QWebSocket::binaryMessageReceived, [=](QByteArray message) {
 		pWebSocket->send(message);
 	});
 
@@ -93,11 +93,11 @@ void ComplianceTest::runTestCases(int startNbr, int stopNbr)
 void ComplianceTest::autobahnTest()
 {
 	//connect to autobahn server at url ws://ipaddress:port/getCaseCount
-	WebSocket *pWebSocket = new WebSocket;
+	QWebSocket *pWebSocket = new QWebSocket;
 	QUrl url = m_url;
 	int numberOfTestCases = 0;
 	QSignalSpy spy(pWebSocket, SIGNAL(disconnected()));
-	QObject::connect(pWebSocket, &WebSocket::textMessageReceived, [&](QString message) {
+	QObject::connect(pWebSocket, &QWebSocket::textMessageReceived, [&](QString message) {
 		numberOfTestCases = message.toInt();
 	});
 
@@ -106,7 +106,7 @@ void ComplianceTest::autobahnTest()
 	spy.wait(60000);
 	QVERIFY(numberOfTestCases > 0);
 
-	QObject::disconnect(pWebSocket, &WebSocket::textMessageReceived, 0, 0);
+	QObject::disconnect(pWebSocket, &QWebSocket::textMessageReceived, 0, 0);
 
 	runTestCases(0, numberOfTestCases);
 
diff --git a/test/tst_websockets.cpp b/test/tst_websockets.cpp
index 2b06cf4..fe914dc 100644
--- a/test/tst_websockets.cpp
+++ b/test/tst_websockets.cpp
@@ -3,7 +3,7 @@
 #include <QSignalSpy>
 #include <QHostInfo>
 #include <QDebug>
-#include "websocket.h"
+#include "qwebsocket.h"
 #include "unittests.h"
 
 class WebSocketsTest : public QObject
@@ -46,7 +46,7 @@ private Q_SLOTS:
 	//void autobahnTest();
 
 private:
-	WebSocket *m_pWebSocket;
+	QWebSocket *m_pWebSocket;
 	QUrl m_url;
 };
 
@@ -58,7 +58,7 @@ WebSocketsTest::WebSocketsTest() :
 
 void WebSocketsTest::initTestCase()
 {
-	m_pWebSocket = new WebSocket();
+	m_pWebSocket = new QWebSocket();
 	m_pWebSocket->open(m_url, true);
 	QTRY_VERIFY_WITH_TIMEOUT(m_pWebSocket->state() == QAbstractSocket::ConnectedState, 1000);
 	QVERIFY(m_pWebSocket->isValid());