void GuiManager::sendFortune()
{
qDebug()<<__FUNCTION__;
QByteArray block;
QDataStream out(&block, QIODevice::WriteOnly);
out.setVersion(QDataStream::Qt_5_4);
out << (quint16)0;
out << fortunes.at(qrand() % fortunes.size());
out.device()->seek(0);
out << (quint16)(block.size() - sizeof(quint16));
QLocalSocket *clientConnection = server->nextPendingConnection();
qDebug()<<"===================="<<clientConnection->isOpen();
QLocalSocket* socket = clientConnection;
QDataStream in(socket);
in.setVersion(QDataStream::Qt_5_4);
quint16 blockSize = 0;
if (blockSize == 0) {
qDebug()<< (socket->bytesAvailable() < (int)sizeof(quint16));
if (socket->bytesAvailable() < (int)sizeof(quint16))
qDebug()<<"socket->bytesAvailable()"<<socket->bytesAvailable() ;
in >> blockSize;
}
void QtLocalPeer::receiveConnection()
{
QLocalSocket* socket = server->nextPendingConnection();
if (!socket)
return;
while (socket->bytesAvailable() < (int)sizeof(quint32))
socket->waitForReadyRead();
QDataStream ds(socket);
QByteArray uMsg;
quint32 remaining;
ds >> remaining;
uMsg.resize(remaining);
int got = 0;
char* uMsgBuf = uMsg.data();
do {
got = ds.readRawData(uMsgBuf, remaining);
remaining -= got;
uMsgBuf += got;
} while (remaining && got >= 0 && socket->waitForReadyRead(2000));
if (got < 0) {
qWarning("QtLocalPeer: Message reception failed %s", socket->errorString().toLatin1().constData());
delete socket;
return;
}
QString message(QString::fromUtf8(uMsg));
socket->write(ack, qstrlen(ack));
socket->waitForBytesWritten(1000);
delete socket;
emit messageReceived(message); //### (might take a long time to return)
}
Application::Application(const SearchQuery &query, QObject *parent) :
QObject(parent)
{
// Ensure only one instance of Application
Q_ASSERT(!m_instance);
m_instance = this;
m_settings = new Settings(this);
m_localServer = new QLocalServer(this);
m_networkManager = new QNetworkAccessManager(this);
m_extractorThread = new QThread(this);
m_extractor = new Extractor();
m_docsetRegistry = new DocsetRegistry();
m_docsetRegistry->init(m_settings->docsetPath);
m_mainWindow = new MainWindow(this);
// Server for detecting already running instances
connect(m_localServer, &QLocalServer::newConnection, [this]() {
QLocalSocket *connection = m_localServer->nextPendingConnection();
// Wait a little while the other side writes the bytes
connection->waitForReadyRead();
if (connection->bytesAvailable()) {
QDataStream in(connection);
Zeal::SearchQuery query;
in >> query;
m_mainWindow->bringToFront(query);
} else {
qint64 QtLocalPeer::getRunningPid() {
if (!isClient())
return 0;
QLocalSocket socket;
bool connOk = false;
for (int i = 0; i < 2; i++) {
// Try twice, in case the other instance is just starting up
socket.connectToServer(socketName);
connOk = socket.waitForConnected(5000/2);
if (connOk || i)
break;
Sleep(250);
}
if (!connOk) return -1;
const char* msg = "qbt://pid";
QDataStream ds(&socket);
ds.writeBytes(msg, qstrlen(msg));
bool res = socket.waitForBytesWritten(5000) && socket.waitForReadyRead(5000);
if (!res) return -1;
DWORD pid;
qint64 pid_size = sizeof pid;
while (socket.bytesAvailable() < pid_size)
socket.waitForReadyRead();
if (socket.read((char *)&pid, pid_size) < pid_size)
return -1;
return pid;
}
void ControlPeer::receiveConnection()
{
QLocalSocket* socket = p->server->nextPendingConnection();
if (!socket) {
return;
}
while (socket->bytesAvailable() < (int)sizeof(quint32)) {
socket->waitForReadyRead();
}
QDataStream ds(socket);
QByteArray uMsg;
quint32 remaining;
ds >> remaining;
uMsg.resize(remaining);
int got = 0;
char* uMsgBuf = uMsg.data();
do {
got = ds.readRawData(uMsgBuf, remaining);
remaining -= got;
uMsgBuf += got;
} while (remaining && got >= 0 && socket->waitForReadyRead(2000));
if (got < 0) {
qWarning("Guzum.ControlPeer: Message reception failed %s", socket->errorString().toLatin1().constData());
delete socket;
return;
}
QString message(QString::fromUtf8(uMsg));
socket->write(ACK, qstrlen(ACK));
socket->waitForBytesWritten(1000);
delete socket;
// split message into the tokens, the format is the following:
// <method_name>\n<arg0>\n<arg1> etc
QStringList tokens = message.split("\n");
QString methodName = tokens[0];
if (methodName == SHOW_DIALOG_METHOD) {
showFileSelectorDialog();
} else if (methodName == OPEN_FILE_METHOD) {
if (tokens.size() == 2) {
// just open file using default gnupg home
QString filename = tokens[1];
editFile(filename);
} else if (tokens.size() == 3) {
// use file and custom gnupg home
QString filename = tokens[1];
QString gnupgHome = tokens[2];
editFile(filename, gnupgHome);
}
QString filename = message.mid(qstrlen(OPEN_FILE_METHOD)+1);
}
}
void PaymentServer::handleURIConnection()
{
QLocalSocket *clientConnection = uriServer->nextPendingConnection();
while (clientConnection->bytesAvailable() < (int)sizeof(quint32))
clientConnection->waitForReadyRead();
connect(clientConnection, &QLocalSocket::disconnected, clientConnection, &QLocalSocket::deleteLater);
QDataStream in(clientConnection);
in.setVersion(QDataStream::Qt_4_0);
if (clientConnection->bytesAvailable() < (int)sizeof(quint16)) {
return;
}
QString msg;
in >> msg;
handleURIOrFile(msg);
}
void LocalSocketIpcServer::socket_new_connection() {
QLocalSocket *clientConnection = m_server->nextPendingConnection();
while (clientConnection->bytesAvailable() < (int)sizeof(quint32))
clientConnection->waitForReadyRead();
connect(clientConnection, SIGNAL(disconnected()),
clientConnection, SLOT(deleteLater()));
QDataStream in(clientConnection);
in.setVersion(QDataStream::Qt_4_0);
if (clientConnection->bytesAvailable() < (int)sizeof(quint16)) {
return;
}
QString message;
in >> message;
emit messageReceived(message);
}
void CLocalSvrCommunication::GetData( )
{
QLocalSocket* pSocket = qobject_cast< QLocalSocket* >( sender( ) );
quint64 nDataSize = pSocket->bytesAvailable( );
if ( 0 == nDataSize ) {
return;
}
QByteArray byData = pSocket->readAll( );
QString strMsg( byData );
emit NotifyMsg( strMsg );
}
void mASocketManager::newConnection()
{
//fprintf(stderr, "[miniAudicle]: received connection from remote\n");
//fflush(stderr);
QLocalSocket * socket = m_server->nextPendingConnection();
QByteArray data;
QString path;
int timeouts = 0;
while(timeouts < MAX_TIMEOUTS)
{
if(socket->bytesAvailable() <= 0 && !socket->waitForReadyRead(MAX_TIMEOUT_MS/MAX_TIMEOUTS))
timeouts++;
else
{
QByteArray bytes = socket->readAll();
data.append(bytes);
bytes.append('\0');
//fprintf(stderr, "[miniAudicle]: received data '%s'\n", bytes.constData());
// check for line ending
if(data.at(data.length()-1) == '\n')
{
path = QString(data);
// remove trailing \n
path.remove(path.length()-1, 1);
socket->close();
socket = NULL;
break;
}
}
}
if(path.length())
{
if(QFileInfo(path).exists())
{
//fprintf(stderr, "[miniAudicle]: received path '%s' from remote\n", path.toUtf8().constData());
//fflush(stderr);
m_mainWindow->openFile(path);
m_mainWindow->activateWindow();
m_mainWindow->raise();
m_mainWindow->show();
}
}
}
//New messages detected
void LSingleApplication::newInputsAvailable(){
while(lserver->hasPendingConnections()){
QLocalSocket *sock = lserver->nextPendingConnection();
QByteArray bytes;
sock->waitForReadyRead();
while(sock->bytesAvailable() > 0){ //if(sock->waitForReadyRead()){
//qDebug() << "Info Available";
bytes.append( sock->readAll() );
}
sock->disconnectFromServer();
QStringList inputs = QString::fromLocal8Bit(bytes).split("::::");
//qDebug() << " - New Inputs Detected:" << inputs;
emit InputsAvailable(inputs);
}
}
void QtLocalPeer::receiveConnection()
{
QLocalSocket* socket = server->nextPendingConnection();
if (!socket)
return;
while (socket->bytesAvailable() < (int)sizeof(quint32))
socket->waitForReadyRead();
QDataStream ds(socket);
QByteArray uMsg;
quint32 remaining;
ds >> remaining;
uMsg.resize(remaining);
int got = 0;
char* uMsgBuf = uMsg.data();
do {
got = ds.readRawData(uMsgBuf, remaining);
remaining -= got;
uMsgBuf += got;
} while (remaining && got >= 0 && socket->waitForReadyRead(2000));
if (got < 0) {
qWarning() << "QtLocalPeer: Message reception failed" << socket->errorString();
delete socket;
return;
}
QString message(QString::fromUtf8(uMsg));
#ifdef Q_OS_WIN
if (message == "qbt://pid") {
qint64 pid = GetCurrentProcessId();
socket->write((const char *)&pid, sizeof pid);
} else {
socket->write(ack, qstrlen(ack));
}
#else
socket->write(ack, qstrlen(ack));
#endif
socket->waitForBytesWritten(1000);
delete socket;
#ifdef Q_OS_WIN
if (message == "qbt://pid")
return;
#endif
emit messageReceived(message); //### (might take a long time to return)
}
Server::Server(QString servername, QObject *parent) : QObject(parent){
qDebug() << "Starting server...";
m_server = new QLocalServer(this);
while(!m_server->listen(servername)){
if(m_server->serverError() == QAbstractSocket::AddressInUseError){
qDebug() << m_server->serverError() << "\nCalling removeServer...";
m_server->removeServer(servername);
}else{
qDebug() << "Not able to start the server!\n" << m_server->serverError();
}
}
if (m_server->isListening())
qDebug() << "Server started.\n\n";
clientID = 0;
connect(m_server, &QLocalServer::newConnection, [this](){
clientID++;
QLocalSocket *sock = m_server->nextPendingConnection();
clients.insert(clientID, sock);
sock->setProperty("ID", QVariant(clientID));
sock->setProperty("BTR", QVariant(0));
QObject::connect(sock, &QLocalSocket::readyRead, [this, sock](){
QDataStream in(sock);
in.setVersion(QDataStream::Qt_5_0);
if(sock->property("BTR").toInt() == 0){
quint64 btr;
in >> btr;
sock->setProperty("BTR", QVariant(btr));
}
if(sock->bytesAvailable() < sock->property("BTR").toInt())
return;
QString message;
in >> message;
sock->setProperty("BTR", QVariant(0));
emit newMessageFromClient(sock->property("ID").toInt(), message);
});
int qt_waitforinput(void)
{
#ifdef USE_MOUSE
fd_set read_fds;
int stdin_fd = fileno(stdin);
int socket_fd = qt_socket.socketDescriptor();
if (!qt_initialized || (socket_fd < 0) || (qt_socket.state() != QLocalSocket::ConnectedState))
return getchar();
// Gnuplot event loop
do
{
// Watch file descriptors
FD_ZERO(&read_fds);
FD_SET(socket_fd, &read_fds);
if (!paused_for_mouse)
FD_SET(stdin_fd, &read_fds);
// Wait for input
if (select(socket_fd+1, &read_fds, NULL, NULL, NULL) < 0)
{
fprintf(stderr, "Qt terminal communication error: select() error\n");
break;
}
// Terminal event coming
if (FD_ISSET(socket_fd, &read_fds))
{
qt_socket.waitForReadyRead(-1);
while (qt_socket.bytesAvailable() >= sizeof(gp_event_t))
{
struct gp_event_t event;
qt_socket.read((char*) &event, sizeof(gp_event_t));
/// @todo don't process mouse move events if others are in the queue
if (qt_processTermEvent(&event))
return '\0'; // exit from paused_for_mouse
}
}
} while (paused_for_mouse || (!paused_for_mouse && !FD_ISSET(stdin_fd, &read_fds)));
#endif
return getchar();
}
void MRmiServerPrivateSocket::_q_readData()
{
QLocalSocket* socket = (QLocalSocket*) sender();
uint sz = socket->bytesAvailable();
QDataStream stream(socket);
stream.setVersion(QDataStream::Qt_4_0);
if (method_size == 0) {
if (sz < (int)sizeof(quint16))
return;
stream >> method_size;
}
if (sz < method_size)
return;
invoke(stream);
}
void QtLocalPeer::receiveMessage()
{
QLocalSocket *socket = (QLocalSocket*)(sender());
QString msg;
while (socket->bytesAvailable() > 0) {
if (socket->canReadLine()) {
msg = socket->readLine();
} else {
msg = socket->readAll();
}
// qDebug()<<"local peer reciveing data:"<<msg<<socket->bytesAvailable();
if (this->isClient()) {
emit messageReceived(msg);
} else {
int client_id = this->clients.value(socket);
emit messageReceived(msg, client_id);
}
}
}
void QtLocalPeer::receiveConnection()
{
QLocalSocket* socket = server->nextPendingConnection();
if (!socket)
return;
int client_id = this->client_seq ++;
this->clients.insert(socket, client_id);
QObject::connect(socket, SIGNAL(readyRead()), this, SLOT(receiveMessage()));
QObject::connect(socket, SIGNAL(disconnected()), this, SLOT(clientDisconnected()));
return;
// multi client long connection support
while (socket->bytesAvailable() < (int)sizeof(quint32))
socket->waitForReadyRead();
QDataStream ds(socket);
QByteArray uMsg;
quint32 remaining;
ds >> remaining;
uMsg.resize(remaining);
int got = 0;
char* uMsgBuf = uMsg.data();
do {
got = ds.readRawData(uMsgBuf, remaining);
remaining -= got;
uMsgBuf += got;
} while (remaining && got >= 0 && socket->waitForReadyRead(2000));
if (got < 0) {
qWarning() << "QtLocalPeer: Message reception failed" << socket->errorString();
delete socket;
return;
}
QString message(QString::fromUtf8(uMsg));
socket->write(ack, qstrlen(ack));
socket->waitForBytesWritten(1000);
// delete socket;
emit messageReceived(message); //### (might take a long time to return)
}
void QtLocalPeer::receiveConnection()
{
QLocalSocket* socket = server->nextPendingConnection();
if (!socket)
return;
// Why doesn't Qt have a blocking stream that takes care of this shait???
while (socket->bytesAvailable() < static_cast<int>(sizeof(quint32))) {
if (!socket->isValid()) // stale request
return;
socket->waitForReadyRead(1000);
}
QDataStream ds(socket);
QByteArray uMsg;
quint32 remaining;
ds >> remaining;
uMsg.resize(remaining);
int got = 0;
char* uMsgBuf = uMsg.data();
//qDebug() << "RCV: remaining" << remaining;
do {
got = ds.readRawData(uMsgBuf, remaining);
remaining -= got;
uMsgBuf += got;
//qDebug() << "RCV: got" << got << "remaining" << remaining;
} while (remaining && got >= 0 && socket->waitForReadyRead(2000));
//### error check: got<0
if (got < 0) {
qWarning() << "QtLocalPeer: Message reception failed" << socket->errorString();
delete socket;
return;
}
// ### async this
QString message = QString::fromUtf8(uMsg.constData(), uMsg.size());
socket->write(ack, qstrlen(ack));
socket->waitForBytesWritten(1000);
emit messageReceived(message, socket); // ##(might take a long time to return)
}
int main(int argv, char** args) {
QApplication app(argv, args);
QLocalSocket sock;
QObject::connect(&sock, &QLocalSocket::readyRead, [&sock]() {
qint64 bytesAvailable = sock.bytesAvailable();
QByteArray buffer = sock.readAll();
QDataStream ds(buffer);
while (bytesAvailable > 0) {
int num;
ds >> num;
qDebug("received %d", num);
bytesAvailable -= 4;
if (num == 1) {
sendData(sock, 2);
sendData(sock, -1);
} else if (num == 3) {
sendData(sock, -3);
}
}
});
void LocalPeer::receiveConnection()
{
#ifdef _WIN32
QLocalSocket* socket = server_->nextPendingConnection();
if (!socket)
return;
while (socket->bytesAvailable() < (int)sizeof(quint32))
socket->waitForReadyRead();
QDataStream ds(socket);
QByteArray uMsg;
quint32 remaining;
ds >> remaining;
uMsg.resize(remaining);
int got = 0;
char* uMsgBuf = uMsg.data();
do
{
got = ds.readRawData(uMsgBuf, remaining);
remaining -= got;
uMsgBuf += got;
}
while (remaining && got >= 0 && socket->waitForReadyRead(2000));
if (got < 0)
{
delete socket;
return;
}
QString message(QString::fromUtf8(uMsg));
if (message == crossprocess_message_get_process_id)
{
unsigned int process_id = 0;
process_id = ::GetCurrentProcessId();
socket->write((const char*) &process_id, sizeof(process_id));
}
else if (message == crossprocess_message_get_hwnd_activate)
{
unsigned int hwnd = 0;
if (wnd_)
{
hwnd = (unsigned int) wnd_->winId();
wnd_->activateFromEventLoop();
}
socket->write((const char*) &hwnd, sizeof(hwnd));
}
else
{
socket->write("icq", qstrlen("icq"));
}
socket->waitForBytesWritten(1000);
socket->waitForDisconnected(1000);
delete socket;
if (message == crossprocess_message_shutdown_process)
{
QApplication::exit(0);
}
#endif //_WIN32
}
int qt_waitforinput(void)
{
#ifdef USE_MOUSE
fd_set read_fds;
int stdin_fd = fileno(stdin);
int socket_fd = qt_socket.socketDescriptor();
if (!qt_initialized || (socket_fd < 0) || (qt_socket.state() != QLocalSocket::ConnectedState))
return getchar();
// Gnuplot event loop
do
{
// Watch file descriptors
FD_ZERO(&read_fds);
FD_SET(socket_fd, &read_fds);
if (!paused_for_mouse)
FD_SET(stdin_fd, &read_fds);
// Wait for input
if (select(socket_fd+1, &read_fds, NULL, NULL, NULL) < 0)
{
// Display the error message except when Ctrl + C is pressed
if (errno != 4)
fprintf(stderr, "Qt terminal communication error: select() error %i %s\n", errno, strerror(errno));
break;
}
// Terminal event coming
if (FD_ISSET(socket_fd, &read_fds))
{
if (!(qt_socket.waitForReadyRead(-1))) {
// Must be a socket error; we need to restart qt_gnuplot
qDebug() << "Error: gnuplot_qt socket not responding";
qt_gnuplot_qtStarted = false;
return '\0';
}
// Temporary event for mouse move events. If several consecutive
// move events are received, only transmit the last one.
gp_event_t tempEvent;
tempEvent.type = -1;
if (qt_socket.bytesAvailable() < sizeof(gp_event_t)) {
qDebug() << "Error: short read from gnuplot_qt socket";
return '\0';
}
while (qt_socket.bytesAvailable() >= sizeof(gp_event_t))
{
struct gp_event_t event;
qt_socket.read((char*) &event, sizeof(gp_event_t));
// Delay move events
if (event.type == GE_motion)
tempEvent = event;
// Other events. Replay the last move event if present
else
{
if (tempEvent.type == GE_motion)
{
qt_processTermEvent(&tempEvent);
tempEvent.type = -1;
}
if (qt_processTermEvent(&event))
return '\0'; // exit from paused_for_mouse
}
}
// Replay move event
if (tempEvent.type == GE_motion)
qt_processTermEvent(&tempEvent);
}
} while (paused_for_mouse || (!paused_for_mouse && !FD_ISSET(stdin_fd, &read_fds)));
#endif
return getchar();
}
size_t callback_write_file(void *ptr, size_t size, size_t nmemb, void *userp)
{
// qDebug()<<__FILE__<<__LINE__<<__FUNCTION__<<size<<nmemb<<userp;
int tlen = size * nmemb;
char *s = (char*)ptr;
int rlen = 0;
CurlFtp *ftp = static_cast<CurlFtp*>(userp);
QLocalSocket *router = ftp->getDataSock2();
QLocalSocket *suppler = ftp->getDataSock();
// qDebug()<<"here";
Q_ASSERT(router != NULL);
// qDebug()<<"here"<<router;
retry_read:
if (!ftp->isPutDataFinished() || router->bytesAvailable() > 0) {
if (router->bytesAvailable() > 0) {
} else {
router->waitForReadyRead(1000);
router = ftp->getDataSock2();
// qDebug()<<"wait for ready read..."<<router->errorString()
// <<router->isOpen();
if (router->bytesAvailable() == 0) {
suppler = ftp->getDataSock();
if (suppler == NULL) {
// suppler is finished.
// ftp->closeDataChannel2();
return 0;
}
// continue;
goto retry_read;
}
}
Q_ASSERT(router->bytesAvailable() > 0);
rlen = router->read(s, tlen);
if (rlen < 0) {
Q_ASSERT(rlen >= 0);
return 0;
} else if (rlen == 0) {
qDebug()<<"no data left";
return 0;
} else {
return rlen;
}
} else {
return 0;
}
return 0;
// for (;;) {
// router = ftp->getDataSock2();
// if (router->bytesAvailable() > 0) {
// } else {
// router->waitForReadyRead(1000);
// router = ftp->getDataSock2();
// // qDebug()<<"wait for ready read..."<<router->errorString()
// // <<router->isOpen();
// if (router->bytesAvailable() == 0) {
// suppler = ftp->getDataSock();
// if (suppler == NULL) {
// // suppler is finished.
// // ftp->closeDataChannel2();
// return 0;
// }
// continue;
// }
// }
// Q_ASSERT(router->bytesAvailable() > 0);
// rlen = router->read(s, tlen);
// if (rlen < 0) {
// Q_ASSERT(rlen >= 0);
// return 0;
// } else if (rlen == 0) {
// qDebug()<<"no data left";
// return 0;
// } else {
// return rlen;
// }
// }
// rlen = router->read(s, tlen);
// if (rlen < 0) {
// Q_ASSERT(rlen >= 0);
// return 0;
// } else if (rlen == 0) {
// return 0;
// } else {
// return rlen;
// }
if (gn == 0) {
gn ++;
} else {
return 0;
}
for (int i = 0 ; i < tlen ; i ++) {
s[i] = 'v';
}
return tlen;
}
void TestThemeDaemonServer::slotClientDataAvailable()
{
QLocalSocket *socket = qobject_cast<QLocalSocket *>(sender());
if (!socket) {
return;
}
while (socket->bytesAvailable()) {
while (socket->bytesAvailable() < sizeof(quint32)) {
socket->waitForReadyRead();
}
QDataStream stream(socket);
stream.setVersion(QDataStream::Qt_4_6);
Packet packet;
stream >> packet;
if (!m_protocolVersionExchanged && (packet.type() == Packet::ProtocolVersionPacket)) {
m_protocolVersionExchanged = true;
}
if (!m_protocolVersionExchanged) {
// A packet has been requested before the client has send an protocol version packet
stream << Packet(Packet::ErrorPacket, packet.sequenceNumber(),
new StringPacketData("A protocol version packet is required before requesting anything else"));
return;
}
if (packet.type() != Packet::ProtocolVersionPacket) {
if (!m_clientRegistered && (packet.type() == Packet::RequestRegistrationPacket)) {
m_clientRegistered = true;
}
if (!m_clientRegistered) {
// A packet has been requested before the client has send an initial registration packet
stream << Packet(Packet::ErrorPacket, packet.sequenceNumber(),
new StringPacketData("A registration packet is required as second packet after the protocol version packet"));
return;
}
}
switch (packet.type()) {
case Packet::RequestPixmapPacket: {
// The client request a pixmap with a given image-id and size
const RequestedPixmapPacketData *requestedPixmap =
static_cast<const RequestedPixmapPacketData *>(packet.data());
const PixmapIdentifier id = requestedPixmap->id;
if (id.imageId == QLatin1String("test_pixmap_3")) {
// See comment in tst_MRemoteThemeDaemonClient::testMostUsedPixmaps(): We use this image-ID
// as trigger to send a list of most used pixmaps.
sendMostUsedPixmaps(stream, packet.sequenceNumber());
}
const QPixmap *pixmap = m_pixmapCache.value(id, 0);
if (pixmap) {
// The requested pixmap has been found, forward it to the client
// TODO: As soon as the handling of the meego graphicssystem sharing is clarified, the line:
// QApplication::setGraphicsSystem("native");
// from main.cpp should be removed and a correct assignment should be done here.
PixmapHandle pixmapHandle;
pixmapHandle.xHandle = pixmap->handle();
stream << Packet(Packet::PixmapUpdatedPacket,
packet.sequenceNumber(),
new PixmapHandlePacketData(id, pixmapHandle));
} else {
// The requested pixmap has not been found, forward an empty pixmap handle to the client
stream << Packet(Packet::PixmapUpdatedPacket,
packet.sequenceNumber(),
new PixmapHandlePacketData());
}
break;
}
case Packet::ReleasePixmapPacket: {
const PixmapIdentifier *pixmapId =
static_cast<const PixmapIdentifier*>(packet.data());
if (!m_pixmapCache.contains(*pixmapId)) {
qWarning() << "Released pixmap that has not been requested first";
}
break;
}
case Packet::ProtocolVersionPacket:
stream << Packet(Packet::ProtocolVersionPacket,
packet.sequenceNumber(),
new NumberPacketData(M::MThemeDaemonProtocol::protocolVersion));
break;
case Packet::RequestRegistrationPacket:
stream << Packet(Packet::ThemeChangedPacket,
packet.sequenceNumber(),
new ThemeChangeInfoPacketData(QStringList(), QStringList()));
break;
default:
qWarning() << "Packet type" << packet.type() << "not handled!";
break;
}
}
}
